@openwop/openwop-conformance 2.42.8 → 2.43.0

package/src/scenarios/audit-log-integrity.test.ts

@@ -1,11 +1,24 @@
 /**
- * Track 13: audit-log integrity profile (auth-profiles.md v1.1).
+ * Track 13: audit-log integrity profile (auth-profiles.md v1.1), and at major 2
+ * the `auditLogIntegrity` family (RFC 0224, spec/v2/core/security-defaults.md
+ * §Audit-log integrity).
  *
- * Verifies that hosts claiming the `openwop-audit-log-integrity` profile:
- *   1. Surface `capabilities.auth.auditLogIntegrity.hashChain: true`.
- *   2. Expose `GET /v1/audit/verify` which returns `{chainValid, checkpoints, anomalies}`.
+ * Verifies that hosts claiming audit-log integrity:
+ *   1. Advertise the facets a verifier needs — at major 1
+ *      `capabilities.auth.auditLogIntegrity.hashChain: true` plus the key; at
+ *      major 2 a record that validates against the generated family schema,
+ *      whose `checkpointPublicKey` is an Ed25519 SPKI key.
+ *   2. Expose `GET /v1/audit/verify` (major 2: `GET /audit/verify`) which
+ *      returns `{chainValid, checkpoints, anomalies}`.
  *   3. Report `chainValid: true` for an unmodified range.
  *   4. Surface at least one signed checkpoint with a non-empty `signature`.
+ *   5. List checkpoints ascending, no more than `checkpointIntervalEntries`
+ *      apart (RFC 0224 §A.3). A host that omits a checkpoint from the verify
+ *      body leaves a gap the advertised cadence forbids.
+ *
+ * Major 1 gates through behaviorGate (strict mode fails an unadvertised
+ * profile). Major 2 records `inapplicable` before any assertion when the
+ * family is absent — presence of the record is the claim.
  *
  * Tamper detection (mutating an entry then asserting `chainValid: false`)
  * requires admin access to the host's audit store and is NOT exercised
@@ -13,14 +26,18 @@
  * test for tamper detection — see auth-profiles.md.
  *
  * @see spec/v1/auth-profiles.md §"Audit-log integrity"
+ * @see spec/v2/core/security-defaults.md §"Audit-log integrity"
  */
 
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
-import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { req } from '../lib/requirement-ids.js';
 import { softSkip } from '../lib/soft-skip.js';
+import { targetMajor } from '../lib/seams.js';
+import { v2RefValidator, v2Validator } from '../lib/v2.js';
+import { checkpointPublicKey } from '../lib/audit-checkpoint.js';
+import { AUDIT_PROFILE, auditClaimName, auditIntegrityAdvert, auditVerifyPath, type AuditIntegrityCaps } from '../lib/auditIntegrity.js';
 import Ajv2020 from 'ajv/dist/2020.js';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
