"""Build the practice set: 12 generated-file tasks + 4 live-Wikipedia multi-hop tasks. .venv/bin/python -m evals.practice.build_practice # (re)write files + tasks.jsonl .venv/bin/python -m evals.practice.build_practice --audio # also re-synthesize the audio Every task is original (written for this repo, not taken or paraphrased from GAIA or the course's 20 questions) and GAIA-Level-1 shaped: one attached file or a 2-hop lookup, a short exact-match answer, and a trap that punishes the usual agent failure (strict vs non-strict bounds, missing values treated as zero, per-sheet vs combined totals, a near-miss name, ...). Gold answers for generated tasks are never typed by hand: each is DERIVED FROM THE FILE ON DISK after writing it (``derive_gold``), and the generator asserts that the derivation matches the value it intended. tests/test_evals.py re-derives every one again with independent code. Wikipedia golds were checked against the live pages on 2026-10-10; each task stores the URL, the revision id read, and the supporting sentence (see WIKI_TASKS). Deterministic: fixed seeds, fixed document timestamps. Audio is synthesized with macOS `say` (voice Samantha) + ffmpeg, so it is only rebuilt with --audio on a Mac; the committed mp3s and their TTS scripts (stored in each task's ``source``) are the reference. """ from __future__ import annotations import argparse import datetime as dt import hashlib import json import random import shutil import subprocess import sys import tempfile import zlib from pathlib import Path PRACTICE_DIR = Path(__file__).resolve().parent FILES_DIR = PRACTICE_DIR / "files" TASKS_PATH = PRACTICE_DIR / "tasks.jsonl" MANIFEST_PATH = PRACTICE_DIR / "manifest.json" REL_ROOT = PRACTICE_DIR.parent.parent # project root; task "file" paths are relative to it GENERATOR = "evals/practice/build_practice.py" RETRIEVED = "2026-10-10" FIXED_TS = dt.datetime(2026, 10, 10, 12, 0, 0) FONT_CANDIDATES = [ "/System/Library/Fonts/Supplemental/Arial Unicode.ttf", "/System/Library/Fonts/Apple Symbols.ttf", "/Library/Fonts/Arial Unicode.ttf", "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", ] TEXT_FONT_CANDIDATES = [ "/System/Library/Fonts/Supplemental/Arial.ttf", "/System/Library/Fonts/Supplemental/Arial Unicode.ttf", "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", ] def rel(p: Path) -> str: return p.resolve().relative_to(REL_ROOT).as_posix() def sha256(p: Path) -> str: return hashlib.sha256(p.read_bytes()).hexdigest() def _font(size: int, candidates=TEXT_FONT_CANDIDATES): from PIL import ImageFont for c in candidates: if Path(c).is_file(): return ImageFont.truetype(c, size) raise RuntimeError(f"No usable TrueType font among {candidates}") def _fmt_num(x: float) -> str: """Gold-number formatting: integers without a decimal point, otherwise minimal digits.""" if float(x).is_integer(): return str(int(x)) return f"{x}".rstrip("0").rstrip(".") # =========================================================================== P01 xlsx: loans LOAN_MEMBERS = { "Student": ["Ava Lindqvist", "Ben Osei", "Chloe Marsh", "Dev Patel", "Elif Kaya", "Femi Adeyemi"], "Staff": ["Grace Holt", "Hugo Brandt", "Ines Duarte"], "Faculty": ["Jonah Weiss", "Keiko Mori"], "Community": ["Liam Doyle", "Maya Rios", "Noor Haddad"], } def _loans_rows() -> list[dict]: rng = random.Random(4101) rows = [] start = dt.date(2026, 2, 15) for i in range(58): tier = rng.choice(["Student"] * 5 + ["Staff"] * 2 + ["Faculty"] + ["Community"] * 2) member = rng.choice(LOAN_MEMBERS[tier]) out = start + dt.timedelta(days=rng.randint(0, 60)) days = rng.choice([None] + list(range(4, 36))) ret = out + dt.timedelta(days=days) if days is not None else None rows.append({"Member": member, "Tier": tier, "Checked Out": out, "Returned": ret}) # Boundary cases that a careless filter gets wrong. rows += [ {"Member": "Ava Lindqvist", "Tier": "Student", "Checked Out": dt.date(2026, 3, 2), "Returned": dt.date(2026, 3, 23)}, # exactly 21 -> no {"Member": "Dev Patel", "Tier": "Student", "Checked Out": dt.date(2026, 3, 9), "Returned": dt.date(2026, 3, 31)}, # 22 -> yes {"Member": "Ben Osei", "Tier": "Student", "Checked Out": dt.date(2026, 2, 28), "Returned": dt.date(2026, 4, 2)}, # Feb -> no {"Member": "Chloe Marsh", "Tier": "Student", "Checked Out": dt.date(2026, 3, 31), "Returned": dt.date(2026, 4, 30)}, # 30, Mar 31 -> yes {"Member": "Elif Kaya", "Tier": "Student", "Checked Out": dt.date(2026, 3, 18), "Returned": None}, # not returned -> no {"Member": "Grace Holt", "Tier": "Staff", "Checked Out": dt.date(2026, 3, 5), "Returned": dt.date(2026, 4, 9)}, # staff -> no ] rng.shuffle(rows) for i, r in enumerate(rows, 1): r["Loan ID"] = f"L{1000 + i}" return rows def build_p01(path: Path) -> None: from openpyxl import Workbook from openpyxl.styles import Font wb = Workbook() ws = wb.active ws.title = "Loans" cols = ["Loan ID", "Member", "Tier", "Checked Out", "Returned"] ws.append(cols) for c in ws[1]: c.font = Font(bold=True) for r in _loans_rows(): ws.append([r[c] for c in cols]) for row in ws.iter_rows(min_row=2, min_col=4, max_col=5): for c in row: c.number_format = "yyyy-mm-dd" ws.column_dimensions["B"].width = 18 ws.column_dimensions["D"].width = 13 ws.column_dimensions["E"].width = 13 _save_wb(wb, path) def derive_p01(path: Path) -> str: import pandas as pd df = pd.read_excel(path) out = pd.to_datetime(df["Checked Out"]) ret = pd.to_datetime(df["Returned"]) m = (df["Tier"] == "Student") & (out.dt.year == 2026) & (out.dt.month == 3) & ret.notna() return str(int(((ret - out).dt.days[m] > 21).sum())) def _save_wb(wb, path: Path) -> None: wb.properties.creator = "gaia-agent practice set" wb.properties.created = FIXED_TS wb.properties.modified = FIXED_TS wb.save(path) _freeze_zip(path) def _freeze_zip(path: Path) -> None: """Make an .xlsx byte-reproducible: fixed zip entry times and a fixed core.xml modified stamp (openpyxl stamps both with the wall clock on save).""" import re import zipfile with zipfile.ZipFile(path) as zin: entries = [(info, zin.read(info.filename)) for info in zin.infolist()] stamp = FIXED_TS.strftime("%Y-%m-%dT%H:%M:%SZ") tmp = path.with_name(path.name + ".tmp") with zipfile.ZipFile(tmp, "w", compression=zipfile.ZIP_DEFLATED) as zout: for info, data in entries: if info.filename == "docProps/core.xml": data = re.sub(rb"(]*>)[^<]*( None: from openpyxl import Workbook from openpyxl.styles import Font wb = Workbook() wb.remove(wb.active) bins = random.Random(4102) for name, items in WAREHOUSES.items(): ws = wb.create_sheet(name) ws.append(["SKU", "Description", "Bin", "Qty On Hand"]) for c in ws[1]: c.font = Font(bold=True) for sku, desc, qty in items: ws.append([sku, desc, f"{bins.choice('ABCDE')}{bins.randint(1, 40):02d}", qty]) ws.column_dimensions["B"].width = 18 _save_wb(wb, path) def derive_p02(path: Path) -> str: import pandas as pd sheets = pd.read_excel(path, sheet_name=None) allrows = pd.concat(sheets.values(), ignore_index=True) totals = allrows.groupby("SKU")["Qty On Hand"].sum().sort_values(ascending=False) assert totals.iloc[0] > totals.iloc[1], "combined maximum must be unique" return str(totals.index[0]) # =========================================================================== P03 csv: trips def _trips_rows() -> list[dict]: rng = random.Random(4103) routes = ["Coastal", "Valley", "Airport", "Uni Loop", "Harbour"] base = dt.datetime(2026, 5, 14, 5, 30) rows = [] for _ in range(36): dep = base + dt.timedelta(minutes=rng.randrange(0, 18 * 60, 5)) dur = rng.choice(list(range(35, 150, 5))) rows.append((rng.choice(routes), dep, dep + dt.timedelta(minutes=dur))) edge = [ ("Airport", dt.datetime(2026, 5, 14, 18, 0), 95), # at 18:00, 95 min -> yes ("Coastal", dt.datetime(2026, 5, 14, 17, 59), 120), # 17:59 -> no ("Valley", dt.datetime(2026, 5, 14, 18, 30), 90), # exactly 90 -> no ("Harbour", dt.datetime(2026, 5, 14, 23, 10), 105), # crosses midnight, 105 -> yes ("Uni Loop", dt.datetime(2026, 5, 14, 22, 45), 85), # crosses midnight, 85 -> no ] rows += [(r, d, d + dt.timedelta(minutes=m)) for r, d, m in edge] rows.sort(key=lambda r: r[1]) return [ {"trip_id": f"T{301 + i}", "route": r, "departure": d.strftime("%Y-%m-%d %H:%M"), "arrival": a.strftime("%Y-%m-%d %H:%M")} for i, (r, d, a) in enumerate(rows) ] def build_p03(path: Path) -> None: import csv rows = _trips_rows() with open(path, "w", newline="", encoding="utf-8") as fh: w = csv.DictWriter(fh, fieldnames=["trip_id", "route", "departure", "arrival"]) w.writeheader() w.writerows(rows) def derive_p03(path: Path) -> str: import pandas as pd df = pd.read_csv(path, parse_dates=["departure", "arrival"]) mins = (df["arrival"] - df["departure"]).dt.total_seconds() / 60 late = df["departure"].dt.hour >= 18 return str(int((late & (mins > 90)).sum())) # =========================================================================== P04 csv: air quality STATIONS = ["Harbour Road", "Mill Lane", "Kingsway", "Riverside Park", "Station Square", "Northgate"] STATION_LEVEL = {"Harbour Road": 31.0, "Mill Lane": 18.0, "Kingsway": 24.5, "Riverside Park": 12.0, "Station Square": 28.0, "Northgate": 21.0} STATION_MISSING = {"Harbour Road": 9, "Northgate": 2, "Kingsway": 1} # Harbour Road: highest true mean, most gaps def build_p04(path: Path) -> None: import csv rng = random.Random(4104) rows = [] for st in STATIONS: hours = list(range(24)) missing = set(rng.sample(hours, STATION_MISSING.get(st, 0))) for h in hours: val = "" if h in missing else f"{max(1.0, rng.gauss(STATION_LEVEL[st], 3.0)):.1f}" rows.append({"timestamp": f"2026-01-20T{h:02d}:00", "station": st, "pm25_ugm3": val}) rows.sort(key=lambda r: (r["timestamp"], r["station"])) with open(path, "w", newline="", encoding="utf-8") as fh: w = csv.DictWriter(fh, fieldnames=["timestamp", "station", "pm25_ugm3"]) w.writeheader() w.writerows(rows) def derive_p04(path: Path) -> str: import pandas as pd df = pd.read_csv(path) means = df.groupby("station")["pm25_ugm3"].mean().sort_values(ascending=False) # NaN skipped zero = df.fillna({"pm25_ugm3": 0}).groupby("station")["pm25_ugm3"].mean().sort_values(ascending=False) assert list(means.index[:3]) != list(zero.index[:3]), "the missing-value trap must change the answer" assert all(means.iloc[i] - means.iloc[i + 1] > 0.5 for i in range(3)), "ranking margins too thin" return ", ".join(means.index[:3]) # =========================================================================== P05 py: queue simulation QUEUE_SIM = '''"""Ticket-counter simulation used for weekend capacity planning.""" def arrivals(minute): """Customers arriving in a given minute: a rush at the top and bottom of each hour.""" if minute % 30 < 5: return 3 return 1 if minute % 3 == 0 else 0 def simulate(minutes, counters=2, service_time=4): """Return how many customers are still queueing (not being served) after `minutes`.""" queue = 0 busy = [0] * counters # minutes left on the customer at each counter for t in range(minutes): queue += arrivals(t) for i in range(counters): if busy[i] > 0: busy[i] -= 1 if busy[i] == 0 and queue > 0: queue -= 1 busy[i] = service_time return queue if __name__ == "__main__": print("customers waiting after 60 minutes:", simulate(60)) ''' def build_p05(path: Path) -> None: path.write_text(QUEUE_SIM, encoding="utf-8") def _load_module(path: Path, name: str): import importlib.util spec = importlib.util.spec_from_file_location(name, path) mod = importlib.util.module_from_spec(spec) spec.loader.exec_module(mod) return mod def derive_p05(path: Path) -> str: mod = _load_module(path, "_practice_queue_sim") default = mod.simulate(60) asked = mod.simulate(240, counters=3) assert asked != default and asked > 0 return str(asked) # =========================================================================== P06 py: cipher CIPHER = '''"""Toy obfuscation used to tag warehouse labels. Not cryptography.""" KEY = "orbit" def encode(word): out = [] for i, ch in enumerate(word): shift = ord(KEY[i % len(KEY)]) - ord("a") out.append(chr((ord(ch) - ord("a") + shift + i) % 26 + ord("a"))) return "".join(reversed(out)) ''' P06_PLAIN = "lantern" def build_p06(path: Path) -> None: path.write_text(CIPHER, encoding="utf-8") def p06_target(path: Path) -> str: return _load_module(path, "_practice_cipher").encode(P06_PLAIN) def derive_p06(path: Path) -> str: """Invert encode() independently of the generator's plaintext.""" mod = _load_module(path, "_practice_cipher") target = p06_target(path) chars = list(reversed(target)) plain = "".join( chr((ord(c) - 97 - (ord(mod.KEY[i % len(mod.KEY)]) - 97) - i) % 26 + 97) for i, c in enumerate(chars) ) assert mod.encode(plain) == target return plain # =========================================================================== P07/P08 audio P07_TTS = ( "Good evening. This is a platform alteration. " "The eighteen fifteen service to Carlisle will now depart from platform nine, not platform four. " "The eighteen forty-two service to Lancaster remains at platform six. " "The nineteen oh five service to Preston is cancelled. " "Passengers for Preston should instead take the nineteen twenty service, departing from platform eleven. " "We apologise for any inconvenience." ) P07_GOLD = "11" P08_TTS = ( "Sensor log for bay three, recorded at the start of the shift. All readings are in degrees Celsius. " "Reading one: 21.4. Reading two: 19.8. Reading three: 22.6. Reading four: 20.2. Reading five: 18.9. " "End of log." ) def p08_readings(tts: str = P08_TTS) -> list[float]: import re return [float(x) for x in re.findall(r"Reading \w+: (\d+\.\d)", tts)] def p08_gold(tts: str = P08_TTS) -> str: from decimal import ROUND_HALF_UP, Decimal vals = [Decimal(str(v)) for v in p08_readings(tts)] mean = sum(vals) / len(vals) return str(mean.quantize(Decimal("0.1"), rounding=ROUND_HALF_UP)) def synth_audio(text: str, path: Path, voice: str = "Samantha") -> None: if not shutil.which("say") or not shutil.which("ffmpeg"): raise RuntimeError("audio synthesis needs macOS `say` and ffmpeg") with tempfile.TemporaryDirectory() as td: aiff = Path(td) / "speech.aiff" subprocess.run(["say", "-v", voice, "-r", "170", "-o", str(aiff), text], check=True) subprocess.run( ["ffmpeg", "-y", "-loglevel", "error", "-i", str(aiff), "-ac", "1", "-ar", "16000", "-b:a", "48k", "-map_metadata", "-1", "-fflags", "+bitexact", str(path)], check=True, ) # =========================================================================== P09 chess image P09_FEN = "6k1/1n1Q1ppp/6q1/R7/7N/B5b1/5PPP/6K1 w - - 0 1" GLYPH = {"k": "♚", "q": "♛", "r": "♜", "b": "♝", "n": "♞", "p": "♟"} def p09_mates(fen: str = P09_FEN) -> list[str]: import chess b = chess.Board(fen) mates = [] for m in list(b.legal_moves): san = b.san(m) b.push(m) if b.is_checkmate(): mates.append(san) b.pop() return mates def build_p09(path: Path, fen: str = P09_FEN) -> None: import chess from PIL import Image, ImageDraw sq, margin = 72, 30 size = 8 * sq + 2 * margin img = Image.new("RGB", (size, size), (250, 248, 240)) d = ImageDraw.Draw(img) piece_font = _font(60, FONT_CANDIDATES) label_font = _font(18) board = chess.Board(fen) for rank in range(8): for file in range(8): x0, y0 = margin + file * sq, margin + (7 - rank) * sq light = (rank + file) % 2 == 1 d.rectangle([x0, y0, x0 + sq, y0 + sq], fill=(240, 217, 181) if light else (181, 136, 99)) piece = board.piece_at(chess.square(file, rank)) if piece: g = GLYPH[piece.symbol().lower()] white = piece.color == chess.WHITE d.text((x0 + sq / 2, y0 + sq / 2 + 2), g, font=piece_font, anchor="mm", fill=(255, 255, 255) if white else (20, 20, 20), stroke_width=2 if white else 0, stroke_fill=(0, 0, 0)) for i in range(8): d.text((margin + i * sq + sq / 2, size - margin / 2), "abcdefgh"[i], font=label_font, anchor="mm", fill=(40, 40, 40)) d.text((margin / 2, margin + (7 - i) * sq + sq / 2), str(i + 1), font=label_font, anchor="mm", fill=(40, 40, 40)) d.rectangle([margin, margin, margin + 8 * sq, margin + 8 * sq], outline=(40, 40, 40), width=2) img.save(path, format="PNG", optimize=True) def derive_p09(path: Path) -> str: mates = p09_mates() assert len(mates) == 1, mates return mates[0] # =========================================================================== P10 bar chart P10_MONTHS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"] P10_VALUES = [88, 71, 57, 55, 49, 38, 29, 41, 66, 92, 97, 85] def build_p10(path: Path) -> None: from PIL import Image, ImageDraw W, H = 1000, 560 left, right, top, bottom = 70, 30, 70, 70 img = Image.new("RGB", (W, H), "white") d = ImageDraw.Draw(img) title, small, tiny = _font(24), _font(16), _font(15) d.text((W / 2, 30), "Monthly rainfall at Elmsford Vale weather station, 2025 (mm)", font=title, anchor="mm", fill=(30, 30, 30)) plot_h = H - top - bottom vmax = 110 for v in range(0, vmax + 1, 20): y = top + plot_h - v / vmax * plot_h d.line([left, y, W - right, y], fill=(225, 225, 225), width=1) d.text((left - 10, y), str(v), font=tiny, anchor="rm", fill=(90, 90, 90)) slot = (W - left - right) / 12 for i, (m, v) in enumerate(zip(P10_MONTHS, P10_VALUES)): x0 = left + i * slot + slot * 0.18 x1 = left + (i + 1) * slot - slot * 0.18 y = top + plot_h - v / vmax * plot_h d.rectangle([x0, y, x1, top + plot_h], fill=(52, 101, 164)) d.text(((x0 + x1) / 2, y - 12), str(v), font=small, anchor="mm", fill=(20, 20, 20)) d.text(((x0 + x1) / 2, top + plot_h + 18), m[:3], font=small, anchor="mm", fill=(30, 30, 30)) d.line([left, top + plot_h, W - right, top + plot_h], fill=(60, 60, 60), width=2) img.save(path, format="PNG", optimize=True) def derive_p10() -> str: mean = sum(P10_VALUES) / len(P10_VALUES) dist = sorted((abs(v - mean), m) for m, v in zip(P10_MONTHS, P10_VALUES)) assert dist[1][0] - dist[0][0] >= 1.0, "closest month must be clearly unique" return dist[0][1] # =========================================================================== P11 PDF minutes P11_ITEMS = [ ("AI-01", "Priya Raman", "2026-11-03", "Circulate revised vendor shortlist"), ("AI-02", "Tomas Ortega", "2026-11-05", "Book site visit to the Leeds depot"), ("AI-03", "Priya Nair", "2026-11-06", "Collect insurance quotes"), ("AI-04", "Priya Raman", "2026-11-14", "Draft RFP section on data retention"), ("AI-05", "Helen Okafor", "2026-11-10", "Confirm budget envelope with finance"), ("AI-06", "Priya Raman", "2026-11-15", "Schedule security review"), ("AI-07", "Priya Nair", "2026-11-02", "Update risk register"), ("AI-08", "Priya Raman", "2026-12-01", "Prepare board summary"), ("AI-09", "Tomas Ortega", "2026-11-12", "Reconcile Q3 invoices"), ("AI-10", "Priya Raman", "2026-10-28", "Send meeting notes to the steering group"), ("AI-11", "Helen Okafor", "2026-11-20", "Review draft contract terms"), ] P11_LINES = [ "Northfield Logistics - Procurement Working Group", "Minutes of meeting held 21 October 2026, 14:00-15:10, Room 3B", "", "Present: Helen Okafor (chair), Priya Raman, Priya Nair, Tomas Ortega", "Apologies: Sam Whitfield", "", "1. Vendor shortlist. The group agreed to keep four vendors on the shortlist.", "2. Budget. Finance has not yet confirmed the envelope; Helen to follow up.", "3. Security. A review must happen before any contract is signed.", "4. AOB. Next meeting on 4 November 2026.", "", "Action items", ] def _pdf_escape(s: str) -> str: return s.replace("\\", "\\\\").replace("(", "\\(").replace(")", "\\)") def write_text_pdf(path: Path, lines: list[str], title: str = "Minutes") -> None: """A minimal, valid single-page PDF 1.4 with Helvetica text (no third-party library).""" ops = ["BT", "/F1 11 Tf", "14 TL", "50 790 Td"] for ln in lines: ops.append(f"({_pdf_escape(ln)}) Tj T*") ops.append("ET") stream = zlib.compress("\n".join(ops).encode("latin-1")) objs = [ b"<< /Type /Catalog /Pages 2 0 R >>", b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>", b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 595 842] /Contents 4 0 R " b"/Resources << /Font << /F1 5 0 R >> >> >>", b"<< /Length %d /Filter /FlateDecode >>\nstream\n" % len(stream) + stream + b"\nendstream", b"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>", ("<< /Title (%s) /Producer (gaia-agent practice set) /CreationDate (D:20261010120000Z) >>" % _pdf_escape(title)).encode("latin-1"), ] out = bytearray(b"%PDF-1.4\n%\xe2\xe3\xcf\xd3\n") offsets = [] for i, body in enumerate(objs, 1): offsets.append(len(out)) out += b"%d 0 obj\n" % i + body + b"\nendobj\n" xref = len(out) out += b"xref\n0 %d\n0000000000 65535 f \n" % (len(objs) + 1) for off in offsets: out += b"%010d 00000 n \n" % off out += b"trailer\n<< /Size %d /Root 1 0 R /Info 6 0 R >>\nstartxref\n%d\n%%%%EOF\n" % (len(objs) + 1, xref) path.write_bytes(bytes(out)) def build_p11(path: Path) -> None: lines = list(P11_LINES) for aid, owner, due, what in P11_ITEMS: lines.append(f"{aid} | {what} | Owner: {owner} | Due: {due}") write_text_pdf(path, lines, title="Procurement Working Group minutes") def derive_p11(path: Path) -> str: import re from pypdf import PdfReader text = "\n".join(p.extract_text() or "" for p in PdfReader(str(path)).pages) items = re.findall(r"(AI-\d+) \| .*? \| Owner: (.+?) \| Due: (\d{4}-\d{2}-\d{2})", text) assert len(items) == len(P11_ITEMS), (len(items), text[:500]) n = sum(1 for _, owner, due in items if owner.strip() == "Priya Raman" and due < "2026-11-15") return str(n) # =========================================================================== P12 JSON orders P12_CUSTOMERS = [("Marta", "Silva"), ("Owen", "Pryce"), ("Lena", "Vogel"), ("Raj", "Iyer"), ("Sofia", "Brun"), ("Theo", "Nakamura")] def build_p12(path: Path) -> None: rng = random.Random(4112) catalog = {"DESK-01": 249.0, "CHAIR-07": 189.5, "LAMP-02": 39.99, "SHELF-11": 74.25, "MAT-03": 22.0} orders = [] statuses = ["shipped"] * 6 + ["cancelled", "refunded", "pending"] for i in range(26): first, last = rng.choice(P12_CUSTOMERS) items = [] for sku in rng.sample(sorted(catalog), rng.randint(1, 3)): items.append({"sku": sku, "qty": rng.randint(1, 3), "unit_price": catalog[sku]}) orders.append({"order_id": f"SO-{5100 + i}", "customer": {"first": first, "last": last, "email": f"{first.lower()}.{last.lower()}@example.org"}, "status": rng.choice(statuses), "items": items}) # A big order that is NOT shipped, so "top overall" differs from "top shipped". orders.append({"order_id": "SO-5190", "customer": {"first": "Owen", "last": "Pryce", "email": "owen.pryce@example.org"}, "status": "cancelled", "items": [{"sku": "DESK-01", "qty": 16, "unit_price": 249.0}, {"sku": "CHAIR-07", "qty": 2, "unit_price": 189.5}]}) doc = {"exported_at": "2026-09-30T23:59:00Z", "currency": "GBP", "orders": orders} path.write_text(json.dumps(doc, indent=2) + "\n", encoding="utf-8") def derive_p12(path: Path) -> str: doc = json.loads(path.read_text(encoding="utf-8")) shipped: dict[str, float] = {} overall: dict[str, float] = {} for o in doc["orders"]: name = f'{o["customer"]["first"]} {o["customer"]["last"]}' total = sum(it["qty"] * it["unit_price"] for it in o["items"]) overall[name] = overall.get(name, 0) + total if o["status"] == "shipped": shipped[name] = shipped.get(name, 0) + total top = sorted(shipped.items(), key=lambda kv: -kv[1]) assert top[0][1] - top[1][1] > 1, "top shipped customer must be clearly unique" assert max(overall, key=overall.get) != top[0][0], "the status trap must change the answer" return top[0][0] # =========================================================================== registry FILE_TASKS = [ { "id": "p01-xlsx-late-loans", "file": "library_loans.xlsx", "build": build_p01, "derive": derive_p01, "format": "number", "skills": ["file:xlsx", "filter", "date-arithmetic", "count", "strict-bound"], "question": "The attached spreadsheet is a library's loan log. Consider only loans by members in the " "Student tier that were checked out during March 2026. How many of those loans were returned " "more than 21 days after the checkout date? Loans with no return date do not count.", "derivation": "Tier == Student, checkout in 2026-03, Returned not blank, (Returned - Checked Out).days > 21", }, { "id": "p02-xlsx-multisheet-sku", "file": "warehouse_stock.xlsx", "build": build_p02, "derive": derive_p02, "format": "string", "skills": ["file:xlsx", "multi-sheet", "group-by", "argmax"], "question": "The attached workbook has one sheet per warehouse. Summed across all warehouses, which SKU has " "the largest total quantity on hand? Answer with the SKU code only.", "derivation": "concat all sheets, group by SKU, sum Qty On Hand, argmax (unique)", }, { "id": "p03-csv-evening-trips", "file": "shuttle_trips.csv", "build": build_p03, "derive": derive_p03, "format": "number", "skills": ["file:csv", "datetime", "filter", "count", "strict-bound"], "question": "The attached CSV lists one day's shuttle trips. How many trips departed at or after 18:00 and " "took longer than 90 minutes from departure to arrival?", "derivation": "departure.hour >= 18 and (arrival - departure) > 90 min (overnight arrivals included)", }, { "id": "p04-csv-pm25-ranking", "file": "air_quality_hourly.csv", "build": build_p04, "derive": derive_p04, "format": "ordered_list", "skills": ["file:csv", "missing-values", "group-by", "ranking", "ordered-list"], "question": "The attached file has hourly PM2.5 readings from several monitoring stations; blank cells are " "missed readings and should be ignored, not treated as zero. Which three stations have the " "highest mean PM2.5? List the station names, highest mean first, separated by commas.", "derivation": "groupby(station).mean() with NaN skipped, top 3 descending", }, { "id": "p05-py-queue-sim", "file": "queue_sim.py", "build": build_p05, "derive": derive_p05, "format": "number", "skills": ["file:py", "code-execution", "modify-parameters"], "question": "The attached Python script simulates a ticket counter and prints how many customers are " "waiting after 60 minutes. If the same simulation were run for 240 minutes with three counters " "open instead of the default (everything else unchanged), how many customers would still be " "waiting at the end?", "derivation": "simulate(240, counters=3) from the attached module", }, { "id": "p06-py-invert-cipher", "file": "label_cipher.py", "build": build_p06, "derive": derive_p06, "format": "string", "skills": ["file:py", "code-reasoning", "inversion"], "question": None, # filled in from the generated file (needs the ciphertext) "derivation": "invert encode(): reverse, then subtract key shift and position index mod 26", }, { "id": "p07-audio-platform", "file": "station_announcement.mp3", "build": None, "derive": None, "format": "number", "skills": ["file:audio", "transcription", "distractors"], "question": "Listen to the attached station announcement. From which platform should a passenger travelling " "to Preston now depart? Answer with the platform number only.", "derivation": "TTS script (source.tts_text): the 19:05 to Preston is cancelled; take the 19:20 from platform eleven", "tts": P07_TTS, }, { "id": "p08-audio-mean-reading", "file": "sensor_readings.mp3", "build": None, "derive": None, "format": "number", "skills": ["file:audio", "transcription", "arithmetic", "rounding"], "question": "The attached recording is a technician reading out temperature measurements in degrees " "Celsius. What is the mean of the readings, rounded to one decimal place?", "derivation": "mean of the five readings in the TTS script, ROUND_HALF_UP to 0.1", "tts": P08_TTS, }, { "id": "p09-image-chess-mate", "file": "chess_diagram.png", "build": build_p09, "derive": derive_p09, "format": "string", "skills": ["file:image", "vision", "chess", "verification"], "question": "The attached image shows a chess position with White to move (White pieces are drawn in white, " "Black pieces in black; White plays up the board from rank 1). White has exactly one move that " "delivers checkmate immediately. Give that move in standard algebraic notation (SAN), " "including the mate symbol.", "derivation": "python-chess: legal moves from source.fen whose result is checkmate (exactly one)", }, { "id": "p10-image-chart-mean", "file": "rainfall_chart.png", "build": build_p10, "derive": None, "format": "string", "skills": ["file:image", "vision", "chart-reading", "arithmetic"], "question": "The attached bar chart shows a weather station's monthly rainfall for one year. Which month's " "rainfall was closest to that year's monthly average? Give the full month name.", "derivation": "argmin |value - mean(values)| over the 12 plotted values (source.values)", }, { "id": "p11-pdf-action-items", "file": "procurement_minutes.pdf", "build": build_p11, "derive": derive_p11, "format": "number", "skills": ["file:pdf", "filter", "date-comparison", "near-miss-names", "count"], "question": "How many action items in the attached meeting minutes are owned by Priya Raman and are due " "before 15 November 2026?", "derivation": "parse 'AIxx | ... | Owner: X | Due: D' lines; Owner == 'Priya Raman' and D < 2026-11-15", }, { "id": "p12-json-top-customer", "file": "orders_export.json", "build": build_p12, "derive": derive_p12, "format": "string", "skills": ["file:json", "nested-data", "filter", "group-by", "argmax"], "question": "The attached JSON is an order export. Counting only orders whose status is \"shipped\", which " "customer spent the most in total (sum of quantity times unit price over their items)? Give the " "customer's full name as First Last.", "derivation": "status == shipped; per customer sum(qty * unit_price); argmax (unique)", }, ] def _wiki(title: str, revid: int, evidence: str) -> dict: return { "url": "https://en.wikipedia.org/wiki/" + title.replace(" ", "_"), "revid": revid, "retrieved": RETRIEVED, "evidence": evidence, } WIKI_TASKS = [ { "id": "w01-wiki-element-city", "format": "number", "gold": "67", "skills": ["web", "wikipedia", "multi-hop", "number"], "question": "A chemical element is named after the Latin name of the capital city of Sweden. What is that " "element's atomic number?", "hops": [ _wiki("Holmium", 1377857933, "The element's name comes from Holmia, the Latin name for the city of Stockholm."), _wiki("Holmium", 1377857933, "Holmium is a chemical element; it has symbol Ho and atomic number 67."), ], }, { "id": "w02-wiki-architect-prize", "format": "number", "gold": "2003", "skills": ["web", "wikipedia", "multi-hop", "year"], "question": "In what year was the architect who designed the Sydney Opera House awarded the Pritzker " "Architecture Prize?", "hops": [ _wiki("Sydney Opera House", 1378768237, "Designed by Danish architect Jørn Utzon and completed by an Australian architectural team headed " "by Peter Hall, the building was formally opened by Queen Elizabeth II on 20 October 1973, ..."), _wiki("Jørn Utzon", 1373787728, "In 2003, he was awarded the Pritzker Prize, architecture's highest honor."), ], }, { "id": "w03-wiki-bolivia-borders", "format": "ordered_list", "gold": "Argentina, Brazil, Chile, Paraguay, Peru", "skills": ["web", "wikipedia", "list", "ordered-list", "alphabetical"], "question": "Which countries share a land border with Bolivia? List them in alphabetical order, separated by " "commas.", "hops": [ _wiki("Bolivia", 1378338095, "Bolivia is bordered by Brazil to the north and east, Paraguay to the southeast, Argentina to the " "south, Chile to the southwest, and Peru to the west."), ], }, { "id": "w04-wiki-mozart-river", "format": "string", "gold": "Salzach", "skills": ["web", "wikipedia", "multi-hop", "entity"], "question": "Which river flows through the city where Wolfgang Amadeus Mozart was born? Give only the " "river's name, without the word \"River\".", "hops": [ _wiki("Wolfgang Amadeus Mozart", 1379458284, "Born in Salzburg, Mozart quickly emerged as a child prodigy under the training of his father " "Leopold, a skilled pedagogue."), _wiki("Salzburg", 1378187032, "The city lies on the Salzach River, near the border with Germany and at the foot of the Alps mountains."), ], }, ] # =========================================================================== build def build(audio: bool = False, quiet: bool = False) -> list[dict]: FILES_DIR.mkdir(parents=True, exist_ok=True) tasks: list[dict] = [] manifest: dict = {"generator": GENERATOR, "built_for": RETRIEVED, "files": {}} for spec in FILE_TASKS: path = FILES_DIR / spec["file"] source: dict = {"type": "generated", "generator": GENERATOR, "derivation": spec["derivation"]} if spec.get("tts"): if audio or not path.exists(): synth_audio(spec["tts"], path) source.update({"tts_text": spec["tts"], "tts_voice": "Samantha (macOS say, rate 170)"}) gold = P07_GOLD if spec["id"].startswith("p07") else p08_gold() else: spec["build"](path) if spec["id"].startswith("p10"): gold = derive_p10() source["values"] = dict(zip(P10_MONTHS, P10_VALUES)) else: gold = spec["derive"](path) if spec["id"].startswith("p09"): source["fen"] = P09_FEN question = spec["question"] if spec["id"].startswith("p06"): target = p06_target(path) question = (f"The attached Python module defines a function encode(). Which lowercase English word w " f"satisfies encode(w) == '{target}'?") source["ciphertext"] = target assert gold == P06_PLAIN, gold tasks.append({ "id": spec["id"], "question": question, "file": rel(path), "gold": gold, "format": spec["format"], "skills": spec["skills"], "source": source, }) manifest["files"][rel(path)] = {"sha256": sha256(path), "bytes": path.stat().st_size} for spec in WIKI_TASKS: tasks.append({ "id": spec["id"], "question": spec["question"], "file": None, "gold": spec["gold"], "format": spec["format"], "skills": spec["skills"], "source": {"type": "wikipedia", "retrieved": RETRIEVED, "hops": spec["hops"]}, }) # Generator self-checks against intended values (the test suite re-derives independently). intended = {"p05-py-queue-sim": None, "p07-audio-platform": "11", "p09-image-chess-mate": "Qe8#", "p10-image-chart-mean": "September", "p06-py-invert-cipher": P06_PLAIN} for t in tasks: want = intended.get(t["id"]) if want is not None: assert t["gold"] == want, (t["id"], t["gold"], want) with open(TASKS_PATH, "w", encoding="utf-8") as fh: for t in tasks: fh.write(json.dumps(t, ensure_ascii=False) + "\n") MANIFEST_PATH.write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n", encoding="utf-8") if not quiet: for t in tasks: print(f"{t['id']:<28} {t['format']:<13} gold={t['gold']}") print(f"wrote {len(tasks)} tasks -> {rel(TASKS_PATH)}") return tasks def load_tasks(path: Path = TASKS_PATH) -> list[dict]: with open(path, encoding="utf-8") as fh: return [json.loads(line) for line in fh if line.strip()] def main(argv: list[str] | None = None) -> int: ap = argparse.ArgumentParser(description=__doc__.splitlines()[0]) ap.add_argument("--audio", action="store_true", help="re-synthesize the audio files (macOS only)") args = ap.parse_args(argv) build(audio=args.audio) return 0 if __name__ == "__main__": sys.exit(main())