@openwop/openwop-conformance 2.35.0 → 2.36.0

package/src/scenarios/v2-capability-maturity-bounded.test.ts

@@ -0,0 +1,108 @@
+/**
+ * v2 — `capability-maturity-bounded` (RFC 0197 §C.7;
+ * `spec/v2/core/capabilities.md` §8, the `technical` row).
+ *
+ * Witness class: witnessable — unaided. `capabilities.md` §8 sourced the
+ * technical maturity axis from "the record's `status`", which is the HOST's
+ * claim about itself. `spec/v2/declaration.json` is the CORPUS's claim, and it
+ * calls 82 of 87 families `experimental`. Nothing compared the two, so a host
+ * could advertise `status: "stable"` for a family the protocol has not
+ * committed to and every gate stayed green. RFC 0197 §C.7 makes the
+ * declaration the upper bound: a host MUST NOT advertise `stable` for a family
+ * whose declaration row is not `technical: "stable"`. Understating is
+ * permitted — a host may call its own offer `experimental` under a `stable`
+ * corpus row, because it is understating, and this row is deliberately
+ * ONE-SIDED so that it never pushes a host to overclaim.
+ *
+ * The declaration is read from the corpus the suite ships with
+ * (`@openwop/spec-artifacts` in the published layout, `spec/v2/` in a repo
+ * checkout — `lib/paths.ts` `SPEC_V2_DIR`), so a consumer installing the
+ * tarball measures against the same declaration a contributor does.
+ *
+ * A key with a record but no declaration row is NOT this row's concern —
+ * `v2-capabilities-root-closed` fails an unregistered root key — but it is
+ * counted and named rather than skipped in silence.
+ *
+ * This row CAN fail: run the driver against MyndHyve's committed discovery
+ * document and 38 families fail. That run is the sabotage proof, recorded in
+ * the RFC 0197 gates PR.
+ *
+ * @see spec/v2/core/capabilities.md §8
+ * @see spec/v2/declaration.json
+ * @see RFCS/0197-v2-surfaces-retired-never-reshaped.md §C
+ */
+
+import { describe, it, expect } from 'vitest';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { v2Discovery } from '../lib/v2.js';
+import { SCHEMAS_DIR, SPEC_V2_DIR } from '../lib/paths.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const DOC = 'spec/v2/core/capabilities.md §8';
+const ID = 'openwop.requirement.0197.maturity-not-overstated';
+
+interface DeclarationFamily { key: string; maturity?: { technical?: string } }
+
+/** Root keys the generated capabilities schema declares as family records. */
+function familyKeys(): Set<string> {
+  const schema = JSON.parse(readFileSync(join(SCHEMAS_DIR, 'v2', 'capabilities.schema.json'), 'utf8')) as { properties?: Record<string, { required?: string[] }> };
+  const out = new Set<string>();
+  for (const [key, prop] of Object.entries(schema.properties ?? {})) {
+    if (['status', 'since', 'witness'].every((r) => (prop.required ?? []).includes(r))) out.add(key);
+  }
+  return out;
+}
+
+function declarationTechnical(): Map<string, string> | null {
+  if (SPEC_V2_DIR === null) return null;
+  const path = join(SPEC_V2_DIR, 'declaration.json');
+  if (!existsSync(path)) return null;
+  const decl = JSON.parse(readFileSync(path, 'utf8')) as { families?: DeclarationFamily[] };
+  const out = new Map<string, string>();
+  for (const f of decl.families ?? []) if (f.maturity?.technical) out.set(f.key, f.maturity.technical);
+  return out;
+}
+
+describe('v2 capability-maturity-bounded (RFC 0197 §C.7)', () => {
+  it('no family record advertises `stable` above its corpus declaration row', async () => {
+    const doc = await v2Discovery().catch(() => null);
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 with a JSON body under OpenWOP-Version: 2.0');
+    const technical = declarationTechnical();
+    if (technical === null) return softSkip('blocked', 'spec/v2/declaration.json is not present in this layout — the corpus bound cannot be read, and a bound that cannot be read is not a pass');
+    const keys = familyKeys();
+    const records = Object.entries(doc).filter(([k, v]) => keys.has(k) && v !== null && typeof v === 'object' && !Array.isArray(v)) as Array<[string, Record<string, unknown>]>;
+    // A row that cannot fail is not a witness: a host advertising no family
+    // record reports `blocked`, never a zero-assertion pass.
+    if (records.length === 0) return softSkip('blocked', 'the host advertises no family record at the v2 root, so this row would assert nothing — it is blocked, not passing');
+    const undeclared: string[] = [];
+    const overstated: string[] = [];
+    for (const [key, rec] of records) {
+      const corpus = technical.get(key);
+      // A key with a record but no declaration row is not this row's concern —
+      // `v2-capabilities-root-closed` owns an unregistered root key — but it is
+      // named rather than skipped in silence.
+      if (corpus === undefined) { undeclared.push(key); continue; }
+      if (rec['status'] === 'stable' && corpus !== 'stable') overstated.push(`${key} (corpus: ${corpus})`);
+    }
+    // The SUMMARY assertion comes first on purpose. A per-record assertion that
+    // failed first would abort the test at family one and report a single name,
+    // when what the host operator needs is the whole list in one message.
+    expect(
+      overstated,
+      req(ID, DOC, `${overstated.length} family record(s) advertise status "stable" above the corpus declaration row. RFC 0197 §C.7 makes the declaration the upper bound — re-cut each with status "experimental" and a future \`until\`, or promote the family by RFC (§C.9). Understating is always permitted, so this bound can never push a host to overclaim. Overstated: ${overstated.join(', ') || 'none'}`),
+    ).toEqual([]);
+    // Then one assertion per record, so the ledger's assertion count equals the
+    // record count rather than one: a row that asserted once over 42 records
+    // would look identical to a row that asserted over none.
+    for (const [key, rec] of records) {
+      const corpus = technical.get(key);
+      expect(
+        corpus === undefined || !(rec['status'] === 'stable' && corpus !== 'stable'),
+        req(ID, DOC, `${key}: status ${JSON.stringify(rec['status'])} against corpus maturity ${corpus ?? '(not declared)'}`),
+      ).toBe(true);
+    }
+    expect(records.length, req(ID, DOC, `the scenario asserted over ${records.length} family record(s)${undeclared.length > 0 ? `; ${undeclared.length} carry no declaration row and are left to v2-capabilities-root-closed: ${undeclared.join(', ')}` : ''}`)).toBeGreaterThan(0);
+  });
+});

