@openwop/openwop-conformance 2.42.9 → 2.43.1

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

@@ -0,0 +1,262 @@
+/**
+ * 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`;
+ *   5. `conformance-approval-reject-routed` (gap G1, suite 2.43.1): rejected, the
+ *      gate fails with `approval_rejected` / `retryable: false`, its
+ *      `any_failed` target runs, its `all_success` target never runs, and the
+ *      run completes;
+ *   6. `conformance-approval-timeout` (gap G2, suite 2.43.1): left unresolved
+ *      past its 1500 ms `timeoutMs` with no `onTimeout`, the host resolves the
+ *      gate itself (`action: timeout`, `decision: rejected`, `reason: timeout`),
+ *      the gate fails with `approval_rejected` and `run.failed` names it;
+ *   7. `conformance-approval-timeout-approve` (openwop#1696, suite 2.43.1): the
+ *      same gate with `onTimeout: "approve"` still resolves rejected — a
+ *      timeout never grants — and the run fails, never completes;
+ *   8. `conformance-approval-reject-loopback` (openwop#1697, suite 2.43.1): a
+ *      rejected gate routed back to itself through `revise` is asked again —
+ *      a second `interrupt.requested` with a different `key`, the run back in
+ *      `waiting-approval`, and no second `interrupt.resolved` (the first
+ *      rejection is not replayed). `inapplicable` on a host that does not
+ *      advertise the fixture, i.e. one that does not run cycles.
+ *
+ * The legs are separate rows so a host that misses one field fails that row
+ * only. Legs 5 and 6 each need their own fixture, because `conformance-approval`
+ * has no edges and no timer and widening a fixture every host serves would force
+ * a re-registration (fixtures.md §conformance-approval-refine); a host that
+ * does not advertise one records `inapplicable`. Leg 5 does not require
+ * `node.skipped`: interrupt.md says the `all_success` edge is not satisfied, not
+ * how a host records that, so the leg asserts only that the target never ran.
+ *
+ * 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';
+import { scaledTimeoutMs } from '../lib/polling.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 ROUTED = 'conformance-approval-reject-routed';
+const TIMEOUT = 'conformance-approval-timeout';
+const TIMEOUT_APPROVE = 'conformance-approval-timeout-approve';
+const LOOPBACK = 'conformance-approval-reject-loopback';
+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);
+
+  it('a rejected gate routed over an any_failed edge fails as a node, its all_success sibling never runs, and the run completes', async () => {
+    if (!(await gateFamily('interrupt'))) return softSkip('inapplicable', 'interrupt family not advertised (gate recorded under openwop.family.interrupt)');
+    if (!isFixtureAdvertised(ROUTED)) return softSkip('inapplicable', `fixture ${ROUTED} is not advertised — the host does not claim the routed-reject fixture`);
+    const s = await suspended(ROUTED);
+    if ('reason' in s) return softSkip('blocked', s.reason);
+    const res = await resolve(s.runId, { action: 'reject' });
+    if (res === null || res.status < 200 || res.status >= 300) return softSkip('blocked', `the reject resolve answered ${res?.status ?? 'nothing'} ${readErrorCode(res?.json) ?? ''} — interrupt resolution owns that contract`);
+    const id = R('reject-routed');
+    const terminal = await waitStatus(s.runId, TERMINAL, 10_000);
+    const evs = await events(s.runId);
+    const ran = (nodeId: string, type: string): boolean => evs.some((e) => e.type === type && (e.payload?.['nodeId'] ?? e.nodeId) === nodeId);
+    const gateFailed = evs.find((e) => e.type === 'node.failed' && (e.payload?.['nodeId'] ?? e.nodeId) === NODE_ID);
+    const err = gateFailed?.payload?.['error'] as { code?: unknown; retryable?: unknown } | undefined;
+    expect({ code: err?.code, retryable: err?.retryable }, req(id, DOC, 'the routed gate still fails as a node: node.failed.error MUST carry approval_rejected and retryable false')).toEqual({ code: CODE, retryable: false });
+    expect(ran('on-reject', 'node.completed'), req(id, DOC, 'the any_failed edge admits the failed gate: on-reject MUST run to node.completed')).toBe(true);
+    expect(ran('on-accept', 'node.started') || ran('on-accept', 'node.completed'), req(id, DOC, 'a rejected gate MUST NOT satisfy an all_success edge: on-accept MUST NOT run')).toBe(false);
+    expect(terminal?.['status'], req(id, DOC, `a routed rejection does not fail the run: it MUST complete (got ${String(terminal?.['status'])})`)).toBe('completed');
+  }, 45_000);
+
+  it('an unresolved gate past its timeoutMs with no onTimeout is resolved rejected by the host and fails the run naming the gate', async () => {
+    if (!(await gateFamily('interrupt'))) return softSkip('inapplicable', 'interrupt family not advertised (gate recorded under openwop.family.interrupt)');
+    if (!isFixtureAdvertised(TIMEOUT)) return softSkip('inapplicable', `fixture ${TIMEOUT} is not advertised — the host does not claim the timeout fixture`);
+    const s = await suspended(TIMEOUT);
+    if ('reason' in s) return softSkip('blocked', s.reason);
+    const id = R('timeout-rejects');
+    const terminal = await waitStatus(s.runId, TERMINAL, scaledTimeoutMs(20_000));
+    const evs = await events(s.runId);
+    const resolved = evs.find((e) => e.type === 'interrupt.resolved');
+    expect(
+      { action: resolved?.payload?.['action'], decision: resolved?.payload?.['decision'], reason: resolved?.payload?.['reason'] },
+      req(id, DOC, 'the host MUST resolve the timed-out gate itself, recording action "timeout", decision "rejected" and reason "timeout"'),
+    ).toEqual({ action: 'timeout', decision: 'rejected', reason: 'timeout' });
+    const gateFailed = evs.find((e) => e.type === 'node.failed' && (e.payload?.['nodeId'] ?? e.nodeId) === NODE_ID);
+    expect(errorCode(gateFailed?.payload?.['error']), req(id, DOC, 'the timed-out gate MUST fail with approval_rejected')).toBe(CODE);
+    const runFailed = evs.find((e) => e.type === 'run.failed');
+    expect({ status: terminal?.['status'], code: errorCode(runFailed?.payload?.['error']), failedNodeId: runFailed?.payload?.['failedNodeId'] }, req(id, DOC, 'with no routing edge the run MUST terminate failed, run.failed carrying approval_rejected and failedNodeId naming the gate')).toEqual({ status: 'failed', code: CODE, failedNodeId: NODE_ID });
+  }, 60_000);
+
+  it('a gate whose onTimeout is approve still resolves rejected on timeout and fails the run: a timeout never grants', async () => {
+    if (!(await gateFamily('interrupt'))) return softSkip('inapplicable', 'interrupt family not advertised (gate recorded under openwop.family.interrupt)');
+    if (!isFixtureAdvertised(TIMEOUT_APPROVE)) return softSkip('inapplicable', `fixture ${TIMEOUT_APPROVE} is not advertised — the host does not claim the timeout-approve fixture`);
+    const s = await suspended(TIMEOUT_APPROVE);
+    if ('reason' in s) return softSkip('blocked', s.reason);
+    const id = R('timeout-never-grants');
+    const terminal = await waitStatus(s.runId, TERMINAL, scaledTimeoutMs(20_000));
+    const evs = await events(s.runId);
+    const resolved = evs.find((e) => e.type === 'interrupt.resolved');
+    expect(
+      { action: resolved?.payload?.['action'], decision: resolved?.payload?.['decision'] },
+      req(id, DOC, 'whatever onTimeout holds, the host MUST resolve the timed-out gate rejected (action "timeout", decision "rejected") — onTimeout "approve" is treated as reject'),
+    ).toEqual({ action: 'timeout', decision: 'rejected' });
+    const gateFailed = evs.find((e) => e.type === 'node.failed' && (e.payload?.['nodeId'] ?? e.nodeId) === NODE_ID);
+    expect(errorCode(gateFailed?.payload?.['error']), req(id, DOC, 'the timed-out gate MUST fail with approval_rejected')).toBe(CODE);
+    expect(terminal?.['status'], req(id, DOC, `a timeout MUST NOT grant a gate: with no routing edge the run MUST terminate failed, never completed (got ${String(terminal?.['status'])})`)).toBe('failed');
+  }, 60_000);
+
+  it('a rejected gate looped back to itself is asked again under a new key, and the first rejection is not replayed', async () => {
+    if (!(await gateFamily('interrupt'))) return softSkip('inapplicable', 'interrupt family not advertised (gate recorded under openwop.family.interrupt)');
+    if (!isFixtureAdvertised(LOOPBACK)) return softSkip('inapplicable', `fixture ${LOOPBACK} is not advertised — the host does not run cycles`);
+    const s = await suspended(LOOPBACK);
+    if ('reason' in s) return softSkip('blocked', s.reason);
+    const res = await resolve(s.runId, { action: 'reject' });
+    if (res === null || res.status < 200 || res.status >= 300) return softSkip('blocked', `the reject resolve answered ${res?.status ?? 'nothing'} ${readErrorCode(res?.json) ?? ''} — interrupt resolution owns that contract`);
+    const id = R('reject-loopback-reasks');
+    const gateRequests = (evs: Ev[]): Ev[] => evs.filter((e) => e.type === 'interrupt.requested' && (e.nodeId ?? e.payload?.['nodeId']) === NODE_ID);
+    const deadline = Date.now() + scaledTimeoutMs(10_000);
+    let evs = await events(s.runId);
+    while (gateRequests(evs).length < 2 && Date.now() < deadline) { await new Promise((r) => setTimeout(r, 250)); evs = await events(s.runId); }
+    const snap = await snapshot(s.runId);
+    const [first, second] = gateRequests(evs);
+    expect(second, req(id, 'spec/v2/core/interrupt.md §Re-entry and resume values', 'the second visit of the gate MUST raise a new interrupt.requested')).toBeDefined();
+    expect(second?.payload?.['key'] !== undefined && second?.payload?.['key'] !== first?.payload?.['key'], req(id, 'spec/v2/core/interrupt.md §Re-entry and resume values', `a later execution of the node MUST derive a different key (got ${String(first?.payload?.['key'])} then ${String(second?.payload?.['key'])})`)).toBe(true);
+    expect(snap?.['status'], req(id, 'spec/v2/core/interrupt.md §Re-entry and resume values', 'the second visit MUST wait for a new decision: the run is waiting-approval again')).toBe('waiting-approval');
+    expect(evs.filter((e) => e.type === 'interrupt.resolved').length, req(id, 'spec/v2/core/interrupt.md §Re-entry and resume values', 'an earlier visit\'s resumeValue MUST NOT be returned: only the one caller resolve is recorded')).toBe(1);
+    await http(() => driver.post(`/runs/${enc(s.runId)}/cancel`, {}));
+  }, 45_000);
+});

package/src/scenarios/v2-error-registry.test.ts

@@ -10,6 +10,14 @@
  * lives in `Retry-After` only, which a `429 rate_limited` MUST set. The
  * deliberately bad request is `GET /runs/does-not-exist` (outside the runId
  * grammar, so a host may answer `400 validation_error` or `404 not_found`).
+ *
+ * `event-code-registered` (openwop#1698, suite 2.43.1): errors.md §The
+ * registry binds `error.code` on `run.failed`, `node.failed` and the snapshot's
+ * `error` exactly as it binds an error response. The leg runs
+ * `conformance-failure` and checks every such code against the registry and the
+ * vendor pattern (first segment an org registered in `spec/v2/declaration.json`).
+ * ADVISORY for suite 2.43.1: a violation is recorded as a partial witness naming
+ * the codes, not a failure, while hosts remap (per-host rows in gaps.json).
  */
 
 import { describe, it, expect } from 'vitest';
