@openwop/openwop-conformance 2.42.3 → 2.42.5

package/schemas/CORPUS-STAMP.json

@@ -1,17 +1,17 @@
 {
   "_comment": "Provenance of @openwop/spec-artifacts (RFC 0168 §D.2). files: SHA-256 per file; the conformance suite compares the installed peer against dist/spec-artifacts.lock.json at start.",
   "package": "@openwop/spec-artifacts",
-  "version": "2.42.3",
-  "corpusTag": "v2.42.3",
+  "version": "2.42.5",
+  "corpusTag": "v2.42.5",
   "files": {
     "api/.redocly.lint-ignore.yaml": "bf5a8350b88a72fa43f59605ed8d903ed24b6cfccda5e45509c9f6ed9ee4e712",
     "api/asyncapi.yaml": "d5ecb9ee6114582be3b1f662c84bfac9ae96dae7bacb853e461168f70a8e1c7d",
     "api/grpc/openwop.proto": "c3e72bb17cba514ee98feb6434e6c9b6ea6795bfd086489ec69fd882dd1ad977",
     "api/openapi.yaml": "69464bc0e1e71ef3b543a73d4fa4f67202343d2603c80af8033f6c3619ef1b30",
     "api/redocly.yaml": "b0604c89b2ca6d5076ec25725c539dad44a741a811fe524439ee6daef8baa09f",
-    "api/seams-v2.yaml": "6824903e9a7d33a6913878d46ad0a1e25746b596c6ab2ae7aa6c31d72babfa63",
-    "api/v2/asyncapi.yaml": "45ee1825660a8d6336e145042e6e6e7f69d63d823fb7a6af8f5e9c46ec93c45f",
-    "api/v2/openapi.yaml": "d45f0d99b6d57b45a30640583c0aa828163ba778768dd58835246ed5dad212b1",
+    "api/seams-v2.yaml": "33312adcc1cf1185db6f926195dbc2af3cdf626fb686b34e12b3e0f5c2d0f12c",
+    "api/v2/asyncapi.yaml": "ef7841d00162c7b89caa6df100f48a62927a619f0363733591a4b9a988ef570d",
+    "api/v2/openapi.yaml": "bb0140dc59875b8d0dc0c04a128372c09a088340dda45f139ff4a218412bbab4",
     "api/v2/redocly.yaml": "1e66b60e6118ad11a823bb620678be464d99dfe50a40e3e6f93ec9429b88b34c",
     "schemas/README.md": "0c0b737ffcf8f30e7d2809cec8a498232de710f41443212922ad8337cdde0b51",
     "schemas/a2a-task-state.schema.json": "75d5049dea8bd873ff0e7546f1c60c8d36c219bec7084264360be54a8be30ae1",
@@ -204,7 +204,7 @@
     "schemas/workspace-file.schema.json": "464de85c2a068243084ee9c1d969bc7cd5d8f7948574e58450d6493c38a0e1e4",
     "spec/v1/alias-detectors.json": "2401fcb1c18cdd688c018b3d716ae6bca85c5e356220ee2b793bd9d81872412d",
     "spec/v1/capability-declaration-classes.json": "e7729aed5c4b4e1dd02abab0530f14cc95f5d4070fe51fb139e7f5cccefa00c6",
-    "spec/v1/core-standard-manifest.json": "4271942ecca7c7455cb6318572bdb5a53ddc34f8d8914e2a68c64b091d131a0f",
+    "spec/v1/core-standard-manifest.json": "570aecd605ffb479c3f5aa73e0e0259747d95ecad0fc26f0438f66deaa67ebad",
     "spec/v1/deprecations.json": "2d03f4729810280147ea08c630ea65434f2dc5370567d0aac41c3595f8337d40",
     "spec/v1/deprecations.schema.json": "3e393c405d2a41b467d8c5e3c468549078df1ce6a6d2588fc488097b95d9b55b",
     "spec/v1/event-codemap.json": "3da60d884157793a360da532a9fcbbfb5285636db325a74cec94b34622186d97",
@@ -294,9 +294,9 @@
     "spec/v2/path-manifest.json": "17298a245c5da9a70aa7ab0b7f2db4277e06209d6fcdd7187a8b4cea179c08f3",
     "spec/v2/peer-dependency-aliases.json": "d10299280abee08258502925bc327293ee413e0108cd6e6ec75ff6110653308d",
     "spec/v2/profiles.json": "0636f19fceae625390003a347e70ef4797d84766b5c24ce8a02cea52aadebca4",
-    "spec/v2/release.json": "1b3dde14cbaf3cfc4eab1ae9a461aab6d357c9c4cda511047087c0b57b400055",
+    "spec/v2/release.json": "5132e4752b9e36d2ab61076455e3efbda31127e76565faadb67446f77707a246",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624",
-    "spec/v2/surface-baseline.json": "dc52941e7f3e19da5151bb5c994af9b18b137a5a3b34ee0b63bc9cb2789dc52a"
+    "spec/v2/surface-baseline.json": "ef98caceff85da0d8bae10e78d044762d47960432b7fa885c4c56697c7038274"
   },
-  "corpusCommit": "d310f781e2dcb00d670e26fc23668c2d61548304"
+  "corpusCommit": "bfa55619a403957a27412e0fa2c8865a48199c38"
 }

