@openwop/openwop-conformance 2.42.4 → 2.42.6

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # `@openwop/openwop-conformance` Changelog
 
+## [2.42.6] — 2026-09-27 — the era-2 writer rule is witnessable again
+
+- **`0176.era-2-append-vocabulary` is a real witness again on a host that serves the new seam.** New OPTIONAL seams-profile seam `appendEra2Event` (`POST /conformance/seams/sample/event-log/append`, `api/seams-v2.yaml`; `host-sample-test-seams.md` §27) appends ONE v2-named event to a seeded era-2 run through the host's PRODUCTION writer; the leg appends `agent.reasoning-delta` (a codemap-renamed type, stored v1 `agent.reasoning.delta`) and requires the translated read to return the v2 name. Sabotaged: a host whose writer stores v2 names fails the read `500 event_type_unmapped` → `executed-fail`. Dispositions: seam served → a real assertion (the 2.42.5 `partial-witness-ok` annotation is gone for that path); seam served but contract broken → `blocked`; seam NOT served → the 2.42.5 partial witness, never `blocked` (an optional seam newer than the leg must not take away a certification); seams profile not claimed → `inapplicable`.
+- **Suite `2.42.6`**. `@openwop/spec-artifacts` moves in lockstep at the same exact pin.
+
+## [2.42.5] — 2026-09-27 — hotfix: a host can certify again
+
+- **`0176.era-2-append-vocabulary` no longer blocks every host.** 2.42.3's unfailable-leg audit made this leg `blockedDespiteAssertions` whenever a host's appended types are spelled the same in v1 and v2. No catalogued seam lets any host make a seeded era-2 run append a type the codemap renames, so the row recorded `blocked` on every host, and one `blocked` row denies the whole bundle (RFC 0168 §E.1). **No host could certify on 2.42.3 or 2.42.4.** The leg now records a partial witness whose detail says the codemap-renaming writer rule is unwitnessed. The append, the read-back and the sequence rules are observed, and the acceptance predicate still refuses a partial-witness row. It is annotated `partial-witness-ok` for the softskip gate. openwop-1f is adding the seam that makes the rule witnessable. Verified on the v2 reference host: the row now records `executed-pass` with that detail.
+- **Suite `2.42.5`**. `@openwop/spec-artifacts` moves in lockstep at the same exact pin.
+
 ## [2.42.4] — 2026-09-27 — unfailable-leg audit wave 2, an on-the-wire Idempotency-Key witness, and a gate so the class stops growing
 
 - **Wave 2 of the unfailable-leg audit.** `scripts/audit-unfailable-legs.mjs --all` widened the scan from Accepted-RFC ids to every leg, and added a sixth shape: *asserts, then soft-skips*. At major 2 an `inapplicable` or `skipped` note after an assertion records `executed-pass` with a `partial-witness:` detail; at major 1 a `blocked` note does too. Certification counts both.

package/README.md

@@ -11,7 +11,7 @@
 # --legacy-peer-deps is REQUIRED, not optional: the exact peer pin is what npm's
 # default resolver refuses. npm 10.9 fails outright with
 # "Cannot read properties of null (reading 'edgesOut')" — use npm >= 11.