@@ -25,6 +33,8 @@ import { req } from '../lib/requirement-ids.js';
 const DOC = 'spec/v2/core/errors.md §The envelope';
 const ERRORS_PATH = join(SCHEMAS_DIR, '..', 'spec', 'v2', 'errors.json');
 const RETRY_SPELLINGS = ['retryAfter', 'retryAfterMs', 'retryAfterSeconds'];
+const DECLARATION_PATH = join(SCHEMAS_DIR, '..', 'spec', 'v2', 'declaration.json');
+const FAILURE_FIXTURE = 'conformance-failure';
 
 async function discovery(): Promise<Record<string, unknown> | null> {
   try { return await v2Discovery(); } catch { return null; }
@@ -40,6 +50,16 @@ function registryStatus(): Map<string, number> | null {
   return new Map(rows.map((r) => [r.code, r.httpStatus]));
 }
 
+/** code → registered, or a vendor code whose org is registered; null when the registry or declaration is absent. */
+function codeAccepted(): ((code: string) => boolean) | null {
+  const registry = registryStatus();
+  if (registry === null || !existsSync(DECLARATION_PATH)) return null;
+  const reg = JSON.parse(readFileSync(ERRORS_PATH, 'utf8')) as { vendorCodePattern?: string };
+  const pattern = new RegExp(reg.vendorCodePattern ?? '^(?!openwop\\.)[a-z][a-z0-9]*(-[a-z0-9]+)*\\.[a-z][a-z0-9_]*$');
+  const orgs = new Set(Object.keys((JSON.parse(readFileSync(DECLARATION_PATH, 'utf8')) as { extensions?: Record<string, unknown> }).extensions ?? {}));
+  return (code: string) => registry.has(code) || (pattern.test(code) && orgs.has(code.split('.')[0] ?? ''));
+}
+
 async function badRequest(): Promise<OpenWOPResponse | { reason: string }> {
   if (!(await discovery())) return { reason: 'v2 discovery unreachable — /.well-known/openwop did not answer 200 with a JSON body under OpenWOP-Version: 2.0' };
   const res = await http(() => driver.get('/runs/does-not-exist'));
@@ -86,4 +106,43 @@ describe('v2 error-registry (RFC 0171 §B.1–§B.2)', () => {
       expect(r.headers.get('retry-after'), req('openwop.requirement.0171.error-registry.retry-after', 'spec/v2/core/errors.md §Retry timing', 'a 429 rate_limited response MUST set Retry-After')).not.toBeNull();
     }
   });
+
+  it('an error code on run.failed, node.failed and the snapshot is registered or a vendor code (advisory in 2.43.1)', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 with a JSON body under OpenWOP-Version: 2.0');
+    const accepted = codeAccepted();
+    if (accepted === null) return softSkip('inapplicable', 'spec/v2/errors.json or spec/v2/declaration.json is not present in this layout');
+    const fixtures = ((await discovery())?.['fixtures'] ?? []) as unknown[];
+    if (!fixtures.includes(FAILURE_FIXTURE)) return softSkip('blocked', `fixture ${FAILURE_FIXTURE} is not advertised — no failing run to read codes from`);
+    const create = await http(() => driver.post('/runs', { workflowId: FAILURE_FIXTURE }));
+    const runId = (create?.json as { runId?: unknown } | null)?.runId;
+    if (create === null || create.status !== 201 || typeof runId !== 'string') return softSkip('blocked', `POST /runs (${FAILURE_FIXTURE}) answered ${create?.status ?? 'nothing'}`);
+    const deadline = Date.now() + 10_000;
+    let snap: Record<string, unknown> | null = null;
+    for (;;) {
+      const r = await http(() => driver.get(`/runs/${encodeURIComponent(runId)}`));
+      snap = r?.status === 200 ? (r.json as Record<string, unknown>) : null;
+      if (snap !== null && ['completed', 'failed', 'cancelled'].includes(String(snap['status']))) break;
+      if (Date.now() > deadline) return softSkip('blocked', `the ${FAILURE_FIXTURE} run did not reach a terminal state within 10 s`);
+      await new Promise((ok) => setTimeout(ok, 250));
+    }
+    const polled = await http(() => driver.get(`/runs/${encodeURIComponent(runId)}/events/poll?timeout=1`));
+    const events = ((polled?.json as { events?: Array<{ type?: string; payload?: { error?: { code?: unknown } } }> } | null)?.events ?? []);
+    const seen: Array<{ where: string; code: string }> = [];
+    for (const e of events) {
+      const code = e.payload?.error?.code;
+      if ((e.type === 'run.failed' || e.type === 'node.failed') && typeof code === 'string') seen.push({ where: e.type, code });
+    }
+    const snapCode = (snap?.['error'] as { code?: unknown } | undefined)?.code;
+    if (typeof snapCode === 'string') seen.push({ where: 'snapshot.error', code: snapCode });
+    const ID = 'openwop.requirement.errors.event-code-registered';
+    expect(seen.length, req(ID, 'spec/v2/core/errors.md §The registry', `a failed ${FAILURE_FIXTURE} run MUST carry an error code on run.failed, node.failed or the snapshot (status ${String(snap?.['status'])})`)).toBeGreaterThan(0);
+    const bad = seen.filter((s) => !accepted(s.code));
+    if (bad.length > 0) {
+      // partial-witness-ok: ADVISORY for suite 2.43.1 (openwop#1698). The codes were
+      // observed and checked above; a violation is recorded, not failed, for one
+      // suite patch while hosts remap. Per-host gap rows track them.
+      return softSkip('inapplicable', `ADVISORY (suite 2.43.1, openwop#1698): unregistered, non-vendor error codes: ${bad.map((b) => `${b.where}=${b.code}`).join(', ')}`);
+    }
+    expect(bad, req(ID, 'spec/v2/core/errors.md §The registry', 'every error code on run.failed, node.failed and the snapshot MUST be registered or a vendor code')).toEqual([]);
+  }, 45_000);
 });

