@openwop/openwop-conformance 2.0.0-rc.52 → 2.0.0-rc.54

package/dist/spec-artifacts.lock.json

@@ -1,5 +1,5 @@
 {
   "package": "@openwop/spec-artifacts",
-  "version": "2.0.0-rc.52",
-  "stampSha256": "81cdf1c9820f034ec60ac59b15a2e1166af70f2e9744c72251ecd1cd88783bc7"
+  "version": "2.0.0-rc.54",
+  "stampSha256": "8af0e97d10089d2d711b67a0fae28d738b32eaf6154cfccbb9c370eea7806318"
 }

package/package.json

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

package/requirement-aliases.json

@@ -1,6 +1,7 @@
 {
   "$comment": "old id → new id. Add a row when a test title is reworded so bundles citing the old id still resolve.",
   "aliases": {
-    "openwop.it.v2-run-cancel.cancelling-a-terminal-run-answers-409-run-terminal-or-200-idempotently-the-prose": "openwop.it.v2-run-cancel.cancelling-a-terminal-run-is-refused-409-run-terminal"
+    "openwop.it.v2-run-cancel.cancelling-a-terminal-run-answers-409-run-terminal-or-200-idempotently-the-prose": "openwop.it.v2-run-cancel.cancelling-a-terminal-run-is-refused-409-run-terminal",
+    "openwop.it.pause-resume.pause-on-an-already-paused-run-is-a-no-op-200-202-idempotent": "openwop.it.pause-resume.pause-on-an-already-paused-run-returns-409-with-details-runstatus-paused-unless"
   }
 }

package/requirements.json

