@openwop/openwop-conformance 2.45.3 → 2.45.5

package/src/lib/backpressure-witness.ts

@@ -0,0 +1,163 @@
+/**
+ * The backpressure witness, shared by every major (`major-profile.ts`).
+ *
+ * A host that advertises `production.backpressure.inflightCap` names a number
+ * the suite can saturate: `cap` long-lived requests hold the slots and the
+ * next request must be refused `503 service_unavailable` with `Retry-After`.
+ *
+ * Two halves, so each can be proven alone:
+ *   - {@link saturate} drives the host and returns what it saw (or why it
+ *     could not see anything). It asserts nothing.
+ *   - {@link judge} is pure: observation in, findings out. The scenario turns
+ *     findings into `expect` calls; the self-test feeds it a conforming and a
+ *     defective observation and checks the verdicts differ.
+ *
+ * Run with `--no-file-parallelism`: saturating the cap leaves no headroom for
+ * a neighbouring scenario's requests.
+ */
+
+import { driver, type OpenWOPResponse } from './driver.js';
+import { loadEnv } from './env.js';
+import { readErrorCode } from './error-envelope.js';
+import { isFixtureAdvertised } from './fixtures.js';
+import type { MajorProfile } from './major-profile.js';
+
+/** The long-running fixture that holds a slot, and the cheap one that probes. */
+export const HOLD_FIXTURE = 'conformance-delay';
+export const PROBE_FIXTURE = 'conformance-noop';
+/** Long enough that the first slot is still held when the last is filled; the runs are cancelled afterwards. */
+const HOLD_MS = 15_000;
+/** The most streams the suite will hold open. A larger advertised cap is not saturated. */
+export const MAX_SATURABLE_CAP = 64;
+const STREAM_OPEN_MS = 5_000;
+const RETRY_DETAIL_KEYS = ['retryAfter', 'retryAfterMs', 'retryAfterSeconds'] as const;
+
+export interface Refusal {
+  readonly cap: number;
+  readonly status: number;
+  readonly code: string | undefined;
+  readonly retryAfterHeader: string | null;
+  readonly details: Record<string, unknown> | null;
+  readonly advertisedRetryAfterSeconds: number | undefined;
+}
+export type Saturation =
+  | { readonly kind: 'skip'; readonly disposition: 'inapplicable' | 'blocked'; readonly reason: string }
+  | { readonly kind: 'refused'; readonly refusal: Refusal };
+
+export interface Finding {
+  /** Which rule the finding is about; the scenario maps it to a requirement id. */
+  readonly rule: 'refusal' | 'retry-after-advertised' | 'retry-timing';
+  readonly ok: boolean;
+  readonly doc: string;
+  readonly message: string;
+}
+
+const isRecord = (v: unknown): v is Record<string, unknown> => v !== null && typeof v === 'object' && !Array.isArray(v);
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> {
+  try { return await fn(); } catch { return null; }
+}
+
+/** Hold `cap` slots with long-lived event streams, send one more request, and report its answer. */
+export async function saturate(profile: MajorProfile, discovery: unknown): Promise<Saturation> {
+  const production = profile.family(discovery, 'production');
+  if (production === null) return { kind: 'skip', disposition: 'inapplicable', reason: 'the host does not advertise production' };
+  const bp = production['backpressure'];
+  if (!isRecord(bp)) return { kind: 'skip', disposition: 'inapplicable', reason: 'the host does not advertise production.backpressure' };
+  const cap = bp['inflightCap'];
+  if (typeof cap !== 'number' || !Number.isInteger(cap) || cap < 1) {
+    return { kind: 'skip', disposition: 'inapplicable', reason: 'the host does not advertise production.backpressure.inflightCap — there is no cap the suite can saturate' };
+  }
+  if (cap > MAX_SATURABLE_CAP) return { kind: 'skip', disposition: 'inapplicable', reason: `inflightCap ${cap} is above the ${MAX_SATURABLE_CAP} streams the suite will hold open — not saturated` };
+  for (const f of [HOLD_FIXTURE, PROBE_FIXTURE]) {
+    if (!isFixtureAdvertised(f)) return { kind: 'skip', disposition: 'inapplicable', reason: `${f} fixture not advertised — the suite cannot hold or probe a slot` };
+  }
+
+  const env = loadEnv();
+  const streams: AbortController[] = [];
+  const pending: Promise<number | null>[] = [];
+  const runIds: string[] = [];
+  try {
+    for (let i = 0; i < cap; i++) {
+      const created = await http(() => driver.post(profile.runsPath, { workflowId: HOLD_FIXTURE, inputs: { delayMs: HOLD_MS } }));
+      if (created === null) return { kind: 'skip', disposition: 'blocked', reason: `POST ${profile.runsPath} unreachable while filling slot ${i + 1} of ${cap}` };
+      const runId = (created.json as { runId?: unknown } | undefined)?.runId;
+      if (created.status !== 201 || typeof runId !== 'string') {
+        return { kind: 'skip', disposition: 'blocked', reason: `slot ${i + 1} of ${cap} could not be filled: POST ${profile.runsPath} answered ${created.status} ${readErrorCode(created.json) ?? ''} (already saturated by a parallel file? run with --no-file-parallelism)`.trim() };
+      }
+      runIds.push(runId);
+      const ctl = new AbortController();
+      streams.push(ctl);
+      // `Accept: text/event-stream` keeps the request in flight; without it a
+      // negotiating host answers a one-shot snapshot and the slot drops.
+      const stream = fetch(`${env.baseUrl}${profile.runsPath}/${encodeURIComponent(runId)}/events`, {
+        headers: { Authorization: `Bearer ${env.apiKey}`, Accept: 'text/event-stream', ...profile.versionHeaders },
+        signal: ctl.signal,
+      }).then((r) => r.status, () => null);
+      pending.push(stream);
+      // The slot is held once the stream's headers are back, not after a
+      // guessed delay. A probe sent before that would convict a host for a slot
+      // the suite had not yet taken.
+      const opened = await Promise.race([stream, new Promise<'slow'>((r) => setTimeout(() => r('slow'), STREAM_OPEN_MS))]);
+      if (opened !== 200) {
+        return { kind: 'skip', disposition: 'blocked', reason: `slot ${i + 1} of ${cap} was not held: the event stream ${opened === 'slow' ? `did not open within ${STREAM_OPEN_MS} ms` : opened === null ? 'failed to connect' : `answered ${opened}`}` };
+      }
+    }
+
+    const probe = await http(() => driver.post(profile.runsPath, { workflowId: PROBE_FIXTURE }));
+    if (probe === null) return { kind: 'skip', disposition: 'blocked', reason: `the cap+1 probe got no response (POST ${profile.runsPath})` };
+    const accepted = (probe.json as { runId?: unknown } | undefined)?.runId;
+    if (probe.status === 201 && typeof accepted === 'string') runIds.push(accepted);
+    const body = isRecord(probe.json) ? probe.json : {};
+    const advertised = bp['retryAfterSeconds'];
+    return {
+      kind: 'refused',
+      refusal: {
+        cap,
+        status: probe.status,
+        code: readErrorCode(probe.json) ?? undefined,
+        retryAfterHeader: probe.headers.get('retry-after'),
+        details: isRecord(body['details']) ? body['details'] : null,
+        advertisedRetryAfterSeconds: typeof advertised === 'number' ? advertised : undefined,
+      },
+    };
+  } finally {
+    // The held runs outlive their streams. Cancel them so the next file does
+    // not meet a saturated host.
+    for (const c of streams) c.abort();
+    if (runIds.length > 0) {
+      const bulk = await http(() => driver.post(`${profile.runsPath}:bulk-cancel`, { runIds }));
+      if (bulk === null || bulk.status >= 400) {
+        for (const id of runIds) await http(() => driver.post(`${profile.runsPath}/${encodeURIComponent(id)}/cancel`, {}));
+      }
+    }
+    await Promise.allSettled(pending);
+  }
+}
+
+/** What the refusal must look like at this major. Pure. */
+export function judge(profile: MajorProfile, r: Refusal): Finding[] {
+  const home = `${profile.specRoot}/${profile.major === 1 ? 'production-profile.md §Backpressure' : 'conformance.md §Production profile'}`;
+  const out: Finding[] = [];
+  out.push({ rule: 'refusal', ok: r.status === 503, doc: home, message: `with inflightCap ${r.cap} slots held, the next request MUST be refused 503 (got ${r.status})` });
+  out.push({ rule: 'refusal', ok: r.code === 'service_unavailable', doc: home, message: `the refusal MUST carry the code service_unavailable (got ${r.code ?? 'none'})` });
+  const header = (r.retryAfterHeader ?? '').trim();
+  out.push({ rule: 'refusal', ok: header.length > 0, doc: home, message: 'the 503 MUST set Retry-After' });
+
+  if (r.advertisedRetryAfterSeconds !== undefined) {
+    out.push({
+      rule: 'retry-after-advertised',
+      ok: /^\d+$/.test(header) && Number(header) === r.advertisedRetryAfterSeconds,
+      doc: 'capabilities.schema.json production.backpressure.retryAfterSeconds',
+      message: `Retry-After MUST equal the advertised retryAfterSeconds ${r.advertisedRetryAfterSeconds} (got "${header}")`,
+    });
+  }
+
+  if (profile.retryTiming === 'header-only') {
+    const spelled = RETRY_DETAIL_KEYS.filter((k) => r.details !== null && k in r.details);
+    out.push({ rule: 'retry-timing', ok: spelled.length === 0, doc: `${profile.specRoot}/errors.md §Retry timing`, message: `retry timing lives in the Retry-After header only; details MUST NOT carry ${spelled.join(', ') || 'retryAfter*'}` });
+  } else {
+    const d = r.details?.['retryAfter'];
+    out.push({ rule: 'retry-timing', ok: typeof d === 'number' && /^\d+$/.test(header) && d === Number(header), doc: home, message: 'details.retryAfter MUST be numeric and equal the Retry-After header in seconds' });
+  }
+  return out;
+}