package/src/scenarios/v2-manifest-ceiling-refused.test.ts

@@ -14,10 +14,12 @@
  *   2. `>=1.0.0 <2.0.0`   (v1 ceiling)      → refused, pack_engine_unsupported
  *   3. `>=2.0.0 <3.0.0`   (admits major 2)  → installs (200/201)
  *
- * Gated on the `packs` family (RFC 0169 §A.2: presence is the claim) and on
- * the seams profile (`conformance.seamsProfile: openwop-conformance-seams-v2`);
- * a host without the profile records `blocked` — the write API is the only
- * install path the suite can drive.
+ * Gated on the seams profile (`conformance.seamsProfile:
+ * openwop-conformance-seams-v2`): its publish seam is the only install path the
+ * suite can drive. Not gated on `packs` since suite 2.43.1 (#1706): §A.1 binds
+ * at install on every path, and `packs` advertises registry resolution, which a
+ * host installing only local packs correctly omits. A seam 404 records `blocked`
+ * when `packs` is advertised and `inapplicable` when it is not.
  *
  * @see RFCS/0177-v2-registry-packs-and-extension-tail.md §A.1
  * @see spec/v2/core/packs.md §"The engine range"
@@ -31,7 +33,7 @@ import { readErrorCode } from '../lib/error-envelope.js';
 import { req } from '../lib/requirement-ids.js';
 import { softSkip, type SoftSkipKind } from '../lib/soft-skip.js';
 import { seamsProfileAdvertised, targetMajor } from '../lib/seams.js';
-import { v2Discovery, gateFamily } from '../lib/v2.js';
+import { v2Discovery, familyAdvertised } from '../lib/v2.js';
 
 const SECTION = 'packs.md §"The engine range" (RFC 0177 §A.1)';
 
@@ -87,6 +89,17 @@ async function publish(manifest: Record<string, unknown>) {
 }
 
 /** The reason this leg cannot run, or null when the seam is reachable. */
+/**
+ * The publish seam answered 404. Whether that is a defect depends on `packs`
+ * (#1706): a host advertising `packs` claims an install path and must mount it
+ * (`blocked`); a host that omits `packs` may have no install path the suite can
+ * drive (`inapplicable`). §A.1 binds at install on every path, not on `packs`.
+ */
+async function seamMissing(): Promise<undefined> {
+  if (await familyAdvertised('packs')) return softSkip('blocked', 'packs-test publish seam answered 404 — packs and the seams profile are advertised but the seam is not mounted');
+  return softSkip('inapplicable', 'packs-test publish seam answered 404 and packs is not advertised — no install path the suite can drive');
+}
+
 async function preflight(): Promise<{ kind: SoftSkipKind; reason: string } | null> {
   if (targetMajor() !== 2) return { kind: 'inapplicable', reason: 'suite 2.0.0 v2 scenario: OPENWOP_TARGET_MAJOR is not 2' };
   let doc: Record<string, unknown> | null;
@@ -96,7 +109,6 @@ async function preflight(): Promise<{ kind: SoftSkipKind; reason: string } | nul
     doc = null;
   }
   if (!doc) return { kind: 'blocked', reason: 'discovery unreachable — /.well-known/openwop (OpenWOP-Version: 2.0) did not answer 200 JSON' };
-  if (!(await gateFamily('packs'))) return { kind: 'inapplicable', reason: 'v2 discovery does not advertise the packs family (RFC 0169 §A.2)' };
   if (!seamsProfileAdvertised(doc)) return { kind: 'inapplicable', reason: 'host does not advertise conformance.seamsProfile: openwop-conformance-seams-v2 — the packs-test publish seam is the only install path the suite can drive (RFC 0168 §C.1)' };
   return null;
 }