package/src/lib/agentOrgChart.ts

@@ -51,12 +51,29 @@ export interface ResponsibilityView {
   responsibilities?: string[];
 }
 
+/** GET the NORMATIVE org-chart (RFC 0087 §A `GET /v1/agents/org-chart`) and
+ *  return the raw status alongside the parsed body, so a scenario can assert
+ *  on the status itself (with a `req()` id) instead of a helper that folds it. */
+export async function getOrgChartResponse(): Promise<{ status: number; chart: OrgChart | undefined }> {
+  const res = await driver.get('/v1/agents/org-chart');
+  const body = res.json;
+  return { status: res.status, chart: body && typeof body === 'object' ? (body as OrgChart) : undefined };
+}
+
 /** GET the NORMATIVE org-chart (RFC 0087 §A `GET /v1/agents/org-chart`);
- *  null when the host doesn't serve it (404/405/501). */
+ *  null when the host doesn't serve it (404/405/501).
+ *
+ *  unfailable-leg audit wave 2, 2026-09-27: every other status used to fold to
+ *  `{}` — an advertised host answering 500/403 read as an EMPTY chart, which
+ *  the tree/member loops then passed vacuously. Any other non-200 (or a 200
+ *  with no object body) now throws, failing the calling leg. */
 export async function getOrgChart(): Promise<OrgChart | null> {
-  const res = await driver.get('/v1/agents/org-chart');
-  if (res.status === 404 || res.status === 405 || res.status === 501) return null;
-  return (res.json as OrgChart | undefined) ?? {};
+  const { status, chart } = await getOrgChartResponse();
+  if (status === 404 || status === 405 || status === 501) return null;
+  if (status !== 200 || chart === undefined) {
+    throw new Error(`RFC 0087 §A: GET /v1/agents/org-chart MUST return 200 with the org-chart object on a host advertising agents.orgChart — got HTTP ${status}${chart === undefined ? ' with no JSON object body' : ''}`);
+  }
+  return chart;
 }
 
 /** GET a department's §D responsibility roll-up. `recursive` defaults to the

package/src/lib/effect-receiver.ts

@@ -50,6 +50,20 @@ export interface EffectArrival {
   readonly at: number;
   /** False when the path carried some other exercise's nonce (or none). */
   readonly mine: boolean;