@@ -31,67 +48,77 @@ import { SCHEMAS_DIR } from '../lib/paths.js';
  * is enforced. (Until 2026-09-27 the suite stripped them because the reference
  * postgres/sqlite hosts emitted a per-checkpoint `verified` bit the schema does
  * not name; the hosts now keep that bit host-internal. The aggregate verdict is
- * the schema's OPTIONAL `checkpointsValid`.)
+ * the schema's OPTIONAL `checkpointsValid`.) Major 2 validates against the v2 copy.
  */
 const VERIFY_RESULT_SCHEMA = JSON.parse(
   readFileSync(join(SCHEMAS_DIR, 'audit-verify-result.schema.json'), 'utf8'),
 ) as Record<string, unknown>;
 
-interface AuditIntegrityCaps {
-  hashChain?: boolean;
-  checkpointSignatureAlgorithm?: string;
-  checkpointPublicKey?: string;
-  checkpointIntervalEntries?: number;
-  checkpointIntervalSeconds?: number;
-}
+const CADENCE = 'openwop.requirement.0224.checkpoint-cadence';
 
-interface AuthCaps {
-  profiles?: string[];
-  auditLogIntegrity?: AuditIntegrityCaps;
+/**
+ * The gate, per major. Major 1: behaviorGate on the profile (unchanged). Major 2:
+ * the family record or null. A null is recorded `inapplicable` by the caller
+ * before any assertion (`unclaimed()`).
+ */
+async function gate(): Promise<AuditIntegrityCaps | null> {
+  const caps = await auditIntegrityAdvert();
+  if (targetMajor() === 2) return caps;
+  return behaviorGate(AUDIT_PROFILE, caps !== null) ? caps : null;
 }
 
-async function isProfileAdvertised(): Promise<boolean> {
-  const disco = await driver.get('/.well-known/openwop');
-  const auth = capabilityFamily<AuthCaps>(disco.json, 'auth') ?? {};
-  return Array.isArray(auth.profiles) && auth.profiles.includes('openwop-audit-log-integrity');
+const unclaimed = (): undefined => softSkip('inapplicable', `the host does not claim ${auditClaimName()} at major ${targetMajor()}`);
+
+function validateVerifyBody(body: unknown): { ok: boolean; errors: string } {
+  if (targetMajor() === 2) return v2Validator('audit-verify-result')(body);
+  const validate = new Ajv2020({ strict: false, allErrors: true }).compile(VERIFY_RESULT_SCHEMA);
+  const ok = validate(body) as boolean;
+  return { ok, errors: JSON.stringify(validate.errors ?? []) };
 }
 
 describe('audit-log-integrity: profile shape', () => {
   it('host that claims the profile advertises required capability fields', async () => {
-    if (!behaviorGate('openwop-audit-log-integrity', await isProfileAdvertised())) {
-      return;
-    }
-
-    const disco = await driver.get('/.well-known/openwop');
-    const integrity =
-      capabilityFamily<AuthCaps>(disco.json, 'auth')
-        ?.auditLogIntegrity ?? {};
+    const integrity = await gate();
+    if (integrity === null) return unclaimed();
 
-    expect(integrity.hashChain, req('openwop.it.audit-log-integrity.host-that-claims-the-profile-advertises-required-capability-fields', 
-      'auth-profiles.md §"Audit-log integrity"',
-      "openwop-audit-log-integrity profile MUST advertise auditLogIntegrity.hashChain: true",
-    )).toBe(true);
-    expect(integrity.checkpointSignatureAlgorithm, req('openwop.it.audit-log-integrity.host-that-claims-the-profile-advertises-required-capability-fields', 
-      'auth-profiles.md §"Audit-log integrity" §"Key management"',
-      'checkpointSignatureAlgorithm MUST be present (canonical: ed25519)',
-    )).toBeDefined();
-    expect(typeof integrity.checkpointPublicKey).toBe('string');
+    if (targetMajor() === 2) {
+      const shape = v2RefValidator('capabilities.schema.json#/properties/auditLogIntegrity')(integrity);
+      expect(shape.ok, req('openwop.it.audit-log-integrity.host-that-claims-the-profile-advertises-required-capability-fields',
+        'security-defaults.md §"Audit-log integrity"',
+        `the auditLogIntegrity record MUST validate against the generated family schema: ${shape.errors}`,
+      )).toBe(true);
+      let keyOk = true;
+      try { checkpointPublicKey(String(integrity.checkpointPublicKey ?? '')); } catch { keyOk = false; }
+      expect(keyOk, req('openwop.it.audit-log-integrity.host-that-claims-the-profile-advertises-required-capability-fields',
+        'security-defaults.md §"Audit-log integrity"',
+        'auditLogIntegrity.checkpointPublicKey MUST be an Ed25519 SubjectPublicKeyInfo, base64',
+      )).toBe(true);
+    } else {
+      expect(integrity.hashChain, req('openwop.it.audit-log-integrity.host-that-claims-the-profile-advertises-required-capability-fields',
+        'auth-profiles.md §"Audit-log integrity"',
+        "openwop-audit-log-integrity profile MUST advertise auditLogIntegrity.hashChain: true",
+      )).toBe(true);
+      expect(integrity.checkpointSignatureAlgorithm, req('openwop.it.audit-log-integrity.host-that-claims-the-profile-advertises-required-capability-fields',
+        'auth-profiles.md §"Audit-log integrity" §"Key management"',
+        'checkpointSignatureAlgorithm MUST be present (canonical: ed25519)',
+      )).toBeDefined();
+      expect(typeof integrity.checkpointPublicKey).toBe('string');
+    }
   });
 });
 
 describe('audit-log-integrity: verify endpoint returns chainValid', () => {
   it('GET /v1/audit/verify on a recent range reports chainValid: true', async () => {
-    if (!behaviorGate('openwop-audit-log-integrity', await isProfileAdvertised())) {
-      return;
-    }
+    if ((await gate()) === null) return unclaimed();
 
-    const verify = await driver.get('/v1/audit/verify?fromSeq=0&toSeq=100');
+    const path = auditVerifyPath(0, 100);
+    const verify = await driver.get(path);
     if (verify.status === 404) {
       // Host claims the profile but doesn't expose the endpoint — that's
       // a profile-claim violation. Fail explicitly.
       expect(verify.status, req('openwop.it.audit-log-integrity.get-v1-audit-verify-on-a-recent-range-reports-chainvalid-true', 
         'auth-profiles.md §"Audit-log integrity" §"Verification endpoint"',
-        'claiming openwop-audit-log-integrity profile REQUIRES exposing GET /v1/audit/verify',
+        `claiming ${auditClaimName()} REQUIRES exposing GET ${path.split('?')[0]}`,
       )).not.toBe(404);
       return softSkip('blocked', 'precondition not met — `verify.status === 404` returned early (seam, prior step, or fixture unavailable)');
     }
@@ -111,11 +138,10 @@ describe('audit-log-integrity: verify endpoint returns chainValid', () => {
     // length > 0)`. The body is now validated against
     // audit-verify-result.schema.json (checkpoints[] + anomalies[] required;
     // each checkpoint needs checkpoint/atSequence/merkleRoot/signature).
-    const validate = new Ajv2020({ strict: false, allErrors: true }).compile(VERIFY_RESULT_SCHEMA);
-    const shapeOk = validate(body);
-    expect(shapeOk, req('openwop.it.audit-log-integrity.get-v1-audit-verify-on-a-recent-range-reports-chainvalid-true',
+    const shape = validateVerifyBody(body);
+    expect(shape.ok, req('openwop.it.audit-log-integrity.get-v1-audit-verify-on-a-recent-range-reports-chainvalid-true',
       'audit-verify-result.schema.json',
-      `GET /v1/audit/verify MUST return the AuditVerifyResult shape: ${JSON.stringify(validate.errors ?? [])}`,
+      `GET ${path.split('?')[0]} MUST return the AuditVerifyResult shape: ${shape.errors}`,
     )).toBe(true);
 
     expect(body.chainValid, req('openwop.it.audit-log-integrity.get-v1-audit-verify-on-a-recent-range-reports-chainvalid-true', 
@@ -132,3 +158,33 @@ describe('audit-log-integrity: verify endpoint returns chainValid', () => {
     }
   });
 });
+
+describe('audit-log-integrity: checkpoints at the advertised cadence', () => {
+  it('verify lists every checkpoint ascending, no more than checkpointIntervalEntries apart', async () => {
+    const integrity = await gate();
+    if (integrity === null) return unclaimed();
+    const every = integrity.checkpointIntervalEntries;
+    if (typeof every !== 'number' || !Number.isInteger(every) || every < 1) {
+      // Required at major 2 (the shape leg owns that failure); optional at major 1.
+      return softSkip(targetMajor() === 2 ? 'blocked' : 'inapplicable', 'checkpointIntervalEntries is not advertised as a positive integer, so no cadence is claimed');
+    }
+    const verify = await driver.get(auditVerifyPath(0, 1_000_000));
+    if (verify.status !== 200) {
+      return softSkip('blocked', `the verify endpoint answered ${verify.status}; the verify leg owns that contract`);
+    }
+    const seqs = (((verify.json as { checkpoints?: Array<{ atSequence?: unknown }> }).checkpoints) ?? []).map((c) => c.atSequence);
+    if (seqs.length === 0) {
+      return softSkip('inapplicable', 'the host has minted no checkpoint yet, so there is no cadence to observe');
+    }
+    let prev = 0;
+    for (const at of seqs) {
+      expect(typeof at === 'number' && Number.isInteger(at), req(CADENCE, 'security-defaults.md §"Audit-log integrity"', 'every checkpoint MUST carry an integer atSequence')).toBe(true);
+      const n = at as number;
+      expect(n >= prev, req(CADENCE, 'security-defaults.md §"Audit-log integrity"', `checkpoints MUST be listed ascending by atSequence: ${n} follows ${prev}`)).toBe(true);
+      expect(n - prev, req(CADENCE, 'security-defaults.md §"Audit-log integrity"',
+        `a checkpoint MUST anchor at most checkpointIntervalEntries (${every}) entries: checkpoint at ${n} follows ${prev === 0 ? 'the start of the log' : `the checkpoint at ${prev}`} — a checkpoint is missing from the verify body, or was never minted`,
+      )).toBeLessThanOrEqual(every);
+      prev = n;
+    }
+  });
+});

package/src/scenarios/byok-roundtrip.test.ts

@@ -6,12 +6,23 @@
  * asserts credentialRefs DO resolve and DO get used (positive test) —
  * with redaction-safe verification via SHA-256 hashing.
  *
- * Both scenarios skip trivially-pass when the host returns 404/422 from
- * the start-run call (production deployments don't advertise the
- * fixture surface). Hosts that opt into `OPENWOP_CONFORMANCE_FIXTURES=1`
+ * This is a FLOOR scenario (`openwop.floor.byok-roundtrip`), so a host that
+ * cannot run it has NOT witnessed the floor. When the canary fixture is not
+ * advertised, or the start-run call answers 404/422, every test records
+ * `blocked` with the reason — never a trivial pass. A production posture that
+ * keeps the `conformance.secret.echo` seam off therefore leaves its claimed
+ * `openwop-secrets` profile uncertified, and only that profile: the cut's
+ * other claims still certify. Hosts that opt into `OPENWOP_CONFORMANCE_FIXTURES=1`
  * AND pre-provision a secret under `openwop-conformance-canary-secret`
  * expose the surface and the scenarios run end-to-end.
  *
+ * Why not `describe.skipIf`: a file whose tests are all skipped WITHOUT a
+ * recorded reason is an unclassified return (RFC 0148 §A), and an
+ * unclassified FLOOR row in a claimed profile rejects the whole
+ * certification, not just that profile. Measured on openwop-app's
+ * 2026-09-28 post-deploy major-1 cut: 2,116 rows, `certified: none`, the
+ * only unclassified row being this file.
+ *
  * The scenarios assert shape + non-empty + redaction, not exact value
  * equality — any host-defined canary value works as long as it's
  * non-empty and the host's `secrets.resolve` returns it intact.
@@ -34,17 +45,18 @@ const SHA256_HEX_RE = /^[0-9a-f]{64}$/;
 
 const BYOK_WORKFLOW_ID = 'openwop-smoke-byok-roundtrip';
 const SKIP_NO_FIXTURE = !isFixtureAdvertised(BYOK_WORKFLOW_ID);
+const NO_FIXTURE_REASON = `precondition not met — the \`${BYOK_WORKFLOW_ID}\` fixture is not advertised, so this host cannot witness the BYOK roundtrip floor (the \`conformance.secret.echo\` seam and the \`openwop-conformance-canary-secret\` canary are off)`;
 
-describe.skipIf(SKIP_NO_FIXTURE)('byok: end-to-end credentialRef resolution roundtrip (openwop-byok profile)', () => {
+describe('byok: end-to-end credentialRef resolution roundtrip (openwop-byok profile)', () => {
   it('the canary fixture run MUST resolve a host-provisioned secret and emit SHA-256 hex', async () => {
+    if (SKIP_NO_FIXTURE) return softSkip('blocked', NO_FIXTURE_REASON);
     const create = await driver.post('/v1/runs', {
       workflowId: 'openwop-smoke-byok-roundtrip',
     });
 
-    // Fixture absent OR canary not provisioned — host doesn't opt in.
-    // Scenario passes trivially.
+    // Fixture absent OR canary not provisioned: the floor is not witnessed.
     if (create.status === 404 || create.status === 422) {
-      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `create.status === 404 || create.status === 422` returned early (Fixture absent OR canary not provisioned — host doesn\'t opt in. Scenario passes trivially.)');
+      return softSkip('blocked', 'precondition not met — `create.status === 404 || create.status === 422` returned early (fixture advertised but the run could not start: canary not provisioned or seam unavailable)');
     }
 
     expect(create.status, req('openwop.it.byok-roundtrip.the-canary-fixture-run-must-resolve-a-host-provisioned-secret-and-emit-sha-256-h', 
@@ -102,6 +114,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('byok: end-to-end credentialRef resolution roun
   });
 
   it('BYOK fixture run MUST emit a node.completed event for the resolve step', async () => {
+    if (SKIP_NO_FIXTURE) return softSkip('blocked', NO_FIXTURE_REASON);
     const create = await driver.post('/v1/runs', {
       workflowId: 'openwop-smoke-byok-roundtrip',
     });
@@ -128,6 +141,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('byok: end-to-end credentialRef resolution roun
   });
 
   it('BYOK fixture run event log MUST NOT echo the resolved secret value (redaction)', async () => {
+    if (SKIP_NO_FIXTURE) return softSkip('blocked', NO_FIXTURE_REASON);
     const create = await driver.post('/v1/runs', {
       workflowId: 'openwop-smoke-byok-roundtrip',
     });

package/src/scenarios/envelope-completion-distinguishes-truncation.test.ts

@@ -34,7 +34,11 @@ import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { req } from '../lib/requirement-ids.js';
 import { softSkip, blockedDespiteAssertions } from '../lib/soft-skip.js';
-import { readDispatchBudgets } from '../lib/mock-ai-budgets.js';
+import { readDispatchBudgets, truncationBudgetVerdict } from '../lib/mock-ai-budgets.js';
+import { holdMockNodes } from '../lib/mock-node-lock.js';
+
+// The mock-AI program seam is keyed by node id; files sharing a fixture's node run one at a time.
+holdMockNodes('truncated-structured-call', 'retry-attempted-structured-call');
 
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
 /**
@@ -159,16 +163,21 @@ describe.skipIf(HTTP_SKIP)('envelope-completion-distinguishes-truncation: trunca
     ]);
     if (seed.status === 404) return softSkip('blocked', 'precondition not met — `seed.status === 404` returned early (seam, prior step, or fixture unavailable)');
 
-    await startRunAndRead(TRUNCATED_FIXTURE);
-    const budget = await lastBudget(TRUNCATED_FIXTURE);
-    if (budget === null) return softSkip('blocked', 'precondition not met — `budget === null` returned early (seam, prior step, or fixture unavailable)');
+    const run = await startRunAndRead(TRUNCATED_FIXTURE);
+    if (run === null) return softSkip('blocked', 'precondition not met — the run create or event-log read failed');
+    // RFC 0033 §B: MAY retry, and the retry budget SHOULD exceed the first
+    // attempt's. Compared through the dispatch-budgets seam; an unmet SHOULD is
+    // recorded, not failed (suite 2.42.9; this leg asserted `> 50` as a MUST).
+    const v = await truncationBudgetVerdict(NODE_OF[TRUNCATED_FIXTURE] as string);
+    if (v.kind === 'skip') return softSkip(v.skip, v.reason);
+    if (v.kind === 'unmet') return softSkip('inapplicable', `RFC 0033 §B SHOULD not met — the retry carried maxTokens ${v.retry} after the first attempt carried ${v.first}; recorded, not failed`);
     expect(
-      budget,
-      req('openwop.it.envelope-completion-distinguishes-truncation.truncation-retry-budget-strictly-greater-than-initial-rfc-0033-b-truncationbudge', 
+      v.retry,
+      req('openwop.it.envelope-completion-distinguishes-truncation.truncation-retry-budget-strictly-greater-than-initial-rfc-0033-b-truncationbudge',
         'RFCS/0033-envelope-completion-contract.md §B',
-        'truncation retry MUST multiply maxTokens by truncationBudgetMultiplier — final budget > initial 50 fixture value',
+        `the truncation retry's budget SHOULD exceed the first attempt's (first ${v.first}, retry ${v.retry})`,
       ),
-    ).toBeGreaterThan(50);
+    ).toBeGreaterThan(v.first);
   });
 });
 

package/src/scenarios/envelope-retry-attempted.test.ts

@@ -117,6 +117,10 @@ import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { req } from '../lib/requirement-ids.js';
 import { softSkip, blockedDespiteAssertions } from '../lib/soft-skip.js';
+import { holdMockNodes } from '../lib/mock-node-lock.js';
+
+// The mock-AI program seam is keyed by node id; files sharing a fixture's node run one at a time.
+holdMockNodes('retry-attempted-structured-call');
 
 const FIXTURE = 'conformance-envelope-retry-attempted';
 const NODE_ID = 'retry-attempted-structured-call';

package/src/scenarios/envelope-truncated.test.ts

@@ -22,6 +22,11 @@ import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { req } from '../lib/requirement-ids.js';
 import { softSkip, blockedDespiteAssertions } from '../lib/soft-skip.js';
+import { holdMockNodes } from '../lib/mock-node-lock.js';
+import { truncationBudgetVerdict } from '../lib/mock-ai-budgets.js';
+
+// The mock-AI program seam is keyed by node id; files sharing a fixture's node run one at a time.
+holdMockNodes('truncated-structured-call');
 
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
 const FIXTURE = 'conformance-envelope-truncated';
@@ -50,12 +55,6 @@ async function startRunAndRead(): Promise<{ events: RunEvent[]; terminal: unknow
   return { events, terminal };
 }
 
-async function lastBudget(): Promise<number | null> {
-  const res = await driver.get(`/v1/host/sample/test/mock-ai/last-dispatch-budget?nodeId=${encodeURIComponent(NODE_ID)}`);
-  if (res.status !== 200) return null;
-  return (res.json as { maxTokens?: number | null }).maxTokens ?? null;
-}
-
 describe.skipIf(HTTP_SKIP)('envelope-truncated: runtime behavior (RFC 0032 §B.4 + RFC 0033 §B)', () => {
   it('when mock returns stopReason: max_tokens on attempt 1, exactly one envelope.truncated event fires with stopReason: max_tokens', async () => {
     if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(FIXTURE)` returned early');
@@ -112,19 +111,20 @@ describe.skipIf(HTTP_SKIP)('envelope-truncated: runtime behavior (RFC 0032 §B.4
 
     const result = await startRunAndRead();
     if (result === null) return softSkip('blocked', 'precondition not met — `result === null` returned early (seam, prior step, or fixture unavailable)');
-    // After the run, the mock's most-recent budget is the SECOND (retry)
-    // attempt's maxTokens. Per RFC 0033 §B, this MUST exceed the fixture's
-    // initial maxTokens (50). The host's default multiplier is 2 — so the
-    // retry should see 100.
-    const budget = await lastBudget();
-    if (budget === null) return softSkip('blocked', 'precondition not met — `budget === null` returned early (host doesn\'t expose the seam) (seam, prior step, or fixture unavailable)'); // host doesn't expose the seam
+    // RFC 0033 §B: the retry budget SHOULD exceed the first attempt's (a MAY retry,
+    // a SHOULD increase). Suite 2.42.9 compares the budgets the provider actually
+    // received, and records an unmet SHOULD rather than failing it; until then this
+    // leg asserted `> 50` (the fixture value) as a MUST.
+    const v = await truncationBudgetVerdict(NODE_ID);
+    if (v.kind === 'skip') return softSkip(v.skip, v.reason);
+    if (v.kind === 'unmet') return softSkip('inapplicable', `RFC 0033 §B SHOULD not met — the retry carried maxTokens ${v.retry} after the first attempt carried ${v.first}; recorded, not failed`);
     expect(
-      budget,
-      req('openwop.it.envelope-truncated.retry-attempt-receives-a-maxtokens-value-strictly-greater-than-the-previous-atte', 
+      v.retry,
+      req('openwop.it.envelope-truncated.retry-attempt-receives-a-maxtokens-value-strictly-greater-than-the-previous-atte',
         'RFCS/0033-envelope-completion-contract.md §B',
-        'truncation retry MUST issue with a strictly-increased maxTokens budget (host multiplies by capabilities.envelopes.reliability.completion.truncationBudgetMultiplier)',
+        `the truncation retry's budget SHOULD exceed the first attempt's (first ${v.first}, retry ${v.retry})`,
       ),
-    ).toBeGreaterThan(50);
+    ).toBeGreaterThan(v.first);
   });
 
   it('run terminates `completed` after the second attempt succeeds', async () => {

package/src/scenarios/v2-approval-reject-disposition.test.ts

@@ -0,0 +1,162 @@
+/**
+ * RFC 0223 — a rejected approval gate fails closed, and the failure is
+ * routable (`spec/v2/core/interrupt.md` §Rejection; suite 2.43.0, target
+ * major 2; gated on the `interrupt` family).
+ *
+ * Legs:
+ *   1. `conformance-approval` (one gate, no edges) resolved `reject` ⇒ the run
+ *      terminates `failed`, and both the snapshot `error.code` and
+ *      `run.failed.error.code` are `approval_rejected`;
+ *   2. the same run's `interrupt.resolved` records `action: "reject"` and
+ *      `decision: "rejected"` (the `action` half is interrupt.md §Events, RFC
+ *      0183; RFC 0223 names both for a reject);
+ *   3. the gate's `node.failed` carries `approval_rejected` with
+ *      `retryable: false`, and `run.failed.failedNodeId` names the gate;
+ *   4. `conformance-interrupt-quorum` (requiredApprovals 3, `majority`): one
+ *      reject leaves the run `waiting-approval`; a second decides the gate and
+ *      the run terminates `failed` with `approval_rejected`.
+ *
+ * The legs are separate rows so a host that misses one field fails that row
+ * only. The timeout disposition is not tested: no registered fixture carries a
+ * gate with a short `timeoutMs`, and the suite cannot make a host's timer fire.
+ * The routed case (an `all_complete` / `any_failed` edge) is not tested either:
+ * `conformance-approval` has no edges, and widening a fixture every host serves
+ * would force a re-registration (fixtures.md §conformance-approval-refine).
+ *
+ * The quorum leg presents distinct votes on one bearer through the resume
+ * value's `voter` member, as `interrupt-quorum-resolution` does at major 1. A
+ * host that counts both votes as one principal cannot be driven to a majority
+ * this way; that records `blocked`, not a failure.
+ *
+ * @see spec/v2/core/interrupt.md §Rejection
+ * @see spec/v2/errors.json approval_rejected
+ * @see RFCS/0223-approval-reject-disposition.md
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { gateFamily } from '../lib/v2.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+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/interrupt.md §Rejection (RFC 0223)';
+const R = (slug: string): string => `openwop.requirement.0223.${slug}`;
+const FIXTURE = 'conformance-approval';
+const QUORUM = 'conformance-interrupt-quorum';
+const NODE_ID = 'gate';
+const CODE = 'approval_rejected';
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+
+interface Ev { type?: string; nodeId?: string; payload?: Record<string, unknown> }
+
+const enc = (id: string): string => encodeURIComponent(id);
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> { try { return await fn(); } catch { return null; } }
+
+async function snapshot(runId: string): Promise<Record<string, unknown> | null> {
+  const res = await http(() => driver.get(`/runs/${enc(runId)}`));
+  return res?.status === 200 && res.json && typeof res.json === 'object' ? (res.json as Record<string, unknown>) : null;
+}
+async function waitStatus(runId: string, wanted: ReadonlySet<string>, timeoutMs: number): Promise<Record<string, unknown> | null> {
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    const s = await snapshot(runId);
+    if (s !== null && wanted.has(String(s['status']))) return s;
+    if (Date.now() > deadline) return s;
+    await new Promise((r) => setTimeout(r, 250));
+  }
+}
+async function events(runId: string): Promise<Ev[]> {
+  const res = await http(() => driver.get(`/runs/${enc(runId)}/events/poll?timeout=1`));
+  return ((res?.json as { events?: Ev[] } | null)?.events ?? []);
+}
+const errorCode = (o: unknown): string | undefined => (o as { code?: unknown } | null | undefined)?.code as string | undefined;
+const resolve = (runId: string, resumeValue: unknown): Promise<OpenWOPResponse | null> => http(() => driver.post(`/runs/${enc(runId)}/interrupts/${enc(NODE_ID)}`, { resumeValue }));
+
+/** Create a run of `fixture` and wait for it to suspend on its gate. */
+async function suspended(fixture: string): Promise<{ runId: string } | { reason: string }> {
+  const res = await http(() => driver.post('/runs', { workflowId: fixture }));
+  if (res === null) return { reason: 'POST /runs unreachable (fetch failed)' };
+  const runId = (res.json as { runId?: unknown } | null)?.runId;
+  if (res.status !== 201 || typeof runId !== 'string') return { reason: `POST /runs (${fixture}) answered ${res.status} ${readErrorCode(res.json) ?? ''}`.trim() };
+  const s = await waitStatus(runId, new Set(['waiting-approval', ...TERMINAL]), 10_000);
+  if (s?.['status'] !== 'waiting-approval') return { reason: `the ${fixture} run did not suspend on its approval gate (status ${String(s?.['status'])})` };
+  return { runId };
+}
+
+/** One rejected `conformance-approval` run per file: legs 1–3 read the same run. */
+let rejected: Promise<{ runId: string; terminal: Record<string, unknown> | null; evs: Ev[] } | { reason: string }> | undefined;
+function rejectedRun(): Promise<{ runId: string; terminal: Record<string, unknown> | null; evs: Ev[] } | { reason: string }> {
+  rejected ??= (async () => {
+    const s = await suspended(FIXTURE);
+    if ('reason' in s) return s;
+    const res = await resolve(s.runId, { action: 'reject' });
+    if (res === null || res.status < 200 || res.status >= 300) return { reason: `the reject resolve answered ${res?.status ?? 'nothing'} ${readErrorCode(res?.json) ?? ''} — interrupt resolution owns that contract` };
+    const terminal = await waitStatus(s.runId, TERMINAL, 10_000);
+    return { runId: s.runId, terminal, evs: await events(s.runId) };
+  })();
+  return rejected;
+}
+
+describe('RFC 0223 — v2-approval-reject-disposition (gated on interrupt + conformance-approval)', () => {
+  it('a rejected gate with no routing edge fails the run with approval_rejected', async () => {
+    if (!(await gateFamily('interrupt'))) return softSkip('inapplicable', 'interrupt family not advertised (gate recorded under openwop.family.interrupt)');
+    const r = await rejectedRun();
+    if ('reason' in r) return softSkip('blocked', r.reason);
+    const id = R('reject-fails-run');
+    expect(r.terminal?.['status'], req(id, DOC, `with no edge admitting a failed source the run MUST terminate failed (got ${String(r.terminal?.['status'])})`)).toBe('failed');
+    expect(errorCode(r.terminal?.['error']), req(id, `${DOC}; runs.md §Snapshot`, 'the terminal snapshot error.code MUST be approval_rejected')).toBe(CODE);
+    const failed = r.evs.find((e) => e.type === 'run.failed');
+    expect(errorCode(failed?.payload?.['error']), req(id, DOC, 'run.failed.error.code MUST be approval_rejected')).toBe(CODE);
+  }, 45_000);
+
+  it('interrupt.resolved records action reject and decision rejected', async () => {
+    if (!(await gateFamily('interrupt'))) return softSkip('inapplicable', 'interrupt family not advertised (gate recorded under openwop.family.interrupt)');
+    const r = await rejectedRun();
+    if ('reason' in r) return softSkip('blocked', r.reason);
+    const id = R('reject-recorded');
+    const resolved = r.evs.find((e) => e.type === 'interrupt.resolved');
+    expect(resolved, req(id, `${DOC}; interrupt.md §Events`, 'the reject MUST be recorded as interrupt.resolved')).toBeDefined();
+    expect(
+      { action: resolved?.payload?.['action'], decision: resolved?.payload?.['decision'] },
+      req(id, `${DOC}; interrupt.md §Events (RFC 0183)`, 'interrupt.resolved MUST carry action "reject" and decision "rejected"'),
+    ).toEqual({ action: 'reject', decision: 'rejected' });
+  }, 45_000);
+
+  it('the gate node fails with approval_rejected, not retryable, and run.failed names it', async () => {
+    if (!(await gateFamily('interrupt'))) return softSkip('inapplicable', 'interrupt family not advertised (gate recorded under openwop.family.interrupt)');
+    const r = await rejectedRun();
+    if ('reason' in r) return softSkip('blocked', r.reason);
+    const id = R('reject-fails-node');
+    const nodeFailed = r.evs.find((e) => e.type === 'node.failed' && (e.payload?.['nodeId'] ?? e.nodeId) === NODE_ID);
+    expect(nodeFailed, req(id, DOC, 'the gate that does not turn the rejection into an output MUST emit node.failed')).toBeDefined();
+    const err = nodeFailed?.payload?.['error'] as { code?: unknown; retryable?: unknown } | undefined;
+    expect({ code: err?.code, retryable: err?.retryable }, req(id, DOC, 'node.failed.error MUST carry code approval_rejected and retryable false')).toEqual({ code: CODE, retryable: false });
+    const runFailed = r.evs.find((e) => e.type === 'run.failed');
+    expect(runFailed?.payload?.['failedNodeId'], req(id, DOC, 'run.failed.failedNodeId MUST name the gate')).toBe(NODE_ID);
+  }, 45_000);
+
+  it('a majority reject decides the quorum gate on the deciding vote and fails the run with approval_rejected', async () => {
+    if (!(await gateFamily('interrupt'))) return softSkip('inapplicable', 'interrupt family not advertised (gate recorded under openwop.family.interrupt)');
+    if (!isFixtureAdvertised(QUORUM)) return softSkip('inapplicable', `fixture ${QUORUM} is not advertised — the host does not claim the quorum fixture`);
+    const s = await suspended(QUORUM);
+    if ('reason' in s) return softSkip('blocked', s.reason);
+    const id = R('quorum-reject-fails-run');
+    const first = await resolve(s.runId, { action: 'reject', voter: 'approver-1' });
+    if (first === null || first.status < 200 || first.status >= 300) return softSkip('blocked', `the first reject vote answered ${first?.status ?? 'nothing'} ${readErrorCode(first?.json) ?? ''}`);
+    const between = (await snapshot(s.runId))?.['status'];
+    const resolvedEarly = (await events(s.runId)).some((e) => e.type === 'interrupt.resolved');
+    const second = await resolve(s.runId, { action: 'reject', voter: 'approver-2' });
+    if (second === null || second.status < 200 || second.status >= 300) return softSkip('blocked', `the second reject vote answered ${second?.status ?? 'nothing'} ${readErrorCode(second?.json) ?? ''}`);
+    const terminal = await waitStatus(s.runId, TERMINAL, 10_000);
+    if (between === 'waiting-approval' && terminal?.['status'] === 'waiting-approval') {
+      await http(() => driver.post(`/runs/${enc(s.runId)}/cancel`, {}));
+      return softSkip('blocked', 'the host counted both votes as one approver (one bearer; the resume value\'s voter was not honoured), so a majority could not be caused');
+    }
+    expect(between, req(id, DOC, 'one reject of three under majority does not decide the gate: the run MUST stay waiting-approval')).toBe('waiting-approval');
+    expect(resolvedEarly, req(id, DOC, 'a vote that does not decide the gate MUST NOT emit interrupt.resolved')).toBe(false);
+    expect(terminal?.['status'], req(id, DOC, `two rejects of three under majority MUST resolve the gate rejected and fail the run (got ${String(terminal?.['status'])})`)).toBe('failed');
+    expect(errorCode(terminal?.['error']), req(id, DOC, 'the terminal snapshot error.code MUST be approval_rejected')).toBe(CODE);
+  }, 60_000);
+});