@@ -106,7 +118,7 @@ describe('v2-manifest-ceiling-refused (RFC 0177 §A.1)', () => {
     const skip = await preflight();
     if (skip) return softSkip(skip.kind, skip.reason);
     const res = await publish(nodePack(freshName('unbounded'), '>=1.0.0'));
-    if (res.status === 404) return softSkip('blocked', 'packs-test publish seam answered 404 — seams profile advertised but the seam is not mounted');
+    if (res.status === 404) return seamMissing();
     expect(res.status, req('openwop.requirement.0177.manifest-ceiling-refused.unbounded', SECTION, 'an unbounded range does not admit protocol major 2 and MUST be refused with 400 pack_engine_unsupported')).toBe(400);
     expect(readErrorCode(res.json), req('openwop.requirement.0177.manifest-ceiling-refused.unbounded', SECTION, 'the refusal code MUST be pack_engine_unsupported (not pack_runtime_requirement_unmet)')).toBe('pack_engine_unsupported');
   });
@@ -115,7 +127,7 @@ describe('v2-manifest-ceiling-refused (RFC 0177 §A.1)', () => {
     const skip = await preflight();
     if (skip) return softSkip(skip.kind, skip.reason);
     const res = await publish(nodePack(freshName('v1-ceiling'), '>=1.0.0 <2.0.0'));
-    if (res.status === 404) return softSkip('blocked', 'packs-test publish seam answered 404 — seams profile advertised but the seam is not mounted');
+    if (res.status === 404) return seamMissing();
     expect(res.status, req('openwop.requirement.0177.manifest-ceiling-refused.v1-ceiling', SECTION, 'a <2.0.0 ceiling does not admit protocol major 2 and MUST be refused with 400 pack_engine_unsupported')).toBe(400);
     expect(readErrorCode(res.json), req('openwop.requirement.0177.manifest-ceiling-refused.v1-ceiling', SECTION, 'the refusal code MUST be pack_engine_unsupported')).toBe('pack_engine_unsupported');
   });
