@openwop/openwop-conformance 2.45.16 → 2.45.18

package/src/scenarios/v2-envelope-tier-one-subset-static.test.ts

@@ -4,12 +4,11 @@
  * The v1 twin is `envelope-tier-one-subset-static`; the walker lives in
  * `lib/envelope-schema-static.ts`.
  *
- *   load-bearing  ALWAYS ON, host-free: each universal-kind payload schema in
- *                 `schemas/v2/envelopes/` uses none of the keywords that fail
- *                 across several Tier-1 vendors (`oneOf`, `allOf`, `not`,
- *                 `if`/`then`/`else`, `dependencies`, `prefixItems`,
- *                 `propertyNames`), nests at most 5 deep and has at most 100
- *                 properties;
+ * The always-on load-bearing walk over the universal kinds reads only the
+ * corpus, so it lives in `src/coherence/v2-envelope-tier-one-universal-static`
+ * (moved in 2.45.18; `conformance.md` §Two products). This file keeps the one
+ * leg that reads host output:
+ *
  *   strict        LIVE: a host advertising `tierOneSubsetCompliance: "strict"`
  *                 has, for every kind it lists in `supportedEnvelopes.kinds`
  *                 that resolves to a corpus schema, a schema meeting the whole
@@ -23,7 +22,7 @@
  * host MUST accept an envelope restricted to the subset from any advertised
  * provider — and does not distinguish strict, warn and off.
  *
- * Dispositions (strict leg): discovery unreadable ⇒ `blocked`; `envelopes` not
+ * Dispositions: discovery unreadable ⇒ `blocked`; `envelopes` not
  * advertised, or `tierOneSubsetCompliance` other than "strict" ⇒
  * `inapplicable`; no advertised kind resolving to a corpus schema ⇒
  * `inapplicable`.
@@ -36,22 +35,10 @@ 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 { loadV2EnvelopeSchema, tierOneViolations, UNIVERSAL_KINDS, type SchemaViolation } from '../lib/envelope-schema-static.js';
+import { loadV2EnvelopeSchema, tierOneViolations, type SchemaViolation } from '../lib/envelope-schema-static.js';
 
-const ID_LOAD_BEARING = 'openwop.requirement.envelopes.tier-one-load-bearing-universal-kinds';
 const ID_STRICT = 'openwop.requirement.envelopes.tier-one-strict-advertised-kinds';
 