package/src/lib/budget-witness.ts

@@ -0,0 +1,165 @@
+/**
+ * The run-budget witness, shared by every major that gives a budget a run wire
+ * surface (`major-profile.ts` `runBudget`).
+ *
+ * Unaided: the suite creates a run of `conformance-budget-tool-calls` (three
+ * scripted tool calls, no model, no seam) with a two-call budget, waits for it
+ * to end, and reads its event log through the poll.
+ *
+ * Two halves, as in `backpressure-witness.ts`: {@link drive} observes and
+ * asserts nothing; {@link judge} is pure.
+ *
+ * The fixture is the opt-in. A host that advertises `budget` without seeding it
+ * records `inapplicable`: the family is then unwitnessed at this major, which
+ * the coverage report shows, and the host is not denied certification for a
+ * fixture it was never asked to seed.
+ */
+
+import { driver, type OpenWOPResponse } from './driver.js';
+import { readErrorCode } from './error-envelope.js';
+import { isFixtureAdvertised } from './fixtures.js';
+import type { MajorProfile } from './major-profile.js';
+
+export const BUDGET_FIXTURE = 'conformance-budget-tool-calls';
+/** The fixture makes 3 calls: 50% is crossed on the first, and the budget cannot cover the third. */
+export const BUDGET_POLICY = { maxToolCalls: 2, thresholdPercent: 50, onExhaustion: 'fail' } as const;
+const DIMENSION = 'toolCalls';
+const CAP_KIND = 'budget-tool-calls';
+/** Keys a `budget.*` or `cap.breached` payload must never carry (`budget-no-pricing-leak`). */
+export const PRICING_KEYS = ['pricing', 'priceTable', 'prices', 'rate', 'rates', 'unitPrice', 'costModel', 'tokenPrice', 'secret', 'apiKey'] as const;
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+
+export interface RunEvent { readonly type: string; readonly sequence: number; readonly payload: Record<string, unknown> }
+export interface BudgetObservation {
+  readonly enforce: 'hard' | 'advisory' | undefined;
+  readonly status: string;
+  readonly errorCode: string | undefined;
+  readonly events: readonly RunEvent[];
+  /** This major's names for the four events the witness reads. */
+  readonly names: { readonly reserved: string; readonly threshold: string; readonly exhausted: string; readonly capBreached: string };
+}
+export type BudgetRun =
+  | { readonly kind: 'skip'; readonly disposition: 'inapplicable' | 'blocked'; readonly reason: string }
+  | { readonly kind: 'refused'; readonly status: number; readonly code: string | undefined }
+  | { readonly kind: 'observed'; readonly observation: BudgetObservation };
+
+export interface Finding {
+  readonly rule: 'create' | 'lifecycle' | 'hard-stop' | 'advisory' | 'content-free';
+  readonly ok: boolean;
+  readonly doc: string;
+  readonly message: string;
+}
+
+const isRecord = (v: unknown): v is Record<string, unknown> => v !== null && typeof v === 'object' && !Array.isArray(v);
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> {
+  try { return await fn(); } catch { return null; }
+}
+
+async function readEvents(profile: MajorProfile, runId: string): Promise<RunEvent[] | null> {
+  const out: RunEvent[] = [];
+  let after = 0;
+  for (let page = 0; page < 50; page++) {
+    const res = await http(() => driver.get(`${profile.runsPath}/${encodeURIComponent(runId)}/events/poll?timeout=1&afterSequence=${after}`));
+    if (res === null || res.status !== 200) return page === 0 ? null : out;
+    const batch = (res.json as { events?: unknown } | undefined)?.events;
+    if (!Array.isArray(batch) || batch.length === 0) return out;
+    for (const e of batch) {
+      if (!isRecord(e) || typeof e['type'] !== 'string' || typeof e['sequence'] !== 'number') continue;
+      out.push({ type: e['type'], sequence: e['sequence'], payload: isRecord(e['payload']) ? e['payload'] : {} });
+      after = Math.max(after, e['sequence']);
+    }
+  }
+  return out;
+}
+
+/** Create the budgeted run, wait for it to end, and return its log. */
+export async function drive(profile: MajorProfile, discovery: unknown, timeoutMs = 20_000): Promise<BudgetRun> {
+  const family = profile.family(discovery, 'budget');
+  if (family === null) return { kind: 'skip', disposition: 'inapplicable', reason: 'the host does not advertise budget' };
+  const fragment = profile.runBudget(BUDGET_POLICY);
+  if (fragment === null) return { kind: 'skip', disposition: 'inapplicable', reason: `major ${profile.major} gives a run budget no createRun surface` };
+  const dims = family['dimensions'];
+  if (!Array.isArray(dims) || !dims.includes(DIMENSION)) return { kind: 'skip', disposition: 'inapplicable', reason: `budget.dimensions does not list ${DIMENSION} — the host does not enforce the dimension this witness spends` };
+  if (!isFixtureAdvertised(BUDGET_FIXTURE)) return { kind: 'skip', disposition: 'inapplicable', reason: `${BUDGET_FIXTURE} fixture not advertised — the host has not opted in to the unaided budget witness` };
+
+  const names = {
+    reserved: profile.eventType('budget.reserved'),
+    threshold: profile.eventType('budget.threshold.crossed'),
+    exhausted: profile.eventType('budget.exhausted'),
+    capBreached: profile.eventType('cap.breached'),
+  };
+  if (names.reserved === undefined || names.threshold === undefined || names.exhausted === undefined || names.capBreached === undefined) {
+    return { kind: 'skip', disposition: 'blocked', reason: `the event name map for major ${profile.major} is not on disk in this layout — the witness will not guess event names` };
+  }
+
+  const created = await http(() => driver.post(profile.runsPath, { workflowId: BUDGET_FIXTURE, ...fragment }));
+  if (created === null) return { kind: 'skip', disposition: 'blocked', reason: `POST ${profile.runsPath} unreachable (fetch failed)` };
+  if (created.status === 429) return { kind: 'skip', disposition: 'blocked', reason: `POST ${profile.runsPath} answered 429 — the run budget of the host, not the wire` };
+  const runId = (created.json as { runId?: unknown } | undefined)?.runId;
+  if (created.status !== 201 || typeof runId !== 'string') return { kind: 'refused', status: created.status, code: readErrorCode(created.json) ?? undefined };
+
+  const deadline = Date.now() + timeoutMs;
+  let snap: Record<string, unknown> | null = null;
+  for (;;) {
+    const res = await http(() => driver.get(`${profile.runsPath}/${encodeURIComponent(runId)}`));
+    snap = res?.status === 200 && isRecord(res.json) ? res.json : null;
+    if (snap !== null && TERMINAL.has(String(snap['status']))) break;
+    if (Date.now() > deadline) {
+      await http(() => driver.post(`${profile.runsPath}/${encodeURIComponent(runId)}/cancel`, {}));
+      return { kind: 'skip', disposition: 'blocked', reason: `the budgeted run did not reach a terminal status within ${timeoutMs} ms (last: ${snap === null ? 'unreadable' : String(snap['status'])})` };
+    }
+    await new Promise((r) => setTimeout(r, 250));
+  }
+  const events = await readEvents(profile, runId);
+  if (events === null) return { kind: 'skip', disposition: 'blocked', reason: `GET ${profile.runsPath}/{runId}/events/poll unreadable — the run ended but its log could not be read` };
+
+  const enforce = family['enforce'];
+  const error = snap['error'];
+  return {
+    kind: 'observed',
+    observation: {
+      enforce: enforce === 'hard' || enforce === 'advisory' ? enforce : undefined,
+      status: String(snap['status']),
+      errorCode: isRecord(error) && typeof error['code'] === 'string' ? error['code'] : undefined,
+      events,
+      names: names as BudgetObservation['names'],
+    },
+  };
+}
+
+/** What the log must show at this major. Pure. */
+export function judge(profile: MajorProfile, o: BudgetObservation): Finding[] {
+  const home = `${profile.specRoot}/runs.md §budget section`;
+  const first = (type: string): RunEvent | undefined => o.events.find((e) => e.type === type);
+  const reserved = first(o.names.reserved);
+  const threshold = first(o.names.threshold);
+  const exhausted = first(o.names.exhausted);
+  const breach = o.events.find((e) => e.type === o.names.capBreached && typeof e.payload['kind'] === 'string' && (e.payload['kind'] as string).startsWith('budget-'));
+  const out: Finding[] = [];
+
+  out.push({ rule: 'lifecycle', ok: reserved !== undefined, doc: home, message: `a budgeted run MUST emit ${o.names.reserved}` });
+  out.push({ rule: 'lifecycle', ok: threshold !== undefined && typeof threshold.payload['percent'] === 'number', doc: home, message: `spending past thresholdPercent MUST emit ${o.names.threshold} with a numeric percent` });
+  out.push({ rule: 'lifecycle', ok: exhausted !== undefined, doc: home, message: `a budget that cannot cover the run MUST emit ${o.names.exhausted}` });
+  if (reserved !== undefined && threshold !== undefined && exhausted !== undefined) {
+    out.push({ rule: 'lifecycle', ok: reserved.sequence < threshold.sequence && threshold.sequence < exhausted.sequence, doc: home, message: `the log MUST order ${o.names.reserved} < ${o.names.threshold} < ${o.names.exhausted}` });
+  }
+
+  if (o.enforce === 'hard') {
+    out.push({ rule: 'hard-stop', ok: breach !== undefined && breach.payload['kind'] === CAP_KIND, doc: home, message: `hard exhaustion under onExhaustion: fail MUST emit ${o.names.capBreached} with kind ${CAP_KIND} (got ${breach === undefined ? 'none' : String(breach.payload['kind'])})` });
+    if (breach !== undefined && exhausted !== undefined) {
+      out.push({ rule: 'hard-stop', ok: exhausted.sequence <= breach.sequence, doc: home, message: `${o.names.capBreached} MUST NOT precede ${o.names.exhausted}` });
+    }
+    out.push({ rule: 'hard-stop', ok: o.status === 'failed' && o.errorCode === 'budget_exhausted', doc: home, message: `hard exhaustion MUST fail the run budget_exhausted (got ${o.status} ${o.errorCode ?? ''})`.trim() });
+  }
+  if (o.enforce === 'advisory') {
+    out.push({ rule: 'advisory', ok: breach === undefined && o.errorCode !== 'budget_exhausted', doc: home, message: 'an advisory host MUST NOT stop the run' });
+  }
+
+  const leaks: string[] = [];
+  for (const e of o.events) {
+    if (!e.type.startsWith('budget.') && e !== breach) continue;
+    for (const k of PRICING_KEYS) if (k in e.payload) leaks.push(`${e.type}.${k}`);
+  }
+  out.push({ rule: 'content-free', ok: leaks.length === 0, doc: home, message: `budget.* and cap.breached MUST NOT carry rate cards, unit prices or credentials (found ${leaks.join(', ') || 'none'})` });
+  return out;
+}

