@openwop/openwop-conformance 2.43.0 → 2.43.2

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

@@ -14,14 +14,32 @@
  *      `retryable: false`, and `run.failed.failedNodeId` names the gate;
  *   4. `conformance-interrupt-quorum` (requiredApprovals 3, `majority`): one
  *      reject leaves the run `waiting-approval`; a second decides the gate and
- *      the run terminates `failed` with `approval_rejected`.
+ *      the 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. The timeout disposition is not tested: no registered fixture carries a
- * gate with a short `timeoutMs`, and the suite cannot make a host's timer fire.
- * The routed case (an `all_complete` / `any_failed` edge) is not tested either:
- * `conformance-approval` has no edges, and widening a fixture every host serves
- * would force a re-registration (fixtures.md §conformance-approval-refine).
+ * 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
@@ -40,11 +58,16 @@ 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']);
@@ -159,4 +182,81 @@ describe('RFC 0223 — v2-approval-reject-disposition (gated on interrupt + conf
     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);

package/src/scenarios/v2-replay-suppression-ordinal.test.ts

@@ -0,0 +1,108 @@
+/**
+ * `spec/v2/core/replay.md` §Suppression rule 2 — a replay fork resolves a
+ * side-effecting node's outcome keyed on `(sourceRunId, nodeId, n)`, where `n`
+ * counts the node's `node.started` events through this execution, including
+ * retries, later visits and the fork's inherited prefix (openwop#1718, suite
+ * 2.43.2, target major 2).
+ *
+ * The rule said `(nodeId, attempt)`. In a run where a node executes more than
+ * once (a loop back over an edge), that key names no single execution: a host
+ * counting attempts per execution resolves every visit from the first visit's
+ * outcome, and one selecting the latest recorded outcome does the same when
+ * only one exists.
+ *
+ * Construction (`conformance-replay-ordinal-loop`): start → effect → wait →
+ * effect, so `effect` executes twice. The suite cancels the source inside
+ * `wait`, after `effect`'s first execution completed and before its second, and
+ * forks `mode: "replay"` at `effect`'s first `node.started`. In the fork:
+ *   - `effect` execution 1 (n = 1) has a recorded outcome and resolves from it;
+ *   - `effect` execution 2 (n = 2) has none, so it MUST fail closed with
+ *     `replay_source_missing` (rule 3) and MUST NOT complete.
+ * Only the fail-closed half is asserted as the discriminator: a host keyed on
+ * the wrong ordinal completes execution 2 from execution 1's outcome.
+ *
+ * Gated on `replay` and on the fixture, which only a host that runs cycles and
+ * suppresses side effects advertises. No such host is known today (the v2
+ * reference host does not loop), so the row has a negative control only — see
+ * RFC 0140's gap register.
+ *
+ * @see spec/v2/core/replay.md §Suppression
+ * @see RFCS/0140-replay-side-effect-suppression.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 ID = 'openwop.requirement.replay.suppression-execution-ordinal';
+const DOC = 'spec/v2/core/replay.md §Suppression';
+const FIXTURE = 'conformance-replay-ordinal-loop';
+const EFFECT = 'effect';
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+
+interface Ev { readonly sequence?: unknown; readonly type?: unknown; readonly nodeId?: unknown; readonly payload?: { readonly nodeId?: unknown; readonly error?: { readonly code?: unknown } } }
+
+const enc = (id: string): string => encodeURIComponent(id);
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> { try { return await fn(); } catch { return null; } }
+const nodeOf = (e: Ev): unknown => e.nodeId ?? e.payload?.nodeId;
+
+async function logOf(runId: string): Promise<Ev[]> {
+  const res = await http(() => driver.get(`/runs/${enc(runId)}/events/poll?timeout=1&streamMode=debug`));
+  const events = (res?.json as { events?: unknown } | null)?.events;
+  return Array.isArray(events) ? (events as Ev[]).filter((e) => typeof e.sequence === 'number').sort((a, b) => (a.sequence as number) - (b.sequence as number)) : [];
+}
+async function statusOf(runId: string): Promise<string | null> {
+  const res = await http(() => driver.get(`/runs/${enc(runId)}`));
+  return res?.status === 200 ? String((res.json as { status?: unknown } | null)?.status ?? '') : null;
+}
+async function until(check: () => Promise<boolean>, ms: number): Promise<boolean> {
+  const deadline = Date.now() + ms;
+  for (;;) {
+    if (await check()) return true;
+    if (Date.now() > deadline) return false;
+    await new Promise((r) => setTimeout(r, 200));
+  }
+}
+
+describe('v2 replay-suppression-ordinal (replay.md §Suppression rule 2, openwop#1718)', () => {
+  it('a replay fork resolves each execution of a looped side-effecting node by its own ordinal, failing closed where none was recorded', async () => {
+    if (!(await gateFamily('replay'))) return softSkip('inapplicable', 'replay family not advertised (gate recorded under openwop.family.replay)');
+    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', `fixture ${FIXTURE} is not advertised — the host does not run cycles with a side-effecting node`);
+
+    const created = await http(() => driver.post('/runs', { workflowId: FIXTURE, inputs: { delayMs: 3000 } }));
+    const runId = (created?.json as { runId?: unknown } | null)?.runId;
+    if (created === null || created.status !== 201 || typeof runId !== 'string') return softSkip('blocked', `POST /runs (${FIXTURE}) answered ${created?.status ?? 'nothing'} ${readErrorCode(created?.json) ?? ''}`.trim());
+
+    // Cancel inside `wait`: effect's first execution completed, its second not yet started.
+    const firstDone = await until(async () => (await logOf(runId)).some((e) => e.type === 'node.completed' && nodeOf(e) === EFFECT), scaledTimeoutMs(10_000));
+    if (!firstDone) return softSkip('blocked', `the source run never completed ${EFFECT}'s first execution`);
+    await http(() => driver.post(`/runs/${enc(runId)}/cancel`, {}));
+    if (!(await until(async () => TERMINAL.has((await statusOf(runId)) ?? ''), scaledTimeoutMs(10_000)))) return softSkip('blocked', 'the cancelled source run did not settle');
+    const source = await logOf(runId);
+    const effectStarts = source.filter((e) => e.type === 'node.started' && nodeOf(e) === EFFECT);
+    const effectDone = source.filter((e) => e.type === 'node.completed' && nodeOf(e) === EFFECT);
+    if (effectStarts.length !== 1 || effectDone.length !== 1) return softSkip('blocked', `the source was cancelled with ${effectStarts.length} starts and ${effectDone.length} completions of ${EFFECT}, not exactly one of each — the second execution cannot be isolated`);
+
+    const fromSeq = effectStarts[0]!.sequence as number;
+    const fork = await http(() => driver.post(`/runs/${enc(runId)}:fork`, { mode: 'replay', fromSeq }));
+    const forkId = (fork?.json as { runId?: unknown } | null)?.runId;
+    if (fork === null || fork.status !== 201 || typeof forkId !== 'string') return softSkip('blocked', `POST /runs/{runId}:fork answered ${fork?.status ?? 'nothing'} ${readErrorCode(fork?.json) ?? ''} — forkRun owns that contract`.trim());
+    await until(async () => TERMINAL.has((await statusOf(forkId)) ?? ''), scaledTimeoutMs(20_000));
+    const forked = await logOf(forkId);
+    const forkEffect = forked.filter((e) => nodeOf(e) === EFFECT);
+
+    expect(
+      forkEffect.filter((e) => e.type === 'node.completed').length,
+      req(ID, DOC, 'only the execution with a recorded outcome (n = 1) may complete in the fork; execution 2 has none and MUST NOT complete'),
+    ).toBeLessThanOrEqual(1);
+    expect(
+      forkEffect.some((e) => e.type === 'node.failed' && e.payload?.error?.code === 'replay_source_missing'),
+      req(ID, `${DOC} rules 2–3`, `the second execution of ${EFFECT} (n = 2) has no recorded source outcome and MUST fail closed with replay_source_missing — a host keyed on (nodeId, attempt), or on the latest outcome, resolves it from the first execution instead`),
+    ).toBe(true);
+  }, 90_000);
+});