-describe('v2 Tier-1 subset: universal kinds meet the load-bearing rules (always on)', () => {
-  for (const kind of UNIVERSAL_KINDS) {
-    it(`${kind} uses no keyword that fails across Tier-1 vendors`, () => {
-      const schema = loadV2EnvelopeSchema(kind);
-      expect(schema !== null, req(ID_LOAD_BEARING, 'RFC 0030 §B', `schemas/v2/envelopes/${kind}.schema.json MUST exist`)).toBe(true);
-      const violations = schema === null ? [] : tierOneViolations(schema, 'load-bearing');
-      expect(violations, req(ID_LOAD_BEARING, 'RFC 0030 §B', `${kind} load-bearing Tier-1 violations: ${JSON.stringify(violations)}`)).toEqual([]);
-    });
-  }
-});
-
 describe('v2 Tier-1 subset: a strict host\'s advertised kinds meet the whole intersection', () => {
   it('a host advertising tierOneSubsetCompliance strict has advertised kinds whose corpus schemas satisfy the Tier-1 intersection', async () => {
     let doc: Record<string, unknown> | null;

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

@@ -10,7 +10,7 @@
  *
  * Not here: import refusal of credential material, dry-run no-write and
  * idempotence: v2 defines no import route ("a host serves them on routes of its
- * own"). The bundle shape is `v2-export-bundle-static`.
+ * own"). The bundle shape is the corpus gate `coherence/v2-export-bundle-static`.
  *
  * Dispositions: discovery unreadable ⇒ `blocked`; `portability` absent, or the
  * facet a leg reads absent ⇒ `inapplicable`.

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

@@ -8,7 +8,9 @@
  *               validates against the closed v2 PromptTemplate;
  *   filters     `?kind=system` and `?source=host` narrow;
  *   fetch       a listed template is fetched by id;
- *   etag        an ETag, when sent (a SHOULD), revalidates to `304`;
+ *   etag        advisory: an ETag, when sent (a SHOULD), revalidates to `304`;
+ *               a non-304 is recorded `inapplicable`, never failed (v2 binds
+ *               304 only on discovery and the run snapshot, headers.md);
  *   unknown     an unknown id is `404` with the v2 error envelope;
  *   gate off    NEW at v2, unaided: with `prompts.endpointsSupported` not
  *               advertised (the record absent, or the facet not `true`),
@@ -77,7 +79,7 @@ describe('v2 prompt library: read surface (host-services.md §prompts)', () => {
     for (const x of out.findings) expect(x.ok, req(ID_FETCH, x.doc, x.message)).toBe(true);
   });
 
-  it('an ETag, when sent, revalidates to 304', async () => {
+  it('advisory: an ETag, when sent, revalidates to 304', async () => {
     const r = await ready();
     if (!r.ok) return r.skip();
     const out = await etagLeg(PROFILE, r.a);

package/src/scenarios/v2-provider-usage-advertisement.test.ts

@@ -8,7 +8,7 @@
  *   currency       an ISO 4217 code, `^[A-Z]{3}$` (absent means USD).
  *
  * Not here: exactly-one-per-invocation emission needs a mock-provider run; the
- * payload shape is `v2-provider-usage-payload-static`.
+ * payload shape is the corpus gate `coherence/v2-provider-usage-payload-static`.
  *
  * Dispositions: discovery unreadable ⇒ `blocked`; `providerUsage` absent, or the
  * facet a leg reads absent ⇒ `inapplicable`.

package/src/scenarios/v2-run-snapshot-etag.test.ts

@@ -7,12 +7,27 @@
  * a host that sends no ETag records `inapplicable`. Every response carries
  * `OpenWOP-Version` (versioning.md §1.4), the 304 included.
  *
+ * The revalidation runs once per client spelling (`OpenWOP-Version: 2.0`,
+ * `2`, and `2` with a wildcard Accept): a host MUST treat them alike
+ * (versioning.md §1), so a host that honours only the suite's own spelling
+ * cannot pass by it.
+ *
  * Control: a non-matching `If-None-Match` MUST receive 200 with the body — a
  * host that answers 304 to any conditional request fails here. `headers.md`
  * scopes `If-None-Match` to the discovery document; runs.md applies it to the
  * snapshot with a MUST (finding 5, filed).
  *
+ * RFC 0235 (`runs.md` §Caching and encoding) adds four legs, shared with
+ * `v2-discovery-etag` through `lib/if-none-match-witness.ts`: the RFC 9110
+ * match (weak, list, `*`, and two negatives), a 304 carrying the ETag, a
+ * request `Cache-Control: no-cache` not suppressing evaluation, and — only on
+ * this surface — evaluation only where the answer would be 2xx: `*` or a
+ * minted tag on a run id that does not exist gets the unconditional status,
+ * never a 304 that would disclose the run. Each of them is `inapplicable` when
+ * the snapshot carries no ETag, like the base leg.
+ *
  * @see spec/v2/core/runs.md §Snapshot
+ * @see spec/v2/core/runs.md §Caching and encoding
  * @see spec/v2/core/versioning.md §1.4
  */
 
@@ -23,10 +38,23 @@ import { v2Discovery } from '../lib/v2.js';
 import { readErrorCode } from '../lib/error-envelope.js';
 import { softSkip } from '../lib/soft-skip.js';
 import { req } from '../lib/requirement-ids.js';
+import { headersLeg, judgeNot2xx, matchLeg, noCacheLeg, type Get, type LegOutcome } from '../lib/if-none-match-witness.js';
 
 const ID = 'openwop.requirement.0170.run-snapshot-etag';
 const DOC = 'spec/v2/core/runs.md §Snapshot';
 const NOOP = 'conformance-noop';
+const MATCH_DOC = 'spec/v2/core/runs.md §Caching and encoding';
+const ID_MATCH = 'openwop.requirement.0235.if-none-match.rfc9110-match';
+const ID_304_ETAG = 'openwop.requirement.0235.if-none-match.304-carries-etag';
+const ID_NO_CACHE = 'openwop.requirement.0235.if-none-match.no-cache-ignored';
+const ID_ONLY_2XX = 'openwop.requirement.0235.if-none-match.only-on-2xx';
+/** The client spellings a host MUST treat alike (versioning.md §1). */
+const SPELLINGS: ReadonlyArray<Readonly<Record<string, string>>> = [
+  { 'OpenWOP-Version': '2.0' },
+  { 'OpenWOP-Version': '2' },
+  { 'OpenWOP-Version': '2', Accept: '*/*' },
+];
+const label = (h: Readonly<Record<string, string>>): string => Object.entries(h).map(([k, v]) => `${k}: ${v}`).join(', ');
 
 async function discovery(): Promise<Record<string, unknown> | null> { try { return await v2Discovery(); } catch { return null; } }
 async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> { try { return await fn(); } catch { return null; } }
@@ -51,32 +79,98 @@ describe('v2 run-snapshot-etag (runs.md §Snapshot)', () => {
     // happened to finish inside the sleep. It also let a host with a CONSTANT tag
     // pass for the wrong reason, which the control below still catches.
     await pollUntilTerminal(runId, { timeoutMs: scaledTimeoutMs(30_000) });
-    let etag: string | null = null;
-    let hit: OpenWOPResponse | null = null;
-    // A terminal run should be still, but "should" is not the claim under test:
-    // if the tag moves again, take the NEW tag and retry. The violation is a 200
-    // whose ETag EQUALS the If-None-Match that was sent — never a 200 per se.
-    for (let attempt = 0; attempt < 4; attempt++) {
-      const first = await http(() => driver.get(path));
-      if (first === null || first.status !== 200) return softSkip('blocked', `GET /runs/{runId} answered ${first?.status ?? 'no response'}`);
-      etag = first.headers.get('etag');
-      if (!etag) return softSkip('inapplicable', 'the snapshot carries no ETag — runs.md §Snapshot makes the ETag a SHOULD; the 304 rule applies only when it is present');
-      const sent = etag;
-      hit = await http(() => driver.get(path, { headers: { 'If-None-Match': sent } }));
-      if (hit === null) return softSkip('blocked', 'conditional GET unreachable (fetch failed)');
-      if (hit.status !== 200 || hit.headers.get('etag') === sent) break; // 304, or the real violation: decided below
-      await new Promise((r) => setTimeout(r, 500)); // 200 with a DIFFERENT tag: the representation moved; the tag sent was honestly stale
+    for (const spelling of SPELLINGS) {
+      let etag: string | null = null;
+      let hit: OpenWOPResponse | null = null;
+      // A terminal run should be still, but "should" is not the claim under test:
+      // if the tag moves again, take the NEW tag and retry. The violation is a 200
+      // whose ETag EQUALS the If-None-Match that was sent — never a 200 per se.
+      for (let attempt = 0; attempt < 4; attempt++) {
+        const first = await http(() => driver.get(path, { headers: { ...spelling } }));
+        if (first === null || first.status !== 200) return softSkip('blocked', `GET /runs/{runId} answered ${first?.status ?? 'no response'}`);
+        etag = first.headers.get('etag');
+        if (!etag) return softSkip('inapplicable', 'the snapshot carries no ETag — runs.md §Snapshot makes the ETag a SHOULD; the 304 rule applies only when it is present');
+        const sent = etag;
+        hit = await http(() => driver.get(path, { headers: { ...spelling, 'If-None-Match': sent } }));
+        if (hit === null) return softSkip('blocked', 'conditional GET unreachable (fetch failed)');
+        if (hit.status !== 200 || hit.headers.get('etag') === sent) break; // 304, or the real violation: decided below
+        await new Promise((r) => setTimeout(r, 500)); // 200 with a DIFFERENT tag: the representation moved; the tag sent was honestly stale
+      }
+      if (hit === null || etag === null) return softSkip('blocked', 'no conditional GET was made');
+      if (hit.status === 200 && hit.headers.get('etag') !== etag) {
+        return softSkip('blocked', `the snapshot of a TERMINAL run kept changing across four reads (last tag sent ${etag}, answered 200 with ${String(hit.headers.get('etag'))}) — the 304 rule cannot be witnessed against a representation that never holds still`);
+      }
+      expect(hit.status, req(ID, DOC, `under ${label(spelling)}, a request whose If-None-Match matches the CURRENT ETag MUST receive 304 — got ${hit.status} while the response still carried the same tag ${etag}`)).toBe(304);
+      expect(hit.text.length, req(ID, DOC, `under ${label(spelling)}, the 304 MUST carry no body (got ${hit.text.length} byte(s))`)).toBe(0);
+      expect(hit.headers.get('openwop-version'), req(ID, 'spec/v2/core/versioning.md §1.4', `under ${label(spelling)}, every response carries OpenWOP-Version, the 304 included`)).not.toBeNull();
     }
-    if (hit === null || etag === null) return softSkip('blocked', 'no conditional GET was made');
-    if (hit.status === 200 && hit.headers.get('etag') !== etag) {
-      return softSkip('blocked', `the snapshot of a TERMINAL run kept changing across four reads (last tag sent ${etag}, answered 200 with ${String(hit.headers.get('etag'))}) — the 304 rule cannot be witnessed against a representation that never holds still`);
-    }
-    expect(hit.status, req(ID, DOC, `a request whose If-None-Match matches the CURRENT ETag MUST receive 304 — got ${hit.status} while the response still carried the same tag ${etag}`)).toBe(304);
-    expect(hit.text.length, req(ID, DOC, `the 304 MUST carry no body (got ${hit.text.length} byte(s))`)).toBe(0);
-    expect(hit.headers.get('openwop-version'), req(ID, 'spec/v2/core/versioning.md §1.4', 'every response carries OpenWOP-Version, the 304 included')).not.toBeNull();
     const miss = await http(() => driver.get(path, { headers: { 'If-None-Match': '"openwop-conformance-no-such-tag"' } }));
     if (miss === null) return softSkip('blocked', 'conditional GET unreachable (fetch failed)');
     expect(miss.status, req(ID, DOC, `a non-matching If-None-Match MUST receive 200 with the body — got ${miss.status} (a host answering 304 to any conditional request is not honouring the tag)`)).toBe(200);
     expect((miss.json as { runId?: unknown } | null)?.runId, req(ID, DOC, 'the 200 body is the snapshot')).toBe(runId);
   });
+
+  /** A settled run whose snapshot carries an ETag, or the reason there is none. */
+  let settled: Promise<{ runId: string; tag: string } | { skip: 'blocked' | 'inapplicable'; reason: string }> | null = null;
+  function settledRun(): Promise<{ runId: string; tag: string } | { skip: 'blocked' | 'inapplicable'; reason: string }> {
+    settled ??= (async () => {
+      if (!(await discovery())) return { skip: 'blocked' as const, reason: 'v2 discovery unreachable' };
+      const created = await http(() => driver.post('/runs', { workflowId: NOOP }));
+      const runId = (created?.json as { runId?: unknown } | null)?.runId;
+      if (created === null || created.status !== 201 || typeof runId !== 'string') return { skip: 'blocked' as const, reason: `POST /runs answered ${created?.status ?? 'no response'} — create refused` };
+      await pollUntilTerminal(runId, { timeoutMs: scaledTimeoutMs(30_000) });
+      const ok = await http(() => driver.get(`/runs/${encodeURIComponent(runId)}`));
+      if (ok === null || ok.status !== 200) return { skip: 'blocked' as const, reason: `GET /runs/{runId} answered ${ok?.status ?? 'no response'}` };
+      const tag = ok.headers.get('etag');
+      if (!tag) return { skip: 'inapplicable' as const, reason: 'the snapshot carries no ETag — runs.md makes it a SHOULD; the If-None-Match rules apply only when it is present' };
+      return { runId, tag };
+    })();
+    return settled;
+  }
+  const runGet = (runId: string): Get => (headers) => http(() => driver.get(`/runs/${encodeURIComponent(runId)}`, { headers: { ...headers } }));
+  async function leg(fn: (get: Get) => Promise<LegOutcome>): Promise<LegOutcome | { kind: 'skip'; skip: 'blocked' | 'inapplicable'; reason: string }> {
+    const run = await settledRun();
+    if ('skip' in run) return { kind: 'skip', ...run };
+    return fn(runGet(run.runId));
+  }
+
+  it('If-None-Match is evaluated as RFC 9110 defines it: a weak tag, a list holding the tag and `*` match; other tags do not', async () => {
+    const out = await leg(matchLeg);
+    if (out.kind === 'skip') return softSkip(out.skip, out.reason);
+    if (out.kind === 'unreadable') return softSkip('blocked', `run snapshot: ${out.reason}`);
+    expect(out.findings.join('; '), req(ID_MATCH, MATCH_DOC, 'If-None-Match is `*` or a list of entity tags compared weakly (RFC 9110 §13.1.2)')).toBe('');
+  });
+
+  it('a 304 carries the ETag and the Vary of the 200', async () => {
+    const out = await leg(headersLeg);
+    if (out.kind === 'skip') return softSkip(out.skip, out.reason);
+    if (out.kind === 'unreadable') return softSkip('blocked', `run snapshot: ${out.reason}`);
+    expect(out.findings.join('; '), req(ID_304_ETAG, MATCH_DOC, 'on a match the host MUST answer 304 carrying the ETag and the Vary the 200 would carry')).toBe('');
+  });
+
+  it('a request Cache-Control: no-cache does not suppress the evaluation', async () => {
+    const out = await leg(noCacheLeg);
+    if (out.kind === 'skip') return softSkip(out.skip, out.reason);
+    if (out.kind === 'unreadable') return softSkip('blocked', `run snapshot: ${out.reason}`);
+    expect(out.findings.join('; '), req(ID_NO_CACHE, MATCH_DOC, 'a request Cache-Control: no-cache MUST NOT suppress the evaluation')).toBe('');
+  });
+
+  it('a conditional request on a run that does not exist gets the unconditional status, never 304', async () => {
+    const run = await settledRun();
+    if ('skip' in run) return softSkip(run.skip, run.reason);
+    // Same grammar and tenant as a real id, last character changed: an id this host never minted.
+    const last = run.runId.slice(-1);
+    const absent = run.runId.slice(0, -1) + (last === 'a' ? 'b' : 'a');
+    const get = runGet(absent);
+    const plain = await get({});
+    if (plain === null) return softSkip('blocked', 'GET /runs/{runId} on an absent id could not be made');
+    if (plain.status >= 200 && plain.status < 300) return softSkip('blocked', `an id differing from a real run in its last character answered ${plain.status}; no absent run to probe`);
+    const findings: string[] = [];
+    for (const sent of ['*', run.tag]) {
+      const c = await get({ 'If-None-Match': sent });
+      if (c === null) return softSkip('blocked', 'the conditional GET on an absent id could not be made');
+      findings.push(...judgeNot2xx(plain.status, c.status, sent));
+    }
+    expect(findings.join('; '), req(ID_ONLY_2XX, MATCH_DOC, 'If-None-Match is evaluated only when the unconditional response would be 2xx; a run the caller cannot read stays 404')).toBe('');
+  });
 });

package/src/scenarios/v2-self-hosted-runner-advertisement.test.ts

@@ -8,7 +8,7 @@
  *   dispatchKinds  `dispatchKinds` lists `model`, `tool` or both, each once.
  *
  * Not here: registration, subject isolation, at-most-once and liveness need a
- * runner seam; the frame shapes are `v2-self-hosted-runner-frames-static`.
+ * runner seam; the frame shapes are the corpus gate `coherence/v2-self-hosted-runner-frames-static`.
  *
  * Dispositions: discovery unreadable ⇒ `blocked`; `selfHostedRunner` absent, or the
  * facet a leg reads absent ⇒ `inapplicable`.

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

@@ -1,93 +0,0 @@
-/**
- * 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-artifact-created-static.test.ts

@@ -1,92 +0,0 @@
-/**
- * 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-envelope-variant-discriminator-static.test.ts

@@ -1,57 +0,0 @@
-/**
- * v2 — variant payload discrimination, statically (RFC 0031 §A). The v1 twin
- * is `envelope-variant-discriminator-static`; the walker lives in
- * `lib/envelope-schema-static.ts`.
- *
- * For every payload schema in `schemas/v2/envelopes/`:
- *   no oneOf       `oneOf` appears at no depth (Gemini drops it silently, so a
- *                  model gets a looser schema than declared);
- *   discriminated  in a variant union — an `anyOf` where two or more branches
- *                  can be objects — every object branch declares, in `required`,
- *                  a property of `type: string` with a one-value `enum`; a `$ref`
- *                  branch is accepted unresolved, as at v1. A type union with at
- *                  most one object branch (`string | binding`, as
- *                  `ui.a2ui-surface` payload v2's `dyn*` defs declare) is
- *                  selected by JSON type and is not judged: a scalar branch has
- *                  no property to discriminate on. This scoping is new at v2 —
- *                  the v1 walker flagged every non-`$ref` branch, which no v1
- *                  schema exercised.
- *
- * No v2 core document states this rule: `spec/v2/core/` carries no text on
- * variant payload discrimination (the nearest is `ext/a2uiSurface/README.md`,
- * whose components are "discriminated by a single-string-enum `component`").
- * The requirement is cited to RFC 0031 §A, its only normative home.
- *
- * Host-free: every leg runs with no OPENWOP_BASE_URL.
- *
- * @see RFCS/0031-envelope-variants-and-model-capabilities.md §A
- */
-
-import { describe, it, expect } from 'vitest';
-import { req } from '../lib/requirement-ids.js';
-import { anyOfDiscriminatorViolations, listV2EnvelopeKinds, loadV2EnvelopeSchema, oneOfViolations, UNIVERSAL_KINDS } from '../lib/envelope-schema-static.js';
-
-const DOC = 'RFC 0031 §A';
-const ID_PRESENT = 'openwop.requirement.envelopes.payload-schemas-present';
-const ID_NO_ONEOF = 'openwop.requirement.envelopes.variant-no-oneof';
-const ID_DISCRIMINATED = 'openwop.requirement.envelopes.variant-anyof-discriminated';
-
-const KINDS = listV2EnvelopeKinds();
-
-describe('v2 envelope variant discrimination (RFC 0031 §A)', () => {
-  it('schemas/v2/envelopes carries a payload schema for each universal kind', () => {
-    for (const k of UNIVERSAL_KINDS) expect(KINDS.includes(k), req(ID_PRESENT, DOC, `schemas/v2/envelopes/${k}.schema.json MUST exist`)).toBe(true);
-  });
-
-  for (const kind of KINDS) {
-    it(`${kind} contains no oneOf at any depth`, () => {
-      const v = oneOfViolations(loadV2EnvelopeSchema(kind));
-      expect(v, req(ID_NO_ONEOF, DOC, `${kind} MUST NOT use oneOf — use anyOf with a single-string-enum discriminator: ${JSON.stringify(v)}`)).toEqual([]);
-    });
-
-    it(`${kind} discriminates every anyOf branch by a single-string-enum property`, () => {
-      const v = anyOfDiscriminatorViolations(loadV2EnvelopeSchema(kind));
-      expect(v, req(ID_DISCRIMINATED, DOC, `${kind} anyOf branches without a discriminator: ${JSON.stringify(v)}`)).toEqual([]);
-    });
-  }
-});

package/src/scenarios/v2-export-bundle-static.test.ts

@@ -1,108 +0,0 @@
-/**
- * v2 — the export bundle, the `import.applied` payload and the `portability`
- * record's `import ⇒ dryRun` rule, statically (`spec/v2/core/portability.md`;
- * RFC 0098; invariant `export-bundle-no-credential-material`). The v1 twin is
- * the server-free half of `export-bundle-portability`; its import-seam leg is
- * not ported (v2 defines no import route).
- *
- *   version     a bundle carries `bundleVersion: "2"`. This FLIPS the v1 leg:
- *               at v1 `"1"` was good and `"2"` rejected; at v2 `"1"` is
- *               rejected;
- *   shape       an unknown item kind and an item without `ref` are rejected;
- *   no-cred     no credential-named field is admitted at the bundle root or
- *               under `source` ("A bundle MUST NOT contain credential values");
- *   applied     `import.applied` is a registered v2 event type, and its payload
- *               is counts and references only, never item payloads;
- *   dryRun      the capabilities seat refuses `import: true` without
- *               `dryRun: true` ("A host advertising `import` MUST advertise
- *               `dryRun: true`"). At v2 that `if/then` sits in the record's
- *               `allOf`, so it is witnessed by validation, not by reading
- *               `portability.if`.
- *
- * Host-free: every leg runs with no OPENWOP_BASE_URL.
- *
- * @see spec/v2/core/portability.md
- * @see schemas/v2/export-bundle.schema.json
- */
-
-import { describe, it, expect } from 'vitest';
-import { v2RefValidator, v2Validator } from '../lib/v2.js';
-import { req } from '../lib/requirement-ids.js';
-
-const DOC = 'portability.md §The export bundle';
-const ID_VERSION = 'openwop.requirement.portability.bundle-version-2';
-const ID_SHAPE = 'openwop.requirement.portability.bundle-item-shape';
-const ID_NO_CRED = 'openwop.requirement.portability.bundle-no-credential-field';
-const ID_APPLIED = 'openwop.requirement.portability.import-applied-content-free';
-const ID_DRY_RUN = 'openwop.requirement.portability.import-dry-run-schema-rule';
-
-const CRED_NAMES = ['clientSecret', 'client_secret', 'apiKey', 'api_key', 'accessToken', 'refreshToken', 'password', 'privateKey'] as const;
-
-const GOOD = {
-  bundleVersion: '2',
-  source: { origin: 'https://host-a.example', exportedAt: '2026-10-04T00:00:00Z' },
-  items: [
-    { kind: 'prompt-template', ref: 'tpl-1', payload: { templateId: 'welcome', version: '1.0.0' } },
-    { kind: 'connection-ref', ref: 'conn-1', dependsOn: ['tpl-1'], payload: { provider: 'slack', credentialRef: 'cred:abc' } },
-  ],
-} as const;
-
-describe('v2 export bundle (portability.md §The export bundle)', () => {
-  const validate = v2Validator('export-bundle');
-
-  it('accepts a conforming bundle at bundleVersion "2"', () => {
-    const r = validate(GOOD);
-    expect(r.ok, req(ID_VERSION, DOC, `a conforming v2 bundle MUST validate (${r.errors})`)).toBe(true);
-  });
-
-  it('rejects the v1 bundleVersion "1" and a missing bundleVersion', () => {
-    expect(validate({ ...GOOD, bundleVersion: '1' }).ok, req(ID_VERSION, DOC, 'a v2 bundle MUST carry bundleVersion "2"; "1" MUST be rejected')).toBe(false);
-    const { bundleVersion: _gone, ...rest } = GOOD;
-    expect(validate(rest).ok, req(ID_VERSION, DOC, 'a bundle without bundleVersion MUST be rejected')).toBe(false);
-  });
-
-  it('rejects an unknown item kind and an item without ref', () => {
-    expect(validate({ ...GOOD, items: [{ kind: 'workflow', ref: 'x', payload: {} }] }).ok, req(ID_SHAPE, DOC, 'an unknown item kind MUST be rejected')).toBe(false);
-    expect(validate({ ...GOOD, items: [{ kind: 'agent', payload: {} }] }).ok, req(ID_SHAPE, DOC, 'an item without a ref MUST be rejected')).toBe(false);
-  });
-
-  it.each(CRED_NAMES)('admits no %s field at the bundle root or under source', (name) => {
-    expect(validate({ ...GOOD, [name]: 'xxx' }).ok, req(ID_NO_CRED, DOC, `a "${name}" field at the bundle root MUST NOT validate`)).toBe(false);
-    expect(validate({ ...GOOD, source: { ...GOOD.source, [name]: 'xxx' } }).ok, req(ID_NO_CRED, DOC, `a "${name}" field under source MUST NOT validate`)).toBe(false);
-  });
-});
-
-describe('v2 import.applied (portability.md §The import.applied event)', () => {
-  const applied = v2RefValidator('run-event-payloads.schema.json#/$defs/importApplied');
-  const ADOC = 'portability.md §The import.applied event';
-
-  it('import.applied is a registered v2 run-event type', () => {
-    const r = v2RefValidator('run-event.schema.json#/properties/type')('import.applied');
-    expect(r.ok, req(ID_APPLIED, ADOC, `import.applied MUST be accepted by the v2 run-event type union (${r.errors})`)).toBe(true);
-  });
-
-  it('a counts-and-refs payload validates; one carrying item payloads does not', () => {
-    const r = applied({ bundleOrigin: 'https://host-a.example', counts: { created: 2, skipped: 1 }, secretsToRebind: ['anthropic'] });
-    expect(r.ok, req(ID_APPLIED, ADOC, `a content-free import.applied MUST validate (${r.errors})`)).toBe(true);
-    expect(applied({ bundleOrigin: 'h', counts: { created: 1 }, items: [{ payload: {} }] }).ok, req(ID_APPLIED, ADOC, 'import.applied MUST NOT carry item payloads')).toBe(false);
-    expect(applied({ bundleOrigin: 'h', counts: { created: 1, leaked: 1 } }).ok, req(ID_APPLIED, ADOC, 'import.applied counts MUST be the four outcome tallies only')).toBe(false);
-  });
-});
-
-describe('v2 portability record: import ⇒ dryRun (portability.md §The portability record)', () => {
-  const record = v2RefValidator('capabilities.schema.json#/properties/portability');
-  const PDOC = 'portability.md §The portability record';
-  const base = { status: 'experimental', since: '2.0', until: '2099-01-01', witness: 'witnessable-gated', export: true } as const;
-
-  it('import: true with dryRun: true validates; import: false needs no dryRun', () => {
-    for (const r of [{ ...base, import: true, dryRun: true }, { ...base, import: false }, { ...base }]) {
-      const v = record(r);
-      expect(v.ok, req(ID_DRY_RUN, PDOC, `a portability record ${JSON.stringify(r)} MUST validate (${v.errors})`)).toBe(true);
-    }
-  });
-
-  it('import: true without dryRun, or with dryRun: false, is rejected', () => {
-    expect(record({ ...base, import: true }).ok, req(ID_DRY_RUN, PDOC, 'import: true without dryRun MUST be rejected')).toBe(false);
-    expect(record({ ...base, import: true, dryRun: false }).ok, req(ID_DRY_RUN, PDOC, 'import: true with dryRun: false MUST be rejected')).toBe(false);
-  });
-});