@@ -3,10 +3,10 @@
   "generatedFrom": "src/scenarios/*.test.ts",
   "counts": {
     "files": 564,
-    "tests": 2148,
-    "withStableId": 2147,
+    "tests": 2149,
+    "withStableId": 2148,
     "interpolatedTitles": 1,
-    "explicitIds": 2057
+    "explicitIds": 2058
   },
   "records": [
     {
@@ -18727,80 +18727,131 @@
     {
       "id": "openwop.it.pause-resume.pause-transitions-to-paused-resume-returns-the-run-to-running",
       "file": "pause-resume.test.ts",
-      "line": 36,
+      "line": 62,
       "title": "pause transitions to paused; resume returns the run to running",
       "explicitId": "openwop.it.pause-resume.pause-transitions-to-paused-resume-returns-the-run-to-running",
       "citations": [
         {
-          "section": "rest-endpoints.md POST /v1/runs/{runId}:pause",
-          "requirement": ":pause MUST return 202 on a pausable run"
+          "section": null,
+          "requirement": ":pause MUST return 202 on a pausable run",
+          "interpolated": true
         },
         {
-          "section": "rest-endpoints.md POST /v1/runs/{runId}:resume",
-          "requirement": ":resume MUST return 202 on a paused run"
+          "section": null,
+          "requirement": ":resume MUST return 202 on a paused run",
+          "interpolated": true
         }
       ]
     },
     {
       "id": "openwop.it.pause-resume.resuming-a-running-not-paused-run-returns-409-with-details-runstatus",
       "file": "pause-resume.test.ts",
-      "line": 82,
+      "line": 110,
       "title": "resuming a running (not paused) run returns 409 with details.runStatus",
       "explicitId": "openwop.it.pause-resume.resuming-a-running-not-paused-run-returns-409-with-details-runstatus",
       "citations": [
         {
-          "section": "rest-endpoints.md POST /v1/runs/{runId}:resume",
-          "requirement": ":resume on a non-paused run MUST return 409"
+          "section": null,
+          "requirement": ":resume on a non-paused run MUST return 409",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "the 409 MUST carry details.runStatus with the actual state",
+          "interpolated": true
         }
       ]
     },
     {
-      "id": "openwop.it.pause-resume.pause-on-an-already-paused-run-is-a-no-op-200-202-idempotent",
+      "id": "openwop.it.pause-resume.pause-on-an-already-paused-run-returns-409-with-details-runstatus-paused-unless",
       "file": "pause-resume.test.ts",
-      "line": 115,
-      "title": ":pause on an already-paused run is a no-op (200/202) — idempotent",
-      "explicitId": "openwop.it.pause-resume.pause-on-an-already-paused-run-is-a-no-op-200-202-idempotent",
+      "line": 144,
+      "title": ":pause on an already-paused run returns 409 with details.runStatus paused, unless the request carries the original Idempotency-Key",
+      "explicitId": "openwop.it.pause-resume.pause-on-an-already-paused-run-returns-409-with-details-runstatus-paused-unless",
       "citations": [
         {
-          "section": "rest-endpoints.md POST /v1/runs/{runId}:pause",
-          "requirement": ":pause on an already-paused run MUST be idempotent (200/202), not 409"
+          "section": null,
+          "requirement": ":pause MUST return 202 on a pausable run",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": ":pause on an already-paused run without a matching Idempotency-Key MUST return 409",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "the 409 MUST carry details.runStatus: paused",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": ":pause with an Idempotency-Key MUST return 202 on a pausable run",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": "a :pause carrying the original Idempotency-Key MUST return 202 with the cached response, not 409",
+          "interpolated": true
         }
       ]
     },
     {
       "id": "openwop.it.pause-resume.pause-on-a-completed-cancelled-failed-run-must-return-409",
       "file": "pause-resume.test.ts",
-      "line": 153,
+      "line": 205,
       "title": ":pause on a completed/cancelled/failed run MUST return 409",
       "explicitId": "openwop.it.pause-resume.pause-on-a-completed-cancelled-failed-run-must-return-409",
       "citations": [
         {
-          "section": "rest-endpoints.md POST /v1/runs/{runId}:pause",
-          "requirement": ":pause on a terminal run MUST return 409"
+          "section": null,
+          "requirement": ":pause on a terminal run MUST return 409",
+          "interpolated": true
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.pause-resume.under-drain-current-node-node-completed-precedes-run-paused-in-the-log",
+      "file": "pause-resume.test.ts",
+      "line": 229,
+      "title": "under drain-current-node node.completed precedes run.paused in the log",
+      "explicitId": "openwop.it.pause-resume.under-drain-current-node-node-completed-precedes-run-paused-in-the-log",
+      "citations": [
+        {
+          "section": null,
+          "requirement": ":pause with drainPolicy drain-current-node MUST return 202 (pause requested)",
+          "interpolated": true
+        },
+        {
+          "section": null,
+          "requirement": null,
+          "interpolated": true
         }
       ]
     },
     {
       "id": "openwop.it.pause-resume.pause-must-not-silently-override-an-active-interrupt-suspend",
       "file": "pause-resume.test.ts",
-      "line": 177,
+      "line": 268,
       "title": ":pause MUST NOT silently override an active interrupt suspend",
       "explicitId": "openwop.it.pause-resume.pause-must-not-silently-override-an-active-interrupt-suspend",
       "citations": [
         {
-          "section": "rest-endpoints.md POST /v1/runs/{runId}:pause",
-          "requirement": ":pause-during-suspend MUST surface the active waiting-* status in the conflict envelope"
+          "section": null,
+          "requirement": ":pause-during-suspend MUST surface the active waiting-* status in the conflict envelope",
+          "interpolated": true
         },
         {
-          "section": "rest-endpoints.md POST /v1/runs/{runId}:pause",
-          "requirement": ":pause-during-suspend MUST NOT silently discard the active interrupt"
+          "section": null,
+          "requirement": ":pause-during-suspend MUST NOT silently discard the active interrupt",
+          "interpolated": true
         }
       ]
     },
     {
       "id": "openwop.it.pause-resume.every-drainpolicy-advertised-by-the-host-is-accepted-on-pause",
       "file": "pause-resume.test.ts",
-      "line": 238,
+      "line": 324,
       "title": "every drainPolicy advertised by the host is accepted on :pause",
       "explicitId": "openwop.it.pause-resume.every-drainpolicy-advertised-by-the-host-is-accepted-on-pause",
       "citations": [

package/schemas/CORPUS-STAMP.json

@@ -1,7 +1,7 @@
 {
   "_comment": "Provenance of @openwop/spec-artifacts (RFC 0168 §D.2). files: SHA-256 per file; the conformance suite compares the installed peer against dist/spec-artifacts.lock.json at start.",
   "package": "@openwop/spec-artifacts",
-  "version": "2.0.0-rc.52",
+  "version": "2.0.0-rc.54",
   "corpusTag": null,
   "files": {
     "api/.redocly.lint-ignore.yaml": "bf5a8350b88a72fa43f59605ed8d903ed24b6cfccda5e45509c9f6ed9ee4e712",
@@ -9,9 +9,9 @@
     "api/grpc/openwop.proto": "c3e72bb17cba514ee98feb6434e6c9b6ea6795bfd086489ec69fd882dd1ad977",
     "api/openapi.yaml": "39081c59fb696159806b0f2f9a42e7e9ff830d622fcf2ad4159b21357580a955",
     "api/redocly.yaml": "b0604c89b2ca6d5076ec25725c539dad44a741a811fe524439ee6daef8baa09f",
-    "api/seams-v2.yaml": "54fced8c0f57bb6af60f5d6f35d2da1b7e262ea895a225daa4ce13df3f5eb488",
-    "api/v2/asyncapi.yaml": "4d337c6dcf7ff3d3c0256ae6d2388aa644741464b3e6911d2d4156655c7909e0",
-    "api/v2/openapi.yaml": "c61a55d1cab7db1747d12fa6af82089ae21cac1415efd28cdf3ecb30c226c11b",
+    "api/seams-v2.yaml": "9357a2a3bc0e95b19ce253313cbf1d63ca079e7f5025fa079a1a8d4206d95e8e",
+    "api/v2/asyncapi.yaml": "0e1516fb4a80a3bedfe9fbb7e3cf30b756a03b2e544634989986107982265ed6",
+    "api/v2/openapi.yaml": "69c7e7d89260db65b08a64b26c27dc80fff690f9459741b904f84cc22df6f1e2",
     "api/v2/redocly.yaml": "1e66b60e6118ad11a823bb620678be464d99dfe50a40e3e6f93ec9429b88b34c",
     "schemas/README.md": "0c0b737ffcf8f30e7d2809cec8a498232de710f41443212922ad8337cdde0b51",
     "schemas/a2a-task-state.schema.json": "c9365918f993f943b4b619d42551eb066a1ed33a08d895d51b395432a5b1f1bc",
@@ -199,7 +199,7 @@
     "schemas/workspace-file.schema.json": "464de85c2a068243084ee9c1d969bc7cd5d8f7948574e58450d6493c38a0e1e4",
     "spec/v1/alias-detectors.json": "fee4594ef49953953ffcd0b3813300067d16b3e65ebff2aac722034ac9b3f545",
     "spec/v1/capability-declaration-classes.json": "e7729aed5c4b4e1dd02abab0530f14cc95f5d4070fe51fb139e7f5cccefa00c6",
-    "spec/v1/core-standard-manifest.json": "6cca7e93821c9bb93c1a4b206e2300be1b2e7f6bea8eb4fdb870cf5c9e0a44d4",
+    "spec/v1/core-standard-manifest.json": "541259e7d6b12bf8d93bc0f13b05e45526a785c40ee45670b48724d03fd61096",
     "spec/v1/deprecations.json": "1d5acb69a9b8ccb57275a95605f74aef1d920685f8407c9d382a46b59dc803bb",
     "spec/v1/deprecations.schema.json": "18c87e78bedc210431f795ae44c5b5d202f2f3317850d5cf86867d4f1fa1cdfb",
     "spec/v1/event-codemap.json": "3da60d884157793a360da532a9fcbbfb5285636db325a74cec94b34622186d97",
@@ -230,8 +230,8 @@
     "spec/v2/path-manifest.json": "034152e09b1458c66810d4050e20a273b2b9b8fe2d92b66e8b819477de58a1be",
     "spec/v2/peer-dependency-aliases.json": "d10299280abee08258502925bc327293ee413e0108cd6e6ec75ff6110653308d",
     "spec/v2/profiles.json": "5019ac8209540bfbeee9c3232530d4e599be0ab926d817ff48edcec8419eb209",
-    "spec/v2/release.json": "80a24ebc5baa87dfe19476762f1999354fb522e58e115e52777618ca7272c298",
+    "spec/v2/release.json": "48be3e323433d659848bb575ccb907e9e994b55b1d98237a5975e58451dcb1dd",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624"
   },
-  "corpusCommit": "7dded60251d6e769e05b8131728b66c2652318fb"
+  "corpusCommit": "14eabff5bde7862ddecb900d92aa24ae1967d1cc"
 }

package/src/scenarios/pause-resume.test.ts

@@ -2,17 +2,31 @@
  * Track 13: operator-driven pause/resume (rest-endpoints.md v1.1).
  *
  * Exercises the `POST /v1/runs/{runId}:pause` and `:resume` endpoints
- * against a long-running fixture (`conformance-delay` or `conformance-cancellable`).
+ * against a long-running fixture (`conformance-cancellable` or `conformance-delay`;
+ * both take `inputs.delayMs` — conformance/fixtures.md).
  *
  * Verifies:
- *   1. :pause on a running run transitions to `paused` and emits `run.paused`.
- *   2. :resume on a paused run transitions to `running` and emits `run.resumed`.
- *   3. :pause on a terminal run returns 409 with details.runStatus.
- *   4. :resume on a non-paused run returns 409 with details.runStatus.
+ *   1. :pause (immediate) on a running run transitions to `paused`; :resume
+ *      returns it to `running` and it reaches a terminal.
+ *   2. :resume on a non-paused run returns 409 with details.runStatus.
+ *   3. :pause on an already-paused run returns 409 (details.runStatus paused)
+ *      without a matching Idempotency-Key, and 202 with the cached response
+ *      when the same key is sent — rest-endpoints.md §:pause Idempotency.
+ *   4. :pause on a terminal run returns 409 with details.runStatus.
+ *   5. drain-current-node lets the executing node reach a terminal FIRST:
+ *      node.completed precedes run.paused in the log.
  *
- * Capability gating: skips when the host doesn't advertise
- * `capabilities.runs.pauseResume.supported: true` (when present) AND
- * skips when no long-running fixture is advertised.
+ * rc.53 (2026-09-05): a tier-1 host un-skipping this file found it
+ * contradicting rest-endpoints.md in three places — it expected 200/202 on a
+ * second :pause (the prose says 409 unless the Idempotency-Key matches), it
+ * asserted an error code `conflict` that v1 never named (v1 mandates 409 +
+ * details.runStatus and names only run_terminal for a terminal run), and it
+ * paused a 30 s node under drain-current-node and polled 10 s for `paused`
+ * (drain lets the node finish; a host that yields mid-node under drain is the
+ * non-conforming one). It also sent `delaySeconds`, a field the fixtures do
+ * not define. v1 is frozen; the scenario was the defect in every case.
+ *
+ * Capability gating: skips when no long-running fixture is advertised.
  *
  * @see spec/v1/rest-endpoints.md §pause/resume
  */
@@ -31,35 +45,49 @@ const FIXTURE =
   null;
 
 const SKIP = !FIXTURE;
+const DOC_PAUSE = 'rest-endpoints.md POST /v1/runs/{runId}:pause';
+const DOC_RESUME = 'rest-endpoints.md POST /v1/runs/{runId}:resume';
+
+async function cancel(runId: string): Promise<void> {
+  await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, { reason: 'conformance-cleanup' });
+}
+
+async function eventTypes(runId: string): Promise<string[]> {
+  const res = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events/poll?timeout=1`);
+  const events = (res.json as { events?: unknown } | null)?.events;
+  return Array.isArray(events) ? events.map((e) => String((e as { type?: unknown }).type)) : [];
+}
 
 describe.skipIf(SKIP)('pause/resume: running → paused → running → terminal', () => {
   it('pause transitions to paused; resume returns the run to running', async () => {
     const create = await driver.post('/v1/runs', {
       workflowId: FIXTURE!,
-      inputs: { delaySeconds: 30 },
+      // 3 s, not 30 s: the resumed node.started is a FRESH attempt (runs.md
+      // §Pause and resume; rc.52), so a 30 s node resumed at ~60 ms completes
+      // at ~30.2 s — past the suite's 30 s test timeout by construction on
+      // any conforming host. rc.53 shipped 30 s and a tier-1 host measured
+      // exactly that. The pause is `immediate`, issued within ~60 ms of
+      // `running`, so 3 s is ample for the pause to land first.
+      inputs: { delayMs: 3_000 },
     });
     expect(create.status).toBe(201);
     const runId = (create.json as { runId: string }).runId;
 
     await pollUntilStatus(runId, 'running', { timeoutMs: 10_000 });
 
+    // `immediate` snapshots between events, so `paused` is observable within
+    // milliseconds. Under drain-current-node the node would finish first
+    // (rest-endpoints.md); that semantic is witnessed by the drain leg below.
     const pause = await driver.post(`/v1/runs/${encodeURIComponent(runId)}:pause`, {
       reason: 'conformance-test',
-      drainPolicy: 'drain-current-node',
+      drainPolicy: 'immediate',
     });
     if (pause.status === 404) {
-      // Pause endpoint not yet implemented by the host — surface the skip honestly.
-      // eslint-disable-next-line no-console
-      console.warn(
-        '[pause-resume] host returned 404 for :pause — endpoint not implemented; skipping rest',
-      );
-      await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
-        reason: 'conformance-cleanup',
-      });
+      await cancel(runId);
       return softSkip('blocked', 'precondition not met — `pause.status === 404` returned early ([pause-resume] host returned 404 for :pause — endpoint not implemented; skipping rest) (seam, prior step, or fixture unavailable)');
     }
-    expect(pause.status, req('openwop.it.pause-resume.pause-transitions-to-paused-resume-returns-the-run-to-running', 
-      'rest-endpoints.md POST /v1/runs/{runId}:pause',
+    expect(pause.status, req('openwop.it.pause-resume.pause-transitions-to-paused-resume-returns-the-run-to-running',
+      DOC_PAUSE,
       ':pause MUST return 202 on a pausable run',
     )).toBe(202);
 
@@ -68,8 +96,8 @@ describe.skipIf(SKIP)('pause/resume: running → paused → running → terminal
     const resume = await driver.post(`/v1/runs/${encodeURIComponent(runId)}:resume`, {
       reason: 'conformance-test',
     });
-    expect(resume.status, req('openwop.it.pause-resume.pause-transitions-to-paused-resume-returns-the-run-to-running', 
-      'rest-endpoints.md POST /v1/runs/{runId}:resume',
+    expect(resume.status, req('openwop.it.pause-resume.pause-transitions-to-paused-resume-returns-the-run-to-running',
+      DOC_RESUME,
       ':resume MUST return 202 on a paused run',
     )).toBe(202);
 
@@ -82,7 +110,7 @@ describe.skipIf(SKIP)('pause/resume: :resume on a non-paused run returns 409', (
   it('resuming a running (not paused) run returns 409 with details.runStatus', async () => {
     const create = await driver.post('/v1/runs', {
       workflowId: FIXTURE!,
-      inputs: { delaySeconds: 30 },
+      inputs: { delayMs: 30_000 },
     });
     expect(create.status).toBe(201);
     const runId = (create.json as { runId: string }).runId;
@@ -91,61 +119,85 @@ describe.skipIf(SKIP)('pause/resume: :resume on a non-paused run returns 409', (
 
     const resume = await driver.post(`/v1/runs/${encodeURIComponent(runId)}:resume`, {});
     if (resume.status === 404) {
-      await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
-        reason: 'conformance-cleanup',
-      });
+      await cancel(runId);
       return softSkip('blocked', 'precondition not met — `resume.status === 404` returned early (seam, prior step, or fixture unavailable)');
     }
-    expect(resume.status, req('openwop.it.pause-resume.resuming-a-running-not-paused-run-returns-409-with-details-runstatus', 
-      'rest-endpoints.md POST /v1/runs/{runId}:resume',
+    expect(resume.status, req('openwop.it.pause-resume.resuming-a-running-not-paused-run-returns-409-with-details-runstatus',
+      DOC_RESUME,
       ':resume on a non-paused run MUST return 409',
     )).toBe(409);
 
+    // v1 mandates the status and details.runStatus; it names no code for
+    // this case (the registry is open — error-envelope.schema.json), so
+    // none is asserted. `run_state_conflict` is the v2 answer (runs.md).
     const body = resume.json as { error?: string; details?: { runStatus?: string } };
-    expect(body.error).toBe('conflict');
-    expect(typeof body.details?.runStatus).toBe('string');
+    expect(typeof body.details?.runStatus, req('openwop.it.pause-resume.resuming-a-running-not-paused-run-returns-409-with-details-runstatus',
+      DOC_RESUME,
+      'the 409 MUST carry details.runStatus with the actual state',
+    )).toBe('string');
 
-    await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
-      reason: 'conformance-cleanup',
-    });
+    await cancel(runId);
   });
 });
 
-describe.skipIf(SKIP)('pause/resume: pause is idempotent when already paused', () => {
-  it(':pause on an already-paused run is a no-op (200/202) — idempotent', async () => {
+describe.skipIf(SKIP)('pause/resume: a second :pause is 409 without a matching Idempotency-Key and 202 with one', () => {
+  it(':pause on an already-paused run returns 409 with details.runStatus paused, unless the request carries the original Idempotency-Key', async () => {
     const create = await driver.post('/v1/runs', {
       workflowId: FIXTURE!,
-      inputs: { delaySeconds: 30 },
+      inputs: { delayMs: 30_000 },
     });
     expect(create.status).toBe(201);
     const runId = (create.json as { runId: string }).runId;
     await pollUntilStatus(runId, 'running', { timeoutMs: 10_000 });
 
-    const first = await driver.post(`/v1/runs/${encodeURIComponent(runId)}:pause`, {});
+    const first = await driver.post(`/v1/runs/${encodeURIComponent(runId)}:pause`, { drainPolicy: 'immediate' });
     if (first.status === 404) {
-      await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
-        reason: 'conformance-cleanup',
-      });
+      await cancel(runId);
       return softSkip('blocked', 'precondition not met — `first.status === 404` returned early (seam, prior step, or fixture unavailable)');
     }
-    expect([200, 202]).toContain(first.status);
+    expect(first.status, req('openwop.it.pause-resume.pause-on-an-already-paused-run-returns-409-with-details-runstatus-paused-unless',
+      DOC_PAUSE,
+      ':pause MUST return 202 on a pausable run',
+    )).toBe(202);
     await pollUntilStatus(runId, 'paused', { timeoutMs: 10_000 });
 
-    // Idempotent second :pause — MUST NOT 409 just because the run is
-    // already paused. 200/202 are both acceptable per the additive
-    // contract; 409 would force callers to read state before calling.
+    // rest-endpoints.md §:pause Idempotency: "a :pause against a run that is
+    // already paused returns 409 (with the existing pause's pausedAt in
+    // details) unless the request carries Idempotency-Key matching the
+    // original pause, in which case the host returns 202 with the cached
+    // response." Until rc.53 this leg asserted 200/202 here, citing an
+    // "additive contract" the prose does not contain.
     const second = await driver.post(`/v1/runs/${encodeURIComponent(runId)}:pause`, {});
-    expect(
-      [200, 202].includes(second.status),
-      req('openwop.it.pause-resume.pause-on-an-already-paused-run-is-a-no-op-200-202-idempotent', 
-        'rest-endpoints.md POST /v1/runs/{runId}:pause',
-        ':pause on an already-paused run MUST be idempotent (200/202), not 409',
-      ),
-    ).toBe(true);
-
-    await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
-      reason: 'conformance-cleanup',
-    });
+    expect(second.status, req('openwop.it.pause-resume.pause-on-an-already-paused-run-returns-409-with-details-runstatus-paused-unless',
+      DOC_PAUSE,
+      ':pause on an already-paused run without a matching Idempotency-Key MUST return 409',
+    )).toBe(409);
+    const body = second.json as { details?: { runStatus?: string } };
+    expect(body.details?.runStatus, req('openwop.it.pause-resume.pause-on-an-already-paused-run-returns-409-with-details-runstatus-paused-unless',
+      DOC_PAUSE,
+      'the 409 MUST carry details.runStatus: paused',
+    )).toBe('paused');
+    await cancel(runId);
+
+    // The keyed form: the same Idempotency-Key on both pauses collapses the
+    // second into the cached 202.
+    const keyed = await driver.post('/v1/runs', { workflowId: FIXTURE!, inputs: { delayMs: 30_000 } });
+    expect(keyed.status).toBe(201);
+    const keyedId = (keyed.json as { runId: string }).runId;
+    await pollUntilStatus(keyedId, 'running', { timeoutMs: 10_000 });
+    const key = `openwop-conformance-pause-${keyedId.replace(/[^A-Za-z0-9._~-]/g, '-')}`.slice(0, 128);
+    const k1 = await driver.post(`/v1/runs/${encodeURIComponent(keyedId)}:pause`, { drainPolicy: 'immediate' }, { headers: { 'Idempotency-Key': key } });
+    expect(k1.status, req('openwop.it.pause-resume.pause-on-an-already-paused-run-returns-409-with-details-runstatus-paused-unless',
+      DOC_PAUSE,
+      ':pause with an Idempotency-Key MUST return 202 on a pausable run',
+    )).toBe(202);
+    await pollUntilStatus(keyedId, 'paused', { timeoutMs: 10_000 });
+    const k2 = await driver.post(`/v1/runs/${encodeURIComponent(keyedId)}:pause`, { drainPolicy: 'immediate' }, { headers: { 'Idempotency-Key': key } });
+    expect(k2.status, req('openwop.it.pause-resume.pause-on-an-already-paused-run-returns-409-with-details-runstatus-paused-unless',
+      DOC_PAUSE,
+      'a :pause carrying the original Idempotency-Key MUST return 202 with the cached response, not 409',
+    )).toBe(202);
+    await cancel(keyedId);
   });
 });
 
@@ -160,19 +212,58 @@ describe.skipIf(SKIP)('pause/resume: :pause on a terminal run returns 409', () =
 
     const pause = await driver.post(`/v1/runs/${encodeURIComponent(runId)}:pause`, {});
     if (pause.status === 404) return softSkip('blocked', 'precondition not met — `pause.status === 404` returned early (seam, prior step, or fixture unavailable)');
-    expect(pause.status, req('openwop.it.pause-resume.pause-on-a-completed-cancelled-failed-run-must-return-409', 
-      'rest-endpoints.md POST /v1/runs/{runId}:pause',
+    expect(pause.status, req('openwop.it.pause-resume.pause-on-a-completed-cancelled-failed-run-must-return-409',
+      DOC_PAUSE,
       ':pause on a terminal run MUST return 409',
     )).toBe(409);
 
+    // v1 mandates details.runStatus; `run_terminal` is the one code v1 names
+    // for a mutation on a terminal run (rest-endpoints.md, bulk-cancel), and
+    // the registry is open, so the code is not asserted here.
     const body = pause.json as { error?: string; details?: { runStatus?: string } };
-    expect(body.error).toBe('conflict');
-    // Spec requires `details.runStatus` to disclose the terminal state so
-    // the caller can decide whether to retry or surface the conflict.
     expect(['completed', 'failed', 'cancelled']).toContain(body.details?.runStatus);
   });
 });
 
+describe.skipIf(SKIP)('pause/resume: drain-current-node lets the executing node reach a terminal first', () => {
+  it('under drain-current-node node.completed precedes run.paused in the log', async () => {
+    // A short node: drain has something to wait for that finishes inside the
+    // poll window. A 30 s node under drain pauses after 30 s — that is the
+    // semantic, not a bug (rest-endpoints.md: "lets the executing node reach
+    // a terminal before the run transitions to paused").
+    const create = await driver.post('/v1/runs', {
+      workflowId: FIXTURE!,
+      inputs: { delayMs: 3_000 },
+    });
+    expect(create.status).toBe(201);
+    const runId = (create.json as { runId: string }).runId;
+    await pollUntilStatus(runId, 'running', { timeoutMs: 10_000 });
+
+    const pause = await driver.post(`/v1/runs/${encodeURIComponent(runId)}:pause`, {
+      reason: 'conformance-drain',
+      drainPolicy: 'drain-current-node',
+    });
+    if (pause.status === 404) {
+      await cancel(runId);
+      return softSkip('blocked', 'precondition not met — `pause.status === 404` returned early (seam, prior step, or fixture unavailable)');
+    }
+    expect(pause.status, req('openwop.it.pause-resume.under-drain-current-node-node-completed-precedes-run-paused-in-the-log',
+      DOC_PAUSE,
+      ':pause with drainPolicy drain-current-node MUST return 202 (pause requested)',
+    )).toBe(202);
+
+    await pollUntilStatus(runId, 'paused', { timeoutMs: 20_000 });
+    const types = await eventTypes(runId);
+    const done = types.indexOf('node.completed');
+    const paused = types.indexOf('run.paused');
+    expect(done >= 0 && paused > done, req('openwop.it.pause-resume.under-drain-current-node-node-completed-precedes-run-paused-in-the-log',
+      DOC_PAUSE,
+      `drain-current-node MUST let the executing node reach a terminal before the run transitions to paused — node.completed MUST precede run.paused (types: ${types.join(', ')})`,
+    )).toBe(true);
+    await cancel(runId);
+  });
+});
+
 describe.skipIf(SKIP)('pause/resume: :pause-during-suspend race', () => {
   it(':pause MUST NOT silently override an active interrupt suspend', async () => {
     // If the host seeds an approval fixture, drive a suspend then attempt
@@ -198,18 +289,15 @@ describe.skipIf(SKIP)('pause/resume: :pause-during-suspend race', () => {
       reason: 'race-test',
     });
     if (pause.status === 404) {
-      // Cleanup.
-      await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
-        reason: 'conformance-cleanup',
-      });
+      await cancel(runId);
       return softSkip('blocked', 'precondition not met — `pause.status === 404` returned early (seam, prior step, or fixture unavailable)');
     }
 
     // Either rejection (preferred) or stacked-pause is OK; silent override is not.
     if (pause.status === 409) {
       const body = pause.json as { details?: { runStatus?: string } };
-      expect(body.details?.runStatus, req('openwop.it.pause-resume.pause-must-not-silently-override-an-active-interrupt-suspend', 
-        'rest-endpoints.md POST /v1/runs/{runId}:pause',
+      expect(body.details?.runStatus, req('openwop.it.pause-resume.pause-must-not-silently-override-an-active-interrupt-suspend',
+        DOC_PAUSE,
         ':pause-during-suspend MUST surface the active waiting-* status in the conflict envelope',
       )).toMatch(/^waiting-/);
     } else {
@@ -220,13 +308,11 @@ describe.skipIf(SKIP)('pause/resume: :pause-during-suspend race', () => {
       const status = (snap.json as { status: string }).status;
       expect(
         status === 'paused' || status.startsWith('waiting-'),
-        req('openwop.it.pause-resume.pause-must-not-silently-override-an-active-interrupt-suspend', 'rest-endpoints.md POST /v1/runs/{runId}:pause', ':pause-during-suspend MUST NOT silently discard the active interrupt'),
+        req('openwop.it.pause-resume.pause-must-not-silently-override-an-active-interrupt-suspend', DOC_PAUSE, ':pause-during-suspend MUST NOT silently discard the active interrupt'),
       ).toBe(true);
     }
 
-    await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
-      reason: 'conformance-cleanup',
-    });
+    await cancel(runId);
   });
 });
 
@@ -249,7 +335,7 @@ describe.skipIf(SKIP)('pause/resume: drainPolicy discrimination per capabilities
     for (const policy of drainPolicies) {
       const create = await driver.post('/v1/runs', {
         workflowId: FIXTURE!,
-        inputs: { delaySeconds: 30 },
+        inputs: { delayMs: 30_000 },
       });
       expect(create.status).toBe(201);
       const runId = (create.json as { runId: string }).runId;
@@ -260,14 +346,12 @@ describe.skipIf(SKIP)('pause/resume: drainPolicy discrimination per capabilities
         reason: `conformance-drainpolicy-${policy}`,
         drainPolicy: policy,
       });
-      expect(pause.status, req('openwop.it.pause-resume.every-drainpolicy-advertised-by-the-host-is-accepted-on-pause', 
+      expect(pause.status, req('openwop.it.pause-resume.every-drainpolicy-advertised-by-the-host-is-accepted-on-pause',
         'capabilities.md §`runs.pauseResume.drainPolicies` + rest-endpoints.md POST /v1/runs/{runId}:pause',
         `host-advertised drainPolicy='${policy}' MUST be accepted on :pause`,
       )).toBe(202);
 
-      await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
-        reason: 'conformance-cleanup',
-      });
+      await cancel(runId);
     }
   });
 });