Update dataset

README.md

@@ -25,10 +25,10 @@ A benchmark dataset for evaluating AI systems on challenging computer science pr
 
 ## Dataset Description
 
-This dataset contains 265 problems across three categories:
+This dataset contains 267 problems across three categories:
 - **Algorithmic**: 188 competitive programming problems with automated judging
 - **Research**: 66 open-ended research problems
-- **2.0**: 11 next-generation open-ended optimization problems
+- **2.0**: 13 next-generation open-ended optimization problems
 
 ## Dataset Structure
 

data/test-00000-of-00001.json

@@ -260,6 +260,8 @@
 {"problem_id": "erdos_demo", "category": "2.0", "statement": "# Erdos Unit Distance Demo\n\n## Problem\n\nPlace exactly `N = 10` distinct points in the Euclidean plane so that the\nnumber of point pairs at Euclidean distance exactly `1` is as large as possible.\n\nThis is a tiny, visually inspectable demo version of the planar unit distance\nproblem. If your construction naturally has a different common distance, scale\nthe coordinates before returning them.\n\n## Program Interface\n\nSubmit a Python file defining one of the following:\n\n```python\ndef solve(n: int) -> list[tuple[float, float]]:\n    ...\n```\n\nor:\n\n```python\ndef generate_points(n: int) -> list[tuple[float, float]]:\n    ...\n```\n\nor:\n\n```python\nPOINTS = [(0.0, 0.0), (1.0, 0.0), ...]\n```\n\nThe returned value must contain exactly 10 two-dimensional points. No stdin is\nused.\n\n## Validity Constraints\n\nA solution is valid if:\n\n1. It returns exactly 10 points.\n2. Every coordinate is a finite real number.\n3. No two points are closer than `1e-6`.\n\nThe objective is translation-invariant. Very large coordinates are allowed as\nlong as pairwise squared distances remain finite.\n\n## Objective\n\nFor all unordered point pairs, count those whose squared Euclidean distance is\nequal to `1` within a small floating-point tolerance. Let `M` be that count.\n\nMaximize `M`.\n\n## Scoring\n\nThe score is naturally scaled to `[0, 100)`, without clipping against a fixed\ntarget. Let:\n\n```text\nbaseline = N\nX = M\n```\n\nIf the point set is invalid, or if `X <= baseline`, the score is `0`. Otherwise:\n\n```text\nscore = 100 * (X - baseline) / X\n```\n\nThis makes the simple `N`-pair baseline worth `0`. With only 10 points, the\nproblem is intended as a quick sanity check and visual demo for agent workflows.\n", "config": "tag: geometry\nruntime:\n  language: python\n  timeout_seconds: 300\n  environment: \"Python 3.11; no external packages required\"\n  docker:\n    image: ubuntu:24.04\n"}
 {"problem_id": "erdos_unit_distance", "category": "2.0", "statement": "# Erdos Unit Distance\n\n## Problem\n\nPlace exactly `N = 65536` distinct points in the Euclidean plane so that the\nnumber of point pairs at Euclidean distance exactly `1` is as large as possible.\n\nThis is a finite, executable version of the planar unit distance problem:\ngiven `n` points, maximize the number of pairs at distance exactly `1`. If your\nconstruction naturally has a different common distance, scale the coordinates\nbefore returning them.\n\n## Program Interface\n\nSubmit a Python file defining one of the following:\n\n```python\ndef solve(n: int) -> list[tuple[float, float]]:\n    ...\n```\n\nor:\n\n```python\ndef generate_points(n: int) -> list[tuple[float, float]]:\n    ...\n```\n\nor:\n\n```python\nPOINTS = [(0.0, 0.0), (1.0, 0.0), ...]\n```\n\nThe returned value must contain exactly 65536 two-dimensional points. No stdin\nis used.\n\n## Validity Constraints\n\nA solution is valid if:\n\n1. It returns exactly 65536 points.\n2. Every coordinate is a finite real number.\n3. No two points are closer than `1e-3`.\n\nThe objective is translation-invariant. Very large coordinates are allowed as\nlong as pairwise squared distances remain finite.\n\n## Objective\n\nFor all unordered point pairs, count those whose squared Euclidean distance is\nequal to `1` within a strict floating-point tolerance. Let `M` be that count.\n\nMaximize `M`.\n\n## Scoring\n\nThe score is naturally scaled to `[0, 100)`, without clipping against a fixed\ntarget. Let:\n\n```text\nbaseline = N\nX = M\n```\n\nIf the point set is invalid, or if `X <= baseline`, the score is `0`. Otherwise\nthe raw score is:\n\n```text\nraw_score = 100 * (X - baseline) / X\n```\n\nThe reported score applies a cubic scale:\n\n```text\nscore = 100 * (raw_score / 100)^3\n```\n\nThis makes the simple `N`-pair baseline worth `0`, rewards every improvement\nabove the baseline, and keeps high-scoring constructions from saturating the\nbenchmark too quickly. The bounded and unbounded score fields both report this\ncubic-scaled score; evaluator messages also include `raw_score` for reference.\n", "config": "tag: geometry\nruntime:\n  language: python\n  timeout_seconds: 10800\n  environment: \"Python 3.11; no external packages required\"\n  docker:\n    image: ubuntu:24.04\n"}
 {"problem_id": "generals_io_bot", "category": "2.0", "statement": "# Generals.io Bot Arena\n\n![Generals.io gameplay](https://raw.githubusercontent.com/strakam/generals-bots/master/generals/assets/gifs/wider_gameplay.gif)\n\nImage credit: `strakam/generals-bots`, MIT license.\n\n## Problem\n\nImplement a bot for a local Generals.io-style arena. Your bot plays repeated\ntwo-player games against fixed baseline bots in the `generals-bots` simulator.\n\nYour goal is simple: protect your own general and capture the opponent's\ngeneral as often and as quickly as possible.\n\nEach game is played on a square grid with fog of war. If no general is captured\nbefore the truncation limit, the game is scored as a draw for win-rate purposes.\n\nThe environment is the local `generals-bots` simulator, not the online\ngenerals.io service. Each turn your bot receives an observation containing:\n\n```text\narmies, generals, cities, mountains, neutral_cells, owned_cells,\nopponent_cells, fog_cells, structures_in_fog, owned/opponent land and army\ncounts, and timestep\n```\n\n## Game Rules\n\nThe arena follows the local `generals-bots` simulator rules:\n\n- The grid contains passable empty cells, impassable mountains, neutral cities,\n  and one general per player.\n- You see every cell in the 3x3 neighborhood around your owned cells. Other\n  cells are fogged. Cities and mountains in fog may appear as\n  `structures_in_fog` obstacles.\n- Each turn both players choose one action. An action is either pass or move\n  from one owned source cell to one adjacent passable destination cell.\n- A non-split move sends `source_army - 1` armies and leaves one army behind.\n  A split move sends `source_army // 2` armies. Moves from cells with one army\n  are invalid and become no-ops.\n- Moving into your own cell reinforces it. Moving into neutral or enemy\n  territory is an attack. The attack captures the destination only when the\n  moving army is strictly larger than the defending army; the remaining army is\n  the absolute difference.\n- Capturing the enemy general immediately wins the game.\n- Army growth is deterministic: every owned cell gains one army when\n  `timestep % 50 == 0`, and owned generals/cities gain one army when\n  `timestep % 2 == 1`.\n- The default task setting uses 10x10 maps, truncates at 180 turns, and runs\n  one game per baseline matchup for quick iteration.\n\n## Submission\n\nSubmit a patch against the public `generals_agent` skeleton. In Harbor, edit the\nrepository under:\n\n```text\n/app/generals_agent\n```\n\nThen run:\n\n```bash\nbash /app/make_submission.sh\nbash /app/submit.sh\n```\n\nStart by submitting the baseline skeleton once before running long local\nexperiments. This establishes black-box feedback early; later submissions can\nreplace it as you improve the bot.\n\nThe patch must produce a Python module with:\n\n```python\nclass FrontierAgent:\n    def act(self, observation, key):\n        ...\n```\n\n`act` must return a `generals-bots` action array:\n\n```text\n[pass, row, col, direction, split]\n```\n\nwhere `direction` is `0=up`, `1=down`, `2=left`, `3=right`, and `split`\nselects whether to move half the army instead of all-but-one.\n\nPatches may modify only these files:\n\n```text\nbot.py\nstrategy.py\nutils.py\n```\n\nThe judge rejects binary patches, oversized patches, path traversal, and common\nfile/network/process access tokens. This is a bot-policy benchmark, not an\nenvironment inspection task.\n\nThe agent workspace intentionally does not include a Frontier-CS match runner,\nbaseline ensemble, hidden seeds, or evaluator implementation. Use the black-box\nsubmission interface for scoring feedback.\n\n## Scoring\n\nEvery submission is evaluated against the same baseline families used by final\nverification. These include random, expansion, hunting/pathing, and\nstrategy-inspired rule-based opponents, so exploiting only one weak bot is not\nenough for a high score. Faster wins also matter: the score gives substantial\ncredit for capturing the enemy general in fewer turns.\n\nThe default Harbor configuration is intentionally lightweight so agents can\niterate quickly: it uses one game per matchup and an internal evaluator time\nbudget. Increase `games_per_matchup`, `grid_sizes`, `truncation`, `pool_size`,\nand `max_eval_seconds` together in `config.yaml` for a heavier run. Adjust\n`speed_weight` if you want fast wins to matter more or less relative to raw win\nrate.\n\nPractical tip: the simulator is JAX-based. Simple array programs compile and\nrun much faster than large Python control-flow policies, so keep `act` compact\nand vectorized when possible.\n\nThe reported score is scaled to `[0, 100]`:\n\n```text\nscore = 100 * ((1 - speed_weight) * mean_baseline_win_rate + speed_weight * mean_baseline_speed_tiebreak)\n```\n\nThe default `speed_weight` is `0.25`. The speed credit is only earned on games\nthat your bot wins and is larger for earlier captures.\n\n## Notes\n\n- The online generals.io service is not used.\n- The hidden evaluator and hidden seeds are not visible in the agent workspace.\n- The task uses `strakam/generals-bots` at pinned commit\n  `c2b77bf72812ec91fb2024d80d90112b961dfa7e` under the MIT license.\n", "config": "tag: games\nruntime:\n  language: patch\n  timeout_seconds: 10800\n  environment: \"Generals.io bot patch; local generals-bots simulator arena\"\n  apt_packages:\n    - bash\n    - ca-certificates\n    - git\n    - python3\n    - python3-pip\n  judge_apt_packages:\n    - bash\n    - ca-certificates\n    - git\n    - python3\n    - python3-pip\n  docker:\n    image: frontiercs/generals-io-bot-agent:experimental-c2b77bf\n    judge_image: frontiercs/generals-io-bot-judge:experimental-c2b77bf\nenvironment:\n  cpus: 4\n  memory_mb: 8192\n  storage_mb: 8192\n  build_timeout_seconds: 1800\nevaluation:\n  generals_bots_commit: \"c2b77bf72812ec91fb2024d80d90112b961dfa7e\"\n  arena_seed: 20260608\n  games_per_matchup: 1\n  async_start_method: spawn\n  max_eval_seconds: 240\n  truncation: 180\n  pool_size: 2\n  speed_weight: 0.25\n  grid_sizes:\n    - 10\n  baselines:\n    - random_low_split\n    - expander\n    - strongest_frontier\n    - hunter\n    - fast_pathing\n    - flobot_fast\nsubmission:\n  kind: file\n  path: /app/solution.patch\n  allow_empty: true\n"}