@@ -124,7 +136,7 @@ describe('v2-manifest-ceiling-refused (RFC 0177 §A.1)', () => {
     const skip = await preflight();
     if (skip) return softSkip(skip.kind, skip.reason);
     const res = await publish(nodePack(freshName('v2-installs'), '>=2.0.0 <3.0.0'));
-    if (res.status === 404) return softSkip('blocked', 'packs-test publish seam answered 404 — seams profile advertised but the seam is not mounted');
+    if (res.status === 404) return seamMissing();
     expect([200, 201].includes(res.status), req('openwop.requirement.0177.manifest-ceiling-refused.v2-installs', SECTION, `a manifest whose range admits major 2 MUST install (got ${res.status} ${readErrorCode(res.json) ?? ''})`)).toBe(true);
   });
 });

package/src/scenarios/v2-manifest-hatch-carried.test.ts

@@ -15,8 +15,10 @@
  *      packs at all (`pack_kind_invalid`) records `skipped` for that leg.
  *
  * Installs through the seams-profile publish seam
- * (`/conformance/seams/packs-test/…`, RFC 0168 §C.2). Gated on `packs` + the
- * seams profile.
+ * (`/conformance/seams/packs-test/…`, RFC 0168 §C.2). Gated on the seams
+ * profile; not on `packs` since suite 2.43.1 (#1706) — the hatch binds at install
+ * on every path. A seam 404 records `blocked` when `packs` is advertised and
+ * `inapplicable` when it is not.
  *
  * @see RFCS/0177-v2-registry-packs-and-extension-tail.md §C.2
  * @see spec/v2/core/packs.md §"The manifest schema family"
@@ -30,7 +32,7 @@ import { readErrorCode } from '../lib/error-envelope.js';
 import { req } from '../lib/requirement-ids.js';
 import { softSkip, type SoftSkipKind } from '../lib/soft-skip.js';
 import { seamsProfileAdvertised, targetMajor } from '../lib/seams.js';
-import { v2Discovery, gateFamily } from '../lib/v2.js';
+import { v2Discovery, familyAdvertised } from '../lib/v2.js';
 
 const SECTION = 'packs.md §"The manifest schema family" (RFC 0177 §C.2)';
 
@@ -67,6 +69,17 @@ async function publish(manifest: Record<string, unknown>, files: Record<string,
     headers: { 'Content-Type': 'application/octet-stream' },
   });
 }
