{"claim":{"id":"e905b1e9-2c0e-4ec4-a2f5-20c5a34b0480","submission_id":"66911635-8bb8-4729-ad83-d479b75f64a1","submission_revision_id":"4696cc42-f72b-4170-8ee8-80818f8b68db","builder":"builder-01","status":"active","claimed_at":"2026-10-15T15:35:12.263122Z","delivered_at":null,"ended_at":null,"delivery_note":null,"end_reason":null},"task":{"submission_id":"66911635-8bb8-4729-ad83-d479b75f64a1","submission_revision_id":"4696cc42-f72b-4170-8ee8-80818f8b68db","revision_version":1,"submission_status":"under_review","submitted_at":"2026-10-01T01:38:59.487660Z","submitter_name":"Jixian Liu","submitter_email":"jliu376@jh.edu","task":{"status":"submitted","version":1,"extra_fields":{"difficulty_self_test":{"estimated_score":"10–20%"}},"submitted_at":"2026-10-01T01:38:59.487660+00:00","industry_domain":"Sports","task_short_name":"cycling_time_trial_pacing","operating_system":"Linux","task_description":"Objective:\nBuild a professional cycling team's time-trial pacing engine. Given one race day - a real course (OpenStreetMap roads, EU-DEM/SRTM elevation), the hourly ERA5 weather of that day, and the rider (individual time trial, ITT) or the team (team time trial, TTT) with their test results - the engine returns the plan with the shortest race time the team's race simulator (ttsim, provided) allows: for an ITT the target power along the course; for a TTT the start order, every turn at the front (who leads, how many metres, rotate or sacrifice the rider) and the power of the rider in front. The evaluator runs the engine on race days the agent never sees (other courses, riders, teams, weather) with a CPU budget per day and compares the race times with those of a reference optimal-control engine.\n\nStarting State:\nAn offline Ubuntu 22.04 VM (8 vCPU, no GPU, no network, sudo) with Python 3.10, NumPy 2.2.6 and SciPy 1.15.3.\n- input/TASK.md: the full brief (race model, plan and engine contracts, deliverables, every check and threshold). input/DATA.md: sources, licences, processing, model references. input/task_contract.json, input/examples/.\n- input/scenarios/dev/: eight development race days (six ITT: a 21.6 km loop at Fuji International Speedway, one and two laps, wet and dry; Heist - Damme - Bruges, 26.2 km; two TTT: Brussels, 22.4 km, eight and six riders), each scenario.json + course.csv + weather.csv; input/dev_reference.json: the reference engine's times on them.\n- software/ttsim/: the race simulator (simulate, profile, baseline) - the evaluator uses an identical copy.\n- output/ is empty.\n\nInstructions & Rules:\nThe race model (ttsim, summarised in TASK.md): course on a 1 m grid; racing line (15 m Gaussian) whose curvature sets corner speeds (friction 0.80 dry / 0.55 wet) and a braking envelope; ERA5 wind reduced to rider height (log profile) and interpolated in time; air density from temperature, humidity, pressure at the rider's elevation; the power balance of Martin et al. (1998); W' balance with recovery below CP (Skiba et al. 2015); available power CP + (Pmax - CP) W'/W'0 (Morton), a pedal-force limit at low speed and a top-gear limit above 18 m/s; TTT: one paceline with position drag factors (leader 0.95, followers 0.67-0.69), the group no faster than every rider in it can follow, 80 m changeovers at full drag, sacrificed riders, the team's time taken on the counted rider (4th of 6, 5th of 8).\nDeliverables:\n- output/engine/: ENGINE.json {\"solve\": [argv with {scenario} and {plan}]} and the engine (Python, NumPy/SciPy only).\n- output/plans/<dev id>.json: the engine's plan for each of the eight development race days.\n- output/results.json: their race times as ttsim simulate reports them.\nRules:\n- The evaluator runs the engine as an unprivileged user without network, one pinned core, ITT 300 CPU-s, TTT 1800 CPU-s, 4 GB, read-only engine and race-day copies; a killed or failing engine fails that race day.\n- The engine must be reproducible (a re-run on a development day within 0.2 % of the delivered plan's time).\n- No network. Do not modify input/, software/ or the Python installation. Time budget: 8 hours.","software_licensing":"Free/Open Source","evaluation_criteria":null,"verification_method":"The evaluator (included: evaluation/main.py and evaluation/scripts/grader/) runs on the VM as root after the agent has finished. It only scores race times it computed itself, against a hidden reference staged only after the agent is done.\n\nGates (score 0 if any fails):\n- numpy, scipy and python3.10 are unmodified (every file of the imported distributions matches its pip RECORD hash; dpkg --verify).\n- output/ contains no links or special files; output/engine/ENGINE.json is valid.\n\nRe-execution:\n- The engine is copied to a root-owned read-only place and run on each of the 14 hidden race days (10 ITT, 4 TTT: other real courses - Paris, Lure - La Planche des Belles Filles, Wattens - Innsbruck, Ripon - Harrogate, Vannes - Plumelec, Lusail - The Pearl - other riders, teams and ERA5 weather, some wet) and re-run on one ITT and one TTT development day.\n- Each run: unprivileged user, no network, one pinned CPU core, ITT 300 CPU-s / TTT 1800 CPU-s, 4 GB; a killed or failing run fails that day.\n- Every plan is validated and simulated with the evaluator's own copy of the race simulator ttsim.\n\nChecks (weights in brackets):\nStage 1, individual time trials:\n- each hidden ITT day: a valid plan at most 0.25 % slower than the reference time of that day [1 each]\n- development evidence [1]: the six ITT development plans valid, results.json within 0.05 s of the simulation, each within 0.25 % of the published reference time, and the engine re-run on dev_itt_fuji_w01 within 0.2 % of the delivered plan\nStage 2, team time trials:\n- each hidden TTT day: a valid plan at most 0.75 % slower than the reference time [1 each]\n- development evidence [1]: the two TTT development plans, same conditions, re-run on dev_ttt_brussels_w6\n\nScoring:\n- S1, S2 = weighted fraction of each stage's passed checks.\n- Score = 0.3 x (0.5 x S1 + 0.5 x S2) + 0.7 x [every check passed]. A team needs an engine it can trust on every race day, so the completion share goes only to an engine that passes everything.\n\nReference and thresholds:\n- The reference time of a race day is the fastest valid plan any of our tools found (the reference engine, its offline searches, calibration variants), re-simulated. The delivered reference engine is within 0.022 % (ITT) and 0.215 % (TTT) of it on every day, runs in 46-83 CPU-s (ITT) and 405-730 CPU-s (TTT), and scores 1.0 with the included evaluator (expert_output/evaluator_report.json), also in a full local ALE flow on an emulated offline Ubuntu 22.04 VM.\n- The TTT limit is wider than the ITT one because the schedule search is combinatorial: our own engine's TTT times move by up to 0.45 % when the wind is perturbed by 1e-9; the ITT solver moves by < 0.02 %.\n- Weaker solutions score 0-0.23: the same engine on a 40 m grid 0.23 (misses 4 of 10 hidden ITT days: corners), a perfect ITT with a team strategy that sacrifices nobody 0.18, with equal turns 0.15, a simulator-tuned heuristic 0.00, the baseline 0.00. The record is in reference/protocol.json (\"calibration\")","software_and_version":"Python 3.10, NumPy 2.2.6, SciPy 1.15.3 (the task's own race simulator ttsim is included)","specific_requirements":null,"expected_completion_time":null},"files":[{"file_id":"4231ca95-b26a-455d-9730-4c0a2e829ced","filename":"inputs.zip","category":"input_materials","content_type":"application/x-zip-compressed","size_bytes":249883},{"file_id":"ed620252-04e9-45b1-8863-4ac9f495cdd4","filename":"reference_and_evaluation.zip","category":"reference_output","content_type":"application/x-zip-compressed","size_bytes":839434}],"deep_review":{"overall_verdict":"Strong Accept","review_text":"**Overall Verdict:** Strong Accept — The submission is complete, professionally scoped, safely packaged, objectively graded, and demonstrably achievable within the stated environment and resource limits.\n\n**Completeness Check:**\n- Instruction: Complete — The objective, race model, solver behavior, output contracts, runtime constraints, reproducibility requirement, and end state are explicit.\n- Inputs: Complete — Eight development scenarios include readable scenario, course, and weather data with documented schemas, units, provenance, processing, and licenses; all records inspected were structurally consistent with no missing fields.\n- Toolchain: Complete — The offline Ubuntu, Python, NumPy, and SciPy environment is specified, and the supplied simulator is documented and byte-identical to the evaluator’s copy.\n- Reference output: Complete — The protected package contains the reference engine, development and hidden reference plans, reported results, protocol, successful evaluator report, calibration evidence, and negative controls.\n- Rubric: Complete — Gates, thresholds, stage weights, scoring formula, hidden tests, development checks, CPU and memory limits, and reproducibility checks are precise and implemented consistently by the evaluator.\n\n**File and Task Reachability:**\nAttachment classification: reachable. Task classification: reachable. Both `inputs.zip` and `reference_and_evaluation.zip` were inspected. Their downloaded sizes matched the manifest; both were valid, unencrypted ZIP archives with safe member paths, regular-file entries, valid UTF-8 content, and successful integrity tests. All JSON members parsed, all CSV members were checked for headers, dimensions, malformed rows, and missing values, and all submitted and reference plans passed static structural checks. The review covered `TASK.md`, `DATA.md`, the task contract and examples, all scenario/course/weather datasets, simulator sources, protocol, evaluator and sandbox logic, expert outputs, reference plans, calibration data, and negative-control results. Auxiliary build and test source was inventoried but not reviewed line by line, and no uploaded program was executed. Solver-visible inputs contain development data and times only; hidden scenarios, plans, and reference times are separately staged and sealed for evaluation. The completion path is coherent: implement and package the engine, generate eight development plans and results, then have the evaluator rerun it on 14 hidden and two development scenarios and independently validate and simulate every plan. The supplied expert run scored 1.0, passed every gate and weighted check, and remained within the stated CPU limits. License keys, accounts, tokens, and other credentials are not required from the contributor. Confidential, proprietary, or internal material may be evaluated as submitted evidence without requiring additional disclosure.\n\n**Special Screening:**\nNone. No affirmative evidence supports an AI-synthetic core, a publicly identifiable benchmark, or a synthetic-defect fixture. External public-identifiability was not independently searched under the review boundary.\n\n**Recommended Changes:**\nThe submission already provides unusually strong contracts, data provenance, evaluator isolation, calibration, negative controls, and successful end-to-end evidence. No changes are required.","reviewed_at":"2026-10-01T01:46:44.228752Z"},"claim":{"id":"e905b1e9-2c0e-4ec4-a2f5-20c5a34b0480","submission_id":"66911635-8bb8-4729-ad83-d479b75f64a1","submission_revision_id":"4696cc42-f72b-4170-8ee8-80818f8b68db","builder":"builder-01","status":"active","claimed_at":"2026-10-15T15:35:12.263122Z","delivered_at":null,"ended_at":null,"delivery_note":null,"end_reason":null}},"revision_is_current":true}