package/src/scenarios/v2-configurable-closed.test.ts

@@ -19,7 +19,7 @@ import { readErrorCode } from '../lib/error-envelope.js';
 import { softSkip } from '../lib/soft-skip.js';
 import { req } from '../lib/requirement-ids.js';
 
-const DOC = 'spec/v2/core/runs.md §configurable';
+const DOC = 'spec/v2/core/runs.md §Run options';
 const NOOP_WORKFLOW_ID = 'conformance-noop';
 const DOTTED = { version: 1, ai: { 'ai.provider': 'x' } };
 const UNKNOWN = { version: 1, unknownKey: 1 };

package/src/scenarios/v2-content-locale-keys.test.ts

@@ -0,0 +1,92 @@
+/**
+ * v2-content-locale-keys — RFC 0206 on a live host (target major 2).
+ *
+ * The corpus half of RFC 0206 (the grammar, the wire agreement, the superset
+ * and the two `resolveSection` properties) is witnessed by the coherence test
+ * `conformance/src/coherence/locale-key-grammar.test.ts`. This file carries the
+ * one row a host has to show: a host that advertises a content locale outside
+ * RFC 0103's `ll(-RR)` subset (`es-419`, `zh-Hant`, `fil`) can author content
+ * for it and delivers it.
+ *
+ * The leg runs only when `content.supportedLocales` contains a case-canonical
+ * tag (RFC 0206 §A.1) that the RFC 0103 grammar rejected. Otherwise it records
+ * `inapplicable` with that reason — never a pass — so the row is accounted for
+ * on every v2 cut. No committed bundle advertises such a tag today (register
+ * G4), so on every current host the row is `inapplicable`.
+ *
+ * Flow: create a published page, write the section's base fields
+ * (`locale == baseLocale`) and then its overlay for the extended tag (a host on
+ * the RFC 0103 grammar answers that write 400 — the leg fails), then
+ * `GET /content/pages/{slug}` with `Accept-Language: <tag>` and assert
+ * `Content-Language` names the tag (case-insensitively, RFC 5646 §2.1.1) and
+ * the section carries the overlay.
+ *
+ * Sabotage: a host that 400s the extended-tag write, or that serves only the
+ * base locale for it, fails the leg (write status / `Content-Language` /
+ * overlay assertion respectively).
+ *
+ * @see RFCS/0206-locale-keys-accept-negotiated-bcp47.md §A.1, §Conformance
+ * @see spec/v1/localized-content.md §C, §D (the v2 `content` family's normativeText)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { familyAdvertised, v2Discovery } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { LOCALE_KEY_PATTERN, LOCALE_KEY_PATTERN_RFC0103 } from '../lib/localized-content.js';
+
+const ID = 'openwop.requirement.0206.delivery-extended-locale';
+const DOC = 'RFC 0206 §A.1; localized-content.md §C, §D';
+
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> {
+  try {
+    return await fn();
+  } catch {
+    return null;
+  }
+}
+
+describe('v2-content-locale-keys (RFC 0206)', () => {
+  it('an advertised extended content locale is written and delivered', async () => {
+    const doc = await v2Discovery().catch(() => null);
+    if (doc === null) return softSkip('blocked', 'v2 discovery unreachable');
+    const content = await familyAdvertised('content');
+    if (content === null || content['supported'] !== true) return softSkip('inapplicable', 'the host does not advertise the content family (no content surface to deliver an extended locale from)');
+    const base = typeof content['baseLocale'] === 'string' ? content['baseLocale'] : null;
+    const supported = Array.isArray(content['supportedLocales']) ? content['supportedLocales'].filter((x): x is string => typeof x === 'string') : [];
+    const keyRe = new RegExp(LOCALE_KEY_PATTERN);
+    const oldRe = new RegExp(LOCALE_KEY_PATTERN_RFC0103);
+    const tag = supported.find((t) => keyRe.test(t) && !oldRe.test(t));
+    if (tag === undefined) return softSkip('inapplicable', `no advertised content locale outside the RFC 0103 subset (content.supportedLocales = ${JSON.stringify(supported)})`);
+    if (base === null) return softSkip('blocked', 'content.baseLocale is not advertised, so the base write cannot be addressed');
+
+    const nonce = Math.random().toString(36).slice(2, 10);
+    const pageId = `rfc0206-${nonce}`;
+    const slug = `rfc0206-${nonce}`;
+    const sectionId = 'hero';
+    const overlay = `overlay:${tag}`;
+
+    const created = await http(() => driver.post('/content/pages', { pageId, slug, name: 'RFC 0206 probe', status: 'published', sectionOrder: [sectionId] }));
+    if (created === null || created.status >= 300) return softSkip('blocked', `POST /content/pages answered ${created?.status ?? 'unreachable'}; the probe page could not be created`);
+    try {
+      const baseWrite = await http(() => driver.put(`/content/pages/${pageId}/sections/${sectionId}`, { locale: base, data: { heading: 'base', cta: 'base-cta' } }));
+      if (baseWrite === null || baseWrite.status >= 300) return softSkip('blocked', `the base-locale section write answered ${baseWrite?.status ?? 'unreachable'}`);
+
+      const tagWrite = await http(() => driver.put(`/content/pages/${pageId}/sections/${sectionId}`, { locale: tag, data: { heading: overlay } }));
+      expect(tagWrite?.status, req(ID, DOC, `the admin write with locale "${tag}" (an advertised content locale, §A.1-valid) MUST be accepted — a 400 means the host still validates the RFC 0103 subset`)).toBeLessThan(300);
+
+      const res = await http(() => driver.get(`/content/pages/${slug}`, { headers: { 'Accept-Language': tag } }));
+      if (res === null) return softSkip('blocked', `GET /content/pages/${slug} was unreachable`);
+      expect(res.status, req(ID, DOC, `GET /content/pages/${slug} for a published page MUST answer 200`)).toBe(200);
+      expect((res.headers.get('content-language') ?? '').toLowerCase(), req(ID, DOC, `Content-Language MUST name the negotiated extended locale "${tag}" (compared case-insensitively)`)).toBe(tag.toLowerCase());
+      const sections = (res.json as { sections?: Array<{ sectionId?: string; data?: Record<string, unknown> }> } | undefined)?.sections ?? [];
+      const hero = sections.find((s) => s.sectionId === sectionId);
+      if (hero === undefined) return softSkip('blocked', `the probe section was not delivered (the §D write alone did not make it servable on this host); the overlay cannot be observed`);
+      expect(hero.data?.['heading'], req(ID, DOC, `the section MUST resolve to its "${tag}" overlay`)).toBe(overlay);
+      expect(hero.data?.['cta'], req(ID, DOC, 'fields absent from the overlay fall through to base data (shallow merge)')).toBe('base-cta');
+    } finally {
+      await http(() => driver.delete(`/content/pages/${pageId}`));
+    }
+  });
+});

package/src/scenarios/v2-conversation-turn-parts.test.ts

@@ -0,0 +1,74 @@
+/**
+ * v2-conversation-turn-parts — RFC 0205 §B.5, the behavioural leg (suite 2.36.0,
+ * target major 2).
+ *
+ * A v2 conversation turn MAY carry `parts`, a non-empty array of A2A `Part`s;
+ * presence is the discriminator that marks the turn A2A-shaped. This leg reads a
+ * live run's `conversation.exchanged` turns and checks every turn that carries
+ * `parts` against `schemas/v2/conversation-turn.schema.json`. It mints
+ * `openwop.requirement.0205.turn-parts-emitted`, the behavioural twin of the
+ * server-free `turn-parts-shape` (a corpus row in
+ * `src/coherence/a2a-parts-schemas.test.ts`), so a server-free pass can never
+ * stand in for it.
+ *
+ * Gates, decided before any assertion:
+ *   - `conversationPrimitive` not advertised, or the
+ *     `conformance-conversation-lifecycle` fixture not advertised ⇒ `inapplicable`;
+ *   - the run emits no `conversation.exchanged` turn ⇒ `blocked` (the fixture's
+ *     own contract is one exchange);
+ *   - no emitted turn carries `parts` ⇒ `inapplicable` ("host emits no
+ *     A2A-shaped turns (SHOULD)"), never `executed-pass`.
+ *
+ * @see RFCS/0205-run-artifacts-and-turns-speak-a2a-parts.md
+ * @see spec/v2/core/runs.md §"Conversation and residency capabilities"
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { familyAdvertised, v2Discovery, v2Validator } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+type Json = Record<string, unknown>;
+const FIXTURE = 'conformance-conversation-lifecycle';
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+
+async function waitTerminal(runId: string, timeoutMs: number): Promise<string | null> {
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    const res = await driver.get(`/runs/${encodeURIComponent(runId)}`);
+    const status = res.status === 200 ? String((res.json as { status?: unknown } | null)?.status ?? '') : null;
+    if (status !== null && TERMINAL.has(status)) return status;
+    if (Date.now() > deadline) return status;
+    await new Promise((r) => setTimeout(r, 200));
+  }
+}
+
+describe('RFC 0205 §B.5 — an emitted turn that carries parts carries a valid Part[]', () => {
+  it('every conversation.exchanged turn carrying parts validates against the v2 turn def', async () => {
+    const doc = await v2Discovery();
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable');
+    if (!(await familyAdvertised('conversationPrimitive'))) return softSkip('inapplicable', 'host does not advertise conversationPrimitive');
+    const fixtures = Array.isArray(doc['fixtures']) ? (doc['fixtures'] as unknown[]) : [];
+    if (!fixtures.includes(FIXTURE)) return softSkip('inapplicable', `host does not advertise the ${FIXTURE} fixture`);
+    const create = await driver.post('/runs', { workflowId: FIXTURE });
+    if (create.status !== 201) return softSkip('blocked', `POST /runs {workflowId: ${FIXTURE}} answered ${create.status}`);
+    const runId = String((create.json as { runId?: unknown } | null)?.runId ?? '');
+    const status = await waitTerminal(runId, 20_000);
+    if (status !== 'completed') return softSkip('blocked', `${FIXTURE} did not complete (status ${status})`);
+    const poll = await driver.get(`/runs/${encodeURIComponent(runId)}/events/poll?timeout=1`);
+    const events = ((poll.json as { events?: unknown } | null)?.events ?? []) as Json[];
+    const turns = (Array.isArray(events) ? events : [])
+      .filter((e) => e['type'] === 'conversation.exchanged')
+      .map((e) => ((e['payload'] ?? {}) as Json)['turn'])
+      .filter((t): t is Json => t !== null && typeof t === 'object' && !Array.isArray(t));
+    if (turns.length === 0) return softSkip('blocked', `${FIXTURE} completed without a conversation.exchanged event carrying a turn`);
+    const shaped = turns.filter((t) => 'parts' in t);
+    if (shaped.length === 0) return softSkip('inapplicable', 'host emits no A2A-shaped turns (SHOULD)');
+    const validate = v2Validator('conversation-turn');
+    for (const t of shaped) {
+      const r = validate(t);
+      expect(r.ok, req('openwop.requirement.0205.turn-parts-emitted', 'RFC 0205 §B.5', `turn ${String(t['messageId'])} carries parts and MUST validate against schemas/v2/conversation-turn.schema.json: ${r.errors}`)).toBe(true);
+    }
+  });
+});

package/src/scenarios/v2-credential-interrupt.test.ts

@@ -0,0 +1,253 @@
+/**
+ * RFC 0199 §C — the `credential` interrupt (`spec/v2/core/oauth.md` §The
+ * credential interrupt, `spec/v2/core/interrupt.md` §Payload). Target major 2.
+ *
+ * Gate: the v2 `oauth` record advertises provider `synthetic` and the fixture
+ * `conformance-credential` is in `fixtures[]` (one `conformance.oauth.use` node
+ * declaring `auth { type: oauth2, provider: synthetic, scopes: [openwop.read] }`).
+ * The facet splits the file:
+ *   - `oauth.credentialInterrupt` present ⇒ the suspend legs (the node
+ *     suspends instead of failing; `connectUrl`; the host-side re-check;
+ *     `declined`; refresh failure raises `reason: expired` after
+ *     `connector.auth-expired`);
+ *   - absent ⇒ the RFC 0047 §C.3 regression leg (refresh failure fails the
+ *     node `connector_auth_expired` and raises no interrupt).
+ *
+ * Every run belongs to a FRESH Subject from the credential mint seam, so no
+ * credential another scenario acquired can satisfy the node (a Subject that
+ * already holds one would make the "missing" leg vacuous). No mint seam ⇒
+ * `blocked`. The grant legs point `synthetic` at the suite's
+ * authorization-server double through `authorize-start` and play the user
+ * agent through the host's own `connectUrl` and production callback.
+ *
+ * @see spec/v2/core/oauth.md §The credential interrupt
+ * @see RFCS/0199-outbound-oauth-client-and-credential-interrupt.md §C
+ * @see SECURITY/invariants.yaml id: oauth-same-user-binding
+ */
+import { describe, it, expect, afterAll } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { loadEnv } from '../lib/env.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { softSkip, seamAbsent } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { v2Validator } from '../lib/v2.js';
+import { SEAMS_PREFIX } from '../lib/seams.js';
+import { EXPIRE_REFRESH, authorizeStart, authorizationUrlOf, consent, oauthGate, startAsDouble, userAgentGet, type AsDouble } from '../lib/oauth-as-double.js';
+
+export const HOST_CALLBACK_NOT_REQUIRED = 'the suite plays the user agent through the host\'s own connectUrl and callback; the only fixture the host reaches is the suite\'s authorization-server double';
+
+const DOC = 'spec/v2/core/oauth.md §The credential interrupt (RFC 0199 §C)';
+const R = (slug: string): string => `openwop.requirement.0199.${slug}`;
+const FIXTURE = 'conformance-credential';
+const NODE = 'use-credential';
+const PROVIDER = 'synthetic';
+const SCOPES = ['openwop.read'];
+const MINT = `${SEAMS_PREFIX}/sample/auth/credential/mint`;
+const validInterrupt = v2Validator('suspend-request');
+
+let double: AsDouble | null = null;
+async function as(): Promise<AsDouble> { double ??= await startAsDouble(); return double; }
+afterAll(async () => { await double?.close(); double = null; });
+
+const auth = (bearer: string): { authenticated: false; headers: Record<string, string> } => ({ authenticated: false, headers: { Authorization: `Bearer ${bearer}` } });
+
+interface Ev { type?: string; sequence?: number; nodeId?: string; payload?: Record<string, unknown> }
+
+type Ready = { ok: true; d: AsDouble; facet: boolean; bearer: string } | { ok: false; skip: () => undefined };
+async function ready(): Promise<Ready> {
+  const g = await oauthGate();
+  if (!g.ok) return { ok: false, skip: () => softSkip(g.kind, g.reason) };
+  if (!g.providers.has(PROVIDER)) return { ok: false, skip: () => softSkip('blocked', `oauth.providers does not list ${PROVIDER} — the fixture's provider`) };
+  if (!isFixtureAdvertised(FIXTURE)) return { ok: false, skip: () => softSkip('blocked', `fixture ${FIXTURE} is not in the advertised fixtures[]`) };
+  const minted = await driver.post(MINT, { lane: 'api-key' }).catch(() => null);
+  const bearer = (minted?.json as { credential?: unknown } | undefined)?.credential;
+  if (minted === null || minted.status >= 300 || typeof bearer !== 'string') return { ok: false, skip: () => seamAbsent(`${MINT} did not mint a fresh Subject (${minted?.status ?? 'unreachable'}) — a Subject that may already hold a credential would make every leg vacuous`) };
+  const d = await as();
+  const point = await authorizeStart({ provider: PROVIDER, authUrl: d.authorizeUrl, tokenUrl: d.tokenUrl, issuer: d.issuer, scopes: SCOPES }, bearer);
+  if (point.status === 404 || point.status === 405) return { ok: false, skip: () => seamAbsent('POST /conformance/seams/sample/oauth/authorize-start is not mounted — the provider cannot be pointed at the suite\'s double') };
+  return { ok: true, d, facet: g.oauth['credentialInterrupt'] === true, bearer };
+}
+
+async function createRun(bearer: string): Promise<string> {
+  const r = await driver.post('/runs', { workflowId: FIXTURE, inputs: {} }, auth(bearer));
+  const runId = (r.json as { runId?: unknown } | undefined)?.runId;
+  expect(typeof runId, req(R('credential-interrupt'), 'runs.md createRun', `createRun of ${FIXTURE} MUST be accepted (got ${r.status} ${r.text.slice(0, 200)})`)).toBe('string');
+  return runId as string;
+}
+async function status(runId: string, bearer: string): Promise<string | undefined> {
+  const r = await driver.get(`/runs/${encodeURIComponent(runId)}`, auth(bearer));
+  return r.status === 200 ? (r.json as { status?: string }).status : undefined;
+}
+async function settle(runId: string, bearer: string, want: (s: string | undefined) => boolean, ms = 10_000): Promise<string | undefined> {
+  const end = Date.now() + ms;
+  let s = await status(runId, bearer);
+  while (!want(s) && Date.now() < end) { await new Promise((ok) => setTimeout(ok, 100)); s = await status(runId, bearer); }
+  return s;
+}
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+const settledOrSuspended = (s: string | undefined): boolean => s !== undefined && (TERMINAL.has(s) || s.startsWith('waiting-'));
+async function events(runId: string, bearer: string): Promise<Ev[]> {
+  const r = await driver.get(`/runs/${encodeURIComponent(runId)}/events/poll?timeout=1`, auth(bearer));
+  return ((r.json as { events?: Ev[] } | undefined)?.events ?? []);
+}
+const credentialRequest = (evs: Ev[]): Ev | undefined => evs.find((e) => e.type === 'interrupt.requested' && e.payload?.['kind'] === 'credential');
+const resolve = (runId: string, bearer: string, resumeValue: unknown): Promise<OpenWOPResponse> => driver.post(`/runs/${encodeURIComponent(runId)}/interrupts/${NODE}`, { resumeValue }, auth(bearer));
+const errCode = (r: OpenWOPResponse): string | undefined => (r.json as { error?: unknown } | undefined)?.error as string | undefined;
+
+/** Run one full grant for `bearer` through authorize-start → the double → the production callback. */
+async function grant(d: AsDouble, bearer: string): Promise<number> {
+  const start = await authorizeStart({ provider: PROVIDER, authUrl: d.authorizeUrl, tokenUrl: d.tokenUrl, issuer: d.issuer, scopes: SCOPES }, bearer);
+  const url = authorizationUrlOf(start);
+  if (url === null) return start.status;
+  const cb = await consent(url.toString());
+  if (cb === null) return 0;
+  return (await userAgentGet(cb, bearer)).status;
+}
+
+describe('RFC 0199 §C — v2-credential-interrupt (gated on oauth + provider synthetic + fixture conformance-credential)', () => {
+  it('a node with no credential suspends on a credential interrupt with a closed CredentialData, status waiting-input', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    if (!r.facet) return softSkip('inapplicable', 'oauth.credentialInterrupt is not advertised — the host keeps RFC 0047 §C.3 (the regression leg below covers it)');
+    const id = R('credential-interrupt');
+    const runId = await createRun(r.bearer);
+    const s = await settle(runId, r.bearer, settledOrSuspended);
+    expect(s, req(id, DOC, `a node declaring oauth2 auth with no credential for the Subject MUST suspend instead of failing — snapshot status waiting-input (got ${s})`)).toBe('waiting-input');
+    const ev = credentialRequest(await events(runId, r.bearer));
+    expect(ev, req(id, `${DOC}; interrupt.md §Payload`, 'the log carries interrupt.requested with kind credential')).toBeDefined();
+    const v = validInterrupt(ev!.payload);
+    expect(v.ok, req(id, 'schemas/v2/suspend-request.schema.json CredentialData (closed)', `the interrupt payload MUST validate, CredentialData closed: ${v.errors}`)).toBe(true);
+    const data = (ev!.payload!['data'] ?? {}) as Record<string, unknown>;
+    expect([data['provider'], data['reason']], req(id, DOC, 'data names the provider and reason missing')).toEqual([PROVIDER, 'missing']);
+    const connect = new URL(String(data['connectUrl']));
+    expect(connect.protocol, req(id, DOC, 'connectUrl MUST be https')).toBe('https:');
+    expect(connect.origin, req(id, `${DOC} (connectUrl is host-owned)`, `connectUrl MUST be on the host's own origin (${new URL(loadEnv().baseUrl).origin})`)).toBe(new URL(loadEnv().baseUrl).origin);
+    await driver.post(`/runs/${encodeURIComponent(runId)}:cancel`, {}, auth(r.bearer));
+  });
+
+  it('a caller resolve of authorized is refused while no credential resolves, and a resume value cannot carry a credential', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    if (!r.facet) return softSkip('inapplicable', 'oauth.credentialInterrupt is not advertised');
+    const id = R('credential-resume-rechecked');
+    const runId = await createRun(r.bearer);
+    expect(await settle(runId, r.bearer, settledOrSuspended), req(id, DOC, 'precondition: the run suspends on the credential interrupt')).toBe('waiting-input');
+    const trusted = await resolve(runId, r.bearer, { outcome: 'authorized' });
+    expect([trusted.status, errCode(trusted)], req(id, `${DOC} (the host re-checks; it does not trust the caller)`, `a resolve of authorized with no credential for the Subject MUST be refused 400 validation_error (got ${trusted.status} ${trusted.text.slice(0, 200)})`)).toEqual([400, 'validation_error']);
+    const field = ((trusted.json as { details?: { field?: unknown } } | undefined)?.details?.field);
+    expect(field, req(id, 'RFC 0199 §C.4', 'the refusal names details.field resumeValue')).toBe('resumeValue');
+    const smuggled = await resolve(runId, r.bearer, { outcome: 'authorized', token: 'xoxb-conformance-not-a-credential' });
+    expect(smuggled.status, req(id, 'interrupt.md §Payload (the resume value is { outcome } and carries no credential)', `a resume value carrying anything but outcome MUST fail resumeSchema with 400 (got ${smuggled.status})`)).toBe(400);
+    expect(await status(runId, r.bearer), req(id, DOC, 'the refused resolves change nothing: the run is still waiting-input')).toBe('waiting-input');
+    await driver.post(`/runs/${encodeURIComponent(runId)}:cancel`, {}, auth(r.bearer));
+  });
+
+  it('connectUrl is not pre-authenticated and begins the grant only for the initiating Subject', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    if (!r.facet) return softSkip('inapplicable', 'oauth.credentialInterrupt is not advertised');
+    const id = R('credential-interrupt');
+    const runId = await createRun(r.bearer);
+    expect(await settle(runId, r.bearer, settledOrSuspended), req(id, DOC, 'precondition: the run suspends on the credential interrupt')).toBe('waiting-input');
+    const connect = String(((credentialRequest(await events(runId, r.bearer))?.payload?.['data'] ?? {}) as Record<string, unknown>)['connectUrl']);
+    const startsGrant = (x: { status: number; location: string | null; text: string }): boolean => (x.location ?? '').startsWith(r.d.authorizeUrl) || x.text.includes(r.d.authorizeUrl);
+    const anon = await userAgentGet(connect, null);
+    expect(startsGrant(anon), req(id, `${DOC} (connectUrl MUST NOT be pre-authenticated)`, `an unauthenticated GET of connectUrl MUST NOT reach an authorization URL (got ${anon.status} → ${anon.location})`)).toBe(false);
+    const minted = await driver.post(MINT, { lane: 'api-key' });
+    const other = (minted.json as { credential?: string } | undefined)?.credential;
+    if (typeof other === 'string') {
+      const foreign = await userAgentGet(connect, other);
+      expect(startsGrant(foreign), req(id, `${DOC}; invariant oauth-same-user-binding`, `connectUrl opened by another Subject MUST NOT begin the grant (got ${foreign.status} → ${foreign.location})`)).toBe(false);
+    }
+    const own = await userAgentGet(connect, r.bearer);
+    expect(startsGrant(own), req(id, DOC, `positive control: the initiating Subject opening connectUrl is sent to the provider's authorization endpoint (got ${own.status} → ${own.location})`)).toBe(true);
+    expect(/ow2\.[a-z0-9]+\.[^/?#]+\./i.test(decodeURIComponent(connect)), req(id, `${DOC} (connectUrl is not the interrupt's capability token)`, 'connectUrl MUST NOT embed the interrupt token (identity.md §4 grammar ow2.<alg>.<kid>.…)')).toBe(false);
+    await driver.post(`/runs/${encodeURIComponent(runId)}:cancel`, {}, auth(r.bearer));
+  });
+
+  it('the grant completes through connectUrl, the host resolves the interrupt itself and the run continues', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    if (!r.facet) return softSkip('inapplicable', 'oauth.credentialInterrupt is not advertised');
+    const id = R('credential-interrupt');
+    const runId = await createRun(r.bearer);
+    expect(await settle(runId, r.bearer, settledOrSuspended), req(id, DOC, 'precondition: the run suspends on the credential interrupt')).toBe('waiting-input');
+    const connect = String(((credentialRequest(await events(runId, r.bearer))?.payload?.['data'] ?? {}) as Record<string, unknown>)['connectUrl']);
+    const open = await userAgentGet(connect, r.bearer);
+    expect(open.location, req(id, DOC, `connectUrl redirects the initiating Subject to the provider (got ${open.status})`)).not.toBeNull();
+    const n = r.d.codeExchanges().length;
+    const cb = await consent(open.location!);
+    const done = await userAgentGet(cb!, r.bearer);
+    expect([done.status < 400, r.d.codeExchanges().length], req(id, DOC, `the production callback completes the grant with one token request (got ${done.status} ${done.text.slice(0, 200)})`)).toEqual([true, n + 1]);
+    const s = await settle(runId, r.bearer, (x) => x !== undefined && TERMINAL.has(x));
+    expect(s, req(id, DOC, `the host resolves the interrupt when the grant completes and the run continues to completion (got ${s})`)).toBe('completed');
+    const resolved = (await events(runId, r.bearer)).find((e) => e.type === 'interrupt.resolved');
+    expect(resolved?.payload?.['resumeValue'], req(id, 'RFC 0199 §C.4', 'interrupt.resolved records resumeValue { outcome: authorized }')).toEqual({ outcome: 'authorized' });
+  });
+
+  it('declined fails the node with connector_auth_declined', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    if (!r.facet) return softSkip('inapplicable', 'oauth.credentialInterrupt is not advertised');
+    const id = R('credential-declined');
+    const runId = await createRun(r.bearer);
+    expect(await settle(runId, r.bearer, settledOrSuspended), req(id, DOC, 'precondition: the run suspends on the credential interrupt')).toBe('waiting-input');
+    const dec = await resolve(runId, r.bearer, { outcome: 'declined' });
+    expect(dec.status, req(id, DOC, `a resolve of declined is accepted (got ${dec.status} ${dec.text.slice(0, 200)})`)).toBeLessThan(300);
+    const s = await settle(runId, r.bearer, (x) => x !== undefined && TERMINAL.has(x));
+    expect(s, req(id, DOC, 'declined fails the node, and the run')).toBe('failed');
+    const failed = (await events(runId, r.bearer)).find((e) => e.type === 'node.failed');
+    expect((failed?.payload?.['error'] as { code?: string } | undefined)?.code, req(id, `${DOC}; errors.json connector_auth_declined`, 'the node fails with connector_auth_declined')).toBe('connector_auth_declined');
+  });
+
+  it('a terminal refresh failure emits connector.auth-expired, then suspends with reason expired', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    if (!r.facet) return softSkip('inapplicable', 'oauth.credentialInterrupt is not advertised');
+    const id = R('credential-interrupt');
+    const got = await grant(r.d, r.bearer);
+    expect(got, req(id, DOC, `precondition: the Subject acquires a credential through the production grant (callback ${got})`)).toBeLessThan(400);
+    const exp = await driver.post(EXPIRE_REFRESH, { provider: PROVIDER }, auth(r.bearer));
+    if (exp.status === 404 || exp.status === 405) return seamAbsent('POST /conformance/seams/sample/oauth/expire-refresh is not mounted');
+    expect(exp.status, req(id, 'api/seams-v2.yaml expireOAuthAccessToken', `expire-refresh answers 204 (got ${exp.status})`)).toBe(204);
+    r.d.refreshRevoked = true;
+    try {
+      const refreshesBefore = r.d.tokenRequests.filter((t) => t.grantType === 'refresh_token').length;
+      const runId = await createRun(r.bearer);
+      const s = await settle(runId, r.bearer, settledOrSuspended);
+      expect(r.d.tokenRequests.filter((t) => t.grantType === 'refresh_token').length, req(id, 'oauth.md §Token lifecycle', 'the expired token is refreshed host-side at the provider (the double counts the refresh)')).toBeGreaterThan(refreshesBefore);
+      expect(s, req(id, DOC, `a terminal refresh failure MUST suspend the node instead of failing it (got ${s})`)).toBe('waiting-input');
+      const evs = await events(runId, r.bearer);
+      const expired = evs.findIndex((e) => e.type === 'connector.auth-expired');
+      const asked = evs.findIndex((e) => e.type === 'interrupt.requested' && e.payload?.['kind'] === 'credential');
+      expect(expired >= 0 && asked > expired, req(id, 'RFC 0199 §C.2(b)', `connector.auth-expired MUST precede the credential interrupt (indices ${expired}, ${asked})`)).toBe(true);
+      expect(((evs[asked]?.payload?.['data'] ?? {}) as Record<string, unknown>)['reason'], req(id, DOC, 'the interrupt carries reason expired')).toBe('expired');
+      await driver.post(`/runs/${encodeURIComponent(runId)}:cancel`, {}, auth(r.bearer));
+    } finally {
+      r.d.refreshRevoked = false;
+    }
+  });
+
+  it('without oauth.credentialInterrupt, a terminal refresh failure fails the node connector_auth_expired and raises no interrupt', async () => {
+    const r = await ready();
+    if (!r.ok) return r.skip();
+    if (r.facet) return softSkip('inapplicable', 'oauth.credentialInterrupt is advertised — the host suspends instead (the legs above)');
+    const id = R('refresh-failure-fails-node');
+    const got = await grant(r.d, r.bearer);
+    expect(got, req(id, DOC, `precondition: the Subject acquires a credential through the production grant (callback ${got})`)).toBeLessThan(400);
+    const exp = await driver.post(EXPIRE_REFRESH, { provider: PROVIDER }, auth(r.bearer));
+    if (exp.status === 404 || exp.status === 405) return seamAbsent('POST /conformance/seams/sample/oauth/expire-refresh is not mounted');
+    r.d.refreshRevoked = true;
+    try {
+      const runId = await createRun(r.bearer);
+      const s = await settle(runId, r.bearer, settledOrSuspended);
+      expect(s, req(id, 'oauth.md §Token lifecycle; RFC 0047 §C.3 (unchanged by RFC 0199 C1)', `without the facet a terminal refresh failure MUST fail the node (got ${s})`)).toBe('failed');
+      const evs = await events(runId, r.bearer);
+      expect(evs.some((e) => e.type === 'connector.auth-expired'), req(id, 'oauth.md §Token lifecycle', 'connector.auth-expired is emitted')).toBe(true);
+      expect(evs.some((e) => e.type === 'interrupt.requested'), req(id, 'RFC 0199 §C.1', 'a host that does not advertise the facet MUST NOT raise an interrupt')).toBe(false);
+      expect(((evs.find((e) => e.type === 'node.failed')?.payload?.['error']) as { code?: string } | undefined)?.code, req(id, 'oauth.md §Token lifecycle', 'the node fails with connector_auth_expired')).toBe('connector_auth_expired');
+    } finally {
+      r.d.refreshRevoked = false;
+    }
+  });
+});

