@openwop/openwop-conformance 2.46.35 → 2.46.37

package/src/scenarios/v2-envelope-reasoning-shape.test.ts

@@ -1,81 +0,0 @@
-/**
- * v2 — the optional `reasoning` payload field (`spec/v2/core/events.md`
- * §`envelopes`; RFC 0030 §A). Static: reads `schemas/v2/envelopes/` only. The
- * v1 twin is `envelope-reasoning-shape`; its two advertisement legs
- * (`envelopes.reasoning`, `envelopes.tierOneSubsetCompliance`) are ported to
- * `v2-envelopes-advertisement`, not repeated here.
- *
- *   declared   `clarification.request`, `schema.request` and `error` declare an
- *              OPTIONAL `reasoning: string` ("A vendor kind whose payload needs
- *              multi-step reasoning SHOULD declare it as optional");
- *   omitted    `schema.response` (a side-channel ack) does not declare it;
- *   absent ok  each of the three validates WITHOUT `reasoning` ("A host MUST NOT
- *              reject an envelope without it, whatever `promptDirective` says");
- *   present ok each validates WITH a string `reasoning`;
- *   typed      a non-string `reasoning` is rejected.
- *
- * Host-free: every leg runs with no OPENWOP_BASE_URL.
- *
- * @see spec/v2/core/events.md §envelopes
- * @see schemas/v2/envelopes/
- */
-
-import { describe, it, expect } from 'vitest';
-import { v2Validator } from '../lib/v2.js';
-import { req } from '../lib/requirement-ids.js';
-import { loadV2EnvelopeSchema } from '../lib/envelope-schema-static.js';
-
-const DOC = 'events.md §envelopes';
-const ID_DECLARED = 'openwop.requirement.envelopes.reasoning-declared-optional-string';
-const ID_OMITTED = 'openwop.requirement.envelopes.reasoning-omitted-from-schema-response';
-const ID_ABSENT_OK = 'openwop.requirement.envelopes.reasoning-absent-accepted';
-const ID_PRESENT_OK = 'openwop.requirement.envelopes.reasoning-present-accepted';
-const ID_TYPED = 'openwop.requirement.envelopes.reasoning-non-string-rejected';
-
-/** A valid payload per kind, without `reasoning`. */
-const BASE: Readonly<Record<string, Record<string, unknown>>> = {
-  'clarification.request': { questions: [{ id: 'q1', question: 'Which provider?' }] },
-  'schema.request': { envelopeType: 'acme.prd.create' },
-  error: { code: 'validation_failed', message: 'Could not match the schema.' },
-};
-const KINDS = Object.keys(BASE);
-
-describe('v2 envelope reasoning: payload schemas (events.md §envelopes)', () => {
-  for (const kind of KINDS) {
-    it(`${kind} declares an optional reasoning of type string`, () => {
-      const schema = loadV2EnvelopeSchema(kind);
-      const props = (schema?.['properties'] ?? {}) as Record<string, Record<string, unknown>>;
-      const required = (schema?.['required'] ?? []) as unknown[];
-      expect(schema !== null, req(ID_DECLARED, DOC, `schemas/v2/envelopes/${kind}.schema.json MUST exist`)).toBe(true);
-      expect(props['reasoning']?.['type'], req(ID_DECLARED, DOC, `${kind} MUST declare reasoning as type string`)).toBe('string');
-      expect(required.includes('reasoning'), req(ID_DECLARED, DOC, `${kind} MUST NOT require reasoning — it is optional`)).toBe(false);
-    });
-  }
-
-  it('schema.response does not declare reasoning (a side-channel ack)', () => {
-    const schema = loadV2EnvelopeSchema('schema.response');
-    const props = (schema?.['properties'] ?? {}) as Record<string, unknown>;
-    expect(schema !== null, req(ID_OMITTED, 'RFC 0030 §A', 'schemas/v2/envelopes/schema.response.schema.json MUST exist')).toBe(true);
-    expect('reasoning' in props, req(ID_OMITTED, 'RFC 0030 §A', 'schema.response MUST NOT declare reasoning')).toBe(false);
-  });
-});
-
-describe('v2 envelope reasoning: round-trip (events.md §envelopes)', () => {
-  for (const kind of KINDS) {
-    const validate = v2Validator(`envelopes/${kind}`);
-
-    it(`${kind} validates without reasoning`, () => {
-      const r = validate(BASE[kind]);
-      expect(r.ok, req(ID_ABSENT_OK, DOC, `a ${kind} payload without reasoning MUST validate — a host MUST NOT reject it (${r.errors})`)).toBe(true);
-    });
-
-    it(`${kind} validates with a string reasoning`, () => {
-      const r = validate({ reasoning: 'The input named X twice; I asked which one.', ...BASE[kind] });
-      expect(r.ok, req(ID_PRESENT_OK, DOC, `a ${kind} payload with a string reasoning MUST validate (${r.errors})`)).toBe(true);
-    });
-
-    it(`${kind} rejects a non-string reasoning`, () => {
-      expect(validate({ reasoning: 42, ...BASE[kind] }).ok, req(ID_TYPED, DOC, `${kind}: a numeric reasoning MUST be rejected — reasoning is a plain string`)).toBe(false);
-    });
-  }
-});

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

