@openwop/openwop-conformance 2.0.0-rc.55 → 2.0.0-rc.56

package/dist/lib/scenario-disposition.js

@@ -77,6 +77,38 @@ export function requirementIdForFile(basename) {
  * the thing that passed.
  */
 export const PARTIAL_WITNESS_PREFIX = 'partial-witness: ';
+/**
+ * The per-`it` record (RFC 0148 §A at test granularity), as `setup.ts`
+ * computes it in `afterEach`. Pure so a lib test can pin it:
+ *   - fail                         ⇒ executed-fail (detail = the first error message)
+ *   - pass with ≥ 1 assertion      ⇒ executed-pass
+ *   - a behaviorGate entry journaled during the test ⇒ that gate's disposition
+ *   - pass with 0 assertions       ⇒ the softSkip note written DURING THIS TEST
+ *                                    (`inapplicable` / `skipped` / `blocked`, worst-first),
+ *                                    else `blocked` + the unclassified-return marker
+ *   - vitest skip (ctx.skip / it.skip) ⇒ the note written before the skip, else `skipped`
+ *
+ * rc.56: the fourth line is new. Until then a zero-assertion pass consulted the
+ * journal only, so a leg that returned `softSkip('inapplicable', …)` was
+ * recorded `blocked / unclassified return` at `it` granularity while its file
+ * row (which does read the notes — `resolveFileRecord`) was `inapplicable`.
+ * A bundle with any `blocked` row does not certify (RFC 0168 §E.1), so the
+ * dishonest per-`it` rows denied certification to every profile on a host that
+ * simply did not advertise the gated surface.
+ */
+export function resolveItRecord(state, assertionCalls, gate, noted, firstError) {
+    if (state === 'fail')
+        return { disposition: 'executed-fail', detail: `the test executed and failed: ${(firstError ?? 'no message').slice(0, 300)}` };
+    if (state === 'pass' && assertionCalls > 0)
+        return { disposition: 'executed-pass' };
+    if (gate !== undefined)
+        return { disposition: gate.disposition, detail: gate.detail ?? `${gate.disposition} (gate recorded no reason)` };
+    if (noted !== null)
+        return { disposition: noted.kind, detail: noted.reason };
+    if (state === 'pass')
+        return { disposition: 'blocked', detail: 'unclassified return: the test passed with zero assertions and recorded no reason — RFC 0148 §A resolves it to blocked, never to a pass' };
+    return { disposition: 'skipped', detail: 'vitest skipped the test (ctx.skip / it.skip) without a recorded gate reason' };
+}
 /** Worker half: fold a file's per-test states (+ any gate-recorded reason) into
  *  the ONE disposition the file records. */
 export function fileDisposition(states, gateReason, assertionCount) {

package/dist/lib/soft-skip.js

@@ -22,12 +22,24 @@
  * resolves it to blocked" — and stays UNCLASSIFIED for certification (a floor
  * row with that disposition still rejects), so the honest bundle row and the
  * pressure to say why both survive.
+ *
+ * rc.56: every note also carries a sequence number, so the per-`it` row can
+ * read the notes written DURING ITS OWN TEST (`softSkipMark()` at test start,
+ * `softSkipDispositionSince(file, mark)` at test end). Until rc.56 the
+ * per-`it` row consulted only the journal's `behaviorGate` entries, never a
+ * softSkip note, so a leg that returned `softSkip('inapplicable', 'a2a facet
+ * not advertised')` was recorded `blocked / unclassified return` at `it`
+ * granularity while its file row was honestly `inapplicable` — and a bundle
+ * with any `blocked` row does not certify (RFC 0168 §E.1). Forty-five such
+ * rows on a host that simply does not advertise A2A/MCP denied certification
+ * to every profile it claimed.
  */
 import { expect } from 'vitest';
 import { basename } from 'node:path';
 /** Detail marker the runner writes for a zero-assertion file that noted nothing. */
 export const UNCLASSIFIED_RETURN_DETAIL = 'every test returned early with zero assertions and no recorded reason — unclassified return; RFC 0148 §A resolves it to blocked (add softSkip(kind, reason) at the early return)';
 const notes = new Map();
+let seq = 0;
 function currentFile() {
     try {
         const p = expect.getState().testPath;
@@ -43,8 +55,9 @@ export function softSkip(kind, reason) {
     if (file === null)
         return undefined;
     const arr = notes.get(file) ?? [];
-    if (!arr.some((n) => n.kind === kind && n.reason === reason))
-        arr.push({ kind, reason });
+    // Every call is recorded with its own sequence number so a per-test window
+    // sees it; the file-level join de-duplicates identical (kind, reason) pairs.
+    arr.push({ kind, reason, seq: ++seq });
     notes.set(file, arr);
     return undefined;
 }
@@ -62,6 +75,17 @@ export function seamAbsent(reason) {
     return softSkip('blocked', reason);
 }
 const RANK = { blocked: 0, skipped: 1, inapplicable: 2 };
+function fold(arr) {
+    if (arr.length === 0)
+        return null;
+    const uniq = [];
+    for (const n of arr)
+        if (!uniq.some((u) => u.kind === n.kind && u.reason === n.reason))
+            uniq.push(n);
+    const kind = [...uniq].sort((a, b) => RANK[a.kind] - RANK[b.kind])[0].kind;
+    const reason = uniq.map((n) => (uniq.length > 1 ? `[${n.kind}] ${n.reason}` : n.reason)).join('; ');
+    return { kind, reason };
+}
 /**
  * The noted disposition for a file, worst-first when mixed (`blocked` beats
  * `skipped` beats `inapplicable` — a file that could not check one thing is
@@ -69,14 +93,21 @@ const RANK = { blocked: 0, skipped: 1, inapplicable: 2 };
  * the reasons joined. `null` when nothing was noted.
  */
 export function softSkipDisposition(file) {
-    const arr = notes.get(file);
-    if (arr === undefined || arr.length === 0)
-        return null;
-    const kind = [...arr].sort((a, b) => RANK[a.kind] - RANK[b.kind])[0].kind;
-    const reason = arr.map((n) => (arr.length > 1 ? `[${n.kind}] ${n.reason}` : n.reason)).join('; ');
-    return { kind, reason };
+    return fold(notes.get(file) ?? []);
+}
+/** A position in the note sequence; pass it to `softSkipDispositionSince`. */
+export function softSkipMark() {
+    return seq;
+}
+/**
+ * The noted disposition for a file counting only notes written AFTER `mark`
+ * — the notes of the test that is ending. Same fold as the file rule.
+ */
+export function softSkipDispositionSince(file, mark) {
+    return fold((notes.get(file) ?? []).filter((n) => n.seq > mark));
 }
 /** Test hook. */
 export function resetSoftSkips() {
     notes.clear();
+    seq = 0;
 }

package/dist/spec-artifacts.lock.json

@@ -1,5 +1,5 @@
 {
   "package": "@openwop/spec-artifacts",
-  "version": "2.0.0-rc.55",
-  "stampSha256": "b0248029d9d1f2892661fa3addada15a500ecbe9a58a09a72102cc9867be6a68"
+  "version": "2.0.0-rc.56",
+  "stampSha256": "d78af0be319b1a6f573bd342ed68df7d9daa61db218ef6c48db2d5036fcdf36c"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwop/openwop-conformance",
-  "version": "2.0.0-rc.55",
+  "version": "2.0.0-rc.56",
   "description": "Production-ready black-box conformance suite for OpenWOP v1.0 compliant servers.",
   "repository": {
     "type": "git",
@@ -56,6 +56,6 @@
     "@openwop/spec-artifacts": "file:../spec-artifacts"
   },
   "peerDependencies": {
-    "@openwop/spec-artifacts": "2.0.0-rc.55"
+    "@openwop/spec-artifacts": "2.0.0-rc.56"
   }
 }

package/schemas/CORPUS-STAMP.json

@@ -1,7 +1,7 @@
 {
   "_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.0.0-rc.55",
+  "version": "2.0.0-rc.56",
   "corpusTag": null,
   "files": {
     "api/.redocly.lint-ignore.yaml": "bf5a8350b88a72fa43f59605ed8d903ed24b6cfccda5e45509c9f6ed9ee4e712",
@@ -9,9 +9,9 @@
     "api/grpc/openwop.proto": "c3e72bb17cba514ee98feb6434e6c9b6ea6795bfd086489ec69fd882dd1ad977",
     "api/openapi.yaml": "39081c59fb696159806b0f2f9a42e7e9ff830d622fcf2ad4159b21357580a955",
     "api/redocly.yaml": "b0604c89b2ca6d5076ec25725c539dad44a741a811fe524439ee6daef8baa09f",
-    "api/seams-v2.yaml": "6f00017b7c5b238f1d2fa67d38e4e2877767a9a723148dbec27c9848916b7a1d",
-    "api/v2/asyncapi.yaml": "bb08bba189e7a5554faa8ee4f7cee338e22a2caf1b97f136feee7e53a2df68ca",
-    "api/v2/openapi.yaml": "a55411c772643be1974acb69e340d306f8b6b00b85bcaac6bb5df0b9f667a297",
+    "api/seams-v2.yaml": "1840bfc791a0b473e37c6f532147af045232e602d1aa8c47c4f192e3014fd638",
+    "api/v2/asyncapi.yaml": "52d40ac8cc3441302de74ed9eaa33784c906f1a43153f282333f58d2e048e98a",
+    "api/v2/openapi.yaml": "2dff5215b2b5c0ba37eedd79f997f79f07da4055fa38a31c24af2a8193bb4e48",
     "api/v2/redocly.yaml": "1e66b60e6118ad11a823bb620678be464d99dfe50a40e3e6f93ec9429b88b34c",
     "schemas/README.md": "0c0b737ffcf8f30e7d2809cec8a498232de710f41443212922ad8337cdde0b51",
     "schemas/a2a-task-state.schema.json": "c9365918f993f943b4b619d42551eb066a1ed33a08d895d51b395432a5b1f1bc",
@@ -199,7 +199,7 @@
     "schemas/workspace-file.schema.json": "464de85c2a068243084ee9c1d969bc7cd5d8f7948574e58450d6493c38a0e1e4",
     "spec/v1/alias-detectors.json": "fee4594ef49953953ffcd0b3813300067d16b3e65ebff2aac722034ac9b3f545",
     "spec/v1/capability-declaration-classes.json": "e7729aed5c4b4e1dd02abab0530f14cc95f5d4070fe51fb139e7f5cccefa00c6",
-    "spec/v1/core-standard-manifest.json": "7d9ab29be97a94750aa1a345205e23f4b3672c426d8f53a0af3203be2edeb4e3",
+    "spec/v1/core-standard-manifest.json": "0c6bf3d8bb239fffc06a6e2819a009ed616922e063c001d0f8aa426614f85dc8",
     "spec/v1/deprecations.json": "1d5acb69a9b8ccb57275a95605f74aef1d920685f8407c9d382a46b59dc803bb",
     "spec/v1/deprecations.schema.json": "18c87e78bedc210431f795ae44c5b5d202f2f3317850d5cf86867d4f1fa1cdfb",
     "spec/v1/event-codemap.json": "3da60d884157793a360da532a9fcbbfb5285636db325a74cec94b34622186d97",
@@ -230,8 +230,8 @@
     "spec/v2/path-manifest.json": "034152e09b1458c66810d4050e20a273b2b9b8fe2d92b66e8b819477de58a1be",
     "spec/v2/peer-dependency-aliases.json": "d10299280abee08258502925bc327293ee413e0108cd6e6ec75ff6110653308d",
     "spec/v2/profiles.json": "5019ac8209540bfbeee9c3232530d4e599be0ab926d817ff48edcec8419eb209",
-    "spec/v2/release.json": "d6c6cf65c949713644ff9ee19acc824b8956135fa2492a1a795181dc96db7da5",
+    "spec/v2/release.json": "86e73d0a91cc0c999241a2ac7178e7244e96570603c4166585115a47ec099cc5",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624"
   },
-  "corpusCommit": "4b603d6f0d24d1df7b7f2f94c544a37e41048ff0"
+  "corpusCommit": "5a392d02160028331ff2e73fc2252050db2be0fb"
 }

package/src/lib/scenario-disposition.ts

@@ -79,6 +79,40 @@ export const PARTIAL_WITNESS_PREFIX = 'partial-witness: ';
 
 export type FileTestState = 'pass' | 'fail' | 'skip';
 
+/**
+ * The per-`it` record (RFC 0148 §A at test granularity), as `setup.ts`
+ * computes it in `afterEach`. Pure so a lib test can pin it:
+ *   - fail                         ⇒ executed-fail (detail = the first error message)
+ *   - pass with ≥ 1 assertion      ⇒ executed-pass
+ *   - a behaviorGate entry journaled during the test ⇒ that gate's disposition
+ *   - pass with 0 assertions       ⇒ the softSkip note written DURING THIS TEST
+ *                                    (`inapplicable` / `skipped` / `blocked`, worst-first),
+ *                                    else `blocked` + the unclassified-return marker
+ *   - vitest skip (ctx.skip / it.skip) ⇒ the note written before the skip, else `skipped`
+ *
+ * rc.56: the fourth line is new. Until then a zero-assertion pass consulted the
+ * journal only, so a leg that returned `softSkip('inapplicable', …)` was
+ * recorded `blocked / unclassified return` at `it` granularity while its file
+ * row (which does read the notes — `resolveFileRecord`) was `inapplicable`.
+ * A bundle with any `blocked` row does not certify (RFC 0168 §E.1), so the
+ * dishonest per-`it` rows denied certification to every profile on a host that
+ * simply did not advertise the gated surface.
+ */
+export function resolveItRecord(
+  state: FileTestState,
+  assertionCalls: number,
+  gate: { disposition: 'inapplicable' | 'skipped'; detail?: string } | undefined,
+  noted: { kind: 'inapplicable' | 'skipped' | 'blocked'; reason: string } | null,
+  firstError?: string,
+): { disposition: Disposition; detail?: string } {
+  if (state === 'fail') return { disposition: 'executed-fail', detail: `the test executed and failed: ${(firstError ?? 'no message').slice(0, 300)}` };
+  if (state === 'pass' && assertionCalls > 0) return { disposition: 'executed-pass' };
+  if (gate !== undefined) return { disposition: gate.disposition, detail: gate.detail ?? `${gate.disposition} (gate recorded no reason)` };
+  if (noted !== null) return { disposition: noted.kind, detail: noted.reason };
+  if (state === 'pass') return { disposition: 'blocked', detail: 'unclassified return: the test passed with zero assertions and recorded no reason — RFC 0148 §A resolves it to blocked, never to a pass' };
+  return { disposition: 'skipped', detail: 'vitest skipped the test (ctx.skip / it.skip) without a recorded gate reason' };
+}
+
 /** Worker half: fold a file's per-test states (+ any gate-recorded reason) into
  *  the ONE disposition the file records. */
 export function fileDisposition(

package/src/lib/soft-skip.ts

@@ -22,6 +22,17 @@
  * resolves it to blocked" — and stays UNCLASSIFIED for certification (a floor
  * row with that disposition still rejects), so the honest bundle row and the
  * pressure to say why both survive.
+ *
+ * rc.56: every note also carries a sequence number, so the per-`it` row can
+ * read the notes written DURING ITS OWN TEST (`softSkipMark()` at test start,
+ * `softSkipDispositionSince(file, mark)` at test end). Until rc.56 the
+ * per-`it` row consulted only the journal's `behaviorGate` entries, never a
+ * softSkip note, so a leg that returned `softSkip('inapplicable', 'a2a facet
+ * not advertised')` was recorded `blocked / unclassified return` at `it`
+ * granularity while its file row was honestly `inapplicable` — and a bundle
+ * with any `blocked` row does not certify (RFC 0168 §E.1). Forty-five such
+ * rows on a host that simply does not advertise A2A/MCP denied certification
+ * to every profile it claimed.
  */
 
 import { expect } from 'vitest';
@@ -32,7 +43,10 @@ export type SoftSkipKind = 'inapplicable' | 'skipped' | 'blocked';
 /** Detail marker the runner writes for a zero-assertion file that noted nothing. */
 export const UNCLASSIFIED_RETURN_DETAIL = 'every test returned early with zero assertions and no recorded reason — unclassified return; RFC 0148 §A resolves it to blocked (add softSkip(kind, reason) at the early return)';
 
-const notes = new Map<string, Array<{ kind: SoftSkipKind; reason: string }>>();
+interface Note { readonly kind: SoftSkipKind; readonly reason: string; readonly seq: number }
+
+const notes = new Map<string, Note[]>();
+let seq = 0;
 
 function currentFile(): string | null {
   try {
@@ -48,7 +62,9 @@ export function softSkip(kind: SoftSkipKind, reason: string): undefined {
   const file = currentFile();
   if (file === null) return undefined;
   const arr = notes.get(file) ?? [];
-  if (!arr.some((n) => n.kind === kind && n.reason === reason)) arr.push({ kind, reason });
+  // Every call is recorded with its own sequence number so a per-test window
+  // sees it; the file-level join de-duplicates identical (kind, reason) pairs.
+  arr.push({ kind, reason, seq: ++seq });
   notes.set(file, arr);
   return undefined;
 }
@@ -69,6 +85,15 @@ export function seamAbsent(reason: string): undefined {
 
 const RANK: Record<SoftSkipKind, number> = { blocked: 0, skipped: 1, inapplicable: 2 };
 
+function fold(arr: readonly Note[]): { kind: SoftSkipKind; reason: string } | null {
+  if (arr.length === 0) return null;
+  const uniq: Note[] = [];
+  for (const n of arr) if (!uniq.some((u) => u.kind === n.kind && u.reason === n.reason)) uniq.push(n);
+  const kind = [...uniq].sort((a, b) => RANK[a.kind] - RANK[b.kind])[0]!.kind;
+  const reason = uniq.map((n) => (uniq.length > 1 ? `[${n.kind}] ${n.reason}` : n.reason)).join('; ');
+  return { kind, reason };
+}
+
 /**
  * The noted disposition for a file, worst-first when mixed (`blocked` beats
  * `skipped` beats `inapplicable` — a file that could not check one thing is
@@ -76,14 +101,24 @@ const RANK: Record<SoftSkipKind, number> = { blocked: 0, skipped: 1, inapplicabl
  * the reasons joined. `null` when nothing was noted.
  */
 export function softSkipDisposition(file: string): { kind: SoftSkipKind; reason: string } | null {
-  const arr = notes.get(file);
-  if (arr === undefined || arr.length === 0) return null;
-  const kind = [...arr].sort((a, b) => RANK[a.kind] - RANK[b.kind])[0]!.kind;
-  const reason = arr.map((n) => (arr.length > 1 ? `[${n.kind}] ${n.reason}` : n.reason)).join('; ');
-  return { kind, reason };
+  return fold(notes.get(file) ?? []);
+}
+
+/** A position in the note sequence; pass it to `softSkipDispositionSince`. */
+export function softSkipMark(): number {
+  return seq;
+}
+
+/**
+ * The noted disposition for a file counting only notes written AFTER `mark`
+ * — the notes of the test that is ending. Same fold as the file rule.
+ */
+export function softSkipDispositionSince(file: string, mark: number): { kind: SoftSkipKind; reason: string } | null {
+  return fold((notes.get(file) ?? []).filter((n) => n.seq > mark));
 }
 
 /** Test hook. */
 export function resetSoftSkips(): void {
   notes.clear();
+  seq = 0;
 }

package/src/setup.ts

@@ -35,8 +35,8 @@ import { basename, join } from 'node:path';
 import { existsSync, readFileSync } from 'node:fs';
 import { PKG_ROOT_PATH } from './lib/paths.js';
 import { recordRequirement, hasRequirement, journalLength, journalSince } from './lib/requirement-ledger.js';
-import { requirementIdForFile, resolveFileRecord, type FileTestState } from './lib/scenario-disposition.js';
-import { softSkipDisposition } from './lib/soft-skip.js';
+import { requirementIdForFile, resolveFileRecord, resolveItRecord, type FileTestState } from './lib/scenario-disposition.js';
+import { softSkipDisposition, softSkipDispositionSince, softSkipMark } from './lib/soft-skip.js';
 import { ItIdAllocator, takeExplicitRequirementId } from './lib/requirement-ids.js';
 import { SPEC_COHERENCE_SCENARIOS, SPEC_COHERENCE_DETAIL } from './lib/spec-coherence.js';
 import type { DiscoveryPayload } from './lib/profiles.js';
@@ -239,6 +239,7 @@ const _ledgerMarks = new Map<string, number>();
 const _itAllocators = new Map<string, ItIdAllocator>();
 const _itMarks = new Map<string, number>();
 const _itAssertionsBefore = new Map<string, number>();
+const _itSoftSkipMarks = new Map<string, number>();
 function _assertionCalls(): number {
   try {
     return (expect.getState() as { assertionCalls?: number }).assertionCalls ?? 0;
@@ -347,6 +348,7 @@ beforeEach(({ task }) => {
   // Window for this test's own gate decisions and its own assertion count.
   _itMarks.set(file, journalLength());
   _itAssertionsBefore.set(file, _assertionCalls());
+  _itSoftSkipMarks.set(file, softSkipMark()); // rc.56: this test's own softSkip window
   takeExplicitRequirementId(); // clear any override left by a test that threw before afterEach
 });
 afterEach(({ task }) => {
@@ -395,7 +397,8 @@ afterEach(({ task }) => {
   _itAllocators.set(file, alloc);
   const itId = explicit ?? alloc.allocate(file, task.name);
   const since = journalSince(_itMarks.get(file) ?? 0);
-  const gate = since.find((e) => e.disposition === 'inapplicable') ?? since.find((e) => e.disposition === 'skipped');
+  const gateEntry = since.find((e) => e.disposition === 'inapplicable') ?? since.find((e) => e.disposition === 'skipped');
+  const gate = gateEntry === undefined ? undefined : { disposition: gateEntry.disposition as 'inapplicable' | 'skipped', ...(gateEntry.detail === undefined ? {} : { detail: gateEntry.detail }) };
   let disposition: 'executed-pass' | 'executed-fail' | 'skipped' | 'inapplicable' | 'blocked';
   let detail: string | undefined;
   // Suite 2.0.0: under the corpus gate (scripts/check-spec-coherence.mjs sets OPENWOP_CORPUS_GATE) a coherence scenario IS the subject; its rows are real dispositions for evidence/corpus-ledger.json.
@@ -405,21 +408,15 @@ afterEach(({ task }) => {
     // rule `resolveFileRecord` applies to the file in the published layout.
     disposition = 'inapplicable';
     detail = SPEC_COHERENCE_DETAIL;
-  } else if (state === 'fail') {
-    disposition = 'executed-fail';
-    const err = (task.result?.errors ?? [])[0] as { message?: string } | undefined;
-    detail = `the test executed and failed: ${(err?.message ?? 'no message').slice(0, 300)}`;
-  } else if (state === 'pass' && calls > 0) {
-    disposition = 'executed-pass';
-  } else if (gate !== undefined) {
-    disposition = gate.disposition as 'skipped' | 'inapplicable';
-    detail = gate.detail ?? `${gate.disposition} (gate recorded no reason)`;
-  } else if (state === 'pass') {
-    disposition = 'blocked';
-    detail = 'unclassified return: the test passed with zero assertions and recorded no reason — RFC 0148 §A resolves it to blocked, never to a pass';
   } else {
-    disposition = 'skipped';
-    detail = 'vitest skipped the test (ctx.skip / it.skip) without a recorded gate reason';
+    // rc.56: the softSkip notes THIS test wrote are its reason (the file row
+    // already read them; the per-`it` row did not, and a leg that said
+    // `inapplicable` came out `blocked` — which denies certification bundle-wide).
+    const noted = softSkipDispositionSince(file, _itSoftSkipMarks.get(file) ?? 0);
+    const err = (task.result?.errors ?? [])[0] as { message?: string } | undefined;
+    const rec = resolveItRecord(state === 'pass' ? 'pass' : state === 'fail' ? 'fail' : 'skip', calls, gate, noted, err?.message);
+    disposition = rec.disposition;
+    detail = rec.detail;
   }
   try {
     recordRequirement(itId, disposition, detail, { assertionCount: calls, scenarioFile: file });