+  /** The `Idempotency-Key` header the host presented on this attempt, if any. */
+  readonly idempotencyKey?: string;
+  /** True when this receiver cut the connection instead of answering (a forced transport failure). */
+  readonly reset: boolean;
+}
+
+export interface EffectReceiverOptions {
+  /**
+   * Destroy the connection, without answering, on the first `failFirst` arrivals
+   * that carry this exercise's nonce. The host sees a genuine transport failure,
+   * not an HTTP status, so a host that retries only at the transport layer (as
+   * RFC 0173 §D.2 G4's seam describes) retries. Default 0.
+   */
+  readonly failFirst?: number;
 }
 
 export interface EffectReceiver {
@@ -98,7 +112,8 @@ export async function waitForFirstArrival(rx: EffectReceiver, budgetMs: number):
  * distinct per exercise whether the port is pinned, ephemeral, or replaced by
  * an operator's public front.
  */
-export async function startEffectReceiver(): Promise<EffectReceiver> {
+export async function startEffectReceiver(opts: EffectReceiverOptions = {}): Promise<EffectReceiver> {
+  const failFirst = Math.max(0, Math.floor(opts.failFirst ?? 0));
   const nonce = randomBytes(9).toString('hex');
   const path = `/effect/${nonce}`;
   const seen: EffectArrival[] = [];
@@ -108,7 +123,13 @@ export async function startEffectReceiver(): Promise<EffectReceiver> {
       const requestPath = request.url ?? '';
       // Matched by CONTAINMENT, not equality: a TLS-terminating front may add
       // or strip a prefix, and the nonce is what identifies the exercise.
-      seen.push({ path: requestPath, method: request.method ?? '', at: Date.now(), mine: requestPath.includes(nonce) });
+      const mine = requestPath.includes(nonce);
+      const key = request.headers['idempotency-key'];
+      const reset = mine && seen.filter((a) => a.mine).length < failFirst;
+      seen.push({ path: requestPath, method: request.method ?? '', at: Date.now(), mine, reset, ...(typeof key === 'string' ? { idempotencyKey: key } : {}) });
+      // The key is recorded BEFORE the cut, so a failed attempt still counts as
+      // an attempt the provider saw.
+      if (reset) { request.socket.destroy(); return; }
       res.writeHead(204);
       res.end();
     });

package/src/lib/toolCatalog.ts

@@ -69,12 +69,36 @@ export interface ToolDescriptor {
   [k: string]: unknown;
 }
 
-/** GET the NORMATIVE tool catalog (RFC 0078 §B `GET /v1/tools`); null when the
- *  host doesn't serve it (404/405/501). */
-export async function listTools(): Promise<ToolDescriptor[] | null> {
+/** The outcome of one `GET /v1/tools` read (see `listTools`). */
+export interface ToolListRead {
+  /** HTTP status of the read. */
+  readonly status: number;
+  /** `true` when the host does not serve the read at all (404/405/501). */
+  readonly unserved: boolean;
+  /** The descriptor list when the read was a `200` carrying a list; `null` otherwise. */
+  readonly tools: ToolDescriptor[] | null;
+}
+
+/** GET the NORMATIVE tool catalog (RFC 0078 §B `GET /v1/tools`).
+ *
+ *  unfailable-leg audit wave 2, 2026-09-27: this used to return `json ?? []`
+ *  for ANY status other than 404/405/501, so a host answering `500`, `403`, or
+ *  `200` with a non-list body read as "an empty catalog" and every per-
+ *  descriptor assertion ran over zero items. Now `tools` is non-null only for a
+ *  `200` whose body is a `ToolDescriptor[]` — the bare array `openapi.yaml`,
+ *  `spec/v2/core/tool-catalog.md`, and the reference host serve, or (major 1
+ *  only) the `{ tools: ToolDescriptor[] }` envelope `spec/v1/tool-catalog.md`
+ *  §B prose names — and the caller asserts on `status` / `tools`. */
+export async function listTools(): Promise<ToolListRead> {
   const res = await driver.get(toolsPath());
-  if (res.status === 404 || res.status === 405 || res.status === 501) return null;
-  return (res.json as ToolDescriptor[] | undefined) ?? [];
+  const unserved = res.status === 404 || res.status === 405 || res.status === 501;
+  if (res.status !== 200) return { status: res.status, unserved, tools: null };
+  const body = res.json;
+  if (Array.isArray(body)) return { status: res.status, unserved, tools: body as ToolDescriptor[] };
+  if (targetMajor() !== 2 && body !== null && typeof body === 'object' && Array.isArray((body as { tools?: unknown }).tools)) {
+    return { status: res.status, unserved, tools: (body as { tools: ToolDescriptor[] }).tools };
+  }
+  return { status: res.status, unserved, tools: null };
 }
 
 /** GET one tool by id (RFC 0078 §B `GET /v1/tools/{toolId}`); returns

package/src/scenarios/agent-manifest-runtime.test.ts

@@ -17,7 +17,7 @@
 import { describe, it, expect } from 'vitest';
 import { readManifestRuntimeCap, listManifestAgents, dispatchAgent } from '../lib/agentRuntime.js';
 import { req } from '../lib/requirement-ids.js';
-import { softSkip } from '../lib/soft-skip.js';
+import { blockedDespiteAssertions, softSkip } from '../lib/soft-skip.js';
 
 describe('agent-manifest-runtime (RFC 0070)', () => {
   it('lists installed manifest agents and dispatches one with attributed events', async () => {
@@ -32,7 +32,16 @@ describe('agent-manifest-runtime (RFC 0070)', () => {
     ).toBe(true);
 
     const inv = await listManifestAgents();
-    if (inv === null) return softSkip('blocked', 'precondition not met — `inv === null` returned early (seam absent — soft-skip) (seam, prior step, or fixture unavailable)'); // seam absent — soft-skip
+    // unfailable-leg audit wave 2, 2026-09-27: a 404/405/501 on GET /v1/agents
+    // was `softSkip('blocked')` after the installScope assert — a partial-witness
+    // PASS for a host that advertised manifestRuntime and served no inventory.
+    // node-packs.md §"Agent inventory (RFC 0072 §A — normative)": an advertiser
+    // MUST serve GET /v1/agents, so absence is a failure, not a missing seam.
+    expect(
+      inv,
+      req('openwop.it.agent-manifest-runtime.lists-installed-manifest-agents-and-dispatches-one-with-attributed-events', 'RFC 0072 §A / node-packs.md §Agent inventory', 'a host advertising agents.manifestRuntime.supported MUST serve GET /v1/agents (it answered 404/405/501)'),
+    ).not.toBeNull();
+    if (inv === null) throw new Error("unreachable: the assertion above fails first");
     const agents = inv.agents ?? [];
     expect(
       Array.isArray(agents),
@@ -56,12 +65,16 @@ describe('agent-manifest-runtime (RFC 0070)', () => {
     }
 
     const agentId = agents[0]?.agentId;
-    if (typeof agentId !== 'string') return softSkip('blocked', 'precondition not met — `typeof agentId !== \'string\'` returned early (seam, prior step, or fixture unavailable)');
+    // unfailable-leg audit wave 2, 2026-09-27: this and the `res === null`
+    // return below were plain `softSkip('blocked')` after the inventory
+    // asserts, recording a partial-witness PASS for a leg whose dispatch half
+    // (terminal status + attributed agent.* events) was never observed.
+    if (typeof agentId !== 'string') return blockedDespiteAssertions( 'precondition not met — `typeof agentId !== \'string\'` returned early (seam, prior step, or fixture unavailable)');
 
     // Opaque-payload dispatch (validateHandoff:false) so the assertion is
     // independent of the chosen agent's handoff schema.
     const res = await dispatchAgent(agentId, { task: {}, validateHandoff: false, availableTools: [] });
-    if (res === null) return softSkip('blocked', 'precondition not met — `res === null` returned early (seam absent — soft-skip) (seam, prior step, or fixture unavailable)'); // seam absent — soft-skip
+    if (res === null) return blockedDespiteAssertions( 'precondition not met — `res === null` returned early (seam absent — soft-skip) (seam, prior step, or fixture unavailable)'); // seam absent — soft-skip
     expect(
       res.status === 'completed' || res.status === 'escalated',
       req('openwop.it.agent-manifest-runtime.lists-installed-manifest-agents-and-dispatches-one-with-attributed-events', 'RFC 0070', 'dispatch MUST resolve to a terminal status (completed | escalated)'),

package/src/scenarios/agent-org-chart-scoping.test.ts

@@ -30,9 +30,8 @@
 
 import { describe, it, expect } from 'vitest';
 import { behaviorGate } from '../lib/behavior-gate.js';
-import { readOrgChartCap, getOrgChart, getDepartmentView } from '../lib/agentOrgChart.js';
+import { readOrgChartCap, getOrgChartResponse, getDepartmentView, type OrgChart } from '../lib/agentOrgChart.js';
 import { req } from '../lib/requirement-ids.js';
-import { softSkip } from '../lib/soft-skip.js';
 
 const ROSTER_ID_RE = /^host:[a-z0-9][a-z0-9._-]*$/;
 
@@ -48,8 +47,22 @@ describe('agent-org-chart-scoping (RFC 0087 §A/§C/§D)', () => {
     ).toBe(true);
 
     // ---- Leg 1: normative read (black-box) -------------------------------
-    const chart = await getOrgChart();
-    if (chart === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `chart === null` returned early (advertised but read not served yet — soft-skip)'); // advertised but read not served yet — soft-skip
+    // unfailable-leg audit wave 2, 2026-09-27: a host that ADVERTISES
+    // agents.orgChart but 404s the normative read (or answers 500/403, which
+    // getOrgChart used to fold into an empty `{}` chart) previously passed —
+    // the 404 as `inapplicable`, the error status as a vacuous empty tree.
+    // The behaviorGate above already established the advertisement, so the
+    // read MUST now be served: any non-200 fails here.
+    const chartRes = await getOrgChartResponse();
+    expect(
+      chartRes.status,
+      req('openwop.it.agent-org-chart-scoping.serves-the-normative-org-chart-responsibility-roll-up-tree-shaped-and-tenant-sco', 'agent-org-chart.md §A / §E', 'a host advertising agents.orgChart.supported MUST serve GET /v1/agents/org-chart with 200'),
+    ).toBe(200);
+    expect(
+      chartRes.chart !== undefined,
+      req('openwop.it.agent-org-chart-scoping.serves-the-normative-org-chart-responsibility-roll-up-tree-shaped-and-tenant-sco', 'agent-org-chart.schema.json', 'GET /v1/agents/org-chart MUST return a JSON org-chart object'),
+    ).toBe(true);
+    const chart: OrgChart = chartRes.chart ?? {};
     const departments = chart.departments ?? [];
     const members = chart.members ?? [];
     expect(
@@ -100,6 +113,16 @@ describe('agent-org-chart-scoping (RFC 0087 §A/§C/§D)', () => {
     const probeDeptId = departments[0]?.departmentId;
     if (typeof probeDeptId === 'string') {
       const { status, view } = await getDepartmentView(probeDeptId);
+      // unfailable-leg audit wave 2, 2026-09-27: a host advertising
+      // `responsibilityView: true` whose GET /v1/agents/org-chart/{id} errored
+      // or 404'd for a department IN ITS OWN chart previously skipped the whole
+      // roll-up leg silently. The advertised view MUST be served.
+      if (cap?.responsibilityView === true) {
+        expect(
+          status,
+          req('openwop.it.agent-org-chart-scoping.serves-the-normative-org-chart-responsibility-roll-up-tree-shaped-and-tenant-sco', 'agent-org-chart.md §D / §E', 'a host advertising agents.orgChart.responsibilityView MUST serve GET /v1/agents/org-chart/{departmentId} with 200 for a department in the caller\'s chart'),
+        ).toBe(200);
+      }
       if (status === 200 && view) {
         expect(
           Array.isArray(view.responsibilities),

package/src/scenarios/agent-roster-attribution.test.ts

@@ -43,7 +43,7 @@ import {
   type TestEvent,
 } from '../lib/event-log-query.js';
 import { req } from '../lib/requirement-ids.js';
-import { softSkip } from '../lib/soft-skip.js';
+import { blockedDespiteAssertions } from '../lib/soft-skip.js';
 
 const ROSTER_ID_RE = /^host:[a-z0-9][a-z0-9._-]*$/;
 
@@ -67,13 +67,23 @@ describe('agent-roster-attribution (RFC 0086 §B/§C)', () => {
     ).toBe(true);
 
     // ---- Leg 1: normative read (black-box on any roster host) -------------
+    // unfailable-leg audit wave 2, 2026-09-27: a host that ADVERTISED
+    // agents.roster.supported but 404/405/501'd the normative read used to
+    // soft-skip 'inapplicable' after the installScope assert — a partial-witness
+    // PASS. Advertised ⇒ the normative read MUST be served, so it now fails.
+    // Likewise `body.roster ?? []` made a body with NO roster[] pass the
+    // "MUST return a roster[] array" assert; the raw field is checked now.
     const body = await listRoster();
-    if (body === null) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `body === null` returned early (host advertises roster but doesn\'t serve the read yet — soft-skip)'); // host advertises roster but doesn't serve the read yet — soft-skip
-    const roster = body.roster ?? [];
     expect(
-      Array.isArray(roster),
+      body !== null,
+      req('openwop.it.agent-roster-attribution.serves-the-normative-roster-attributes-a-portfolio-fire-content-free-ordered-and', 'agent-roster.md §B', 'a host advertising agents.roster.supported MUST serve GET /v1/agents/roster (got 404/405/501)'),
+    ).toBe(true);
+    if (body === null) throw new Error("unreachable: the assertion above fails first");
+    expect(
+      Array.isArray(body.roster),
       req('openwop.it.agent-roster-attribution.serves-the-normative-roster-attributes-a-portfolio-fire-content-free-ordered-and', 'agent-roster.md §B', 'GET /v1/agents/roster MUST return a roster[] array'),
     ).toBe(true);
+    const roster = Array.isArray(body.roster) ? body.roster : [];
     expect(
       body.total === roster.length,
       req('openwop.it.agent-roster-attribution.serves-the-normative-roster-attributes-a-portfolio-fire-content-free-ordered-and', 'agent-roster-response.schema.json', 'total MUST equal roster.length'),
@@ -103,12 +113,22 @@ describe('agent-roster-attribution (RFC 0086 §B/§C)', () => {
     }
 
     // ---- Leg 2: attribution + ordering (seam-gated) ----------------------
+    // unfailable-leg audit wave 2, 2026-09-27: when the event-log seam, the
+    // fire seam, or the event query was absent, this leg fell through with
+    // nothing observed and the whole `it` (named for attribution + ordering)
+    // recorded a full pass on the leg-1 read alone. Track whether attribution
+    // was actually observed; if not, the row records `blocked`.
+    let attributionObserved = false;
+    let attributionGap = 'event-log seam /v1/host/sample/test-events not available';
     if (await isEventLogSeamAvailable()) {
+      attributionGap = 'roster fire seam /v1/host/sample/roster/fire unwired (404/405) or returned no runId';
       // Scheduled portfolio fire.
       const fired = await fireRosterPortfolio({ triggerSource: 'schedule' });
       if (fired?.runId) {
         const q = await queryTestEvents(fired.runId);
+        attributionGap = 'event-log query for the fired run failed';
         if (q.ok) {
+          attributionObserved = true;
           const init = firstOf(q.events, ['roster.run.initiated']);
           expect(
             init !== undefined,
@@ -176,5 +196,9 @@ describe('agent-roster-attribution (RFC 0086 §B/§C)', () => {
         req('openwop.it.agent-roster-attribution.serves-the-normative-roster-attributes-a-portfolio-fire-content-free-ordered-and', 'agent-roster.md §B / RFC 0074', "GET /v1/agents/roster/{id} for a cross-tenant id MUST 404 (no cross-tenant disclosure)"),
       ).toBe(true);
     }
+
+    if (!attributionObserved) {
+      return blockedDespiteAssertions(`roster attribution + ordering (RFC 0086 §C) not observed — ${attributionGap}`);
+    }
   });
 });

package/src/scenarios/agentPackExport.test.ts

@@ -15,6 +15,11 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import { SCHEMAS_DIR } from '../lib/paths.js';
 import { driver } from '../lib/driver.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { isAgentSupported } from '../lib/multi-agent-capabilities.js';
@@ -24,6 +29,26 @@ import { req } from '../lib/requirement-ids.js';
 const FIXTURE = 'conformance-agent-pack-export';
 const SKIP = !isAgentSupported() || !isFixtureAdvertised(FIXTURE);
 
+/**
+ * The AgentManifest validator (major 1 — this file is `[1]` in
+ * scenario-majors.json). Peers are pre-loaded exactly as `fixtures-valid`
+ * does: agent-manifest → prompt-ref → prompt-kind, under both the canonical
+ * `$id` and the relative file name.
+ */
+function agentManifestValidator(): (doc: unknown) => { ok: boolean; errors: string } {
+  const load = (n: string): Record<string, unknown> => JSON.parse(readFileSync(join(SCHEMAS_DIR, n), 'utf8')) as Record<string, unknown>;
+  const ajv = new Ajv2020({ allErrors: true, strict: false });
+  addFormats(ajv);
+  const promptRef = load('prompt-ref.schema.json');
+  const promptKind = load('prompt-kind.schema.json');
+  ajv.addSchema(promptRef, 'prompt-ref.schema.json');
+  ajv.addSchema(promptRef, './prompt-ref.schema.json');
+  ajv.addSchema(promptKind, 'prompt-kind.schema.json');
+  ajv.addSchema(promptKind, './prompt-kind.schema.json');
+  const validate = ajv.compile(load('agent-manifest.schema.json'));
+  return (doc: unknown) => ({ ok: validate(doc) as boolean, errors: ajv.errorsText(validate.errors, { separator: '; ' }) });
+}
+
 describe.skipIf(SKIP)('agentPackExport: workspace agents project to AgentManifest', () => {
   it('exported manifests contain required AgentManifest fields', async () => {
     const res = await driver.get('/v1/packs/export');
@@ -39,8 +64,16 @@ describe.skipIf(SKIP)('agentPackExport: workspace agents project to AgentManifes
     const manifests = body.manifests ?? [];
     expect(manifests.length).toBeGreaterThan(0);
 
+    // unfailable-leg audit wave 2, 2026-09-27: only `typeof agentId ===
+    // 'string'` was checked, so a host exporting `[{ agentId: 'x' }]` — no
+    // persona, no modelClass, a non-namespaced id — passed a leg named
+    // "required AgentManifest fields". Each exported manifest now validates
+    // against schemas/agent-manifest.schema.json.
+    const validate = agentManifestValidator();
     for (const m of manifests) {
       expect(typeof m.agentId).toBe('string');
+      const v = validate(m);
+      expect(v.ok, req('openwop.it.agentPackExport.exported-manifests-contain-required-agentmanifest-fields', 'schemas/agent-manifest.schema.json', `exported manifest ${String(m.agentId)} MUST validate as an AgentManifest (${v.errors})`)).toBe(true);
       // Exported manifests SHOULD carry sourceManifestId provenance when
       // they originated from a prior install (covered by agentPackProvenance).
     }

package/src/scenarios/agentPackInstall.test.ts

@@ -16,6 +16,11 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import { SCHEMAS_DIR } from '../lib/paths.js';
 import { driver } from '../lib/driver.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { isAgentSupported } from '../lib/multi-agent-capabilities.js';
@@ -25,6 +30,26 @@ import { req } from '../lib/requirement-ids.js';
 const FIXTURE = 'conformance-agent-pack-install';
 const SKIP = !isAgentSupported() || !isFixtureAdvertised(FIXTURE);
 
+/**
+ * The AgentManifest validator (major 1 — this file is `[1]` in
+ * scenario-majors.json). Peers are pre-loaded exactly as `fixtures-valid`
+ * does: agent-manifest → prompt-ref → prompt-kind, under both the canonical
+ * `$id` and the relative file name.
+ */
+function agentManifestValidator(): (doc: unknown) => { ok: boolean; errors: string } {
+  const load = (n: string): Record<string, unknown> => JSON.parse(readFileSync(join(SCHEMAS_DIR, n), 'utf8')) as Record<string, unknown>;
+  const ajv = new Ajv2020({ allErrors: true, strict: false });
+  addFormats(ajv);
+  const promptRef = load('prompt-ref.schema.json');
+  const promptKind = load('prompt-kind.schema.json');
+  ajv.addSchema(promptRef, 'prompt-ref.schema.json');
+  ajv.addSchema(promptRef, './prompt-ref.schema.json');
+  ajv.addSchema(promptKind, 'prompt-kind.schema.json');
+  ajv.addSchema(promptKind, './prompt-kind.schema.json');
+  const validate = ajv.compile(load('agent-manifest.schema.json'));
+  return (doc: unknown) => ({ ok: validate(doc) as boolean, errors: ajv.errorsText(validate.errors, { separator: '; ' }) });
+}
+
 describe.skipIf(SKIP)('agentPackInstall: pack agents[] entries surface as AgentManifest', () => {
   it('host exposes installed agent manifests with required AgentManifest fields', async () => {
     // Host-specific pack-listing endpoint. The conformance suite probes
@@ -45,9 +70,16 @@ describe.skipIf(SKIP)('agentPackInstall: pack agents[] entries surface as AgentM
     const allAgents = packs.flatMap((p) => p.agents ?? []);
 
     expect(allAgents.length).toBeGreaterThan(0);
+    // unfailable-leg audit wave 2, 2026-09-27: only a >=3-char string agentId
+    // was checked, so a host listing `agents: [{ agentId: 'abc' }]` passed a
+    // leg named "required AgentManifest fields". Each surfaced agents[] entry
+    // now validates against schemas/agent-manifest.schema.json.
+    const validate = agentManifestValidator();
     for (const a of allAgents) {
       expect(typeof a.agentId).toBe('string');
       expect(a.agentId!.length).toBeGreaterThanOrEqual(3);
+      const v = validate(a);
+      expect(v.ok, req('openwop.it.agentPackInstall.host-exposes-installed-agent-manifests-with-required-agentmanifest-fields', 'schemas/agent-manifest.schema.json', `pack agents[] entry ${String(a.agentId)} MUST validate as an AgentManifest (${v.errors})`)).toBe(true);
     }
   });
 });

package/src/scenarios/agentReasoningEvents.test.ts

@@ -98,27 +98,36 @@ describe.skipIf(SKIP)('agentReasoningEvents: agent.* event family emission', ()
     //      paired eventId through.
     const calls = agentEvents.filter((e) => e.type === 'agent.toolCalled');
     const returns = agentEvents.filter((e) => e.type === 'agent.toolReturned');
+    // unfailable-leg audit wave 2, 2026-09-27: a toolReturned with NO callId
+    // used to `continue` (skipping pairing entirely), and a matched toolCalled
+    // with no eventId skipped the causationId check — so a host that omitted
+    // both schema-required fields passed the whole pairing requirement.
+    // callId is required on agentToolReturned (run-event-payloads.schema.json)
+    // and eventId on every RunEventDoc (run-event.schema.json): both asserted.
     for (const ret of returns) {
-      const callId = ret.payload?.callId as string | undefined;
-      if (callId === undefined) continue;
+      const callId = ret.payload?.callId;
+      expect(
+        typeof callId === 'string' && callId.length > 0,
+        req('openwop.it.agentReasoningEvents.host-emits-at-least-one-canonical-agent-event-during-a-reasoning-fixture-run', 'schemas/run-event-payloads.schema.json#/$defs/agentToolReturned', 'agent.toolReturned MUST carry a callId (schema-required)'),
+      ).toBe(true);
       const matched = calls.find((c) => c.payload?.callId === callId);
       expect(
         matched,
         req('openwop.it.agentReasoningEvents.host-emits-at-least-one-canonical-agent-event-during-a-reasoning-fixture-run', 'schemas/run-event-payloads.schema.json', `agent.toolReturned.callId=${callId} MUST pair with a prior agent.toolCalled`),
       ).toBeDefined();
 
-      // Strict causationId chain — only assert when the host actually
-      // surfaces eventId on the matched toolCalled event. Hosts that
-      // omit eventId from their `/events` projection skip this check
-      // (and SHOULD add it — RFC 0002 §B's chain integrity depends on
-      // it).
+      // Strict causationId chain. eventId is required on every RunEventDoc
+      // (run-event.schema.json), so a matched toolCalled without one is a
+      // projection defect, not a reason to skip RFC 0002 §B's chain check.
       const matchedEventId = matched?.eventId;
-      if (typeof matchedEventId === 'string' && matchedEventId.length > 0) {
-        expect(
-          ret.causationId,
-          req('openwop.it.agentReasoningEvents.host-emits-at-least-one-canonical-agent-event-during-a-reasoning-fixture-run', 'schemas/run-event-payloads.schema.json', `agent.toolReturned (callId=${callId}) MUST carry causationId === paired agent.toolCalled.eventId per RFC 0002 §B`),
-        ).toBe(matchedEventId);
-      }
+      expect(
+        typeof matchedEventId === 'string' && matchedEventId.length > 0,
+        req('openwop.it.agentReasoningEvents.host-emits-at-least-one-canonical-agent-event-during-a-reasoning-fixture-run', 'schemas/run-event.schema.json', `the agent.toolCalled paired with callId=${String(callId)} MUST carry an eventId (schema-required)`),
+      ).toBe(true);
+      expect(
+        ret.causationId,
+        req('openwop.it.agentReasoningEvents.host-emits-at-least-one-canonical-agent-event-during-a-reasoning-fixture-run', 'schemas/run-event-payloads.schema.json', `agent.toolReturned (callId=${String(callId)}) MUST carry causationId === paired agent.toolCalled.eventId per RFC 0002 §B`),
+      ).toBe(matchedEventId);
     }
   });
 });

package/src/scenarios/agents-run-tool-allowlist.test.ts

@@ -85,10 +85,14 @@ describe('category: core.openwop.agents.run — tool-allowlist enforcement (OPEN
   it('skips cleanly when pack source is not bundled', () => {
     if (!packAvailable) {
       console.warn('[agents-run-tool-allowlist] pack source not present; skipping');
-      expect(packAvailable, req('openwop.it.agents-run-tool-allowlist.skips-cleanly-when-pack-source-is-not-bundled', 'threat-model-prompt-injection.md', 'skips cleanly when pack source is not bundled')).toBe(false);
+      // unfailable-leg audit wave 2, 2026-09-27: this leg asserted
+      // `packAvailable === false` inside `if (!packAvailable)` (and `=== true`
+      // in the else) — tautologies that turned a sentinel into an
+      // `executed-pass` row measuring nothing. It now records `inapplicable`
+      // with zero assertions either way.
       return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!packAvailable` returned early ([agents-run-tool-allowlist] pack source not present; skipping)');
     }
-    expect(packAvailable).toBe(true);
+    return softSkip('inapplicable', 'sentinel leg — pack source is present; the behavioural legs in this file carry the assertions');
   });
 
   it('rejects function-typed tool.handler (the defect path)', async () => {

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

@@ -68,15 +68,16 @@ describe.skipIf(HTTP_SKIP)('ai-envelope-shape: advertisement contract (RFC 0021
   it('capabilities.supportedEnvelopes is an array of strings (when present)', async () => {
     const d = await readDiscovery();
     if (d === null) return softSkip('blocked', 'precondition not met — `d === null` returned early (seam, prior step, or fixture unavailable)');
-    const env = supportedEnvelopes(d);
-    // No assertion if absent — the field is optional. When present, each entry MUST be a string.
-    for (const k of env) {
-      expect(typeof k, req('openwop.it.ai-envelope-shape.capabilities-supportedenvelopes-is-an-array-of-strings-when-present', 'capabilities.md §supportedEnvelopes', 'each entry MUST be a string')).toBe('string');
-    }
-    // Re-affirm shape: array if present (root-first per RFC 0073).
+    // unfailable-leg audit wave 2, 2026-09-27: this loop used to iterate
+    // `supportedEnvelopes(d)`, which had ALREADY filtered out every non-string
+    // entry — so a host advertising `supportedEnvelopes: [42, {}]` passed the
+    // "each entry MUST be a string" assertion. Iterate the RAW advertised array.
     const advertised = capabilityFamily<unknown>(d, 'supportedEnvelopes');
-    if (advertised !== undefined) {
-      expect(Array.isArray(advertised), req('openwop.it.ai-envelope-shape.capabilities-supportedenvelopes-is-an-array-of-strings-when-present', 'capabilities.md §supportedEnvelopes', 'supportedEnvelopes MUST be an array')).toBe(true);
+    // The field is optional: absent is not a violation, but nothing is observed.
+    if (advertised === undefined) return softSkip('inapplicable', 'host does not advertise supportedEnvelopes (optional field)');
+    expect(Array.isArray(advertised), req('openwop.it.ai-envelope-shape.capabilities-supportedenvelopes-is-an-array-of-strings-when-present', 'capabilities.md §supportedEnvelopes', 'supportedEnvelopes MUST be an array')).toBe(true);
+    for (const k of advertised as unknown[]) {
+      expect(typeof k, req('openwop.it.ai-envelope-shape.capabilities-supportedenvelopes-is-an-array-of-strings-when-present', 'capabilities.md §supportedEnvelopes', 'each entry MUST be a string')).toBe('string');
     }
   });
 });

package/src/scenarios/anonymous-actor-write-gated.test.ts

@@ -24,7 +24,7 @@ import { describe, it, expect } from 'vitest';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { readAnonymousActorCap, anonDispatch } from '../lib/anonymousActor.js';
 import { req } from '../lib/requirement-ids.js';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, blockedDespiteAssertions } from '../lib/soft-skip.js';
 
 const PROFILE = 'openwop-anonymous-actor';
 
@@ -74,11 +74,17 @@ describe('anonymous-actor-write-gated (RFC 0132 §C.3)', () => {
       decided?.allowed === false || res.status === 403 || res.status === 429,
       req('openwop.it.anonymous-actor-write-gated.an-anon-write-with-no-resolvable-control-is-denied-with-a-machine-reason', 'SECURITY anon-actor-write-egress-gated', 'an anon write with no resolvable control MUST be denied'),
     ).toBe(true);
-    if (decided && decided.allowed === false) {
-      expect(
-        decided.reason,
-        req('openwop.it.anonymous-actor-write-gated.an-anon-write-with-no-resolvable-control-is-denied-with-a-machine-reason', 'RFC 0132 §C.3', 'an ungated anon write denial carries a machine reason'),
-      ).toBe('anon-write-ungated');
+    // unfailable-leg audit wave 2, 2026-09-27: when the seam surfaced no
+    // `authorizationDecided` denial (a bare 403/429), the machine-reason check
+    // was silently skipped and the leg passed — a host whose denial carried NO
+    // reason (or the wrong one) passed "denied with a machine reason". The
+    // reason is now either asserted or the leg records `blocked`.
+    if (!decided || decided.allowed !== false) {
+      return blockedDespiteAssertions('the denial surfaced no authorizationDecided { allowed: false } payload, so the machine reason (anon-write-ungated) was not observed');
     }
+    expect(
+      decided.reason,
+      req('openwop.it.anonymous-actor-write-gated.an-anon-write-with-no-resolvable-control-is-denied-with-a-machine-reason', 'RFC 0132 §C.3', 'an ungated anon write denial carries a machine reason'),
+    ).toBe('anon-write-ungated');
   });
 });