+{"problem_id": "nanowm_rollout_speedup", "category": "2.0", "statement": "# NanoWM Rollout Speedup — fast diffusion sampling for a frozen video world model\n\n## Problem\n\nYou are given a clean checkout of **Nano World Models** (arXiv:2605.23993) and\nits frozen **NanoWM-L/2 CSGO** checkpoint — a diffusion-forcing video world model.\nThe judge runs a **fixed** autoregressive long-rollout: from 4 context frames,\ngenerate **50 future frames** of held-out CSGO gameplay, sequential scheduling,\nnominal **50 DDIM steps**.\n\nYour job: **make that rollout faster** by submitting a **Python-only patch** to\nthe diffusion **sampling** code, **without degrading rollout quality**. Score is\nwall-clock speedup over the unpatched baseline, gated by a quality guardrail.\n\nThis is a real fast-sampling problem: the paper's Fig. 6 shows DDIM step count\ngenuinely trades off against rollout quality on CSGO (unlike saturated toy\ndomains). Naively cutting steps degrades quality and fails the guardrail; to win\nyou must reproduce ~50-step quality with less compute — DPM-Solver++ / higher-order\nor exponential integrators, KV/feature caching across denoising steps and frames,\nmixed precision, `torch.compile`, fused attention, redundancy elimination, etc.\n\n## What you submit\n\nA unified-diff patch at **`/app/solution.patch`** against the checkout in\n`/app/nano-world-model`. **Python source only**, and only within the diffusion\nsampling layer:\n\n**Allowed:** `src/diffusion/**.py`, `src/sample/sampling_utils.py`\n**Denied:** the model architecture (`src/models/**`), VAE (`src/latent_codecs/**`),\nthe metric (`src/sample/evaluate_metrics.py`), the rollout harness\n(`src/sample/rollout.py`), data loading (`src/wm_datasets/**`), training/eval\nharness, and any native/build/dependency files. New `.py` files inside the\nallowed areas are fine. Patches are validated **before** running.\n\nThe rollout invocation (length, context, nominal step count, scheduling) is\n**fixed by the judge** — you change the sampler internals, not the call. Patches\nthat read judge/Modal/HF env vars, hard-code episode ids or ground truth,\nshort-circuit/sleep, or special-case the benchmark are rejected.\n\n## Evaluation & scoring\n\n- The judge applies your patch to a clean checkout and runs the fixed CSGO\n  rollout on hidden held-out episodes on a **GPU (served via Modal)**. Iterative\n  (`bash /app/submit.sh`) uses a small quick set; the final verifier uses a\n  larger disjoint set.\n- **Quality guardrail:** rollout **LPIPS vs ground truth** must not rise more\n  than `quality_tolerance` (default **3%**) above the unpatched seq@50 baseline.\n  (Calibration: seq@20 is already +5% over seq@50, so naive step-cutting fails\n  this — real fast-sampling is required.)\n- **Score:**\n\n```\ngeomean_speedup = baseline_seconds / patched_seconds   (rollout generation)\nscore           = clip(100 * log2(geomean_speedup), 0, 100) * quality_multiplier\n```\n\n  `quality_multiplier` is 1.0 within tolerance and decays inverse-proportionally\n  beyond it. `score_unbounded` keeps rewarding speedup past 2× (the bounded score\n  caps at 100). A patch that degrades quality past tolerance is penalized toward\n  0; one that crashes, exceeds limits, or violates the patch policy scores 0.\n\n## Resource budget\n\nCPU agent + judge containers (8 CPU / 32 GB); one Modal GPU per evaluation.\nEvaluation timeout 21600 s. Submission queue depth 2.\n\n## Getting started\n\n`/app/nano-world-model` is the checkout you patch. `bash /app/public_test.sh`\nruns a tiny local policy check on your `solution.patch`. See `AGENT.md` and\n`harbor/app/README.md` for the submission workflow, and the paper / `docs/` for\nthe sampling code you'll be optimizing (`src/diffusion/df_sample.py`,\n`gaussian_diffusion.py`).\n", "config": "tag: systems\nruntime:\n  # Submission is a Python-only source patch (the real reference is\n  # reference.patch). `language: python` keeps the file extension/CLI conventions\n  # standard (mirrors vllm_llm_serving_optimization, #145); there is no separate\n  # \"patch\" language in the framework.\n  language: python\n  timeout_seconds: 21600\n  environment: >-\n    Python-only patch against a clean NanoWM checkout (Nano World Models,\n    arXiv:2605.23993); Modal GPU runs the NanoWM-L/2 CSGO 50-frame long-rollout;\n    speedup-vs-baseline judge with an LPIPS rollout-quality guardrail\n  apt_packages:\n    - bash\n    - ca-certificates\n    - curl\n    - git\n    - python3\n    - python3-pip\n  judge_apt_packages:\n    - bash\n    - ca-certificates\n    - curl\n    - git\n    - python3\n    - python3-pip\n  judge_pip_packages:\n    - modal\n  docker:\n    # Experimental local images; build with docker/build_images.sh before a local\n    # Harbor trial. Both bake a clean NanoWM checkout + the L/2 CSGO ckpt; the\n    # judge image additionally vendors the held-out CSGO episode subset, the\n    # LPIPS scorer, and the cached vanilla baseline metrics.\n    image: frontiercs/nanowm-rollout-speedup-agent:experimental-v0\n    judge_image: frontiercs/nanowm-rollout-speedup-judge:experimental-v0\nenvironment:\n  cpus: 8\n  memory_mb: 32768\n  storage_mb: 32768\n  build_timeout_seconds: 5400\nevaluation:\n  # GPU served on Modal (one per environment); judge container is CPU-only.\n  # H100 matches the hardware the reference + noise floor were calibrated on, so\n  # the production scoring path and the validated numbers share one GPU SKU.\n  model: nanowm_l2_csgo\n  dataset: game/csgo\n  gpu: H100\n  # FIXED rollout invocation (the agent's patch changes sampler internals, not these).\n  rollout_length: 50\n  history_length: 4\n  num_steps: 50            # nominal reference DDIM budget\n  scheduling: sequential\n  history_stab: 0.02\n  # Quality guardrail: patched rollout LPIPS-vs-GT may rise at most this\n  # (relative) above the unpatched seq@50 baseline before the score is penalized.\n  # Calibrated: seq@20 is already +5% over seq@50, so a 3% tolerance forces real\n  # fast-sampling work (DPM-Solver++, caching, distillation), not naive step cuts.\n  quality_tolerance: 0.03\n  # (E) Speedup at which the latency score saturates to 100: score is\n  # 100*log2(speedup)/log2(target). The old bare 100*log2 capped everything >=2x\n  # at 100; 4x keeps a gradient across the achievable range (causal-prefix ~3x).\n  speedup_target: 4.0\n  # (A) Faithfulness BACKSTOP: mean LPIPS between PATCHED and BASELINE rollout\n  # frames (paired final run), always reported; penalty only past this generous\n  # threshold so it catches an egregious rollout SUBSTITUTION, not legitimate\n  # iso-quality speedups. Calibrated on H100: bf16 reference drifts 0.206 from the\n  # fp32 baseline (iso-quality vs GT, different trajectory), so 0.30 clears it with\n  # margin while still flagging ~half-divergent substitutions; causal-prefix ~0.\n  faithfulness_tol: 0.30\n  quick_clips: 4           # iterative (agent-role) public feedback\n  final_clips: 16          # final (verifier-role) evaluation\n  batch_size: 4\n  # Key MUST be `baseline_cache` (settings.py strips the FRONTIER_NWM_ prefix and\n  # looks up `baseline_cache`); `baseline_cache_path` was silently ignored.\n  baseline_cache: /opt/nanowm/baseline/baseline_metrics.json\nsubmission:\n  kind: file\n  path: /app/solution.patch\n  max_queue_size: 2\n"}
+{"problem_id": "nanowm_rollout_stability", "category": "2.0", "statement": "# NanoWM Rollout Stability — minimize long-horizon drift at fixed compute\n\n## Problem\n\nYou are given a clean checkout of Nano World Models (arXiv:2605.23993) and its\nfrozen NanoWM-L/2 CSGO checkpoint. The judge runs a **fixed long-horizon**\nautoregressive rollout (sequential, **50 DDIM steps**). Long autoregressive\nrollouts accumulate perceptual error — by the tail of the rollout the prediction\nhas drifted into a \"plausible but wrong\" state (paper Finding #5).\n\nYour job: **minimize that drift** — the mean LPIPS-vs-ground-truth over the\n**drifted tail frames** (the late portion of the rollout) — by submitting a\n**Python-only patch** to the diffusion **sampling** code, **without using more\ncompute** (a wall-clock budget = the unpatched baseline's generation time is\nenforced).\n\nThe exact rollout length and which frames are scored as the \"tail\" are fixed by\nthe judge and **not disclosed** — the scored horizon is drawn per run — so a\nsolution must reduce drift **generally**; keying behaviour off an assumed rollout\nlength or a hardcoded frame index will not transfer to the scored run.\n\nThis is a hard, open problem: simply adding denoising steps reduces drift but is\ndisallowed (it costs compute — that's the *speedup* task). At fixed compute you\nmust use the budget *smarter*: history stabilization, scheduling-matrix design,\ndrift-aware KV/feature caching that frees time for re-grounding, periodic\ncontext re-anchoring, error-feedback correction, better solvers, etc.\n\n## What you submit\n\nA unified-diff patch at `/app/solution.patch` against `/app/nano-world-model`.\n**Python source only**, within the diffusion sampling layer:\n**Allowed:** `src/diffusion/**.py`, `src/sample/sampling_utils.py`.\n**Denied:** model (`src/models/**`), VAE, the metric, the rollout harness\n(`src/sample/rollout.py`), data loading, training/eval harness, native/build\nfiles. No env-var/benchmark/timing tricks. Validated before running.\n\n## Evaluation & scoring\n\n- Judge applies your patch, runs the fixed long-horizon CSGO rollout on hidden\n  episodes (Modal GPU), measures **tail-drift** (mean LPIPS-vs-GT over the late /\n  tail frames) and **generation wall-clock**. Quick set for iterative `submit.sh`;\n  a larger disjoint set for the final verifier (enough clips to resolve small drift\n  reductions above per-clip noise). The exact rollout length and tail window are\n  not disclosed and vary per scored run.\n- **Score:**\n\n```\nscore = clip(100 * (baseline_tail_drift - patched_tail_drift) / baseline_tail_drift, 0, 100)\n        * wallclock_multiplier\n```\n\n  `wallclock_multiplier` is 1.0 while patched generation time stays within 10%\n  of the baseline, and decays beyond (so you cannot buy drift reduction with\n  more compute). A patch that does not reduce drift, exceeds the wall-clock\n  budget, crashes, or violates the patch policy scores 0.\n\n## Reference & difficulty\n\n`reference.patch` raises history stabilization (a one-line sampling change) — it\nreliably reduces tail-drift ~6.8% (± 1.2%) over the baseline at iso-wall-clock\n(validated under common-random-numbers pairing: 74% per-clip win, pooled paired\nt=5.15, p<1e-4 across 3 seeds × 22 clips), proving the task is solvable.\nSubstantially beating it is the open challenge.\n\n## Resource budget\n\nCPU agent + judge; one Modal GPU per evaluation. Evaluation timeout 21600 s.\nSee `AGENT.md` and `harbor/app/README.md`.\n", "config": "tag: systems\nruntime:\n  # Submission is a Python-only source patch (the real reference is\n  # reference.patch). `language: python` keeps the file extension/CLI conventions\n  # standard (mirrors vllm_llm_serving_optimization, #145); there is no separate\n  # \"patch\" language in the framework.\n  language: python\n  # 12h. The scored final is a 22->12-clip baseline+patched PAIR of 80-frame\n  # rollouts under strict determinism (TF32 off ~3x slower): ~5-7h on H100. The\n  # old 6h verifier timeout was SHORTER than the final run, so the verifier raised\n  # VerifierTimeoutError -> reward 0 even though the agent submissions scored fine.\n  # Matches the Modal _rollout_pair function timeout (43200s).\n  timeout_seconds: 43200\n  environment: >-\n    Python-only patch against a clean NanoWM checkout (Nano World Models,\n    arXiv:2605.23993); Modal GPU runs a NanoWM-L/2 CSGO long-horizon rollout (the\n    exact length and scored tail are fixed by the judge and not disclosed);\n    minimize long-horizon drift (tail-frame LPIPS) at iso-wall-clock\n  apt_packages: [bash, ca-certificates, curl, git, python3, python3-pip]\n  judge_apt_packages: [bash, ca-certificates, curl, git, python3, python3-pip]\n  judge_pip_packages: [modal]\n  docker:\n    image: frontiercs/nanowm-rollout-stability-agent:experimental-v0\n    judge_image: frontiercs/nanowm-rollout-stability-judge:experimental-v0\nenvironment:\n  cpus: 8\n  memory_mb: 32768\n  storage_mb: 32768\n  build_timeout_seconds: 5400\nevaluation:\n  # H100 matches the hardware the reference + noise floor were calibrated on, so\n  # the production scoring path and the validated numbers share one GPU SKU.\n  model: nanowm_l2_csgo\n  dataset: game/csgo\n  gpu: H100\n  # LONG rollout so error accumulates into a drifted tail; FIXED steps + a\n  # wall-clock budget => the agent improves the rollout PROCEDURE at iso-compute\n  # (stabilization / scheduling / drift-aware caching), not by adding steps.\n  rollout_length: 80       # NOMINAL: agent-role QUICK loop + cache fingerprint\n  history_length: 4\n  num_steps: 50            # fixed compute budget\n  scheduling: sequential\n  history_stab: 0.02       # baseline default (repo long_rollout setting)\n  drift_tail_start: 60     # NOMINAL tail (cached agent path); scored tail derives from the randomized horizon\n  # Anti-overfit (audit #7): the SCORED (role=final) horizon is drawn at random per\n  # run from [rollout_length_min, rollout_length_max] (MAX < nominal so the agent's\n  # dev-measured horizon never scores, and GT headroom/clip-count are unchanged), and\n  # the scored tail = horizon - tail_frames. This neutralizes the codex module-counter\n  # tail-targeting hack (its period 76 / frame-64 ramp misfire off the tail at <=72;\n  # see stability_eval/test_antihack_horizon.py). Tune to trade anti-hack margin vs\n  # SNR (lower max = stronger anti-hack; raise toward 80 = closer to calibrated tail>=60).\n  rollout_length_min: 64\n  rollout_length_max: 72\n  tail_frames: 20\n  # Wall-clock guardrail: patched gen time may rise at most this over baseline,\n  # else drift is being bought with compute (the speedup task's axis).\n  wallclock_tolerance: 0.10\n  # Drift reductions are small; enough clips to resolve above per-clip noise\n  # (validated under common-random-numbers pairing: stab=0.20 reference beats\n  # baseline; 74% per-clip win, pooled paired t=5.15, p<1e-4 across 3 seeds x 22 clips).\n  quick_clips: 8\n  # Full held-out set = the 22 test_split episodes number<=200 staged from the\n  # 1-200 chunk (>22 indexes past the sliced dataset and crashes). The scored final\n  # uses all 22 for SNR (validated headline). The 80-frame paired rollout is ~10h\n  # sequentially under strict determinism, so the judge FANS the clips out across\n  # Modal containers (chunk_size each) -- bit-identical to the sequential run since\n  # the per-batch seed keys on the global clip index -- finishing in ~one chunk's\n  # wall-time. batch_size=2 => QUICK(8) is a noise-identical prefix of FINAL(22).\n  final_clips: 22\n  batch_size: 2\n  # Clips per Modal container in the fanned-out scored pair (rounded up to a\n  # multiple of batch_size for global batch alignment). 22/4 => 6 parallel chunks.\n  chunk_size: 4\n  # Key MUST be `baseline_cache` (settings.py strips the FRONTIER_NWM_ prefix and\n  # looks up `baseline_cache`); `baseline_cache_path` was silently ignored.\n  baseline_cache: /opt/nanowm/baseline/stability_baseline.json\nsubmission:\n  kind: file\n  path: /app/solution.patch\n  max_queue_size: 2\n"}
 {"problem_id": "vector_db_ann", "category": "2.0", "statement": "# Vector DB ANN\n\n## Problem\n\nBuild a fast approximate nearest-neighbor vector search engine for a\nSIFT1M-scale benchmark.\n\nThe hidden benchmark contains exactly `1,000,000` base vectors with dimension\n`128`. Queries use the same dimension, distance is squared Euclidean distance,\nand each query asks for the top `10` nearest vector ids.\n\nYour objective is to maximize serving throughput while preserving search\nquality: submissions must reach `recall@10 >= 0.95`, and valid submissions are\nranked by an effective QPS that includes query time plus a small load/index-build\npenalty.\n\nThe Harbor agent container starts with a small Rust skeleton project in\n`/app`. You may use it, modify it, or replace it entirely. You may also use any\nRust crates, internal harness, data structures, and build layout you want, as\nlong as the final project satisfies the judge contract below.\n\nThe judge builds and runs your service with:\n\n```bash\ncargo build --release\nPORT=<port> cargo run --release --quiet\n```\n\nThe Harbor environment uses the Ubuntu `apt` Rust toolchain:\n\n```text\nrustc 1.75\ncargo 1.75\n```\n\nIf you add crates, choose versions compatible with this toolchain or pin\ntransitive dependencies accordingly.\n\nThe service and judge run with the task resource limits below. Design your\nparallel search and indexing strategy for this budget:\n\n```text\nvCPUs: 8\nmemory: 16 GiB\nquery concurrency: 8\ntimed queries per worker: 64\n```\n\nThe service must listen on `PORT` and implement these endpoints:\n\n```text\nPOST /insert\nPOST /bulk_insert\nPOST /search\n```\n\n`/bulk_insert` receives:\n\n```json\n{\"vectors\":[{\"id\":0,\"vector\":[0.1,0.2,...]}]}\n```\n\nand returns:\n\n```json\n{\"status\":\"ok\",\"inserted\":1}\n```\n\n`/search` receives:\n\n```json\n{\"vector\":[0.1,0.2,...],\"top_k\":10}\n```\n\nand returns:\n\n```json\n{\"results\":[{\"id\":0,\"distance\":0.0}]}\n```\n\n## Local Harness\n\nThe official evaluator uses hidden data and a black-box judge. You may call:\n\n```bash\nbash /app/submit.sh\n```\n\nat any time to submit the current `/app` project to the official judge and get\nscore feedback.\n\n## Validity\n\nA submission is valid if:\n\n1. It builds successfully with `cargo build --release`.\n2. `cargo run --release --quiet` starts the service and implements the required HTTP\n   endpoints.\n3. Every returned id is in `[0, 1_000_000)`.\n4. Its `recall@10` is at least `0.95` against the hidden exact top-10 ground\n   truth.\n\n## Scoring\n\nAt trial startup, the Harbor judge sidecar prepares the hidden benchmark and\nruns an exact-search reference HTTP service through the same `/bulk_insert`\nand `/search` client harnesses to produce ground-truth nearest neighbors and\nthe trial-local scoring baseline:\n\n```text\nbaseline_qps\nbaseline_effective_qps\nbaseline_load_seconds\n```\n\nInteractive submissions and the final verifier both score through this same\njudge sidecar, so the baseline and runtime environment are shared within a\ntrial while still letting different machines measure their own local baseline.\n\nEach submission is then timed independently. The load phase includes all\n`/bulk_insert` calls and any index construction performed by the service before\nqueries begin. The query phase uses 8 concurrent workers, each issuing 64\nqueries, and measures only `/search` throughput:\n\n```text\ncandidate_qps\ncandidate_load_seconds\n```\n\nThe reported `qps` is the raw query-only QPS. Scoring uses an effective QPS\nthat includes a small index-build/load penalty:\n\n```text\neffective_qps = Q / (query_seconds + 0.01 * load_seconds)\n```\n\nThe load phase has a default `900s` timeout. This keeps the benchmark focused\non serving performance while still making very expensive offline indexing pay a\nbounded, explicit cost.\n\nDuring evaluation, the load and query phases may stop early and return `0` once\nthe elapsed time plus the load penalty makes it impossible for the final\neffective QPS to beat the baseline. During load, this assumes a best-case query\ntime of zero.\n\nIf the submission is invalid, if `recall@10 < 0.95`, or if\n`candidate_effective_qps <= baseline_effective_qps`, the score is `0`.\nOtherwise:\n\n```text\nscore = 100 * (1 - sqrt(baseline_effective_qps) / sqrt(candidate_effective_qps))\n```\n\nThe bounded and unbounded score fields both report this score. Harbor JSON\nresults include the measured `qps`, `effective_qps`, `baseline_qps`,\n`baseline_effective_qps`, `recall_at_10`, load time, and runtime metrics under\nthe `metrics` field.\n", "config": "tag: systems\nruntime:\n  language: rust\n  timeout_seconds: 10800\n  environment: \"Rust project; hidden ANN benchmark; Python/NumPy judge\"\n  apt_packages:\n    - build-essential\n    - cargo\n    - git\n    - rustc\n  judge_apt_packages:\n    - build-essential\n    - cargo\n    - rustc\n    - python3-pip\n    - python3-numpy\n  judge_pip_packages:\n    - faiss-cpu\n  docker:\n    image: ubuntu:24.04\nenvironment:\n  # If these resource limits change, also update the resource budget text in\n  # readme and harbor/app/README.md so agents can design parallel algorithms\n  # for the actual CPU and memory budget.\n  cpus: 8\n  memory_mb: 16384\n  storage_mb: 8192\n  build_timeout_seconds: 3600\nevaluation:\n  # The judge drives the search service with this many concurrent workers.\n  # Keep this aligned with the CPU budget unless the task is intentionally\n  # changed into a higher-concurrency service benchmark.\n  query_concurrency: 8\n  queries_per_worker: 64\nsubmission:\n  kind: directory\n  path: /app\n  exclude:\n    - target\n    - .git\n    - .frontier-cs\n"}
 {"problem_id": "vector_db_ann_disk", "category": "2.0", "statement": "# Vector DB ANN Disk\n\n## Problem\n\nBuild a fast approximate nearest-neighbor vector search engine for a\nSIFT100M-scale benchmark.\n\nThe hidden benchmark contains exactly `100,000,000` base vectors with dimension\n`128`. Queries use the same dimension, distance is squared Euclidean distance,\nand each query asks for the top `10` nearest vector ids.\n\nThe benchmark provides a pre-built graph index generated using the [DiskANN](https://github.com/g4197/FreshDiskANN-baseline)\nconstruction algorithm. The graph has a bounded maximum degree and is stored on\ndisk. Your objective is to maximize serving throughput while preserving search\nquality: submissions must reach `recall@10 >= 0.95`, and valid submissions are\nranked by query throughput.\n\nThe Harbor agent container starts with a small Rust skeleton project in\n`/app`. You may use it, modify it, or replace it entirely. You may also use any\nRust crates, internal harness, data structures, and build layout you want, as\nlong as the final project satisfies the judge contract below.\n\nThe judge builds and runs your service with:\n\n```bash\ncargo build --release\nPORT=<port> cargo run --release --quiet\n```\n\nThe Harbor environment uses the Ubuntu `apt` Rust toolchain:\n\n```text\nrustc 1.75\ncargo 1.75\n```\n\nIf you add crates, choose versions compatible with this toolchain or pin\ntransitive dependencies accordingly.\n\nThe service and judge run with the task resource limits below. Design your\nsearch strategy for this budget:\n\n```text\nvCPUs: 8\nmemory: 8 GiB\nquery concurrency: 8\n```\n\nThe graph and vector data may be substantially larger than the available\nmemory. Submissions may load any information they deem useful into memory\nduring the load phase, subject to the memory limit above.\n\nThe load phase is executed once before queries begin and must complete within:\n\n```text\n600 seconds\n```\n\nThe service must listen on `PORT` and implement these endpoints:\n\n```text\nPOST /load\nPOST /search\n```\n\nImportant: submissions must implement an online ANN service that answers each\n`/search` using the index and vectors provided through `/load`. Query vectors are\nsupplied by the evaluator at request time. Results must come from searching the\nprovided index; do not hardcode answers or rely on any precomputed or external\ndata. Any attempt to obtain results other than by searching the provided index is\noutside the task contract and is treated as invalid.\n\nOptimization guidance: after a valid graph-based ANN implementation exists,\nminor parameter sweeps over search-list size, beam width, or cache limits tend\nto provide limited gains. Prefer substantive algorithmic and I/O improvements,\nsuch as better graph traversal, batching/asynchronous disk reads, candidate\nmanagement, vector/PQ distance computation, and cache design. A well-designed\nANN algorithmic change is expected to be a better acceleration path than\nrepeated manual tuning of a few constants.\n\n`/load` receives the paths to the pre-built index and vector data:\n\n```json\n{\n    \"index_path\":\"graph.bin\",\n    \"vector_path\":\"vectors.bin\",\n    \"vector_dtype\":\"uint8\",\n    \"pq_compressed_path\":\"pq_compressed.bin\",\n    \"pq_pivots_path\":\"pq_pivots.bin\"\n}\n```\n\nFor compatibility, the service should also accept `graph_path` as an alias for\n`index_path`, and `pq_vector_path` as an alias for `pq_compressed_path`.\n`vector_dtype` is optional and may be `float32`, `uint8`, or `int8`; do not\nassume the vector file stores `float32` rows. These files follow the same format\nand organization as those in the [provided repository](https://github.com/g4197/FreshDiskANN-baseline);\nyou can refer to it to load the graph, compressed vectors, and other required\ndata structures.\n\nand returns:\n\n```json\n{\n    \"status\":\"ok\"\n}\n```\n\n`/search` receives:\n\n```json\n{\"vector\":[0.1,0.2,...],\"top_k\":10}\n```\n\nand returns:\n\n```json\n{\"results\":[{\"id\":0,\"distance\":0.0}]}\n```\n\n## Local Harness\n\nThe official evaluator uses hidden data and a black-box judge. You may call:\n\n```bash\nbash /app/submit.sh\n```\n\nat any time to submit the current `/app` project to the official judge and get\nscore feedback.\n\nEach evaluation rebuilds your project, runs `/load` once (loading the on-disk\nindex can take tens of seconds), then runs the timed query phase, so a single\nsubmission takes on the order of a few minutes to score. Submissions are\nasynchronous: prefer to let a running evaluation finish and read its score\nrather than cancelling and resubmitting repeatedly. To keep iterative feedback\nresponsive, an agent `submit.sh` evaluation times only a representative subset\nof the query set (see below); the final score is always computed over the full\nset.\n\n## Validity\n\nA submission is valid if:\n\n1. It builds successfully with `cargo build --release`.\n2. `cargo run --release --quiet` starts the service and implements the required HTTP\n   endpoints.\n3. Every returned id is in `[0, 100_000_000)`.\n4. Its `recall@10` is at least `0.95` against the hidden exact top-10 ground\n   truth.\n5. The `/load` phase completes within `600` seconds.\n\n## Scoring\n\nEach submission is scored against a hidden exact top-10 ground truth and a\nreference throughput baseline (`baseline_qps`) measured under the same `/load`\nand `/search` harness.\n\nThe load phase consists of a single `/load` call. Any preprocessing performed\nduring `/load` must complete within the timeout above.\n\nAfter the load phase completes, the query phase uses 8 concurrent workers to\nissue the timed query set and measures only `/search` throughput\n(`candidate_qps`). The reported `qps` is the raw query-only QPS.\n\nIf the submission is invalid, if `recall@10 < 0.95`, or if\n`candidate_qps <= baseline_qps`, the score is `0`.\n\nOtherwise:\n\n```text\nscore = 100 * (1 - sqrt(baseline_qps) / sqrt(candidate_qps))\n```\n\nThe bounded and unbounded score fields both report this score. Harbor JSON\nresults include the measured `qps`, `baseline_qps`, `recall_at_10`, load time,\nand runtime metrics under the `metrics` field.\n\n### Iterative feedback vs. final scoring\n\nTo make the `submit.sh` loop responsive, an iterative (agent) submission times\nonly a representative subset of the query set (`2000` queries by default) and\nreports it as a fast estimate; its message is prefixed with `[iterative]` and\nstates how many queries were used. The **final verifier** always times the full\nquery set (`Q = 10000`) and reports the authoritative `[final]` score using the\nexact same scoring rule. recall@10 and QPS are stable averages, so the iterative\nestimate closely tracks the final score; use it to iterate quickly, and rely on\nthe final score for the definitive number. (The subset size is the `metrics`\nfield `n_queries`; the full count is `n_queries_full`.)\n", "config": "tag: systems\nruntime:\n  language: rust\n  timeout_seconds: 10800\n  environment: \"Rust project; hidden disk ANN benchmark; Python/NumPy judge\"\n  apt_packages:\n    - build-essential\n    - cargo\n    - git\n    - rustc\n  judge_apt_packages:\n    - build-essential\n    - cargo\n    - rustc\n    - python3-pip\n    - python3-numpy\n  judge_pip_packages:\n    - faiss-cpu\n  docker:\n    # Agent image is the default ubuntu:24.04 (the agent needs no hidden data).\n    # The judge image bakes the SIFT100M benchmark data in; build it before a\n    # local Harbor trial with 2.0/problems/vector_db_ann_disk/docker/build_images.sh.\n    image: ubuntu:24.04\n    judge_image: frontiercs/vector-db-ann-disk-judge:experimental-v1\nenvironment:\n  # If these resource limits change, also update the resource budget text in\n  # readme and harbor/app/README.md so agents can design parallel algorithms\n  # for the actual CPU and memory budget.\n  cpus: 8\n  memory_mb: 8192\n  storage_mb: 8192\n  build_timeout_seconds: 3600\nevaluation:\n  # The judge drives the search service with this many concurrent workers.\n  # Keep this aligned with the CPU budget unless the task is intentionally\n  # changed into a higher-concurrency service benchmark.\n  query_concurrency: 8\n  # Fallback only: the actual timed query count is pinned to the full official\n  # query set via FRONTIER_VECTOR_DB_Q=10000 in docker/judge/Dockerfile, which\n  # overrides this. (The local CI smoke in evaluate.sh sets its own small Q.)\n  queries_per_worker: 64\n# The hidden benchmark data is baked into the custom judge image\n# (runtime.docker.judge_image); the data paths, dtype, N=100,000,000, and\n# Q=10,000 are pinned as ENV in docker/judge/Dockerfile. truth.bin / baseline.json\n# live under /data/private_100M, which is never passed to /load.\nsubmission:\n  kind: directory\n  path: /app\n  exclude:\n    - target\n    - .git\n    - .frontier-cs\n"}
 {"problem_id": "vector_db_ann_relaxed", "category": "2.0", "statement": "# Vector DB ANN Relaxed\n\n## Problem\n\nBuild a fast approximate nearest-neighbor vector search engine for a\nSIFT1M-scale benchmark. This relaxed variant uses the same data, API, resource\nbudget, and recall target as Vector DB ANN, but penalizes load/index-build time\n10x less heavily.\n\nThe hidden benchmark contains exactly `1,000,000` base vectors with dimension\n`128`. Queries use the same dimension, distance is squared Euclidean distance,\nand each query asks for the top `10` nearest vector ids.\n\nYour objective is to maximize serving throughput while preserving search\nquality: submissions must reach `recall@10 >= 0.95`, and valid submissions are\nranked by an effective QPS that includes query time plus a small\nload/index-build penalty.\n\nThe Harbor agent container starts with a small Rust skeleton project in\n`/app`. You may use it, modify it, or replace it entirely. You may also use any\nRust crates, internal harness, data structures, and build layout you want, as\nlong as the final project satisfies the judge contract below.\n\nThe judge builds and runs your service with:\n\n```bash\ncargo build --release\nPORT=<port> cargo run --release --quiet\n```\n\nThe Harbor environment uses the Ubuntu `apt` Rust toolchain:\n\n```text\nrustc 1.75\ncargo 1.75\n```\n\nIf you add crates, choose versions compatible with this toolchain or pin\ntransitive dependencies accordingly.\n\nThe service and judge run with the task resource limits below. Design your\nparallel search and indexing strategy for this budget:\n\n```text\nvCPUs: 8\nmemory: 16 GiB\nquery concurrency: 8\ntimed queries per worker: 64\n```\n\nThe service must listen on `PORT` and implement these endpoints:\n\n```text\nPOST /insert\nPOST /bulk_insert\nPOST /search\n```\n\n`/bulk_insert` receives:\n\n```json\n{\"vectors\":[{\"id\":0,\"vector\":[0.1,0.2,...]}]}\n```\n\nand returns:\n\n```json\n{\"status\":\"ok\",\"inserted\":1}\n```\n\n`/search` receives:\n\n```json\n{\"vector\":[0.1,0.2,...],\"top_k\":10}\n```\n\nand returns:\n\n```json\n{\"results\":[{\"id\":0,\"distance\":0.0}]}\n```\n\n## Local Harness\n\nThe official evaluator uses hidden data and a black-box judge. You may call:\n\n```bash\nbash /app/submit.sh\n```\n\nat any time to submit the current `/app` project to the official judge and get\nscore feedback.\n\n## Validity\n\nA submission is valid if:\n\n1. It builds successfully with `cargo build --release`.\n2. `cargo run --release --quiet` starts the service and implements the required HTTP\n   endpoints.\n3. Every returned id is in `[0, 1_000_000)`.\n4. Its `recall@10` is at least `0.95` against the hidden exact top-10 ground\n   truth.\n\n## Scoring\n\nAt trial startup, the Harbor judge sidecar prepares the hidden benchmark and\nruns an exact-search reference HTTP service through the same `/bulk_insert`\nand `/search` client harnesses to produce ground-truth nearest neighbors and\nthe trial-local scoring baseline:\n\n```text\nbaseline_qps\nbaseline_effective_qps\nbaseline_load_seconds\n```\n\nInteractive submissions and the final verifier both score through this same\njudge sidecar, so the baseline and runtime environment are shared within a\ntrial while still letting different machines measure their own local baseline.\n\nEach submission is then timed independently. The load phase includes all\n`/bulk_insert` calls and any index construction performed by the service before\nqueries begin. The query phase uses 8 concurrent workers, each issuing 64\nqueries, and measures only `/search` throughput:\n\n```text\ncandidate_qps\ncandidate_load_seconds\n```\n\nThe reported `qps` is the raw query-only QPS. Scoring uses an effective QPS\nthat includes a small index-build/load penalty:\n\n```text\neffective_qps = Q / (query_seconds + 0.001 * load_seconds)\n```\n\nThe load phase has a default `900s` timeout. This keeps the benchmark focused\non serving performance while still making very expensive offline indexing pay a\nbounded, explicit cost. This relaxed variant makes the load/index-build penalty\nsmall enough that spending additional time on a stronger index can be worthwhile\nwhen it materially improves query throughput or recall.\n\nDuring evaluation, the load and query phases may stop early and return `0` once\nthe elapsed time plus the load penalty makes it impossible for the final\neffective QPS to beat the baseline. During load, this assumes a best-case query\ntime of zero.\n\nIf the submission is invalid, if `recall@10 < 0.95`, or if\n`candidate_effective_qps <= baseline_effective_qps`, the score is `0`.\nOtherwise:\n\n```text\nscore = 100 * (1 - sqrt(baseline_effective_qps) / sqrt(candidate_effective_qps))\n```\n\nThe bounded and unbounded score fields both report this score. Harbor JSON\nresults include the measured `qps`, `effective_qps`, `baseline_qps`,\n`baseline_effective_qps`, `recall_at_10`, load time, and runtime metrics under\nthe `metrics` field.\n", "config": "tag: systems\nruntime:\n  language: rust\n  timeout_seconds: 10800\n  environment: \"Rust project; hidden ANN benchmark; Python/NumPy judge\"\n  apt_packages:\n    - build-essential\n    - cargo\n    - git\n    - rustc\n  judge_apt_packages:\n    - build-essential\n    - cargo\n    - rustc\n    - python3-pip\n    - python3-numpy\n  judge_pip_packages:\n    - faiss-cpu\n  docker:\n    image: ubuntu:24.04\nenvironment:\n  # If these resource limits change, also update the resource budget text in\n  # readme and harbor/app/README.md so agents can design parallel algorithms\n  # for the actual CPU and memory budget.\n  cpus: 8\n  memory_mb: 16384\n  storage_mb: 8192\n  build_timeout_seconds: 3600\nevaluation:\n  # The judge drives the search service with this many concurrent workers.\n  # Keep this aligned with the CPU budget unless the task is intentionally\n  # changed into a higher-concurrency service benchmark.\n  query_concurrency: 8\n  queries_per_worker: 64\n  # Weight applied to load/index-build time when computing effective QPS.\n  # This relaxed variant rewards stronger indexes by penalizing build time\n  # 10x less than the standard Vector DB ANN task.\n  load_penalty_weight: 0.001\nsubmission:\n  kind: directory\n  path: /app\n  exclude:\n    - target\n    - .git\n    - .frontier-cs\n"}