@@ -1,64 +0,0 @@
-/**
- * v2 — the Tier-1 structured-output subset, statically (RFC 0030 §B;
- * `envelopes.tierOneSubsetCompliance` in `schemas/v2/capabilities.schema.json`).
- * The v1 twin is `envelope-tier-one-subset-static`; the walker lives in
- * `lib/envelope-schema-static.ts`.
- *
- * 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
- *                 intersection (closed objects, every property required, no
- *                 string/number/array bounds). Host-served vendor schemas are
- *                 not fetched, as at v1.
- *
- * The strict rule is stated by the schema seat's description ("`strict`: every
- * host-served envelope schema passes the static subset-compliance check"). The
- * v2 prose (`events.md` §envelopes) states a different, behavioural rule — the
- * host MUST accept an envelope restricted to the subset from any advertised
- * provider — and does not distinguish strict, warn and off.
- *
- * Dispositions: discovery unreadable ⇒ `blocked`; `envelopes` not
- * advertised, or `tierOneSubsetCompliance` other than "strict" ⇒
- * `inapplicable`; no advertised kind resolving to a corpus schema ⇒
- * `inapplicable`.
- *
- * @see RFCS/0030-envelope-reasoning-and-tier-one-subset.md §B
- * @see spec/v2/core/events.md §envelopes
- */
-
-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, type SchemaViolation } from '../lib/envelope-schema-static.js';
-
-const ID_STRICT = 'openwop.requirement.envelopes.tier-one-strict-advertised-kinds';
-
-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;
-    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');
-    const envelopes = await familyAdvertised('envelopes');
-    if (envelopes === null) return softSkip('inapplicable', 'the host does not advertise envelopes');
-    if (envelopes['tierOneSubsetCompliance'] !== 'strict') return softSkip('inapplicable', `envelopes.tierOneSubsetCompliance is ${JSON.stringify(envelopes['tierOneSubsetCompliance'])}, not "strict" — the strict walk binds only a strict host`);
-    const catalog = await familyAdvertised('supportedEnvelopes');
-    const kinds = Array.isArray(catalog?.['kinds']) ? (catalog['kinds'] as unknown[]).filter((k): k is string => typeof k === 'string') : [];
-    const walked: Record<string, SchemaViolation[]> = {};
-    let resolved = 0;
-    for (const kind of kinds) {
-      const schema = loadV2EnvelopeSchema(kind);
-      if (schema === null) continue;
-      resolved++;
-      const v = tierOneViolations(schema, 'strict');
-      if (v.length > 0) walked[kind] = v;
-    }
-    if (resolved === 0) return softSkip('inapplicable', `none of the ${kinds.length} kinds in supportedEnvelopes.kinds resolves to a corpus schema; host-served vendor schemas are not fetched`);
-    expect(walked, req(ID_STRICT, 'capabilities.schema.json §envelopes.tierOneSubsetCompliance', `a strict host's advertised kinds MUST satisfy the Tier-1 intersection: ${JSON.stringify(walked)}`)).toEqual({});
-  });
-});

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