package/src/scenarios/v2-effect-identity-business-key.test.ts

@@ -120,12 +120,12 @@ describe('RFC 0173 §B — effect-identity-business-key (gated on idempotency)',
     const keys = new Set(attempts.map((e) => String(e['providerKey'] ?? '')));
     expect(
       keys.size,
-      req('openwop.requirement.0173.effect-identity-business-key.retry', 'spec/v2/core/replay.md §Effect identity', `every attempt of one effect MUST present the same provider key across a transport retry — ${attempts.length} attempt(s) presented ${keys.size} distinct key(s)`),
+      req('openwop.requirement.0173.effect-identity-business-key.retry', 'spec/v2/core/idempotency.md §Layer 2: effect identity', `every attempt of one effect MUST present the same provider key across a transport retry — ${attempts.length} attempt(s) presented ${keys.size} distinct key(s)`),
     ).toBe(1);
     for (const a of attempts) {
       expect(
         a['keying'],
-        req('openwop.requirement.0173.effect-identity-business-key.retry', 'spec/v2/core/replay.md §Effect identity', `a Layer-2 host keys a retried effect on business identity, not the activity recipe (attempt ${String(a['attempt'])})`),
+        req('openwop.requirement.0173.effect-identity-business-key.retry', 'spec/v2/core/idempotency.md §Layer 2: effect identity', `a Layer-2 host keys a retried effect on business identity, not the activity recipe (attempt ${String(a['attempt'])})`),
       ).toBe('business-identity');
     }
   });

