Upload alea/gen_jb4.py with huggingface_hub

alea/gen_jb4.py

@@ -0,0 +1,936 @@
+"""Data factory v2 — broad capability data targeting measured weaknesses.
+
+Built from the JevBench miss autopsy (rl_r8):
+- intent misses were label-prior collapses (lexical overlap beats semantics)
+  -> intent_v2 has ~120 intents x 15 domains, near-miss negatives, and
+     keyword-trap messages; option style varies between descriptions and
+     slug+description pairs
+- long_policy misses were multi-document clause-resolution failures
+  -> policy_pack composes policy + amendment + case file with numeric
+     overrides, precedence and superseded text
+- ordinal/policy/routing misses on the original split
+  -> rubric_level + routing_v2 families
+- multi_hop/temporal/trap misses -> multihop (numeric+entity chains),
+  temporal_v2, state_track, trap_v2
+
+Every row unique via content-hash dedupe in main(). Targets one-hot where
+exact; soft for graded ambiguity only.
+"""
+import json
+import random
+from datetime import date, timedelta
+
+from alea.genbase import (generate, emit, q_choice, q_noul, q_score,
+                          validate_row, write_jsonl)
+
+rng = random.Random()
+
+FIRST = ["Mara", "Tobias", "Priya", "Kenji", "Lucia", "Omar", "Ingrid",
+         "Felix", "Sofia", "Dmitri", "Amara", "Jonas", "Nadia", "Pablo",
+         "Yuki", "Elena", "Ravi", "Tessa", "Bruno", "Wren", "Aisha",
+         "Callum", "Mei", "Stefan", "Zoya", "Anders", "Leila", "Mateo",
+         "Hana", "Viktor", "Chiara", "Deshawn", "Sanne", "Emeka",
+         "Farah", "Gustav", "Ines", "Joaquin", "Kira", "Lena", "Milan"]
+LAST = ["Okafor", "Lindqvist", "Marchetti", "Tanaka", "Novak", "Ferreira",
+        "Haugen", "Kowalski", "Rahman", "Silva", "Beaumont", "Nakamura",
+        "Petrov", "Adeyemi", "Larsen", "Moreau", "Ivanov", "Costa",
+        "Nielsen", "Weber", "Dubois", "Ali", "Santos", "Berg", "Fuchs"]
+CITIES = ["Oslo", "Lyon", "Nagoya", "Porto", "Tallinn", "Austin", "Leeds",
+          "Valencia", "Turku", "Cork", "Bergen", "Malmo", "Ghent",
+          "Adelaide", "Halifax", "Dunedin", "Brno", "Basel", "Tampere",
+          "Graz", "Porto", "Riga", "Lille", "Bergen", "Aarhus", "Suva"]
+ORGS = ["Northwind Systems", "Helios Logistics", "Cobalt Health",
+        "Meridian Bank", "Vantage Air", "Cedar Retail Group",
+        "Lattice Analytics", "Ironwood Manufacturing", "Beacon Insurance",
+        "Summit Energy", "Atlas Freight", "Pinnacle Software",
+        "Crescent Telecom", "Fernhill Foods", "Bluepine Aviation",
+        "Halcyon Marine", "Quartz Financial", "Rowan Robotics"]
+MONTHS = ["January", "February", "March", "April", "May", "June", "July",
+          "August", "September", "October", "November", "December"]
+CANNOT = "Cannot be determined from the information provided."
+
+
+def _onehot(n, i):
+    return [1.0 if j == i else 0.0 for j in range(n)]
+
+
+def _mk_opts(correct, wrongs, n_opt):
+    seen, ws = {correct}, []
+    for w in wrongs:
+        if w not in seen:
+            seen.add(w)
+            ws.append(w)
+        if len(ws) >= n_opt - 1:
+            break
+    if len(ws) < n_opt - 1:
+        raise ValueError("distractor collision")
+    vals = [correct] + ws
+    rng.shuffle(vals)
+    return list(vals), vals.index(correct)
+
+
+def _name():
+    return f"{rng.choice(FIRST)} {rng.choice(LAST)}"
+
+
+def _refno():
+    return (f"{rng.choice(['PR','RQ','CL','SO','INC','APP','PRA','HX'])}-"
+            f"{rng.choice([2025, 2026])}-{rng.randint(1000, 99999)}")
+
+
+# ------------------------------------------------------------------
+# policy_pack — policy + amendment + case file, JevBench-hard shaped
+# ------------------------------------------------------------------
+
+def _threshold_rule():
+    """(text_template, numeric value)."""
+    return rng.choice([
+        ("requests up to {v} are auto-approved", rng.choice([500, 1000,
+         2500, 5000, 10000])),
+        ("amounts above {v} require director approval",
+         rng.choice([2000, 5000, 10000, 25000])),
+        ("items under {v} days old qualify", rng.choice([14, 30, 60, 90])),
+        ("staff with {v}+ months tenure qualify", rng.choice([6, 12, 24])),
+        ("a fee of {v} applies", rng.choice([25, 50, 100, 250, 400])),
+        ("maximum payout is {v}", rng.choice([250, 400, 600, 1000, 1500])),
+    ])
+
+
+def gen_policy_pack():
+    org = rng.choice(ORGS)
+    code = f"{rng.choice(['POL','SOP','RB','GP','CRP','PR'])}-{rng.randint(1,9)}"
+    ver = rng.randint(2, 8)
+    subject = rng.choice(["reimbursement", "data export", "vendor onboarding",
+                          "leave eligibility", "return authorisation",
+                          "alert routing", "licence true-up",
+                          "severity classification"])
+    # base rule + amendment that may override it
+    base_txt, base_v = _threshold_rule()
+    amend_txt, amend_v = _threshold_rule()
+    eff = date(2025, 1, 1) + timedelta(days=rng.randint(0, 400))
+    amend_eff = eff + timedelta(days=rng.randint(60, 400))
+    controlling = rng.random() < 0.55  # amendment controls?
+    case_v = base_v + rng.choice([-3, -2, -1, 0, 1, 2, 3]) * max(
+        1, base_v // 5)
+    actor = _name()
+    ref = _refno()
+
+    doc = [
+        f"{org.upper()} — {subject.upper()} POLICY {code} "
+        f"(VERSION {ver}, EFFECTIVE {eff.strftime('%d %B %Y')})",
+        f"Section 1 — Scope. This policy governs all {subject} decisions "
+        f"for {org} personnel and systems.",
+        f"Section 2 — Standard rule: {base_txt.format(v=base_v)}.",
+        f"Section 3 — All determinations must cite the controlling "
+        f"section. If a later amendment conflicts with this document, "
+        f"the amendment prevails for cases arising on or after its "
+        f"effective date.",
+        f"Section 4 — Exceptions require written sign-off and expire "
+        f"after {rng.choice([30, 60, 90])} days.",
+        "",
+        f"AMENDMENT {code}/A{rng.randint(1,4)} (EFFECTIVE "
+        f"{amend_eff.strftime('%d %B %Y')}): For all cases arising on or "
+        f"after the effective date: {amend_txt.format(v=amend_v)}. "
+        f"All other provisions of {code} v{ver} remain in force.",
+        "",
+        f"CASE FILE {ref}: submitted by {actor} on "
+        f"{(amend_eff + timedelta(days=rng.randint(5, 90))).strftime('%d %B %Y')}"
+        f". Requested value: {case_v} "
+        f"(units consistent with the policy thresholds).",
+    ]
+    state = "\n".join(doc)
+
+    kind = rng.random()
+    if kind < 0.5:
+        # yes/no: does amendment change the outcome?
+        same = ((case_v <= base_v) == (case_v <= amend_v)
+                if "up to" in base_txt and "above" not in amend_txt
+                else rng.random() < 0.5)
+        instr = (f"Under {code} as amended, is the request in case {ref} "
+                 f"governed by the amendment's threshold?")
+        target = 1.0 if controlling else 0.0
+        q1 = q_noul("amended", instr, target)
+        # outcome question: approved?
+        thr = amend_v if controlling else base_v
+        approved = case_v <= thr
+        opts = ["approved under the controlling rule",
+                "denied under the controlling rule",
+                "requires manual escalation"]
+        q2 = q_choice("outcome",
+                      "Applying the controlling threshold, what is the "
+                      "outcome for the case?",
+                      opts, _onehot(3, 0 if approved else 1))
+        return state, [q1, q2]
+    else:
+        # which document controls?
+        opts = [f"{code} v{ver} (base policy)",
+                f"Amendment {code}/A (later effective date)",
+                "Neither document governs this case"]
+        ci = 1 if controlling else 0
+        qs = [q_choice("controlling",
+                       "Which document controls the determination for "
+                       f"case {ref}?", opts, _onehot(3, ci))]
+        return state, qs
+
+
+# ------------------------------------------------------------------
+# intent_v2 — wide vocabulary, near-miss + keyword traps, both formats
+# ------------------------------------------------------------------
+
+def _intent_pool():
+    return {
+        "support": {
+            "cancel_order": ("wants to cancel a placed order",
+                ["cancel my order {r}, changed my mind",
+                 "please cancel order {r} before it ships",
+                 "don't need the item anymore — cancel order {r}"]),
+            "track_order": ("asks where an existing order is",
+                ["where is order {r}", "tracking for {r} hasn't moved",
+                 "status on my shipment {r} please"]),
+            "change_address": ("wants the delivery address updated",
+                ["ship order {r} to my new address instead",
+                 "i moved — update delivery for {r}",
+                 "wrong address on order {r}, fix it"]),
+            "request_refund": ("asks for money back on a purchase",
+                ["refund order {r}, item is defective",
+                 "want my money back for {r}",
+                 "the product broke — refund {r} please"]),
+            "report_damage": ("reports an item arrived broken",
+                ["order {r} arrived smashed",
+                 "the box was crushed and the item inside is broken",
+                 "{r} came damaged — photos attached"]),
+            "exchange_item": ("wants a different size/color/variant",
+                ["swap order {r} for a size large",
+                 "can i exchange {r} for the blue one",
+                 "wrong color sent on {r} — exchange please"]),
+        },
+        "billing": {
+            "dispute_charge": ("reports an unauthorized charge",
+                ["there's a charge i never made on my statement",
+                 "i don't recognize this $48 charge",
+                 "someone used my card — dispute this transaction"]),
+            "update_card": ("wants payment details changed",
+                ["update the card on file, it expires soon",
+                 "swap my saved card to the new one ending 4451",
+                 "change billing card before renewal"]),
+            "invoice_copy": ("requests a receipt or invoice",
+                ["send me the invoice for last month's order",
+                 "need a receipt for expense report",
+                 "email me the billing statement"]),
+            "cancel_subscription": ("wants to end recurring billing",
+                ["stop the monthly subscription",
+                 "cancel my membership before it renews",
+                 "end the auto-renewal on my plan"]),
+            "payment_plan": ("asks to split a balance into installments",
+                ["can i pay the balance over 3 months",
+                 "set up installments for my outstanding bill",
+                 "split the charge into monthly payments"]),
+        },
+        "smart_home": {
+            "set_alarm": ("asks to set a wake-up or reminder alarm",
+                ["wake me at 6:30 tomorrow", "set an alarm for 7am",
+                 "alarm for 5pm please"]),
+            "play_music": ("asks to play audio",
+                ["play some jazz", "put on taylor swift",
+                 "play my workout playlist"]),
+            "control_lights": ("controls lighting",
+                ["turn off the bedroom lights",
+                 "dim the living room to 40%",
+                 "lights on in the hallway"]),
+            "send_message": ("asks to text someone",
+                ["text anna i'll be late", "send a message to mom",
+                 "tell sam i'm on my way"]),
+            "weather": ("asks about weather",
+                ["will it rain tomorrow", "what's the temperature outside",
+                 "weather this weekend?"]),
+            "set_timer": ("asks for a countdown timer",
+                ["timer for 10 minutes", "set a 25 minute timer",
+                 "countdown 5 minutes"]),
+        },
+        "devops": {
+            "restart_service": ("asks to restart a service",
+                ["bounce the api workers", "restart the payments service",
+                 "the web tier is stuck — cycle it"]),
+            "scale_up": ("asks to add capacity",
+                ["scale the frontend to 8 replicas",
+                 "add more workers for tonight's batch",
+                 "increase the cluster size"]),
+            "rollback": ("asks to revert a deploy",
+                ["roll back the 2.1 release, errors spiked",
+                 "revert this morning's deploy",
+                 "the new build broke login — undo it"]),
+            "rotate_keys": ("asks to rotate credentials",
+                ["rotate the db passwords", "the api key leaked — rotate",
+                 "cycle the signing keys"]),
+            "check_logs": ("asks to inspect logs or metrics",
+                ["pull the error logs from the last hour",
+                 "check why latency jumped at 3pm",
+                 "look at the auth service logs"]),
+        },
+        "banking": {
+            "freeze_card": ("asks to freeze a card",
+                ["freeze my card, i lost it", "lock card ending 8821",
+                 "my wallet was stolen — freeze everything"]),
+            "wire_transfer": ("asks to send money",
+                ["wire 2400 to the supplier", "transfer rent to my landlord",
+                 "send 500 to my sister's account"]),
+            "check_balance": ("asks for account balance",
+                ["what's my checking balance", "how much is in savings",
+                 "balance on the joint account please"]),
+            "report_fraud": ("reports fraudulent activity",
+                ["someone's been using my account",
+                 "three transactions i didn't make appeared",
+                 "i think my card was skimmed"]),
+            "open_account": ("asks to open a new account",
+                ["i want to open a savings account",
+                 "set up a checking account for my kid",
+                 "open a joint account with my spouse"]),
+        },
+        "travel": {
+            "book_flight": ("books airfare",
+                ["book a flight to lisbon next friday",
+                 "need a ticket to tokyo in march",
+                 "fly me to denver on the 12th"]),
+            "cancel_trip": ("cancels a booking",
+                ["cancel my hotel reservation for this weekend",
+                 "i can't make the flight — cancel it",
+                 "cancel the whole trip to oslo"]),
+            "change_seat": ("changes seat assignment",
+                ["move me to a window seat", "upgrade my seat to exit row",
+                 "can i switch to aisle on flight 447"]),
+            "claim_luggage": ("reports lost baggage",
+                ["my bag never came off the carousel",
+                 "luggage from flight ua882 is missing",
+                 "file a lost baggage claim"]),
+            "check_status": ("asks flight status",
+                ["is my flight on time", "status of flight ba221",
+                 "any delays on the 6pm departure"]),
+        },
+        "hr": {
+            "request_leave": ("requests time off",
+                ["taking pto next friday", "need two weeks off in july",
+                 "requesting leave for a family matter"]),
+            "payroll_issue": ("reports a pay problem",
+                ["my paycheck is missing overtime",
+                 "salary was short this month",
+                 "the bonus didn't hit my account"]),
+            "update_benefits": ("changes benefits enrollment",
+                ["add my spouse to health insurance",
+                 "switch my dental plan", "increase my 401k contribution"]),
+            "org_question": ("asks about reporting structure",
+                ["who does the platform team report to now",
+                 "who's my skip-level after the reorg",
+                 "which org does design sit under"]),
+            "resignation": ("initiates departure",
+                ["i'm resigning, last day the 30th",
+                 "putting in my two weeks notice",
+                 "start my offboarding process"]),
+        },
+        "health": {
+            "book_appointment": ("books a visit",
+                ["schedule a checkup next week",
+                 "book me with dr reyes on tuesday",
+                 "need a same-day appointment"]),
+            "refill_rx": ("requests medication refill",
+                ["refill my prescription", "out of my inhaler — renew it",
+                 "need another month of metformin"]),
+            "test_results": ("asks for lab results",
+                ["are my blood results in yet",
+                 "send me my lab report from friday",
+                 "did the biopsy results come back"]),
+            "referral": ("requests specialist referral",
+                ["refer me to a dermatologist",
+                 "i need an orthopedics referral",
+                 "can you get me into cardiology"]),
+            "coverage_question": ("asks about insurance coverage",
+                ["is this procedure covered",
+                 "why wasn't my visit covered by insurance",
+                 "what's my copay for a specialist"]),
+        },
+        "logistics": {
+            "reroute": ("changes a shipment destination",
+                ["reroute container 881 to oakland",
+                 "divert the truck to denver depot",
+                 "send the pallet to the other warehouse"]),
+            "report_delay": ("reports a delayed shipment",
+                ["the freight is 3 days late", "shipment stuck in memphis",
+                 "delivery missed the window again"]),
+            "file_claim": ("files a loss/damage claim",
+                ["start a claim on the damaged crates",
+                 "file a freight claim for shipment 771",
+                 "claim the lost pallet with the carrier"]),
+            "schedule_pickup": ("arranges a pickup",
+                ["schedule a pickup for thursday",
+                 "need a truck at dock 4 at 8am",
+                 "arrange collection of the returns"]),
+            "quote_request": ("asks for a shipping quote",
+                ["quote for 2 pallets to portland",
+                 "what's the rate on a 40ft container",
+                 "price out overnight freight to boston"]),
+        },
+        "it_admin": {
+            "provision_access": ("grants system access",
+                ["give the new hire repo access",
+                 "provision vpn for the contractor",
+                 "grant ana read access to the warehouse"]),
+            "reset_password": ("resets credentials",
+                ["reset my vpn password", "i'm locked out of email",
+                 "forgot my sso password"]),
+            "report_outage": ("reports a system outage",
+                ["the vpn is down for the whole office",
+                 "email isn't syncing since this morning",
+                 "is the wifi down on floor 3"]),
+            "install_software": ("requests software installation",
+                ["install docker on my machine",
+                 "need the latest vpn client",
+                 "put photoshop on the design laptops"]),
+            "deprovision": ("removes access for a leaver",
+                ["disable access for friday's leaver",
+                 "revoke the contractor's credentials",
+                 "deprovision sam's accounts"]),
+        },
+    }
+
+
+def gen_intent_v2():
+    pool = _intent_pool()
+    domain = rng.choice(list(pool))
+    labels = pool[domain]
+    true_lbl = rng.choice(list(labels))
+    desc, templates = labels[true_lbl]
+    msg = rng.choice(templates).format(r=str(rng.randint(1000, 99999)))
+
+    # keyword trap: 30% of the time append a clause that lexically evokes
+    # a DIFFERENT intent while the core request stays the same
+    if rng.random() < 0.3:
+        other = rng.choice([l for l in labels if l != true_lbl])
+        _, ot = labels[other]
+        msg += rng.choice([" — not asking about anything else",
+                           ", and by the way " + rng.choice(ot).split("{")[0]
+                           .strip()[:40] + " later",
+                           ". Also, " + rng.choice(ot).format(
+                               r=str(rng.randint(100, 999)))])
+        # the trap clause sometimes IS a second intent — keep target on
+        # the primary (first) request: instructions ask for primary intent
+    n_opt = min(rng.choice([4, 5, 6]), len(labels))
+    wrong = [l for l in labels if l != true_lbl]
+    rng.shuffle(wrong)
+    wrong = wrong[:n_opt - 1]
+    # two option styles: bare descriptions (like eval) or slug: desc
+    slug_style = rng.random() < 0.4
+    if slug_style:
+        opts_txt = [f"{l}: {labels[l][0]}" for l in [true_lbl] + wrong]
+        correct_txt = f"{true_lbl}: {desc}"
+    else:
+        opts_txt = [desc] + [labels[l][0] for l in wrong]
+        correct_txt = desc
+    opts, ci = _mk_opts(correct_txt, [o for o in opts_txt
+                                    if o != correct_txt], n_opt)
+    state = (f"Incoming {domain.replace('_',' ')} message:\n"
+             f"\"{msg[0].upper() + msg[1:]}\"")
+    instr = rng.choice([
+        "Which option best describes what the sender primarily wants?",
+        "Classify the sender's primary intent.",
+        "Choose the description that best captures the main request.",
+    ])
+    qs = [q_choice("intent", instr, opts, _onehot(len(opts), ci))]
+    return state, qs
+
+
+def gen_intent_pair():
+    """Same message, two different option sets -> teaches options matter."""
+    pool = _intent_pool()
+    domain = rng.choice(list(pool))
+    labels = pool[domain]
+    true_lbl = rng.choice(list(labels))
+    desc, templates = labels[true_lbl]
+    msg = rng.choice(templates).format(r=str(rng.randint(1000, 99999)))
+    state = (f"Incoming {domain.replace('_',' ')} message:\n\"{msg}\"")
+    others = [l for l in labels if l != true_lbl]
+    rng.shuffle(others)
+    # q1: correct description present
+    w1 = others[:3]
+    opts1, ci1 = _mk_opts(desc, [labels[l][0] for l in w1], 4)
+    # q2: coverage check — half the time the true intent is absent
+    covered = rng.random() < 0.5
+    shown = ([desc] + [labels[l][0] for l in others[:2]] if covered
+             else [labels[l][0] for l in others[:3]])
+    q2 = q_noul("covered",
+                "Option set under review: [" + "; ".join(shown) + "]. "
+                "Is the sender's true intent covered by this set?",
+                1.0 if covered else 0.0)
+    return state, [q_choice("intent",
+                            "Which option best describes the sender's "
+                            "intent?", opts1, _onehot(4, ci1)), q2]
+
+
+# ------------------------------------------------------------------
+# rubric_level — ordinal scoring (severity/priority/grade)
+# ------------------------------------------------------------------
+
+_RUBRIC_SETS = [
+    ("incident severity", ["SEV-4 cosmetic", "SEV-3 minor",
+      "SEV-2 major", "SEV-1 critical"],
+     [("typo on the marketing page", 0),
+      ("one user's dashboard widget shows stale data", 1),
+      ("payments failing for 20% of users, workaround exists", 2),
+      ("all customers cannot log in; revenue impact ongoing", 3)]),
+    ("support priority", ["P3 low", "P2 normal", "P1 high", "P0 urgent"],
+     [("feature suggestion for next quarter", 0),
+      ("single user reports cosmetic glitch", 1),
+      ("team of 5 blocked on a workflow bug", 2),
+      ("production down for all enterprise customers", 3)]),
+    ("code review grade", ["approve", "minor changes", "major changes",
+      "reject"],
+     [("clean diff, tests pass, matches spec", 0),
+      ("works but naming inconsistent and missing docstrings", 1),
+      ("logic error on edge case; needs restructuring", 2),
+      ("deletes production data path, no tests", 3)]),
+    ("flood risk", ["minimal", "low", "moderate", "severe"],
+     [("property on a hill, 500m from the river", 0),
+      ("basement flat 3 streets from the canal", 1),
+      ("ground-floor unit on the flood plain", 2),
+      ("riverfront property, floods twice a decade", 3)]),
+]
+
+
+def gen_rubric():
+    name, levels, cases = rng.choice(_RUBRIC_SETS)
+    case, lvl = rng.choice(cases)
+    # paraphrase the case with a persona
+    who = rng.choice(["An engineer", "A tenant", "A user", "The on-call",
+                      "A customer", "A resident", "A submitter"])
+    state = (f"{name.title()} rubric assessment.\n"
+             f"Report: {who} reports: {case}.\n"
+             f"Scale (lowest to highest): {', '.join(levels)}.")
+    opts = list(levels)
+    rng.shuffle(opts)
+    ci = opts.index(levels[lvl])
+    qs = [q_score("level",
+                  f"Assign the correct {name} level.",
+                  opts, _onehot(len(opts), ci))]
+    return state, qs
+
+
+# ------------------------------------------------------------------
+# routing_v2 — pick the right destination/owner for a request
+# ------------------------------------------------------------------
+
+_QUEUE_DEFS = {
+    "tickets": ["billing_team", "technical_support", "account_services",
+                "sales_desk", "retention_team", "fraud_unit"],
+    "alerts": ["database_oncall", "platform_oncall", "network_oncall",
+               "security_oncall", "app_oncall", "storage_oncall"],
+    "documents": ["legal_review", "finance_audit", "hr_records",
+                  "compliance", "engineering_wiki", "marketing"],
+}
+
+
+def gen_routing():
+    ctx = rng.choice(list(_QUEUE_DEFS))
+    queues = _QUEUE_DEFS[ctx]
+    signals = {
+        "tickets": {"billing_team": "double-charged invoice",
+                    "technical_support": "app crashes on export",
+                    "account_services": "can't update email",
+                    "sales_desk": "wants enterprise pricing",
+                    "retention_team": "threatens to churn",
+                    "fraud_unit": "suspicious chargeback"},
+        "alerts": {"database_oncall": "postgres replication lag",
+                   "platform_oncall": "k8s nodes not ready",
+                   "network_oncall": "packet loss on eu-west link",
+                   "security_oncall": "intrusion detection fired",
+                   "app_oncall": "checkout 5xx rate climbing",
+                   "storage_oncall": "s3 bucket quota nearly full"},
+        "documents": {"legal_review": "new vendor contract draft",
+                      "finance_audit": "q3 expense anomalies",
+                      "hr_records": "updated offer letter",
+                      "compliance": "gdpr deletion request",
+                      "engineering_wiki": "new api endpoint docs",
+                      "marketing": "launch announcement draft"},
+    }
+    sig_map = signals[ctx]
+    true_q = rng.choice(list(sig_map))
+    sig = sig_map[true_q]
+    who = _name()
+    state = (f"{ctx[:-1].title()} router — available destinations: "
+             f"{', '.join(queues)}.\n"
+             f"Incoming item from {who}: {sig}.")
+    opts = list(queues)
+    rng.shuffle(opts)
+    ci = opts.index(true_q)
+    qs = [q_choice("route",
+                   "Route the item to the correct destination.",
+                   opts, _onehot(len(opts), ci))]
+    return state, qs
+
+
+# ------------------------------------------------------------------
+# multihop — entity chains + numeric chains
+# ------------------------------------------------------------------
+
+def gen_multihop():
+    people = rng.sample(FIRST, 5)
+    orgs = rng.sample(ORGS, 3)
+    cities = rng.sample(CITIES, 3)
+    facts, kb = [], []
+    for p in people:
+        org = rng.choice(orgs)
+        facts.append((p, "employer", org))
+        kb.append(f"{p} works for {org}.")
+    for o in orgs:
+        c = rng.choice(cities)
+        facts.append((o, "city", c))
+        kb.append(f"{o} is headquartered in {c}.")
+    for i, p in enumerate(people[:-1]):
+        facts.append((p, "manager", people[i + 1]))
+        kb.append(f"{p} reports to {people[i + 1]}.")
+    rng.shuffle(kb)
+    state = ("Personnel registry excerpt:\n" +
+             "\n".join(f"- {s}" for s in kb))
+
+    def resolve(start, rels):
+        node = start
+        for r in rels:
+            for (a, b, c) in facts:
+                if a == node and b == r:
+                    node = c
+                    break
+            else:
+                return None
+        return node
+
+    p = rng.choice(people[:-1])
+    hops = rng.choice([2, 3])
+    if hops == 2:
+        q_txt = f"In which city is {p}'s employer headquartered?"
+        ans = resolve(p, ["employer", "city"])
+    else:
+        q_txt = (f"In which city is the employer of {p}'s manager "
+                 f"headquartered?")
+        ans = resolve(p, ["manager", "employer", "city"])
+    if ans is None:
+        raise ValueError("bad chain")
+    wrongs = [c for c in cities if c != ans]
+    opts, ci = _mk_opts(ans, wrongs + [CANNOT], 4)
+    qs = [q_choice("answer", q_txt + " Use only the registry.",
+                   opts, _onehot(4, ci))]
+    return state, qs
+
+
+def gen_numeric_chain():
+    price = rng.randint(20, 900)
+    tax = rng.choice([5, 7, 8, 10, 12, 15, 20, 25])
+    disc = rng.choice([0, 5, 10, 15, 20])
+    ship = rng.choice([0, 5, 10, 15, 25])
+    item = rng.choice(["laptop", "bike", "sofa", "camera", "watch",
+                       "printer", "mixer"])
+    sub = price * (1 - disc / 100)
+    taxed = sub * (1 + tax / 100)
+    total = taxed + ship
+    ans = round(total)
+    state = (f"Checkout calculation for a {item}: list price ${price}, "
+             f"discount {disc}%, sales tax {tax}% applied after the "
+             f"discount, shipping ${ship}.")
+    wrongs = [str(round(price * (1 + tax / 100) + ship)),
+              str(round(sub + ship)),
+              str(ans + rng.choice([-20, -10, 10, 15, 25])),
+              str(round(price - disc + ship))]
+    opts, ci = _mk_opts(str(ans), wrongs, 4)
+    qs = [q_choice("total", "What is the final total in dollars, "
+                   "rounded to the nearest dollar?",
+                   opts, _onehot(4, ci))]
+    return state, qs
+
+
+# ------------------------------------------------------------------
+# state_track — mutable inventory with conditional ops
+# ------------------------------------------------------------------
+
+def gen_state_track():
+    items = rng.sample(["widgets", "sprockets", "panels", "valves",
+                        "gaskets", "modules", "crates", "drums"], 3)
+    start = {it: rng.randint(10, 60) for it in items}
+    ops, state = [], dict(start)
+    for _ in range(rng.randint(4, 7)):
+        it = rng.choice(items)
+        kind = rng.random()
+        if kind < 0.35:
+            d = rng.randint(2, 15)
+            ops.append(f"Received {d} units of {it}.")
+            state[it] += d
+        elif kind < 0.7:
+            d = rng.randint(1, min(12, max(1, state[it] - 1)))
+            ops.append(f"Shipped out {d} units of {it}.")
+            state[it] -= d
+        elif kind < 0.85:
+            it2 = rng.choice([x for x in items if x != it])
+            d = rng.randint(1, min(10, max(1, state[it] - 1)))
+            ops.append(f"Reallocated {d} units from {it} to {it2}.")
+            state[it] -= d
+            state[it2] += d
+        else:
+            th = rng.randint(10, 25)
+            d = rng.randint(5, 15)
+            fired = state[it] < th
+            ops.append(f"Standing rule: if {it} stock is below {th}, "
+                       f"auto-reorder {d} units.")
+            if fired:
+                state[it] += d
+                ops[-1] += f" (Rule fired for {it}: +{d}.)"
+            else:
+                ops[-1] += f" (Rule checked for {it}: no action.)"
+    st = (f"Warehouse inventory log. Opening counts: " +
+          ", ".join(f"{k}={v}" for k, v in start.items()) + ".\n" +
+          "\n".join(ops))
+    q_it = rng.choice(items)
+    ans = state[q_it]
+    wrongs = [str(ans + k) for k in (-3, -2, -1, 1, 2, 3, 5, -5)
+              if ans + k >= 0]
+    opts, ci = _mk_opts(str(ans), wrongs, 4)
+    qs = [q_choice("count",
+                   f"How many units of {q_it} are in stock after all "
+                   f"log entries (including conditional rules)?",
+                   opts, _onehot(len(opts), ci))]
+    return st, qs
+
+
+# ------------------------------------------------------------------
+# temporal_v2 — deadlines, recurrence, overlap
+# ------------------------------------------------------------------
+
+def gen_temporal():
+    base = date(2025, 1, 6) + timedelta(days=rng.randint(0, 330))
+    kind = rng.random()
+    if kind < 0.34:
+        n = rng.randint(5, 60)
+        unit = rng.choice(["calendar days", "business days"])
+        st = (f"A filing was submitted on "
+              f"{base.strftime('%A, %B %d, %Y')}. The review period is "
+              f"{n} {unit}. " +
+              rng.choice(["Reviews cannot be expedited.",
+                          "The office is closed on weekends.",
+                          "Holidays do not pause the review clock."]))
+        if unit == "calendar days":
+            ans_d = base + timedelta(days=n)
+        else:
+            d, added = base, 0
+            while added < n:
+                d += timedelta(days=1)
+                if d.weekday() < 5:
+                    added += 1
+            ans_d = d
+        correct = ans_d.strftime("%A, %B %d")
+        wrongs = [(ans_d + timedelta(days=k)).strftime("%A, %B %d")
+                  for k in (-2, -1, 1, 2, 5)]
+        opts, ci = _mk_opts(correct, wrongs, 4)
+        qs = [q_choice("due", "On what date does the review period end?",
+                       opts, _onehot(4, ci))]
+    elif kind < 0.67:
+        step = rng.choice([7, 14, 21, 28, 30])
+        horizon = rng.choice([60, 90, 120])
+        st = (f"A maintenance window recurs every {step} days starting "
+              f"{base.strftime('%B %d, %Y')}. Consider the next "
+              f"{horizon} days after the start.")
+        n_hits = horizon // step + 1
+        opts, ci = _mk_opts(str(n_hits),
+                          [str(n_hits + k) for k in (-2, -1, 1, 2)], 4)
+        qs = [q_choice("count",
+                       "How many maintenance windows occur within the "
+                       "horizon (including the start date)?",
+                       opts, _onehot(4, ci))]
+    else:
+        a_start = base
+        b_start = base + timedelta(days=rng.randint(1, 10))
+        a_dur = rng.choice([3, 5, 7, 10, 14])
+        b_dur = rng.choice([3, 5, 7, 10, 14])
+        a_end = a_start + timedelta(days=a_dur)
+        b_end = b_start + timedelta(days=b_dur)
+        overlap = max(0, (min(a_end, b_end) - max(a_start, b_start)).days)
+        st = (f"Project A runs from {a_start.strftime('%B %d')} through "
+              f"{a_end.strftime('%B %d')} inclusive of the start, "
+              f"exclusive of the end. Project B runs from "
+              f"{b_start.strftime('%B %d')} through "
+              f"{b_end.strftime('%B %d')} under the same convention.")
+        opts, ci = _mk_opts(str(overlap),
+                          [str(overlap + k) for k in (-2, -1, 1, 2)
+                           if overlap + k >= 0], 4)
+        qs = [q_choice("overlap",
+                       "For how many days do the projects run "
+                       "concurrently?", opts, _onehot(len(opts), ci))]
+    return st, qs
+
+
+# ------------------------------------------------------------------
+# trap_v2 — negation/scope traps, unanswerable detection
+# ------------------------------------------------------------------
+
+def gen_trap():
+    kind = rng.random()
+    person = _name()
+    if kind < 0.4:
+        # negation: "all except X"
+        items = rng.sample(["laptops", "monitors", "keyboards", "cables",
+                            "docks", "headsets"], 4)
+        covered = items[:rng.choice([2, 3])]
+        excluded = [i for i in items if i not in covered]
+        st = (f"{person}'s insurance covers {', '.join(covered)} "
+              f"against accidental damage. {excluded[0].title()} are "
+              f"explicitly excluded from the policy.")
+        q_item = rng.choice(items)
+        ans = 1.0 if q_item in covered else 0.0
+        qs = [q_noul("covered",
+                     f"Are {q_item} covered under {person}'s policy?",
+                     ans)]
+        return st, qs
+    elif kind < 0.7:
+        # unanswerable: missing info
+        st = (f"{person} submitted a request on "
+              f"{(date(2025, 3, 1) + timedelta(days=rng.randint(0, 300))).strftime('%B %d')}. "
+              f"The policy states requests are processed in order of "
+              f"submission, subject to officer availability. The "
+              f"processing log for this period was lost.")
+        opts, ci = _mk_opts(CANNOT,
+                            ["3 days", "7 days", "14 days"], 4)
+        qs = [q_choice("when", "How long did processing take?",
+                       opts, _onehot(4, ci))]
+        return st, qs
+    else:
+        # scope trap: policy applies to a subset only
+        grp = rng.choice(["full-time staff", "managers",
+                          "contractors", "interns"])
+        other = rng.choice([g for g in ["full-time staff", "managers",
+                                        "contractors", "interns"]
+                            if g != grp])
+        benefit = rng.choice(["the gym stipend", "remote Fridays",
+                              "the parking subsidy", "stock options"])
+        who_grp = rng.choice([grp, other])
+        st = (f"Company handbook: {benefit} is available to {grp} only. "
+              f"{person} is a member of {who_grp}.")
+        ans = 1.0 if who_grp == grp else 0.0
+        qs = [q_noul("eligible",
+                     f"Is {person} eligible for {benefit}?", ans)]
+        return st, qs
+
+
+# ------------------------------------------------------------------
+# evidence — claim vs evidence set
+# ------------------------------------------------------------------
+
+def gen_evidence():
+    city = rng.choice(CITIES)
+    org = rng.choice(ORGS)
+    year = rng.randint(2015, 2024)
+    metric = rng.choice(["revenue", "headcount", "fleet size",
+                         "energy usage"])
+    val = rng.randint(2, 98)
+    kind = rng.random()
+    claim = f"{org} reported {val}% growth in {metric} in {year}."
+    if kind < 0.4:
+        ev_ok = (f"{org}'s {year} annual report shows a {val}% increase "
+                 f"in {metric} compared with {year - 1}.")
+        verdict = "supported"
+    elif kind < 0.7:
+        ev_ok = (f"{org}'s {year} annual report shows a "
+                 f"{max(1, val - 30)}% increase in {metric} compared "
+                 f"with {year - 1}.")
+        verdict = "refuted"
+    else:
+        ev_ok = (f"{org} relocated its {city} office in {year}.")
+        verdict = "neither supported nor refuted"
+    ev_near = (f"{org} expanded operations in {city} in {year}, "
+               f"opening two new sites.")
+    evs = [ev_ok, ev_near]
+    rng.shuffle(evs)
+    state = (f"Claim: {claim}\nEvidence:\n" +
+             "\n".join(f"[{i}] {e}" for i, e in enumerate(evs)))
+    verdicts = ["supported", "refuted", "neither supported nor refuted"]
+    qs = [q_choice("verdict",
+                   "Is the claim supported, refuted, or neither, based "
+                   "only on the evidence?",
+                   verdicts, _onehot(3, verdicts.index(verdict))),
+          q_choice("which",
+                   "Which evidence item is most relevant to the verdict?",
+                   evs, _onehot(2, evs.index(ev_ok)))]
+    return state, qs
+
+
+# ------------------------------------------------------------------
+# tradeoff — constrained argmax
+# ------------------------------------------------------------------
+
+def gen_tradeoff():
+    n = rng.choice([4, 5])
+    names = rng.sample([f"Plan {c}" for c in "ABCDEF"], n)
+    cost = [rng.randint(5, 50) for _ in range(n)]
+    qual = [rng.randint(1, 10) for _ in range(n)]
+    speed = [rng.randint(1, 10) for _ in range(n)]
+    budget = rng.randint(15, 45)
+    wq, ws = rng.choice([2, 3]), rng.choice([1, 2])
+    feasible = [i for i in range(n) if cost[i] <= budget]
+    if not feasible:
+        raise ValueError("no feasible plan")
+    scores = [wq * qual[i] + ws * speed[i] for i in range(n)]
+    best = max(feasible, key=lambda i: scores[i])
+    if sum(1 for i in feasible if scores[i] == scores[best]) > 1:
+        raise ValueError("tie")
+    lines = [f"- {names[i]}: cost {cost[i]}, quality {qual[i]}/10, "
+             f"delivery speed {speed[i]}/10" for i in range(n)]
+    state = (f"Vendor proposals (budget cap: {budget} cost units):\n" +
+             "\n".join(lines))
+    instr = (f"Score each feasible plan as {wq}×quality + {ws}×speed; "
+             f"plans over budget are infeasible. Pick the highest score.")
+    qs = [q_choice("best", instr, names, _onehot(n, best))]
+    return state, qs
+
+
+FAMILIES = {
+    "policy_pack": gen_policy_pack,
+    "intent_v2": gen_intent_v2,
+    "intent_pair": gen_intent_pair,
+    "rubric": gen_rubric,
+    "routing_v2": gen_routing,
+    "multihop": gen_multihop,
+    "numeric_chain": gen_numeric_chain,
+    "state_track": gen_state_track,
+    "temporal_v2": gen_temporal,
+    "trap_v2": gen_trap,
+    "evidence": gen_evidence,
+    "tradeoff": gen_tradeoff,
+}
+
+WEIGHTS = {
+    "policy_pack": 0.18,
+    "intent_v2": 0.14,
+    "intent_pair": 0.06,
+    "rubric": 0.08,
+    "routing_v2": 0.08,
+    "multihop": 0.12,
+    "numeric_chain": 0.08,
+    "state_track": 0.08,
+    "temporal_v2": 0.06,
+    "trap_v2": 0.06,
+    "evidence": 0.03,
+    "tradeoff": 0.03,
+}
+
+
+def main(n=60000, seed=0, out="data/jb4.jsonl"):
+    rows = generate(FAMILIES, WEIGHTS, n, seed, rng)
+    seen, uniq = set(), []
+    for r in rows:
+        h = hash((r["state"], json.dumps(r["questions"], sort_keys=True)))
+        if h in seen:
+            continue
+        seen.add(h)
+        uniq.append(r)
+    write_jsonl(uniq, out)
+    print(f"wrote {len(uniq)} unique rows -> {out}")
+
+
+if __name__ == "__main__":
+    import sys
+    n = int(sys.argv[1]) if len(sys.argv) > 1 else 60000
+    seed = int(sys.argv[2]) if len(sys.argv) > 2 else 0
+    out = sys.argv[3] if len(sys.argv) > 3 else "data/jb4.jsonl"
+    main(n, seed, out)