-npm install --legacy-peer-deps @openwop/openwop-conformance@2.42.4 @openwop/spec-artifacts@2.42.4
+npm install --legacy-peer-deps @openwop/openwop-conformance@2.42.6 @openwop/spec-artifacts@2.42.6
 # or run without install:
 npx @openwop/openwop-conformance --base-url https://api.example.com --api-key hk_test_...
 ```

package/dist/spec-artifacts.lock.json

@@ -1,5 +1,5 @@
 {
   "package": "@openwop/spec-artifacts",
-  "version": "2.42.4",
-  "stampSha256": "90c82d8a7f1af393b716e4f020d80d6c1925880de7866483ca99aa40a1a7c118"
+  "version": "2.42.6",
+  "stampSha256": "f52bf05bf4a2f7218557589a5f54422ec57b5ec081102a5f4ab72ed3fb3f72c9"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwop/openwop-conformance",
-  "version": "2.42.4",
+  "version": "2.42.6",
   "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.42.4"
+    "@openwop/spec-artifacts": "2.42.6"
   }
 }

package/requirements.json

@@ -29109,7 +29109,7 @@
     {
       "id": "openwop.it.v2-era-2-append-vocabulary.a-host-append-to-an-open-era-2-run-keeps-the-log-in-v1-vocabulary-so-the-whole-l",
       "file": "v2-era-2-append-vocabulary.test.ts",
-      "line": 48,
+      "line": 50,
       "title": "a host append to an open era-2 run keeps the log in v1 vocabulary, so the whole log still reads",
       "explicitId": "openwop.requirement.0176.era-2-append-vocabulary",
       "citations": [
@@ -29128,6 +29128,11 @@
           "requirement": null,
           "interpolated": true
         },
+        {
+          "section": "spec/v2/core/persistence.md §The writer rule",
+          "requirement": null,
+          "interpolated": true
+        },
         {
           "section": "spec/v2/core/persistence.md §The writer rule",
           "requirement": null,
@@ -29138,7 +29143,7 @@
     {
       "id": "openwop.it.v2-era-2-append-vocabulary.the-run-keeps-the-era-it-was-created-with-an-append-does-not-promote-it-to-era-3",
       "file": "v2-era-2-append-vocabulary.test.ts",
-      "line": 165,
+      "line": 189,
       "title": "the run keeps the era it was created with; an append does not promote it to era 3",
       "explicitId": "openwop.requirement.0176.era-2-append-vocabulary",
       "citations": [

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.4",
-  "corpusTag": "v2.42.4",
+  "version": "2.42.6",
+  "corpusTag": "v2.42.6",
   "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": "227838ab19cdebb23f80b2db19526d8e15aa6af906d24370cb4004ce85cc7c9f",
-    "api/v2/asyncapi.yaml": "6292c9f01b46bdfe708afa96a6ae1c34e63630b3d80658add2c3a90813e6576b",
-    "api/v2/openapi.yaml": "a24ce54a3eb36593db67275e43003366ce8052f1cdb091f4689119ae2d19e530",
+    "api/seams-v2.yaml": "c188943dbb662ddb1d8ed26759c1daa560f63617fedd2a116b8abcc41c2f42de",
+    "api/v2/asyncapi.yaml": "94b9174faeccabea8f2d29fe3e80da7d16037b497ea02f91e61e512ff8ea8d62",
+    "api/v2/openapi.yaml": "5f2bcb438b77c250e0732f1808690bb710941a7c7ee5150a27e66537dee9fcb8",
     "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": "ace1458d77b5a6a34363793173fc32094aea5c94e234b6d28de424b1cc713986",
+    "spec/v1/core-standard-manifest.json": "844a89d3bba9b850d8ae949dc7f0b0ecade689c748263d6c7360e2fe7fb7cf8f",
     "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": "9fe9d757a7d32f98c277d3fc80e76c7a24c312d2144c8df039614a0195f66722",
+    "spec/v2/release.json": "f599686983f47f146a03edec608d63f31525b3e3268036684434afcb972e1cef",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624",
-    "spec/v2/surface-baseline.json": "1acd214d2d65d76c0ed63eca079d029890b920f64faae2b03f68264b5a807ee1"
+    "spec/v2/surface-baseline.json": "34404cc65fb70b8a54bbee40d8e0f5047a29e7df4f1abd55741a697549ccaccf"
   },
-  "corpusCommit": "764dcd152efa9bef1d60210da15780a0dede7849"
+  "corpusCommit": "d578116b9665df11f8d1eaad11fc45f71e826d37"
 }

package/src/lib/era2-seed.ts

@@ -85,6 +85,36 @@ export function era2Gate(doc: Record<string, unknown> | null): Seeded | null {
   return null;
 }
 
+export const APPEND_PATH_V1 = '/v1/host/sample/event-log/append';
+export const APPEND_PATH = seamPath(APPEND_PATH_V1);
+
+export type Appended =
+  | { readonly ok: true; readonly sequence: number }
+  | { readonly ok: false; readonly unserved: true; readonly reason: string }
+  | { readonly ok: false; readonly unserved: false; readonly kind: 'blocked'; readonly reason: string };
+
+/**
+ * Append ONE v2-named event to a seeded era-2 run through the host's production
+ * writer (host-sample-test-seams.md §27, `appendEra2Event`). The seam is only
+ * the trigger: which spelling is STORED is the host writer's decision, and the
+ * production read is what the caller asserts on. UNSERVED (404/405/501) is
+ * reported separately from a served seam that breaks its contract: §27 is an
+ * OPTIONAL seam added after the leg already certified, so its absence falls back
+ * to the pre-seam partial witness rather than denying certification.
+ */
+export async function appendEra2Event(runId: string, type: string, payload: Record<string, unknown>): Promise<Appended> {
+  const res = await http(() => driver.post(APPEND_PATH_V1, { runId, type, payload }));
+  if (res === null) return { ok: false, unserved: false, kind: 'blocked', reason: `${APPEND_PATH} unreachable (fetch failed)` };
+  if (res.status === 404 || res.status === 405 || res.status === 501) {
+    return { ok: false, unserved: true, reason: `${APPEND_PATH} answered ${res.status} — the host does not serve the optional appendEra2Event seam (host-sample-test-seams.md §27)` };
+  }
+  const sequence = (res.json as { sequence?: unknown } | undefined)?.sequence;
+  if (res.status !== 202 || typeof sequence !== 'number') {
+    return { ok: false, unserved: false, kind: 'blocked', reason: `${APPEND_PATH} answered ${res.status} ${readErrorCode(res.json) ?? ''} without a 202 { runId, sequence } — the append contract is not honoured`.trim() };
+  }
+  return { ok: true, sequence };
+}
+
 /** Seed an era-2 log in v1 vocabulary; the reason names the seam when it is absent. */
 export async function seedEra2Log(events: readonly SeedEvent[], status: 'completed' | 'running' | 'paused' = 'completed'): Promise<Seeded> {
   const res = await http(() => driver.post(SEED_PATH_V1, { eventLogSchemaVersion: 2, status, events }));

package/src/scenarios/v2-era-2-append-vocabulary.test.ts

@@ -28,13 +28,15 @@
 import { describe, it, expect } from 'vitest';
 import { driver, type OpenWOPResponse } from '../lib/driver.js';
 import { v2Discovery } from '../lib/v2.js';
-import { blockedDespiteAssertions, softSkip } from '../lib/soft-skip.js';
+import { softSkip } from '../lib/soft-skip.js';
 import { req } from '../lib/requirement-ids.js';
 import { readErrorCode } from '../lib/error-envelope.js';
-import { codemapV1toV2, era2Gate, eventsOf, pollEvents, seedEra2Log, v1FixtureLog, type ReadEvent } from '../lib/era2-seed.js';
+import { appendEra2Event, codemapV1toV2, era2Gate, eventsOf, pollEvents, seedEra2Log, v1FixtureLog, type ReadEvent } from '../lib/era2-seed.js';
 
 const ID = 'openwop.requirement.0176.era-2-append-vocabulary';
 const DOC = 'spec/v2/core/persistence.md §The writer rule';
+/** A type the codemap renames (v1 `agent.reasoning.delta`); artifact event, no projection effect. */
+const WITNESS_TYPE = 'agent.reasoning-delta';
 
 async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> {
   try {
@@ -88,20 +90,31 @@ describe('v2-era-2-append-vocabulary (RFC 0176 §A — the writer rule)', () =>
     // Neither answer is asserted: the resume transition's event set is not
     // pinned to a renamed type, and a seeded run's pause is host latitude. If
     // no renamed type is appended, the leg records `blocked` below, not a pass.
+    // 2.42.6: the writer-rule witness proper. `appendEra2Event` (host-sample-test-
+    // seams.md §27) hands the host ONE event of a type the codemap RENAMES
+    // (`agent.reasoning-delta`, stored v1 `agent.reasoning.delta`) and the host's
+    // production writer chooses the stored spelling; the read below is the witness.
+    // It is an artifact event, so it moves no projection. A host that does not
+    // serve the seam falls through to the pre-seam path below and ends in the
+    // annotated partial witness, never `blocked` (see the next comment); the gate
+    // above already made a host without the seams profile `inapplicable`.
+    const appended = await appendEra2Event(runId, WITNESS_TYPE, { agentId: 'conformance', delta: 'era-2 writer-rule witness', sequence: 0 });
+    // A served seam that breaks its contract is `blocked`. An UNSERVED seam is not:
+    // §27 is optional and newer than this leg, so its absence falls through to the
+    // pre-seam path and ends in the partial witness below — it never denies a
+    // host certification it held before the seam existed.
+    if (!appended.ok && !appended.unserved) return softSkip(appended.kind, appended.reason);
+    const seamServed = appended.ok;
+
     const enc = encodeURIComponent(runId);
     const paused = await http(() => driver.post(`/runs/${enc}:pause`, { reason: 'conformance', drainPolicy: 'immediate' }));
-    const resumed = paused?.status === 202 ? await http(() => driver.post(`/runs/${enc}:resume`, { reason: 'conformance' })) : null;
-
-    // One canonical mutation so the HOST's own writer appends. Cancel is the
-    // universally available terminal transition; a host that refuses it on a
-    // seeded run records `blocked` rather than a pass — unless the pause and
-    // resume above were both accepted, which already drove the host's writer.
-    const cancelled = await http(() => driver.post(`/runs/${enc}/cancel`, {}));
-    const cancelOk = cancelled !== null && (cancelled.status === 200 || cancelled.status === 202 || cancelled.status === 204);
-    const pauseResumeOk = paused?.status === 202 && resumed?.status === 202;
-    if (!cancelOk && !pauseResumeOk) {
-      return softSkip('blocked', `POST /runs/{runId}/cancel answered ${cancelled?.status ?? 'no response'} on a seeded era-2 run (pause ${paused?.status ?? 'no response'}, resume ${resumed?.status ?? 'not attempted'}) — no canonical mutation drove the host's writer, so the append is unwitnessed`);
-    }
+    if (paused?.status === 202) await http(() => driver.post(`/runs/${enc}:resume`, { reason: 'conformance' }));
+
+    // A canonical mutation as well, so the host's own lifecycle writer appends
+    // beside the seam's append. The seam append above already drove the
+    // production writer, so a host that refuses cancel on a SEEDED run no longer
+    // leaves the rule unwitnessed — the answer is not asserted here.
+    await http(() => driver.post(`/runs/${enc}/cancel`, {}));
 
     const after = await pollEvents(runId);
     if (after === null) return softSkip('blocked', 'the event read failed after the append');