package/src/lib/major-profile.ts

@@ -0,0 +1,93 @@
+/**
+ * What differs between protocol majors, as data.
+ *
+ * A scenario that is "the same requirement at another major" used to be a
+ * copy of the earlier file with the paths, event names and envelope rules
+ * edited by hand. The differences are few and regular, so they live in one
+ * table here. A shared witness (`backpressure-witness.ts`) takes a profile and
+ * never names a major; the scenario file for each major is a thin wrapper.
+ *
+ * **Adding a major** is one row in {@link MAJOR_PROFILES} plus one thin
+ * scenario file per ported witness. `majorProfile()` throws on a major with no
+ * row, so a missing row is a loud failure and never a silent fall back to an
+ * older major's rules.
+ *
+ * Keep a field here only when a shared witness reads it. A rule one major
+ * states and another does not is not a field: the witness asks the profile
+ * whether the rule binds (see `retryTiming`), and cites the document that
+ * states it.
+ */
+
+import { capabilityFamily } from './discovery-capabilities.js';
+import { codemapV1toV2 } from './era2-seed.js';
+
+export interface MajorProfile {
+  readonly major: number;
+  /** The run collection, e.g. `/v1/runs` or `/runs`. */
+  readonly runsPath: string;
+  /** Headers a raw `fetch` must add to speak this major (the driver adds its own). */
+  readonly versionHeaders: Readonly<Record<string, string>>;
+  /** Where the corpus states this major's rules, for requirement citations. */
+  readonly specRoot: string;
+  /**
+   * Where retry timing lives on an error response. `header-and-details`: the
+   * envelope repeats `Retry-After` in `details.retryAfter`. `header-only`: the
+   * header is the only place, and `details.retryAfter*` is forbidden.
+   */
+  readonly retryTiming: 'header-and-details' | 'header-only';
+  /** The advertised record for a capability family, or `null` when the host does not advertise it. */
+  family(doc: unknown, key: string): Record<string, unknown> | null;
+  /**
+   * The `createRun` body fragment that carries a run budget policy, or `null`
+   * when this major has no run wire surface for one (a witness that needs it
+   * is then `inapplicable` at this major).
+   */
+  runBudget(policy: Readonly<Record<string, unknown>>): Record<string, unknown> | null;
+  /**
+   * This major's name for an event, given its era-1 name. `undefined` when the
+   * mapping is not on disk in this layout: the caller records that as an
+   * unread observation and never guesses a name.
+   */
+  eventType(era1Name: string): string | undefined;
+}
+
+const isRecord = (v: unknown): v is Record<string, unknown> => v !== null && typeof v === 'object' && !Array.isArray(v);
+
+export const MAJOR_PROFILES: Readonly<Record<number, MajorProfile>> = {
+  1: {
+    major: 1,
+    runsPath: '/v1/runs',
+    versionHeaders: {},
+    specRoot: 'spec/v1',
+    retryTiming: 'header-and-details',
+    // v1: a family is advertised when its record says `supported: true`.
+    family: (doc, key) => {
+      const rec = capabilityFamily(doc, key);
+      return isRecord(rec) && rec['supported'] === true ? rec : null;
+    },
+    // v1 budgets are driven through a host seam, not `createRun`.
+    runBudget: () => null,
+    eventType: (era1Name) => era1Name,
+  },
+  2: {
+    major: 2,
+    runsPath: '/runs',
+    versionHeaders: { 'OpenWOP-Version': '2.0' },
+    specRoot: 'spec/v2/core',
+    retryTiming: 'header-only',
+    // v2: presence of the record is the advertisement.
+    family: (doc, key) => {
+      const rec = isRecord(doc) ? doc[key] : undefined;
+      return isRecord(rec) ? rec : null;
+    },
+    runBudget: (policy) => ({ configurable: { version: 1, budget: { ...policy } } }),
+    eventType: (era1Name) => codemapV1toV2().get(era1Name),
+  },
+};
+
+/** The profile for a major. Throws when the table has no row for it. */
+export function majorProfile(major: number): MajorProfile {
+  const p = MAJOR_PROFILES[major];
+  if (p === undefined) throw new Error(`no MajorProfile for major ${major} — add a row to MAJOR_PROFILES in lib/major-profile.ts`);
+  return p;
+}