+/**
+ * The publish seam answered 404. Whether that is a defect depends on `packs`
+ * (#1706): a host advertising `packs` claims an install path and must mount it
+ * (`blocked`); a host that omits `packs` may have no install path the suite can
+ * drive (`inapplicable`). §A.1 binds at install on every path, not on `packs`.
+ */
+async function seamMissing(): Promise<undefined> {
+  if (await familyAdvertised('packs')) return softSkip('blocked', 'packs-test publish seam answered 404 — packs and the seams profile are advertised but the seam is not mounted');
+  return softSkip('inapplicable', 'packs-test publish seam answered 404 and packs is not advertised — no install path the suite can drive');
+}
+
 async function preflight(): Promise<{ kind: SoftSkipKind; reason: string } | null> {
   if (targetMajor() !== 2) return { kind: 'inapplicable', reason: 'suite 2.0.0 v2 scenario: OPENWOP_TARGET_MAJOR is not 2' };
   let doc: Record<string, unknown> | null;
@@ -76,7 +89,6 @@ async function preflight(): Promise<{ kind: SoftSkipKind; reason: string } | nul
     doc = null;
   }
   if (!doc) return { kind: 'blocked', reason: 'discovery unreachable — /.well-known/openwop (OpenWOP-Version: 2.0) did not answer 200 JSON' };
-  if (!(await gateFamily('packs'))) return { kind: 'inapplicable', reason: 'v2 discovery does not advertise the packs family (RFC 0169 §A.2)' };
   if (!seamsProfileAdvertised(doc)) return { kind: 'inapplicable', reason: 'host does not advertise conformance.seamsProfile: openwop-conformance-seams-v2 — the packs-test publish seam is the only install path the suite can drive (RFC 0168 §C.1)' };
   return null;
 }
@@ -93,10 +105,14 @@ describe('v2-manifest-hatch-carried (RFC 0177 §C.2)', () => {
       engines: { openwop: '>=2.0.0 <3.0.0' },
       runtime: { language: 'javascript', entry: 'index.mjs', format: 'esm' },
       nodes: [{ typeId: `${name}.echo`, version: '1.0.0', category: 'data', role: 'pure' }],
-      agents: [{ agentId: `${name}.helper`, persona: 'Hatch Helper', modelClass: 'general', 'x-vendor-note': 'a hatch property the host MUST ignore' }],
+      // systemPrompt: agent-manifest requires exactly one of systemPrompt /
+      // systemPromptRef (oneOf). Without it the fixture was schema-invalid for a
+      // reason unrelated to the hatch, and a conforming host had to refuse it
+      // (2.43.1; reported by MyndHyve).
+      agents: [{ agentId: `${name}.helper`, persona: 'Hatch Helper', modelClass: 'general', systemPrompt: 'You are a conformance fixture.', 'x-vendor-note': 'a hatch property the host MUST ignore' }],
     };
     const res = await publish(manifest, { 'index.mjs': ENTRY });
-    if (res.status === 404) return softSkip('blocked', 'packs-test publish seam answered 404 — seams profile advertised but the seam is not mounted');
+    if (res.status === 404) return seamMissing();
     expect([200, 201].includes(res.status), req('openwop.requirement.0177.manifest-hatch-carried.agents-x-field', SECTION, `agent-manifest admits ^(openwop-|x-|vendor\\.) — a pack whose agents[0] carries x-vendor-note MUST install (got ${res.status} ${readErrorCode(res.json) ?? ''})`)).toBe(true);
   });
 