@@ -1,85 +0,0 @@
-/**
- * v2 — the `envelopes` advertisement (`spec/v2/core/events.md` §`envelopes`;
- * RFCs 0030, 0032, 0033). A claims-check family: what the host says about its
- * envelope posture is what is witnessed. The v1 twins are the advertisement
- * legs of `envelope-reasoning-shape`, `envelope-retry-attempted` /
- * `envelope-refusal-shape` and `envelope-completion-distinguishes-truncation`;
- * the legs live in `lib/family-advert-witness.ts`.
- *
- *   record       the record validates against its seat in
- *                `schemas/v2/capabilities.schema.json` (no v1 `supported` seat);
- *   reasoning    `reasoning.promptDirective` is mandatory | advisory | off;
- *   tier-one     `tierOneSubsetCompliance` is strict | warn | off;
- *   reliability  `reliability.events[]` names only reliability events and, with
- *                the four v1 dotted names folded to their v2 equivalents
- *                (aliases until 3.0, RFC 0228 §G), lists the two MUST-tier
- *                events `envelope.retry-exhausted` and `envelope.refusal`;
- *   completion   `reliability.completion.distinguishesTruncation` is a boolean
- *                and `truncationBudgetMultiplier` is in [1, 8].
- *
- * Dispositions: discovery unreadable ⇒ `blocked`; `envelopes` absent, or the
- * facet a leg reads absent ⇒ `inapplicable`.
- *
- * @see spec/v2/core/events.md §envelopes
- */
-
-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 { envelopesCompletionLeg, envelopesReasoningLeg, envelopesReliabilityLeg, envelopesTierOneLeg, recordSchemaLeg } from '../lib/family-advert-witness.js';
-
-const PROFILE = majorProfile(2);
-const ID_RECORD = 'openwop.requirement.envelopes.advert-record-schema';
-const ID_REASONING = 'openwop.requirement.envelopes.reasoning-advert-shape';
-const ID_TIER_ONE = 'openwop.requirement.envelopes.tier-one-subset-compliance-value';
-const ID_RELIABILITY = 'openwop.requirement.envelopes.reliability-events-advert';
-const ID_COMPLETION = 'openwop.requirement.envelopes.completion-advert-shape';
-
-async function discovery(): Promise<Record<string, unknown> | null> {
-  try { return await v2Discovery(); } catch { return null; }
-}
-const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
-
-describe('v2 envelopes advertisement (events.md §envelopes)', () => {
-  it('the envelopes record validates against its capabilities-schema seat', async () => {
-    const doc = await discovery();
-    if (!doc) return softSkip('blocked', UNREADABLE);
-    const out = recordSchemaLeg(PROFILE, doc, 'envelopes', 'events.md §envelopes');
-    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('envelopes.reasoning.promptDirective is mandatory, advisory or off', async () => {
-    const doc = await discovery();
-    if (!doc) return softSkip('blocked', UNREADABLE);
-    const out = envelopesReasoningLeg(PROFILE, doc);
-    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
-    for (const x of out.findings) expect(x.ok, req(ID_REASONING, x.doc, x.message)).toBe(true);
-  });
-
-  it('envelopes.tierOneSubsetCompliance is strict, warn or off', async () => {
-    const doc = await discovery();
-    if (!doc) return softSkip('blocked', UNREADABLE);
-    const out = envelopesTierOneLeg(PROFILE, doc);
-    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
-    for (const x of out.findings) expect(x.ok, req(ID_TIER_ONE, x.doc, x.message)).toBe(true);
-  });
-
-  it('envelopes.reliability.events lists only reliability events and includes retry-exhausted and refusal', async () => {
-    const doc = await discovery();
-    if (!doc) return softSkip('blocked', UNREADABLE);
-    const out = envelopesReliabilityLeg(PROFILE, doc);
-    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
-    for (const x of out.findings) expect(x.ok, req(ID_RELIABILITY, x.doc, x.message)).toBe(true);
-  });
-
-  it('envelopes.reliability.completion.distinguishesTruncation is a boolean', async () => {
-    const doc = await discovery();
-    if (!doc) return softSkip('blocked', UNREADABLE);
-    const out = envelopesCompletionLeg(PROFILE, doc);
-    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
-    for (const x of out.findings) expect(x.ok, req(ID_COMPLETION, x.doc, x.message)).toBe(true);
-  });
-});

package/src/scenarios/v2-limits-envelope-caps-advertisement.test.ts

@@ -1,61 +0,0 @@
-/**
- * v2 — the three envelope caps on `limits` (`spec/v2/core/runs.md` §Limits:
- * "`limits` always carries `clarificationRounds` (per task), `schemaRounds`
- * (per envelope) and `envelopesPerTurn` (per chat turn)"). The v1 twin is the
- * advertisement half of `aiEnvelope.capBreached`; the legs live in
- * `lib/family-advert-witness.ts`. The other `limits` facets
- * (`maxRunDurationMs`, `maxLoopIterations`) are `v2-run-execution-bounds`.
- *
- * Each cap MUST be present and validate against its subschema in
- * `schemas/v2/capabilities.schema.json` (a non-negative integer).
- *
- * Dispositions: discovery unreadable ⇒ `blocked`; `limits` absent ⇒
- * `inapplicable` (at v2 presence of the record is the claim; the v1 rule that
- * `limits` itself is always present has no v2 seat — the root schema requires
- * only `protocolVersions` and `preferredVersion`).
- *
- * @see spec/v2/core/runs.md §Limits
- */
-
-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 { limitsCapLeg } from '../lib/family-advert-witness.js';
-
-const PROFILE = majorProfile(2);
-const UNREADABLE = 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0';
-const ID_CLARIFICATION = 'openwop.requirement.limits.clarification-rounds-advertised';
-const ID_SCHEMA = 'openwop.requirement.limits.schema-rounds-advertised';
-const ID_ENVELOPES = 'openwop.requirement.limits.envelopes-per-turn-advertised';
-
-async function discovery(): Promise<Record<string, unknown> | null> {
-  try { return await v2Discovery(); } catch { return null; }
-}
-
-describe('v2 limits envelope caps (runs.md §Limits)', () => {
-  it('limits.clarificationRounds is present and a non-negative integer', async () => {
-    const doc = await discovery();
-    if (!doc) return softSkip('blocked', UNREADABLE);
-    const out = limitsCapLeg(PROFILE, doc, 'clarificationRounds');
-    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
-    for (const x of out.findings) expect(x.ok, req(ID_CLARIFICATION, x.doc, x.message)).toBe(true);
-  });
-
-  it('limits.schemaRounds is present and a non-negative integer', async () => {
-    const doc = await discovery();
-    if (!doc) return softSkip('blocked', UNREADABLE);
-    const out = limitsCapLeg(PROFILE, doc, 'schemaRounds');
-    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
-    for (const x of out.findings) expect(x.ok, req(ID_SCHEMA, x.doc, x.message)).toBe(true);
-  });
-
-  it('limits.envelopesPerTurn is present and a non-negative integer', async () => {
-    const doc = await discovery();
-    if (!doc) return softSkip('blocked', UNREADABLE);
-    const out = limitsCapLeg(PROFILE, doc, 'envelopesPerTurn');
-    if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
-    for (const x of out.findings) expect(x.ok, req(ID_ENVELOPES, x.doc, x.message)).toBe(true);
-  });
-});