package/src/scenarios/v2-fork-a-v1-run.test.ts

@@ -8,7 +8,7 @@
  * output modulo clock fields and freshly minted ids), and `run.started` on the
  * fork MUST carry the legacy Subject (`issuer: urn:openwop:legacy`,
  * identity.md) where the parent had none (`spec/v2/core/replay.md` §Forking a
- * v1 run; persistence.md §Forking a v1 run; RFC 0170 §A.3).
+ * v1 run; RFC 0170 §A.3).
  *
  * The era-2 parent is seeded in v1 vocabulary with a `run.started` that
  * carries no `owner` (a v1 payload) through the event-log seed seam

package/src/scenarios/v2-implementation-informational.test.ts

@@ -0,0 +1,33 @@
+/**
+ * RFC 0208 §G — `implementation` gains an optional `url` (the operator's site:
+ * A2A `AgentProvider.url`, MCP `Implementation.websiteUrl`) and stays a closed
+ * object (`spec/v2/core/capabilities.md` §3.1). Target major 2; server-free —
+ * the leg validates against the packaged `schemas/v2/capabilities.schema.json`
+ * and never contacts a host.
+ *
+ * The §G SHOULD NOT ("a client SHOULD NOT change behaviour because of it or
+ * authorize from it") binds consumers and is not witnessable from a host; it is
+ * stated in the RFC's falsifiability table, not claimed here.
+ *
+ * @see spec/v2/core/capabilities.md §3.1
+ * @see RFCS/0208-v2-a2a-mcp-operation-mappings.md §G
+ */
+import { describe, it, expect } from 'vitest';
+import { v2Validator } from '../lib/v2.js';
+import { req } from '../lib/requirement-ids.js';
+
+export const HOST_CALLBACK_NOT_REQUIRED = 'server-free: validates documents against the packaged v2 capabilities schema';
+
+const ID = 'openwop.requirement.0208.implementation-shape';
+const DOC = 'spec/v2/core/capabilities.md §3.1 (RFC 0208 §G)';
+const ROOT = { protocolVersions: ['2.0'], preferredVersion: '2.0' };
+
+describe('RFC 0208 §G — v2-implementation-informational (server-free)', () => {
+  it('implementation accepts name, version, vendor and url, and still rejects an unknown key', () => {
+    const validate = v2Validator('capabilities');
+    const good = validate({ ...ROOT, implementation: { name: 'conformance', version: '1.0.0', vendor: 'openwop', url: 'https://example.org' } });
+    expect(good.ok, req(ID, DOC, `implementation.url (format uri) MUST validate beside name, version and vendor (${good.errors})`)).toBe(true);
+    expect(validate({ ...ROOT, implementation: { name: 'conformance', homepage: 'https://example.org' } }).ok, req(ID, DOC, 'implementation stays closed: an unknown key (homepage) MUST fail validation')).toBe(false);
+    expect(validate({ ...ROOT, implementation: { url: 'not a uri' } }).ok, req(ID, DOC, 'implementation.url is format uri: a non-URI MUST fail validation')).toBe(false);
+  });
+});