@@ -112,7 +128,7 @@ describe('v2-manifest-hatch-carried (RFC 0177 §C.2)', () => {
       prompts: [{ templateId: `${name}.system`, version: '1.0.0', kind: 'system', text: 'You are a conformance fixture.', 'x-vendor-note': 'a hatch property the host MUST ignore' }],
     };
     const res = await publish(manifest, {});
-    if (res.status === 404) return softSkip('blocked', 'packs-test publish seam answered 404 — seams profile advertised but the seam is not mounted');
+    if (res.status === 404) return seamMissing();
     const code = readErrorCode(res.json);
     if (res.status >= 400 && code === 'pack_kind_invalid') return softSkip('skipped', 'host does not install kind: prompt packs (pack_kind_invalid) — the prompt-template hatch cannot be observed on this host');
     expect([200, 201].includes(res.status), req('openwop.requirement.0177.manifest-hatch-carried.prompt-template-x-field', SECTION, `prompt-template admits ^(openwop-|x-|vendor\\.) — a prompt pack whose prompts[0] carries x-vendor-note MUST install (got ${res.status} ${code ?? ''})`)).toBe(true);

package/src/scenarios/v2-pack-isolation.test.ts

@@ -1,5 +1,10 @@
 /**
- * RFC 0173 §B — `pack-isolation` (suite 2.0.0, target major 2; gated on `packs` + `sandbox`).
+ * RFC 0173 §B — `pack-isolation` (suite 2.0.0, target major 2; gated on `sandbox`).
+ *
+ * Gated on `sandbox` alone since suite 2.43.1 (#1706). It was gated on `packs`
+ * + `sandbox`, but `packs` advertises registry resolution (packs.md §The
+ * `packs` capability), which a host executing only local packs correctly omits.
+ * `sandbox` is the advertisement §B requires of any host executing packs.
  *
  * Isolation binds with pack EXECUTION: a host that executes third-party packs
  * MUST enforce the eight `node-pack-sandbox-*` invariants and MUST advertise
@@ -41,11 +46,10 @@ async function discovery(): Promise<Record<string, unknown> | null> {
   try { return await v2Discovery(); } catch { return null; }
 }
 
-/** Gate for every leg: packs + sandbox advertised. Returns the sandbox facet or null (reason recorded). */
+/** Gate for every leg: sandbox advertised. Returns the sandbox facet or null (reason recorded). */
 async function gated(): Promise<Record<string, unknown> | null> {
   const doc = await discovery();
   if (!doc) { softSkip('blocked', 'discovery unreachable'); return null; }
-  if (!(await gateFamily('packs'))) { softSkip('inapplicable', 'packs family not advertised — no pack execution, no isolation obligation (gate recorded under openwop.family.packs)'); return null; }
   const sandbox = await gateFamily('sandbox');
   if (!sandbox) { softSkip('inapplicable', 'sandbox family not advertised (gate recorded under openwop.family.sandbox)'); return null; }
   return sandbox;
@@ -56,7 +60,7 @@ async function invoke(typeId: string, extra: Record<string, unknown> = {}): Prom
   const doc = await discovery();
   if (!doc || !seamsProfileAdvertised(doc)) { softSkip('inapplicable', `the ${typeId} leg is seam-driven — seams profile (conformance.seamsProfile = openwop-conformance-seams-v2) not advertised`); return null; }
   const res = await driver.post(INVOKE, { typeId, ...extra });
-  if (res.status === 404 || res.status === 403 || res.status === 405) { seamAbsent(`host advertises packs + sandbox but ${INVOKE} answered ${res.status} — the ${typeId} leg is unobservable (host-sample-test-seams.md §8)`); return null; }
+  if (res.status === 404 || res.status === 403 || res.status === 405) { seamAbsent(`host advertises sandbox but ${INVOKE} answered ${res.status} — the ${typeId} leg is unobservable (host-sample-test-seams.md §8)`); return null; }
   // The same id is ALSO asserted by its own `it` above, and that is the copy the
   // registry can see: `generate-requirement-registry.mjs` harvests `req(…)` only
   // within an `it`, so this helper-level call alone left the id out of
@@ -74,7 +78,7 @@ function expectEscape(id: string, r: InvokeResult, escapeKind: string, invariant
   expect(r.error?.details?.escapeKind, req(id, 'host-sample-test-seams.md §8 SandboxError', `escapeKind MUST be ${escapeKind}`)).toBe(escapeKind);
 }
 
-describe('RFC 0173 §B — pack-isolation (gated on packs + sandbox)', () => {
+describe('RFC 0173 §B — pack-isolation (gated on sandbox)', () => {
   it('sandbox.isolationModel names a real mechanism, never node:vm', async () => {
     const sandbox = await gated();
     if (!sandbox) return softSkip('inapplicable', 'gate not met (reason recorded above)');
@@ -94,7 +98,7 @@ describe('RFC 0173 §B — pack-isolation (gated on packs + sandbox)', () => {
     const doc = await discovery();
     if (!doc || !seamsProfileAdvertised(doc)) return softSkip('inapplicable', 'seam-driven — seams profile (conformance.seamsProfile = openwop-conformance-seams-v2) not advertised');
     const res = await driver.post(INVOKE, { typeId: 'misbehave.fs-escape-read' });
-    if (res.status === 404 || res.status === 403 || res.status === 405) return seamAbsent(`host advertises packs + sandbox but ${INVOKE} answered ${res.status}`);
+    if (res.status === 404 || res.status === 403 || res.status === 405) return seamAbsent(`host advertises sandbox but ${INVOKE} answered ${res.status}`);
     expect(
       res.status,
       req('openwop.requirement.0173.pack-isolation.seam', 'host-sample-test-seams.md §8', `${INVOKE} MUST answer 200 { result } | 200 { error } — the eight behavioural legs are unobservable otherwise`),

package/src/scenarios/v2-peer-dependency-declared.test.ts

@@ -17,8 +17,10 @@
  *      failure; any other refusal fails.
  *
  * Both legs install through the seams-profile publish seam
- * (`/conformance/seams/packs-test/…`, RFC 0168 §C.2). Gated on `packs` + the
- * seams profile.
+ * (`/conformance/seams/packs-test/…`, RFC 0168 §C.2). Gated on the seams
+ * profile; not on `packs` since suite 2.43.1 (#1706) — the rule binds at install
+ * on every path. A seam 404 records `blocked` when `packs` is advertised and
+ * `inapplicable` when it is not.
  *
  * @see RFCS/0177-v2-registry-packs-and-extension-tail.md §B.1, §B.2
  * @see spec/v2/core/packs.md §"Peer-dependency identifiers", §"The alias table"
@@ -35,7 +37,7 @@ import { SCHEMAS_DIR } from '../lib/paths.js';
 import { req } from '../lib/requirement-ids.js';
 import { softSkip, type SoftSkipKind } from '../lib/soft-skip.js';
 import { seamsProfileAdvertised, targetMajor } from '../lib/seams.js';
-import { v2Discovery, gateFamily, familyAdvertised } from '../lib/v2.js';
+import { v2Discovery, familyAdvertised } from '../lib/v2.js';
 
 const SECTION = 'packs.md §"Peer-dependency identifiers" (RFC 0177 §B.1)';
 const ALIASES = join(SCHEMAS_DIR, '..', 'spec', 'v2', 'peer-dependency-aliases.json');
@@ -86,6 +88,17 @@ async function publish(manifest: Record<string, unknown>) {
     headers: { 'Content-Type': 'application/octet-stream' },
   });
 }
+/**
+ * The publish seam answered 404. Whether that is a defect depends on `packs`
+ * (#1706): a host advertising `packs` claims an install path and must mount it
+ * (`blocked`); a host that omits `packs` may have no install path the suite can
+ * drive (`inapplicable`). §A.1 binds at install on every path, not on `packs`.
+ */
+async function seamMissing(): Promise<undefined> {
+  if (await familyAdvertised('packs')) return softSkip('blocked', 'packs-test publish seam answered 404 — packs and the seams profile are advertised but the seam is not mounted');
+  return softSkip('inapplicable', 'packs-test publish seam answered 404 and packs is not advertised — no install path the suite can drive');
+}
+
 async function preflight(): Promise<{ kind: SoftSkipKind; reason: string } | null> {
   if (targetMajor() !== 2) return { kind: 'inapplicable', reason: 'suite 2.0.0 v2 scenario: OPENWOP_TARGET_MAJOR is not 2' };
   let doc: Record<string, unknown> | null;
@@ -95,7 +108,6 @@ async function preflight(): Promise<{ kind: SoftSkipKind; reason: string } | nul
     doc = null;
   }
   if (!doc) return { kind: 'blocked', reason: 'discovery unreachable — /.well-known/openwop (OpenWOP-Version: 2.0) did not answer 200 JSON' };
-  if (!(await gateFamily('packs'))) return { kind: 'inapplicable', reason: 'v2 discovery does not advertise the packs family (RFC 0169 §A.2)' };
   if (!seamsProfileAdvertised(doc)) return { kind: 'inapplicable', reason: 'host does not advertise conformance.seamsProfile: openwop-conformance-seams-v2 — the packs-test publish seam is the only install path the suite can drive (RFC 0168 §C.1)' };
   return null;
 }
@@ -105,7 +117,7 @@ describe('v2-peer-dependency-declared (RFC 0177 §B.1/§B.2)', () => {
     const skip = await preflight();
     if (skip) return softSkip(skip.kind, skip.reason);
     const res = await publish(nodePack(freshName('peer-undefined'), { 'host.nonexistent': 'required' }));
-    if (res.status === 404) return softSkip('blocked', 'packs-test publish seam answered 404 — seams profile advertised but the seam is not mounted');
+    if (res.status === 404) return seamMissing();
     expect(res.status, req('openwop.requirement.0177.peer-dependency-declared.undefined-key', SECTION, 'a key absent from spec/v2/declaration.json MUST be refused with 400 pack_peer_dependency_undefined')).toBe(400);
     expect(readErrorCode(res.json), req('openwop.requirement.0177.peer-dependency-declared.undefined-key', SECTION, 'the refusal code MUST be pack_peer_dependency_undefined')).toBe('pack_peer_dependency_undefined');
   });
@@ -124,7 +136,7 @@ describe('v2-peer-dependency-declared (RFC 0177 §B.1/§B.2)', () => {
     }
     if (!chosen) return softSkip('inapplicable', 'no facet-less alias row names a family this host advertises — the overlap alias cannot be exercised');
     const res = await publish(nodePack(freshName('peer-alias'), { [chosen.alias]: 'required' }));
-    if (res.status === 404) return softSkip('blocked', 'packs-test publish seam answered 404 — seams profile advertised but the seam is not mounted');
+    if (res.status === 404) return seamMissing();
     const code = readErrorCode(res.json);
     if (res.status === 400 && code === 'pack_peer_dependency_undefined') return softSkip('skipped', `host does not resolve the overlap alias ${chosen.alias} (RFC 0177 §B.2 is a MAY during the overlap; MUST NOT after v1 end-of-support)`);
     expect([200, 201].includes(res.status), req('openwop.requirement.0177.peer-dependency-declared.alias-overlap', 'packs.md §"The alias table" (RFC 0177 §B.2)', `alias ${chosen.alias} → ${chosen.family} (advertised) MUST install through the overlap or be refused only with pack_peer_dependency_undefined (got ${res.status} ${code ?? ''})`)).toBe(true);