package/src/lib/scenario-disposition.ts

@@ -27,7 +27,7 @@
  */
 
 import { scenarioFileOfItId } from './requirement-ids.js';
-import { PROFILE_FLOOR_SCENARIOS, floorMemberFiles } from './profiles.js';
+import { DEPRECATED_PROFILE_ALIASES, PROFILE_FLOOR_SCENARIOS, floorMemberFiles } from './profiles.js';
 import { targetMajor } from './seams.js';
 import { PKG_ROOT_PATH } from './paths.js';
 import { v2ProfileFloorFiles } from './requirement-registry.js';
@@ -450,8 +450,17 @@ export function deriveRequirementDispositions(
   // `openwop.floor.any.interrupt-` row recorded `blocked` ("no interrupt-*
   // scenario ran"), which by RFC 0168 §E.1 denied certification to every
   // profile on every major-2 bundle. The fifth unjoined floor site.
+  //
+  // Only for a CLAIMED profile's floor (2.45.5), as the any-of rows below have
+  // been since 2.45.4, and for the same reason: a floor nobody claims is not a
+  // requirement on this host, and its summary row is `blocked` whenever no
+  // matching file passed. A major-1 host that does not claim
+  // `openwop-interrupts` got an `openwop.floor.any.interrupt-` row it could
+  // only satisfy by passing a scenario of a profile it never claimed, and a v3
+  // bundle with any `blocked` row certifies nothing (RFC 0168 §E.1).
+  const claimed = new Set(claimedProfiles.map((p) => DEPRECATED_PROFILE_ALIASES[p] ?? p));
   const prefixIds = new Set<string>();
-  if (!v2FloorsActive()) for (const floor of Object.values(PROFILE_FLOOR_SCENARIOS)) for (const p of floor.requiredAnyPrefix ?? []) prefixIds.add(p);
+  if (!v2FloorsActive()) for (const [profile, floor] of Object.entries(PROFILE_FLOOR_SCENARIOS)) if (claimed.has(profile)) for (const p of floor.requiredAnyPrefix ?? []) prefixIds.add(p);
   for (const prefix of [...prefixIds].sort()) {
     const matching = [...perFile.entries()].filter(([f]) => f.startsWith(prefix)).map(([, r]) => r);
     const id = requirementIdForPrefix(prefix);
@@ -478,7 +487,15 @@ export function deriveRequirementDispositions(
   // no member failing; `inapplicable`/`skipped` members never satisfy it. v1
   // hand table only, like the prefix groups (the major-2 floors have none).
   const groups = new Map<string, readonly string[]>();
-  if (!v2FloorsActive()) for (const floor of Object.values(PROFILE_FLOOR_SCENARIOS)) for (const g of floor.requiredAnyOf ?? []) groups.set(requirementIdForAnyOf(g), g);
+  //
+  // Only for a CLAIMED profile's floor (2.45.4). The row is `blocked` when no
+  // member was witnessed, and a v1 floor reads `inapplicable` as certifiable, so
+  // the row cannot simply say `inapplicable`. But 2.45.3 wrote it for every
+  // floor in the table: a host that does not advertise secrets records both
+  // members `inapplicable`, got one `blocked` row for a profile it never
+  // claimed, and a bundle with any `blocked` row certifies nothing (RFC 0168
+  // §E.1). A group nobody claims is not a requirement on this host.
+  if (!v2FloorsActive()) for (const [profile, floor] of Object.entries(PROFILE_FLOOR_SCENARIOS)) if (claimed.has(profile)) for (const g of floor.requiredAnyOf ?? []) groups.set(requirementIdForAnyOf(g), g);
   for (const [id, members] of [...groups.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
     const scenarioId = `anyof:${members.join('|')}`;
     const matching = members.map((f) => perFile.get(f)).filter((r): r is DerivedRequirement => r !== undefined);

package/src/lib/scratch-host.ts

@@ -0,0 +1,130 @@
+/**
+ * A scratch host: the smallest HTTP server a shared witness can be proven
+ * against, in both directions, inside the suite's own self-tests.
+ *
+ * Some families are advertised by no reference host, so a new witness for them
+ * cannot be sabotage-proved against a real one. A witness that was never seen
+ * to fail is not a witness. The scratch host serves a discovery document and a
+ * scripted run surface, and each self-test turns on ONE defect to show the
+ * witness convicts it.
+ *
+ * It is a test double, not a host: it executes nothing, and nothing it does is
+ * evidence about any implementation. It takes a {@link MajorProfile}, so the
+ * same double proves the next major's port.
+ */
+
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import type { MajorProfile } from './major-profile.js';
+
+export interface ScriptedEvent { readonly type: string; readonly payload?: Record<string, unknown> | undefined }
+export interface ScriptedRun {
+  readonly status: 'completed' | 'failed' | 'running';
+  readonly error?: { readonly code: string; readonly message: string };
+  readonly events: readonly ScriptedEvent[];
+}
+export interface ScratchRefusal {
+  readonly status: number;
+  readonly headers?: Readonly<Record<string, string>>;
+  readonly body: Record<string, unknown>;
+}
+export interface ScratchOptions {
+  readonly profile: MajorProfile;
+  /** The discovery document, served as given. */
+  readonly discovery: Readonly<Record<string, unknown>>;
+  /** What a created run looks like, by workflowId and request body. Default: an empty running run. */
+  readonly script?: ((workflowId: string, body: Readonly<Record<string, unknown>>) => ScriptedRun) | undefined;
+  /** Concurrent in-flight requests admitted before {@link refusal} answers. Unset: no cap. */
+  readonly inflightCap?: number | undefined;
+  readonly refusal?: ScratchRefusal | undefined;
+}
+
+interface StoredRun { readonly id: string; run: ScriptedRun }
+
+export class ScratchHost {
+  private server: Server | undefined;
+  private readonly runs = new Map<string, StoredRun>();
+  private inflight = 0;
+  private seq = 0;
+  url = '';
+
+  constructor(private opts: ScratchOptions) {}
+
+  /** Swap behaviour between cases. The address stays the same, since the driver caches its base URL per file. */
+  reconfigure(next: Partial<ScratchOptions>): void {
+    this.opts = { ...this.opts, ...next };
+    this.runs.clear();
+  }
+
+  async start(): Promise<string> {
+    this.server = createServer((req, res) => { void this.handle(req, res); });
+    await new Promise<void>((r) => this.server!.listen(0, '127.0.0.1', r));
+    this.url = `http://127.0.0.1:${(this.server.address() as AddressInfo).port}`;
+    return this.url;
+  }
+
+  async stop(): Promise<void> {
+    const s = this.server;
+    if (s === undefined) return;
+    s.closeAllConnections();
+    await new Promise<void>((r) => s.close(() => r()));
+  }
+
+  private send(res: ServerResponse, status: number, body: unknown, headers: Readonly<Record<string, string>> = {}): void {
+    res.writeHead(status, { 'content-type': 'application/json', ...headers });
+    res.end(JSON.stringify(body));
+  }
+
+  private async body(req: IncomingMessage): Promise<Record<string, unknown>> {
+    const chunks: Buffer[] = [];
+    for await (const c of req) chunks.push(c as Buffer);
+    try {
+      const v: unknown = JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}');
+      return v !== null && typeof v === 'object' && !Array.isArray(v) ? (v as Record<string, unknown>) : {};
+    } catch { return {}; }
+  }
+
+  private async handle(req: IncomingMessage, res: ServerResponse): Promise<void> {
+    const path = (req.url ?? '/').split('?')[0] ?? '/';
+    const runs = this.opts.profile.runsPath;
+    // Discovery is never counted against the cap.
+    if (req.method === 'GET' && path === '/.well-known/openwop') return this.send(res, 200, this.opts.discovery);
+
+    const cap = this.opts.inflightCap;
+    if (cap !== undefined && this.inflight >= cap) {
+      const r = this.opts.refusal ?? { status: 503, headers: { 'retry-after': '1' }, body: { error: 'service_unavailable', message: 'at capacity' } };
+      return this.send(res, r.status, r.body, r.headers);
+    }
+    this.inflight++;
+    res.on('close', () => { this.inflight--; });
+
+    if (req.method === 'POST' && path === runs) {
+      const body = await this.body(req);
+      const workflowId = String(body['workflowId'] ?? '');
+      const id = `scratch/run-${++this.seq}`;
+      this.runs.set(id, { id, run: this.opts.script?.(workflowId, body) ?? { status: 'running', events: [] } });
+      return this.send(res, 201, { runId: id, status: 'running' });
+    }
+    if (req.method === 'POST' && path === `${runs}:bulk-cancel`) return this.send(res, 200, { results: [] });
+
+    const m = new RegExp(`^${runs}/([^/]+)(/events/poll|/events|/cancel)?$`).exec(path);
+    const stored = m ? this.runs.get(decodeURIComponent(m[1] as string)) : undefined;
+    if (!m || stored === undefined) return this.send(res, 404, { error: 'not_found', message: 'no such route or run' });
+    const tail = m[2];
+    if (tail === '/cancel') return this.send(res, 200, { status: 'cancelled' });
+    if (tail === '/events') {
+      // Held open until the client aborts: this is what occupies a slot.
+      res.writeHead(200, { 'content-type': 'text/event-stream' });
+      res.write(': held\n\n');
+      return;
+    }
+    if (tail === '/events/poll') {
+      const after = Number(new URL(req.url ?? '/', 'http://x').searchParams.get('afterSequence') ?? '0');
+      const events = stored.run.events
+        .map((e, i) => ({ eventId: `e${i + 1}`, runId: stored.id, type: e.type, payload: e.payload ?? {}, sequence: i + 1, schemaVersion: 2, timestamp: new Date(0).toISOString() }))
+        .filter((e) => e.sequence > after);
+      return this.send(res, 200, { events });
+    }
+    return this.send(res, 200, { runId: stored.id, workflowId: 'scratch', status: stored.run.status, ...(stored.run.error === undefined ? {} : { error: stored.run.error }) });
+  }
+}

package/src/scenarios/runner-ledger.test.ts

@@ -135,12 +135,9 @@ describe('RFC 0148 §A (S6) — the runner derivation', () => {
       expect(p.disposition).toBe('executed-pass');
       expect(p.scenarioId).toBe(`${prefix}*`);
     }
-    // An any-of group belongs to its own profile's floor (RFC 0229 §E). None of
-    // its members is in this synthetic report, so its summary row is honestly
-    // `blocked`, and it is not one of the requirements this floor certifies on.
-    const foreignAnyOf = d.requirements.filter((r) => r.scenarioId.startsWith('anyof:') && !(floor.requiredAnyOf ?? []).some((g) => g.join('|') === r.scenarioId.slice('anyof:'.length)));
-    for (const r of foreignAnyOf) expect(r.disposition, r.requirementId).toBe('blocked');
-    expect(d.totals.executedPass).toBe(d.requirements.length - foreignAnyOf.length);
+    // An any-of group's summary row is written only for a claimed profile's floor
+    // (2.45.4), so this floor's rows are all there is and every one passed.
+    expect(d.totals.executedPass).toBe(d.requirements.length);
   });
 
   it('a floor file that vitest passed but that recorded NOTHING is unclassified when a ledger exists — silence is not a witness', () => {