Upload alea/gen_jb.py with huggingface_hub

alea/gen_jb.py

@@ -0,0 +1,604 @@
+"""gen_jb: synthetic generators for JevBench-STYLE hard families.
+
+Pure synthetic, programmatically exact answers. Original content only —
+no benchmark items are read, copied or paraphrased. Families target the
+measured weak spots: intent collapse, multi-hop, temporal, routing,
+policy adjudication, traps/decoys, ambiguity, severity ordinals,
+probability, extraction-verify, dedup/consistency.
+
+Emit rows in alea format:
+  {"state": str, "questions": {"q0": {...}}, "targets": {"q0": ...},
+   "family": str}
+"""
+import argparse
+import json
+import random
+
+rng = random.Random(4242)
+
+
+def choice(state, instr, crit, correct_key, family):
+    keys = list(crit.keys())
+    tgt = [0.0] * len(keys)
+    tgt[keys.index(correct_key)] = 1.0
+    return {"state": state,
+            "questions": {"q0": {"type": "choice", "instructions": instr,
+                                 "criteria": crit}},
+            "targets": {"q0": tgt}, "family": family}
+
+
+def noul(state, instr, val, family):
+    return {"state": state,
+            "questions": {"q0": {"type": "noul", "instructions": instr}},
+            "targets": {"q0": float(val)}, "family": family}
+
+
+# ---------------- intent (anti-mode-collapse) ----------------
+
+INTENT_BANK = {
+    "cancel_order": ["cancel my order", "I want to cancel the order I just "
+                     "placed", "please cancel order", "undo my purchase",
+                     "I changed my mind, cancel it"],
+    "track_order": ["where is my package", "track my shipment", "when will my "
+                    "order arrive", "status of my delivery", "is my order "
+                    "shipped yet"],
+    "refund": ["I want my money back", "issue a refund", "refund me for the "
+               "broken item", "return my payment", "give me a refund"],
+    "change_address": ["update my shipping address", "I moved, change the "
+                       "delivery address", "send it to my new address",
+                       "correct my address", "reroute to a different address"],
+    "report_damage": ["the item arrived broken", "my package was damaged",
+                      "the product is defective", "it came cracked",
+                      "screen is shattered on arrival"],
+    "billing_question": ["why was I charged twice", "question about my "
+                         "invoice", "explain this charge on my card",
+                         "what is this billing line", "you billed me wrong"],
+    "upgrade_plan": ["upgrade my subscription", "I want the premium tier",
+                     "move me to the pro plan", "upgrade my account",
+                     "switch to the business plan"],
+    "reset_password": ["forgot my password", "reset my login", "I cant sign "
+                       "in, need a password reset", "help me get back into "
+                       "my account", "password not working"],
+    "cancel_subscription": ["cancel my subscription", "stop the monthly "
+                            "charges", "end my membership", "I want to "
+                            "unsubscribe", "cancel my plan"],
+    "technical_issue": ["the app keeps crashing", "website wont load",
+                        "getting an error message", "feature is broken",
+                        "nothing happens when I click"],
+    "complaint": ["I am very unhappy with your service", "this is "
+                  "unacceptable", "I want to file a complaint", "worst "
+                  "experience ever", "terrible support"],
+    "praise": ["great job on the delivery", "love the new update", "thanks "
+               "for the quick help", "excellent service", "very happy with "
+               "the product"],
+    "set_alarm": ["wake me at 7", "set an alarm for tomorrow morning",
+                  "alarm at 6:30 please", "remind me at 8am", "set a timer "
+                  "for 20 minutes"],
+    "play_music": ["play some jazz", "put on my workout playlist", "play "
+                   "the new album", "start the radio", "play music"],
+    "weather": ["what is the weather today", "is it going to rain",
+                "forecast for the weekend", "temperature outside",
+                "will it snow tonight"],
+    "send_message": ["text mom I am running late", "send a message to "
+                     "John", "tell Sarah the meeting moved", "message the "
+                     "group chat", "send an sms to my boss"],
+    "book_flight": ["book a flight to Denver", "I need a ticket to "
+                    "Chicago next Friday", "find me flights to Miami",
+                    "reserve a seat on the morning flight", "book airfare"],
+    "restaurant_reservation": ["book a table for two tonight", "reserve a "
+                               "spot at the italian place", "dinner "
+                               "reservation for four", "table for 7pm",
+                               "book a restaurant"],
+}
+
+INTENT_TEMPLATES = ["{}", "Hey, {}", "Hi - {}", "{}", "Can you {}",
+                    "Please {}", "I need help: {}", "{}", "{}", "{}"]
+
+
+def gen_intent(n):
+    names = list(INTENT_BANK)
+    out = []
+    for _ in range(n):
+        true = rng.choice(names)
+        phrase = rng.choice(INTENT_BANK[true])
+        tmpl = rng.choice(INTENT_TEMPLATES)
+        msg = tmpl.format(phrase)
+        # distractors: intents sharing vocabulary where possible
+        vocab = {"order": ["cancel_order", "track_order"],
+                 "address": ["change_address"], "cancel": ["cancel_order",
+                 "cancel_subscription"], "book": ["book_flight",
+                 "restaurant_reservation"], "refund": ["refund",
+                 "billing_question"], "set": ["set_alarm"]}
+        pool = [x for x in names if x != true]
+        for w, cands in vocab.items():
+            if w in phrase.lower():
+                pool = cands[:1] + [x for x in pool if x not in cands]
+        k = rng.randint(3, 6)
+        opts = [true] + rng.sample(pool, k)
+        rng.shuffle(opts)
+        crit = {o: f"Route to the '{o.replace('_', ' ')}' handler" for o in opts}
+        st = ("Incoming user message to the assistant router:\n\n\"%s\"" % msg)
+        out.append(choice(st, "Pick the single intent this message maps to.",
+                          crit, true, "jb_intent"))
+    return out
+
+
+# ---------------- multi-hop arithmetic ----------------
+
+def gen_multihop(n):
+    out = []
+    for _ in range(n):
+        kind = rng.choice(["rates", "diff", "combine", "percent"])
+        if kind == "rates":
+            a = rng.randint(3, 9); b = rng.randint(2, 8); c = rng.randint(2, 6)
+            st = (f"A warehouse packs {a} crates per hour. It operates {b} "
+                  f"hours per shift and runs {c} shifts this week. A client "
+                  f"ordered {{}} crates.\n\nHow many crates does the "
+                  f"warehouse pack this week?")
+            ans = a * b * c
+            st = st.replace("{}", str(rng.randint(50, 400)))
+            ds = [ans + rng.choice([-1, 1]) * rng.randint(2, 20)
+                  for _ in range(3)]
+        elif kind == "diff":
+            x = rng.randint(200, 900); y = rng.randint(30, 199)
+            z = rng.randint(20, 90)
+            st = (f"An account starts at ${x}. A fee of ${y} is charged, "
+                  f"then a deposit of ${z} arrives. A second fee of ${y//2} "
+                  f"is charged.\n\nWhat is the final balance?")
+            ans = x - y + z - y // 2
+            ds = [ans + rng.choice([-1, 1]) * rng.randint(2, 30)
+                  for _ in range(3)]
+        elif kind == "combine":
+            p = rng.randint(2, 6); q_ = rng.randint(3, 8); r_ = rng.randint(2, 7)
+            st = (f"Team A finishes {p} tasks per day for {q_} days. Team B "
+                  f"finishes {r_} tasks per day for {q_} days.\n\nHow many "
+                  f"tasks did both teams finish in total?")
+            ans = (p + r_) * q_
+            ds = [p * q_ + r_, p * q_, r_ * q_]
+        else:
+            base = rng.randint(200, 2000); pct = rng.choice([5, 10, 15, 20, 25])
+            st = (f"A subscription costs ${base} per year. It increases by "
+                  f"{pct}% this year, then a ${rng.randint(10, 50)} loyalty "
+                  f"credit is applied.\n\nWhat is the effective yearly cost?")
+            credit = int(st.split("$")[-1].split(" loyalty")[0])
+            ans = base * (1 + pct / 100) - credit
+            ans = round(ans, 2)
+            ds = [round(base * (1 + pct / 100), 2),
+                  round(base * (1 - pct / 100), 2),
+                  round(ans + rng.choice([-1, 1]) * rng.randint(5, 40), 2)]
+        opts = [f"{ans:g}"] + [f"{d:g}" for d in ds]
+        keys = [f"answer_{i}" for i in range(4)]
+        order = list(range(4)); rng.shuffle(order)
+        crit = {keys[j]: opts[j] for j in order}
+        correct = keys[order.index(0)]
+        out.append(choice(st, "Compute the answer. Only the exact value is "
+                          "correct.", crit, correct, "jb_multihop"))
+    return out
+
+
+# ---------------- temporal ----------------
+
+WD = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday",
+      "Sunday"]
+
+def gen_temporal(n):
+    out = []
+    for _ in range(n):
+        kind = rng.choice(["weekday", "deadline", "duration", "age"])
+        if kind == "weekday":
+            d0 = rng.randint(1, 28); m0 = rng.randint(1, 12)
+            off = rng.randint(3, 20)
+            import datetime as dt
+            base = dt.date(2026, m0, d0)
+            tgt_d = base + dt.timedelta(days=off)
+            st = (f"A ticket was opened on {base.strftime('%A, %B %d, %Y')}. "
+                  f"The SLA requires a response within {off} calendar days.\n\n"
+                  f"On which weekday does the SLA expire?")
+            opts = WD[:]
+            rng.shuffle(opts)
+            crit = {o: f"SLA expires on a {o}" for o in opts}
+            out.append(choice(st, "Choose the weekday on which the SLA "
+                              "expires.", crit, tgt_d.strftime("%A"),
+                              "jb_temporal"))
+        elif kind == "deadline":
+            import datetime as dt
+            m0, d0 = rng.randint(1, 12), rng.randint(1, 28)
+            try:
+                base = dt.date(2026, m0, d0)
+            except ValueError:
+                continue
+            biz = rng.randint(3, 10)
+            dd = base; added = 0
+            while added < biz:
+                dd += dt.timedelta(days=1)
+                if dd.weekday() < 5:
+                    added += 1
+            st = (f"Contract signed {base.strftime('%B %d, %Y')}. Payment is "
+                  f"due within {biz} business days (Mon-Fri only, ignoring "
+                  f"holidays).\n\nWhat is the payment due date?")
+            wrongs = [base + dt.timedelta(days=biz),
+                      dd + dt.timedelta(days=rng.choice([-2, 2])),
+                      base + dt.timedelta(days=biz + 2)]
+            opts = [dd.strftime("%B %d")] + [w.strftime("%B %d")
+                                             for w in wrongs]
+            keys = [f"date_{i}" for i in range(4)]
+            order = list(range(4)); rng.shuffle(order)
+            crit = {keys[j]: opts[j] for j in order}
+            out.append(choice(st, "Choose the correct due date.", crit,
+                              keys[order.index(0)], "jb_temporal"))
+        elif kind == "duration":
+            h1 = rng.randint(6, 22); m1 = rng.choice([0, 15, 30, 45])
+            h2 = rng.randint(6, 22); m2 = rng.choice([0, 15, 30, 45])
+            t1 = h1 * 60 + m1; t2 = h2 * 60 + m2
+            if t2 <= t1:
+                continue
+            diff = t2 - t1
+            st = (f"A shift runs from {h1:02d}:{m1:02d} to {h2:02d}:{m2:02d} "
+                  f"with a {rng.choice([15, 30, 45])}-minute unpaid break.")
+            brk = int(st.split("a ")[1].split("-minute")[0])
+            ans = diff - brk
+            ds = [diff, diff - brk + rng.choice([15, 30]), diff - 60]
+            opts = [f"{ans//60}h{ans%60:02d}"] + [f"{d//60}h{d%60:02d}"
+                                                 for d in ds]
+            keys = [f"dur_{i}" for i in range(4)]
+            order = list(range(4)); rng.shuffle(order)
+            crit = {keys[j]: opts[j] for j in order}
+            out.append(choice(st, "Choose the paid duration.", crit,
+                              keys[order.index(0)], "jb_temporal"))
+        else:
+            by = rng.randint(1958, 1990); ref = rng.choice([2024, 2025, 2026])
+            st = (f"A document says the person was born in {by}. The record "
+                  f"was checked in {ref}.\n\nHow old was the person when "
+                  f"checked? (Assume birthday already occurred.)")
+            ans = ref - by
+            ds = [ans - 1, ans + 1, ans + rng.choice([-2, 2])]
+            opts = [str(ans)] + [str(d) for d in ds]
+            keys = [f"age_{i}" for i in range(4)]
+            order = list(range(4)); rng.shuffle(order)
+            crit = {keys[j]: opts[j] for j in order}
+            out.append(choice(st, "Choose the correct age.", crit,
+                              keys[order.index(0)], "jb_temporal"))
+    return out
+
+
+# ---------------- policy adjudication ----------------
+
+POLICY_KINDS = [
+    {"domain": "refund",
+     "clauses": [
+         ("standard", "Standard items may be returned within {D1} days for a "
+                      "full refund."),
+         ("final_sale", "Items marked 'final sale' cannot be returned or "
+                        "refunded."),
+         ("opened_media", "Opened software and media may be returned within "
+                          "{D2} days only if defective."),
+         ("restocking", "Electronics returns incur a {P}% restocking fee."),
+         ("gift", "Gift purchases are refunded as store credit only."),
+     ],
+     "facts": ["the item was marked final sale", "the item arrived defective",
+               "the return is within the allowed window", "the return is "
+               "past the allowed window", "the item was opened software",
+               "the item is electronics", "the purchase was a gift"],
+     "outcomes": ["full_refund", "store_credit", "defective_exchange",
+                  "deny_return", "refund_minus_restocking"]},
+    {"domain": "insurance",
+     "clauses": [
+         ("excl_flood", "Flood damage is excluded under this policy."),
+         ("excl_wind", "Wind damage is excluded in coastal zones."),
+         ("cover_theft", "Theft is covered up to ${L} per occurrence."),
+         ("deductible", "All claims carry a ${DD} deductible."),
+         ("grace", "Claims reported within {D} days of loss qualify for "
+                   "expedited handling."),
+     ],
+     "facts": ["the damage was caused by flooding", "the damage was caused "
+               "by wind in a coastal zone", "the loss is a theft",
+               "the claim was reported late", "the claim was reported "
+               "promptly"],
+     "outcomes": ["cover_minus_deductible", "deny_excluded_peril",
+                  "deny_late_report", "cover_expedited"]},
+    {"domain": "leave",
+     "clauses": [
+         ("tenure", "Employees with <{Y} year tenure get no extended leave."),
+         ("parental", "Parental leave: {W} weeks paid for primary "
+                      "caregivers."),
+         ("medical", "Medical leave requires a physician note."),
+         ("cap", "Total paid leave cannot exceed {C} weeks per year."),
+     ],
+     "facts": ["the employee has 8 months tenure", "the employee has 3 years "
+               "tenure", "the request is for parental leave as primary "
+               "caregiver", "no physician note was provided", "a physician "
+               "note was provided", "the request would exceed the annual cap"],
+     "outcomes": ["approve_paid", "approve_unpaid", "deny_no_documentation",
+                  "deny_tenure", "deny_cap_exceeded"]},
+]
+
+
+def gen_policy(n):
+    out = []
+    for _ in range(n):
+        pk = rng.choice(POLICY_KINDS)
+        # instantiate numbers
+        subs = {"D1": rng.choice([14, 30, 60]), "D2": rng.choice([7, 14]),
+                "P": rng.choice([10, 15, 20]), "L": rng.choice([2000, 5000,
+                10000]), "DD": rng.choice([250, 500, 1000]),
+                "D": rng.choice([14, 30]), "Y": 1, "W": rng.choice([8, 12]),
+                "C": rng.choice([6, 8])}
+        clauses = [(cid, txt.format(**subs)) for cid, txt in pk["clauses"]]
+        fact = rng.choice(pk["facts"])
+        # pick the clause that governs + the outcome it implies
+        dom = pk["domain"]
+        if dom == "refund":
+            if "final sale" in fact:
+                res = "deny_return"; src = "final_sale"
+            elif "defective" in fact and "opened software" in fact:
+                res = "defective_exchange"; src = "opened_media"
+            elif "defective" in fact:
+                res = "defective_exchange"; src = "opened_media"
+            elif "past the allowed window" in fact:
+                res = "deny_return"; src = "standard"
+            elif "gift" in fact:
+                res = "store_credit"; src = "gift"
+            elif "electronics" in fact:
+                res = "refund_minus_restocking"; src = "restocking"
+            else:
+                res = "full_refund"; src = "standard"
+        elif dom == "insurance":
+            if "flood" in fact:
+                res = "deny_excluded_peril"; src = "excl_flood"
+            elif "wind" in fact:
+                res = "deny_excluded_peril"; src = "excl_wind"
+            elif "late" in fact:
+                res = "deny_late_report"; src = "grace"
+            elif "promptly" in fact:
+                res = "cover_expedited"; src = "grace"
+            else:
+                res = "cover_minus_deductible"; src = "cover_theft"
+        else:
+            if "8 months" in fact:
+                res = "deny_tenure"; src = "tenure"
+            elif "no physician" in fact and "medical" in " ".join(
+                    c[0] for c in clauses):
+                res = "deny_no_documentation"; src = "medical"
+            elif "exceed" in fact:
+                res = "deny_cap_exceeded"; src = "cap"
+            elif "parental" in fact:
+                res = "approve_paid"; src = "parental"
+            else:
+                res = "approve_unpaid"; src = "medical"
+        policy_txt = "\n".join(f"  ({i+1}) {t}" for i, (_, t)
+                               in enumerate(clauses))
+        st = (f"POLICY ({dom.upper()})\n{policy_txt}\n\nCLAIM FACTS\n"
+              f"Reviewer's note: {fact}. All other facts are standard and "
+              f"unremarkable.\n\nA junior adjuster wrote: \"surface answer "
+              f"looks like a routine approval\".")
+        crit = {o: f"Outcome '{o.replace('_', ' ')}' applies" for o in
+                pk["outcomes"]}
+        out.append(choice(st, "As the adjudicator, apply the policy clauses "
+                          "to the facts. The correct outcome follows the "
+                          "controlling clause, not the surface impression.",
+                          crit, res, "jb_policy"))
+    return out
+
+
+# ---------------- trap / decoy ----------------
+
+def gen_trap(n):
+    out = []
+    for _ in range(n):
+        kind = rng.choice(["stale_note", "unit_mix", "negation", "wrong_field"])
+        if kind == "stale_note":
+            mo = rng.choice(["Mar", "Apr", "May"])
+            st = (f"DATABASE RECORD (verified {mo} 2026):\n  "
+                  f"subscription_status: active\n  "
+                  f"renewal_date: {rng.randint(1,28)} Jun 2026\n\n"
+                  f"UNVERIFIED STICKY NOTE (dated 2024):\n  \"customer "
+                  f"cancelled - account closed\"\n\n"
+                  f"Is the subscription active per the verified record?")
+            out.append(choice(st, "Answer using only the verified record; "
+                              "the sticky note is stale.",
+                              {"active": "Subscription is active",
+                               "cancelled": "Subscription is cancelled",
+                               "unknown": "Cannot be determined"},
+                              "active", "jb_trap"))
+        elif kind == "unit_mix":
+            a = rng.randint(2, 9); b = rng.randint(3, 12)
+            st = (f"A recipe needs {a} grams of salt per serving and serves "
+                  f"{b} people. A shopper bought a {a*b} gram box and a "
+                  f"{a*b*10} gram refill pack.\n\nDoes one box suffice for "
+                  f"one batch of the recipe?")
+            out.append(choice(st, "Compute servings x grams; compare to the "
+                              "box size, not the refill pack.",
+                              {"yes_exactly": "Yes, exactly enough",
+                               "yes_spare": "Yes, with spare",
+                               "no": "No, insufficient"},
+                              "yes_exactly", "jb_trap"))
+        elif kind == "negation":
+            st = (f"Release checklist for build {rng.randint(200,999)}:\n"
+                  f"  [x] unit tests pass\n  [x] docs updated\n"
+                  f"  [ ] security scan clean\n  [x] changelog written\n\n"
+                  f"Policy: release is blocked only if a REQUIRED item is "
+                  f"unchecked. All four items are required.")
+            out.append(choice(st, "Apply the policy literally: any unchecked "
+                              "required item blocks the release.",
+                              {"release_ok": "Release may proceed",
+                               "blocked_security": "Blocked: security scan "
+                               "not complete",
+                               "blocked_docs": "Blocked: docs missing"},
+                              "blocked_security", "jb_trap"))
+        else:
+            a, b = rng.randint(100, 999), rng.randint(100, 999)
+            st = (f"Spreadsheet row: quantity={a}, unit_price={b}, "
+                  f"discount_pct=0, region=EU, sku_total={a + b} (this "
+                  f"column holds quantity + unit_price, NOT revenue).\n\n"
+                  f"Which value equals revenue (quantity x unit_price)?")
+            rev = a * b
+            ds = [a + b, rev // 10, rev + rng.choice([-1, 1]) * a]
+            opts = [f"{rev}"] + [f"{d}" for d in ds]
+            keys = [f"v{i}" for i in range(4)]
+            order = list(range(4)); rng.shuffle(order)
+            crit = {keys[j]: opts[j] for j in order}
+            out.append(choice(st, "Pick the cell semantics correctly; "
+                              "sku_total is a decoy.", crit,
+                              keys[order.index(0)], "jb_trap"))
+    return out
+
+
+# ---------------- ambiguity ----------------
+
+def gen_ambiguity(n):
+    out = []
+    for _ in range(n):
+        has = rng.random() < 0.5
+        field = rng.choice(["delivery date", "refund amount", "contract "
+                            "term", "manager name", "budget line"])
+        if has:
+            val = rng.choice(["12 days", "$" + str(rng.randint(50, 900)),
+                              "24 months", "R. Alvarez",
+                              "$" + str(rng.randint(2, 40)) + "k"])
+            st = (f"Ticket summary: customer requests escalation. The "
+                  f"system record shows {field}: {val}. No other fields "
+                  f"populated.")
+            correct = "present"
+        else:
+            st = (f"Ticket summary: customer requests escalation. No "
+                  f"{field} is recorded anywhere in the record. Other "
+                  f"fields are present.")
+            correct = "absent"
+        out.append(choice(st, f"Does the record state the {field}? Answer "
+                          "only what the record contains.",
+                          {"present": "The field is recorded",
+                           "absent": "The field is not recorded",
+                           "unclear": "Cannot be determined"},
+                          correct, "jb_ambiguity"))
+    return out
+
+
+# ---------------- severity ordinal ----------------
+
+def gen_ordinal(n):
+    out = []
+    levels = {"sev_0": "No impact; cosmetic or documentation only",
+              "sev_1": "Minor impairment; workaround exists",
+              "sev_2": "Major impairment; core function degraded",
+              "sev_3": "Critical; outage, data loss, or safety risk"}
+    scen = [
+        ("Typo in a settings label", "sev_0"),
+        ("Button misaligned on mobile", "sev_0"),
+        ("Search returns slow results but works", "sev_1"),
+        ("PDF export missing images; copy-paste works", "sev_1"),
+        ("Payment retries fail for a subset of users", "sev_2"),
+        ("API returns 500s for one endpoint", "sev_2"),
+        ("All users logged out, sessions unrecoverable", "sev_3"),
+        ("Customer data corrupted in production", "sev_3"),
+        ("Dashboard chart color wrong", "sev_0"),
+        ("Login fails for users on one provider", "sev_2"),
+        ("Docs page 404s", "sev_0"),
+        ("Backup job delayed but completes", "sev_1"),
+    ]
+    for _ in range(n):
+        desc, sev = rng.choice(scen)
+        # add distractor detail
+        extra = rng.choice(["Users reported it during peak hours.",
+                            "One engineer could not reproduce it.",
+                            "A customer mentioned it in a survey.",
+                            "It appeared after the last deploy."])
+        st = f"Incident report: {desc}. {extra}"
+        out.append(choice(st, "Rate severity by the strict rubric; the "
+                          "highest level that the facts support.",
+                          dict(levels), sev, "jb_ordinal"))
+    return out
+
+
+# ---------------- probability ----------------
+
+def gen_probability(n):
+    out = []
+    for _ in range(n):
+        kind = rng.choice(["urn", "dice", "cards"])
+        if kind == "urn":
+            r_, b_ = rng.randint(2, 8), rng.randint(2, 8)
+            tot = r_ + b_
+            st = (f"An urn holds {r_} red and {b_} blue marbles. One marble "
+                  f"is drawn uniformly at random.")
+            ans = r_ / tot
+            ds = [b_ / tot, 1 - ans, (r_ - 1) / max(tot - 1, 1)]
+            opts = [f"{ans:.3f}"] + [f"{d:.3f}" for d in ds]
+            q = "What is the probability the marble is red?"
+        elif kind == "dice":
+            k = rng.randint(2, 4)
+            faces = rng.choice([6, 8, 12, 20])
+            st = (f"A fair {faces}-sided die is rolled once.")
+            ans = k / faces
+            ds = [(k + 1) / faces, (k - 1) / faces if k > 1 else
+                  (k + 2) / faces, 1 / faces]
+            opts = [f"{ans:.3f}"] + [f"{d:.3f}" for d in ds]
+            q = f"What is the probability the roll is {k} or less?"
+        else:
+            st = "A standard 52-card deck; one card is drawn."
+            ans = 13 / 52
+            ds = [1 / 52, 4 / 52, 26 / 52]
+            opts = [f"{ans:.3f}"] + [f"{d:.3f}" for d in ds]
+            q = "What is the probability the card is a heart?"
+        st += "\n\n" + q
+        keys = [f"p{i}" for i in range(4)]
+        order = list(range(4)); rng.shuffle(order)
+        crit = {keys[j]: opts[j] for j in order}
+        out.append(choice(st, "Choose the exact probability.", crit,
+                          keys[order.index(0)], "jb_probability"))
+    return out
+
+
+# ---------------- extraction verify (noul) ----------------
+
+def gen_extract(n):
+    out = []
+    for _ in range(n):
+        name = rng.choice(["Invoice", "Ticket", "Form", "Record"])
+        f1 = rng.choice(["amount", "status", "owner", "date"])
+        v1 = rng.choice(["$" + str(rng.randint(10, 999)),
+                         rng.choice(["open", "closed", "pending"]),
+                         rng.choice(["team-a", "team-b", "ops"]),
+                         f"2026-{rng.randint(1,12):02d}-{rng.randint(1,28):02d}"])
+        match = rng.random() < 0.5
+        claim_v = v1 if match else rng.choice(["$9999", "deleted",
+                                               "unknown", "1970-01-01"])
+        st = (f"{name} fields: {f1} = {v1}; priority = "
+              f"{rng.choice(['low','high'])}.\n\nClaim to verify: \"the "
+              f"{f1} is {claim_v}\".")
+        out.append(noul(st, "Decide whether the claim is supported by the "
+                        "fields shown.", match, "jb_extract"))
+    return out
+
+
+GENS = {
+    "intent": gen_intent,
+    "multihop": gen_multihop,
+    "temporal": gen_temporal,
+    "policy": gen_policy,
+    "trap": gen_trap,
+    "ambiguity": gen_ambiguity,
+    "ordinal": gen_ordinal,
+    "probability": gen_probability,
+    "extract": gen_extract,
+}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--out", default="data/jb.jsonl")
+    ap.add_argument("--per", type=int, default=4000)
+    args = ap.parse_args()
+    rows = []
+    for name, fn in GENS.items():
+        got = fn(args.per)
+        print(name, len(got))
+        rows += got
+    rng.shuffle(rows)
+    with open(args.out, "w") as f:
+        for r in rows:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+    print("TOTAL", len(rows), "->", args.out)
+
+
+if __name__ == "__main__":
+    main()