@@ -154,12 +167,23 @@ describe('v2-era-2-append-vocabulary (RFC 0176 §A — the writer rule)', () =>
     // positive witness: the stored spelling was the v1 one the reader maps
     // from. When every appended type is spelled the same in both vocabularies,
     // the rows above hold for a v1-writing and a v2-writing host alike, so the
-    // writer rule is unobserved — `blocked`, not a pass.
+    // writer rule is unobserved.
     const renamedV2 = new Set([...codemapV1toV2()].filter(([v1, v2]) => v1 !== v2).map(([, v2]) => v2));
     const appendedTypes = rows.slice(seedCount).map((r) => String(r.type ?? ''));
-    if (!appendedTypes.some((t) => renamedV2.has(t))) {
-      return blockedDespiteAssertions(`every type the host appended to the era-2 log (${appendedTypes.join(', ') || 'none'}) is spelled identically in v1 and v2 (spec/v2/event-codemap.json), so a host writing v2 names reads back the same as one writing v1 names — the writer rule is unobserved. The leg needs a canonical mutation that appends a renamed type (e.g. run.resuming → run.resume-started); pause ${paused?.status ?? 'no response'} / resume ${resumed?.status ?? 'not attempted'} on the seeded run appended none, and the seed seam (api/seams-v2.yaml seedEra2EventLog) cannot seed a paused or interrupt-suspended era-2 run to resume.`);
+    if (!seamServed && !appendedTypes.some((t) => renamedV2.has(t))) {
+      // partial-witness-ok: the host does not serve the optional appendEra2Event
+      // seam (host-sample-test-seams.md §27), and none of its own appends was a
+      // codemap-RENAMED type, so the writer rule is unobserved here. The append,
+      // the read-back and the sequence rules above ARE observed. This is the
+      // 2.42.5 disposition, kept for hosts without the seam; the acceptance
+      // predicate refuses a partial-witness row. (A host without the seam whose
+      // own pause/resume appended a renamed type falls through: that IS a witness.)
+      return softSkip('inapplicable', `partial witness — the codemap-renaming writer rule is UNWITNESSED: ${appended.ok ? '' : appended.reason}; every type the host appended to the era-2 log (${appendedTypes.join(', ') || 'none'}) is spelled identically in v1 and v2 (spec/v2/event-codemap.json)`);
     }
+    if (seamServed) expect(
+      appendedTypes.includes(WITNESS_TYPE),
+      req(ID, DOC, `the event appended through appendEra2Event (${WITNESS_TYPE}, a codemap-RENAMED type) MUST read back under its v2 name through the translated read — it read as ${appendedTypes.join(', ') || 'nothing'}: a host that stored the v2 spelling in an era-2 log makes the reader map it a second time (event_type_unmapped), and one that bypassed the storage boundary leaks the v1 spelling`),
+    ).toBe(true);
   });
 
   it('the run keeps the era it was created with; an append does not promote it to era 3', async () => {