test(bonds): anchor auctionDiscountBps assertions to the specific guard

Both arkanaai (O1) and CodeRabbit's review of #38 flagged the same
test-quality issue on tests/repayment_pool_test.rs:276-281 (and the
parallel rollIn assertion at 694-698): the original
  assert!(gte >= 1, ...)
on OP_GREATERTHANOREQUAL64 was too loose. issue() emits five other
asset-amount `>=` checks (output.assets.lookup(...) >= N), so deleting
the `auctionDiscountBps >= 0` guard would drop GTE64 from 6 to 5 —
still >= 1, still passing.

Replaced both sites with a targeted 3-token window check:
  contains_window_3(output, fn_name,
                    "<auctionDiscountBps>", "OP_GREATERTHANOREQUAL", "0")
plus the symmetric `< 10000` check
  contains_window_3(output, fn_name,
                    "<auctionDiscountBps>", "OP_LESSTHAN", "10000")

The helper accepts any permutation of the three tokens within a 3-token
sliding window (the emitter's display order for the discount comparison
is `<auctionDiscountBps> OP_GREATERTHANOREQUAL 0`, which is not strict
postfix; the set-equality test is robust to that emitter quirk and to
future reordering).

Verified by regression injection: deleting `require(auctionDiscountBps
>= 0, ...)` from issue() makes test_issue_enforces_deployment_invariants
fail with the message
  "issue must carry the `auctionDiscountBps >= 0` deployment guard
   (expected window of <auctionDiscountBps>, OP_GREATERTHANOREQUAL, 0
    within 3 consecutive ASM tokens of `issue`)"
restoring the guard makes the test pass. Same behaviour for rollIn.

Tests: 256/256 (unchanged total — the asserts changed shape but not
count). cargo fmt --check clean.

Author: claude

tests/repayment_pool_test.rs

@@ -267,20 +267,67 @@ fn test_issue_enforces_deployment_invariants() {
          `> 0` value guards, found {gt})"
     );
 
-    // OP_GREATERTHANOREQUAL64 for auctionDiscountBps >= 0 — exactly one
-    // site in the deployment-safety block. (asset-amount `>=` checks like
-    // `output.assets.lookup(...) >= N` use the same opcode, but those fire
-    // AFTER the deployment checks and aren't counted as deployment guards.
-    // Floor at 1 captures the deployment check without coupling to the
-    // exact count of asset-amount checks.)
-    let gte = opcode_count(&output, "issue", "OP_GREATERTHANOREQUAL64");
-    assert!(
-        gte >= 1,
-        "issue must carry auctionDiscountBps >= 0 (OP_GREATERTHANOREQUAL64, \
-         found {gte} total — at least one must be the discount-bound check)"
+    // Targeted check for `auctionDiscountBps >= 0` — must anchor to the
+    // specific guard's tokens, not just count any `>=` opcode. arkanaai O1
+    // and CodeRabbit's review both flagged that a bare `gte >= 1` floor on
+    // OP_GREATERTHANOREQUAL64 would still pass if the discount guard were
+    // deleted, because issue() emits many asset-amount `>=` checks
+    // (`output.assets.lookup(...) >= N`) that satisfy that floor.
+    //
+    // The compiler emits the comparison block with `<auctionDiscountBps>`,
+    // `OP_GREATERTHANOREQUAL`, and `0` clustered within a 3-token window
+    // (display order is `<auctionDiscountBps> OP_GREATERTHANOREQUAL 0` in
+    // the current emitter — execution order may differ; we accept any
+    // permutation to stay robust to that).
+    assert!(
+        contains_window_3(
+            &output,
+            "issue",
+            "<auctionDiscountBps>",
+            "OP_GREATERTHANOREQUAL",
+            "0"
+        ),
+        "issue must carry the `auctionDiscountBps >= 0` deployment guard \
+         (expected window of <auctionDiscountBps>, OP_GREATERTHANOREQUAL, 0 \
+         within 3 consecutive ASM tokens of `issue`)"
+    );
+    assert!(
+        contains_window_3(
+            &output,
+            "issue",
+            "<auctionDiscountBps>",
+            "OP_LESSTHAN",
+            "10000"
+        ),
+        "issue must carry the `auctionDiscountBps < 10000` deployment guard \
+         (expected window of <auctionDiscountBps>, OP_LESSTHAN, 10000 within \
+         3 consecutive ASM tokens of `issue`)"
     );
 }
 
+/// True iff the function `name`'s server-variant ASM contains three given
+/// tokens in any order within a 3-token sliding window. Used for targeted
+/// regression checks where the compiler may emit a comparison's operands
+/// and opcode in a non-postfix display order — what matters is adjacency,
+/// not exact sequence.
+fn contains_window_3(
+    output: &arkade_compiler::models::ContractJson,
+    name: &str,
+    a: &str,
+    b: &str,
+    c: &str,
+) -> bool {
+    let tokens = asm_tokens(output, name);
+    if tokens.len() < 3 {
+        return false;
+    }
+    let target: std::collections::BTreeSet<&str> = [a, b, c].into_iter().collect();
+    tokens.windows(3).any(|w| {
+        let s: std::collections::BTreeSet<&str> = w.iter().map(|t| t.as_str()).collect();
+        s == target
+    })
+}
+
 #[test]
 fn test_issue_uses_ceiling_division_on_required_collateral() {
     // Dust-issuance defence: the required-collateral floor is computed via
@@ -691,10 +738,32 @@ fn test_roll_pair_enforces_all_deployment_invariants() {
         gt, 6,
         "rollIn must replicate issue's invariants (expected 6 OP_GREATERTHAN, found {gt})"
     );
-    let gte = opcode_count(&output, "rollIn", "OP_GREATERTHANOREQUAL64");
-    assert!(
-        gte >= 1,
-        "rollIn must carry auctionDiscountBps >= 0 (found {gte} OP_GREATERTHANOREQUAL64)"
+    // Targeted check for `auctionDiscountBps >= 0` AND `< 10000` — see
+    // the parallel test in `test_issue_enforces_deployment_invariants` for
+    // the rationale (arkanaai O1 / CodeRabbit review).
+    assert!(
+        contains_window_3(
+            &output,
+            "rollIn",
+            "<auctionDiscountBps>",
+            "OP_GREATERTHANOREQUAL",
+            "0"
+        ),
+        "rollIn must carry the `auctionDiscountBps >= 0` deployment guard \
+         (expected window of <auctionDiscountBps>, OP_GREATERTHANOREQUAL, 0 \
+         within 3 consecutive ASM tokens of `rollIn`)"
+    );
+    assert!(
+        contains_window_3(
+            &output,
+            "rollIn",
+            "<auctionDiscountBps>",
+            "OP_LESSTHAN",
+            "10000"
+        ),
+        "rollIn must carry the `auctionDiscountBps < 10000` deployment guard \
+         (expected window of <auctionDiscountBps>, OP_LESSTHAN, 10000 within \
+         3 consecutive ASM tokens of `rollIn`)"
     );
 }