diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000000000000000000000000000000000000..659a91655d41add13e7a1cc3caf806c33724158b
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,6 @@
+assets/edgebench_taxonomy.png filter=lfs diff=lfs merge=lfs -text
+assets/fig_dual_loop.png filter=lfs diff=lfs merge=lfs -text
+assets/fig_full_136_curve_fit_side_by_side.png filter=lfs diff=lfs merge=lfs -text
+assets/fig_rank_paper_panel.png filter=lfs diff=lfs merge=lfs -text
+assets/logo.jpg filter=lfs diff=lfs merge=lfs -text
+assets/time_area_log2_curve.png filter=lfs diff=lfs merge=lfs -text
diff --git a/BENCHMARK.yaml b/BENCHMARK.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..089eec108c21d6196d812524fc328252f0b39ccd
--- /dev/null
+++ b/BENCHMARK.yaml
@@ -0,0 +1,130 @@
+name: edgebench
+base_images:
+ java:
+ official_image: maven:3.9-eclipse-temurin-17
+ extra_packages:
+ - git
+ - curl
+ - jq
+ - build-essential
+ - ant
+ - unzip
+ - python3
+ rust:
+ official_image: rust:1.78
+ extra_packages:
+ - git
+ - curl
+ - jq
+ - build-essential
+ python:
+ official_image: python:3.11
+ extra_packages:
+ - git
+ - curl
+ - jq
+ - build-essential
+ python310:
+ official_image: python:3.10
+ extra_packages:
+ - git
+ - curl
+ - jq
+ - build-essential
+ cpp:
+ official_image: ubuntu:22.04
+ extra_packages:
+ - git
+ - curl
+ - jq
+ - build-essential
+ - cmake
+ - gcc
+ - g++
+ - libffi-dev
+ - pkg-config
+ - ca-certificates
+ coq:
+ official_image: coqorg/coq:8.20
+ extra_packages:
+ - git
+ - curl
+ - jq
+ - build-essential
+ - gcc
+ - g++
+ - python3
+ - make
+ - procps
+ user_directive: 'USER root
+
+ '
+ post_install_directive: 'ENV PATH="/home/coq/.opam/${COMPILER}/bin:${PATH}"
+
+ RUN chmod -R a+rX /home/coq/.opam
+
+ ENTRYPOINT []
+
+ '
+ lean_4_28_0_main:
+ official_image: ubuntu:22.04
+ extra_packages:
+ - git
+ - curl
+ - jq
+ - build-essential
+ - gcc
+ - g++
+ - python3
+ - make
+ - procps
+ - ca-certificates
+ user_directive: 'USER root
+
+ '
+ post_install_directive: 'ENV ELAN_HOME=/opt/elan
+
+ ENV PATH="/opt/elan/bin:${PATH}"
+
+ RUN mkdir -p /opt/elan && chown -R agent:agent /opt/elan
+
+ RUN curl https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh
+ -sSf | env ELAN_HOME=/opt/elan sh -s -- -y --default-toolchain none
+
+ WORKDIR /home/workspace
+
+ RUN lake +leanprover/lean4:v4.28.0 new baseline math
+
+ ENTRYPOINT []
+
+ '
+ lean_4:
+ official_image: ubuntu:22.04
+ extra_packages:
+ - git
+ - curl
+ - jq
+ - build-essential
+ - gcc
+ - g++
+ - python3
+ - make
+ - procps
+ - ca-certificates
+ user_directive: 'USER root
+
+ '
+ post_install_directive: 'ENV ELAN_HOME=/opt/elan
+
+ ENV PATH="/opt/elan/bin:${PATH}"
+
+ RUN mkdir -p /opt/elan && chown -R agent:agent /opt/elan
+
+ RUN curl https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh
+ -sSf | env ELAN_HOME=/opt/elan sh -s -- -y --default-toolchain none
+
+ WORKDIR /home/workspace
+
+ ENTRYPOINT []
+
+ '
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..2f8f0e41ff1e41e88504d5fc056ed3a299e60922
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,360 @@
+Attribution 4.0 International
+
+=======================================================================
+
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of Creative
+Commons public licenses does not create a lawyer-client or other
+relationship. Creative Commons makes its licenses and related information
+available on an "as-is" basis. Creative Commons gives no warranties
+regarding its licenses, any material licensed under their terms and
+conditions, or any related information. Creative Commons disclaims all
+liability for damages resulting from their use to the fullest extent
+possible.
+
+Using Creative Commons Public Licenses
+
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright and
+certain other rights specified in the public license below. The following
+considerations are for informational purposes only, are not exhaustive,
+and do not form part of our licenses.
+
+ Considerations for licensors: Our public licenses are intended for
+ use by those authorized to give the public permission to use material
+ in ways otherwise restricted by copyright and certain other rights.
+ Our licenses are irrevocable. Licensors should read and understand
+ the terms and conditions of the license they choose before applying
+ it. Licensors should also secure all rights necessary before applying
+ our licenses so that the public can reuse the material as expected.
+ Licensors should clearly mark any material not subject to the license.
+ This includes other CC-licensed material, or material used under an
+ exception or limitation to copyright. More considerations for
+ licensors:
+ wiki.creativecommons.org/Considerations_for_licensors
+
+ Considerations for the public: By using one of our public licenses,
+ a licensor grants the public permission to use the licensed material
+ under specified terms and conditions. If the licensor's permission is
+ not necessary for any reason--for example, because of any applicable
+ exception or limitation to copyright--then that use is not regulated
+ by the license. Our licenses grant only permissions under copyright
+ and certain other rights that a licensor has authority to grant. Use
+ of the licensed material may still be restricted for other reasons,
+ including because others have copyright or other rights in the
+ material. A licensor may make special requests, such as asking that
+ all changes be marked or described. Although not required by our
+ licenses, you are encouraged to respect those requests where
+ reasonable. More considerations for the public:
+ wiki.creativecommons.org/Considerations_for_licensees
+
+=======================================================================
+
+Creative Commons Attribution 4.0 International Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution 4.0 International Public License ("Public License"). To the
+extent this Public License may be interpreted as a contract, You are
+granted the Licensed Rights in consideration of Your acceptance of these
+terms and conditions, and the Licensor grants You such rights in
+consideration of benefits the Licensor receives from making the Licensed
+Material available under these terms and conditions.
+
+Section 1 -- Definitions.
+
+a. Adapted Material means material subject to Copyright and Similar Rights
+ that is derived from or based upon the Licensed Material and in which
+ the Licensed Material is translated, altered, arranged, transformed, or
+ otherwise modified in a manner requiring permission under the Copyright
+ and Similar Rights held by the Licensor. For purposes of this Public
+ License, where the Licensed Material is a musical work, performance, or
+ sound recording, Adapted Material is always produced where the Licensed
+ Material is synched in timed relation with a moving image.
+
+b. Adapter's License means the license You apply to Your Copyright and
+ Similar Rights in Your contributions to Adapted Material in accordance
+ with the terms and conditions of this Public License.
+
+c. Copyright and Similar Rights means copyright and/or similar rights
+ closely related to copyright including, without limitation, performance,
+ broadcast, sound recording, and Sui Generis Database Rights, without
+ regard to how the rights are labeled or categorized. For purposes of
+ this Public License, the rights specified in Section 2(b)(1)-(2) are
+ not Copyright and Similar Rights.
+
+d. Effective Technological Measures means those measures that, in the
+ absence of proper authority, may not be circumvented under laws
+ fulfilling obligations under Article 11 of the WIPO Copyright Treaty
+ adopted on December 20, 1996, and/or similar international agreements.
+
+e. Exceptions and Limitations means fair use, fair dealing, and/or any
+ other exception or limitation to Copyright and Similar Rights that
+ applies to Your use of the Licensed Material.
+
+f. Licensed Material means the artistic or literary work, database, or
+ other material to which the Licensor applied this Public License.
+
+g. Licensed Rights means the rights granted to You subject to the terms
+ and conditions of this Public License, which are limited to all
+ Copyright and Similar Rights that apply to Your use of the Licensed
+ Material and that the Licensor has authority to license.
+
+h. Licensor means the individual(s) or entity(ies) granting rights under
+ this Public License.
+
+i. Share means to provide material to the public by any means or process
+ that requires permission under the Licensed Rights, such as reproduction,
+ public display, public performance, distribution, dissemination,
+ communication, or importation, and to make material available to the
+ public including in ways that members of the public may access the
+ material from a place and at a time individually chosen by them.
+
+j. Sui Generis Database Rights means rights other than copyright resulting
+ from Directive 96/9/EC of the European Parliament and of the Council of
+ 11 March 1996 on the legal protection of databases, as amended and/or
+ succeeded, as well as other essentially equivalent rights anywhere in
+ the world.
+
+k. You means the individual or entity exercising the Licensed Rights under
+ this Public License. Your has a corresponding meaning.
+
+Section 2 -- Scope.
+
+a. License grant.
+
+ 1. Subject to the terms and conditions of this Public License, the
+ Licensor hereby grants You a worldwide, royalty-free,
+ non-sublicensable, non-exclusive, irrevocable license to exercise
+ the Licensed Rights in the Licensed Material to:
+
+ A. reproduce and Share the Licensed Material, in whole or in part;
+ and
+
+ B. produce, reproduce, and Share Adapted Material.
+
+ 2. Exceptions and Limitations. For the avoidance of doubt, where
+ Exceptions and Limitations apply to Your use, this Public License
+ does not apply, and You do not need to comply with its terms and
+ conditions.
+
+ 3. Term. The term of this Public License is specified in Section 6(a).
+
+ 4. Media and formats; technical modifications allowed. The Licensor
+ authorizes You to exercise the Licensed Rights in all media and
+ formats whether now known or hereafter created, and to make technical
+ modifications necessary to do so. The Licensor waives and/or agrees
+ not to assert any right or authority to forbid You from making
+ technical modifications necessary to exercise the Licensed Rights,
+ including technical modifications necessary to circumvent Effective
+ Technological Measures. For purposes of this Public License, simply
+ making modifications authorized by this Section 2(a)(4) never
+ produces Adapted Material.
+
+ 5. Downstream recipients.
+
+ A. Offer from the Licensor -- Licensed Material. Every recipient of
+ the Licensed Material automatically receives an offer from the
+ Licensor to exercise the Licensed Rights under the terms and
+ conditions of this Public License.
+
+ B. No downstream restrictions. You may not offer or impose any
+ additional or different terms or conditions on, or apply any
+ Effective Technological Measures to, the Licensed Material if doing
+ so restricts exercise of the Licensed Rights by any recipient of
+ the Licensed Material.
+
+ 6. No endorsement. Nothing in this Public License constitutes or may be
+ construed as permission to assert or imply that You are, or that Your
+ use of the Licensed Material is, connected with, or sponsored,
+ endorsed, or granted official status by, the Licensor or others
+ designated to receive attribution as provided in Section 3(a)(1)(A)(i).
+
+b. Other rights.
+
+ 1. Moral rights, such as the right of integrity, are not licensed under
+ this Public License, nor are publicity, privacy, and/or other similar
+ personality rights; however, to the extent possible, the Licensor
+ waives and/or agrees not to assert any such rights held by the
+ Licensor to the limited extent necessary to allow You to exercise the
+ Licensed Rights, but not otherwise.
+
+ 2. Patent and trademark rights are not licensed under this Public
+ License.
+
+ 3. To the extent possible, the Licensor waives any right to collect
+ royalties from You for the exercise of the Licensed Rights, whether
+ directly or through a collecting society under any voluntary or
+ waivable statutory or compulsory licensing scheme. In all other cases
+ the Licensor expressly reserves any right to collect such royalties.
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+a. Attribution.
+
+ 1. If You Share the Licensed Material (including in modified form), You
+ must:
+
+ A. retain the following if it is supplied by the Licensor with the
+ Licensed Material:
+
+ i. identification of the creator(s) of the Licensed Material and
+ any others designated to receive attribution, in any reasonable
+ manner requested by the Licensor (including by pseudonym if
+ designated);
+
+ ii. a copyright notice;
+
+ iii. a notice that refers to this Public License;
+
+ iv. a notice that refers to the disclaimer of warranties;
+
+ v. a URI or hyperlink to the Licensed Material to the extent
+ reasonably practicable;
+
+ B. indicate if You modified the Licensed Material and retain an
+ indication of any previous modifications; and
+
+ C. indicate the Licensed Material is licensed under this Public
+ License, and include the text of, or the URI or hyperlink to, this
+ Public License.
+
+ 2. You may satisfy the conditions in Section 3(a)(1) in any reasonable
+ manner based on the medium, means, and context in which You Share the
+ Licensed Material. For example, it may be reasonable to satisfy the
+ conditions by providing a URI or hyperlink to a resource that includes
+ the required information.
+
+ 3. If requested by the Licensor, You must remove any of the information
+ required by Section 3(a)(1)(A) to the extent reasonably practicable.
+
+ 4. If You Share Adapted Material You produce, the Adapter's License You
+ apply must not prevent recipients of the Adapted Material from
+ complying with this Public License.
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that apply
+to Your use of the Licensed Material:
+
+a. for the avoidance of doubt, Section 2(a)(1) grants You the right to
+ extract, reuse, reproduce, and Share all or a substantial portion of the
+ contents of the database;
+
+b. if You include all or a substantial portion of the database contents in
+ a database in which You have Sui Generis Database Rights, then the
+ database in which You have Sui Generis Database Rights (but not its
+ individual contents) is Adapted Material; and
+
+c. You must comply with the conditions in Section 3(a) if You Share all or
+ a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not replace
+Your obligations under this Public License where the Licensed Rights include
+other Copyright and Similar Rights.
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE EXTENT
+ POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS AND
+ AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND
+ CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS, IMPLIED, STATUTORY,
+ OR OTHER. THIS INCLUDES, WITHOUT LIMITATION, WARRANTIES OF TITLE,
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT,
+ ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OR
+ ABSENCE OF ERRORS, WHETHER OR NOT KNOWN OR DISCOVERABLE. WHERE
+ DISCLAIMERS OF WARRANTIES ARE NOT ALLOWED IN FULL OR IN PART, THIS
+ DISCLAIMER MAY NOT APPLY TO YOU.
+
+b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE TO YOU
+ ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION, NEGLIGENCE) OR
+ OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT, INCIDENTAL, CONSEQUENTIAL,
+ PUNITIVE, EXEMPLARY, OR OTHER LOSSES, COSTS, EXPENSES, OR DAMAGES
+ ARISING OUT OF THIS PUBLIC LICENSE OR USE OF THE LICENSED MATERIAL,
+ EVEN IF THE LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+ LOSSES, COSTS, EXPENSES, OR DAMAGES. WHERE A LIMITATION OF LIABILITY IS
+ NOT ALLOWED IN FULL OR IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+c. The disclaimer of warranties and limitation of liability provided above
+ shall be interpreted in a manner that, to the extent possible, most
+ closely approximates an absolute disclaimer and waiver of all liability.
+
+Section 6 -- Term and Termination.
+
+a. This Public License applies for the term of the Copyright and Similar
+ Rights licensed here. However, if You fail to comply with this Public
+ License, then Your rights under this Public License terminate
+ automatically.
+
+b. Where Your right to use the Licensed Material has terminated under
+ Section 6(a), it reinstates:
+
+ 1. automatically as of the date the violation is cured, provided it is
+ cured within 30 days of Your discovery of the violation; or
+
+ 2. upon express reinstatement by the Licensor.
+
+ For the avoidance of doubt, this Section 6(b) does not affect any right
+ the Licensor may have to seek remedies for Your violations of this Public
+ License.
+
+c. For the avoidance of doubt, the Licensor may also offer the Licensed
+ Material under separate terms or conditions or stop distributing the
+ Licensed Material at any time; however, doing so will not terminate this
+ Public License.
+
+d. Sections 1, 5, 6, 7, and 8 survive termination of this Public License.
+
+Section 7 -- Other Terms and Conditions.
+
+a. The Licensor shall not be bound by any additional or different terms or
+ conditions communicated by You unless expressly agreed.
+
+b. Any arrangements, understandings, or agreements regarding the Licensed
+ Material not stated herein are separate from and independent of the
+ terms and conditions of this Public License.
+
+Section 8 -- Interpretation.
+
+a. For the avoidance of doubt, this Public License does not, and shall not
+ be interpreted to, reduce, limit, restrict, or impose conditions on any
+ use of the Licensed Material that could lawfully be made without
+ permission under this Public License.
+
+b. To the extent possible, if any provision of this Public License is deemed
+ unenforceable, it shall be automatically reformed to the minimum extent
+ necessary to make it enforceable. If the provision cannot be reformed,
+ it shall be severed from this Public License without affecting the
+ enforceability of the remaining terms and conditions.
+
+c. No term or condition of this Public License will be waived and no failure
+ to comply consented to unless expressly agreed to by the Licensor.
+
+d. Nothing in this Public License constitutes or may be interpreted as a
+ limitation upon, or waiver of, any privileges and immunities that apply
+ to the Licensor or You, including from the legal processes of any
+ jurisdiction or authority.
+
+=======================================================================
+
+Creative Commons is not a party to its public licenses.
+Notwithstanding, Creative Commons may elect to apply one of its public
+licenses to material it publishes and in those instances will be considered
+the "Licensor." The text of the Creative Commons public licenses is
+dedicated to the public domain under the CC0 Public Domain Dedication.
+Except for the limited purpose of indicating that material is shared under
+a Creative Commons public license or as otherwise permitted by the Creative
+Commons policies published at creativecommons.org/policies, Creative
+Commons does not authorize the use of the trademark "Creative Commons" or
+any other trademark or logo of Creative Commons without its prior written
+consent including, without limitation, in connection with any unauthorized
+modifications to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For the
+avoidance of doubt, this paragraph does not form part of the public
+licenses.
+
+Creative Commons may be contacted at creativecommons.org.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..8ccf117ca461cf56b2266632a9698d4b8b9daa4d
--- /dev/null
+++ b/README.md
@@ -0,0 +1,208 @@
+---
+license: cc-by-4.0
+task_categories:
+ - text-generation
+language:
+ - en
+pretty_name: EdgeBench
+size_categories:
+ - n<1K
+tags:
+ - benchmark
+ - code-agents
+ - evaluation
+ - long-horizon
+viewer: false
+---
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+## Overview
+
+**EdgeBench** is a benchmark of **134 real-world tasks** for evaluating how autonomous AI agents *learn from real-world environments*. Instead of measuring one-shot performance, EdgeBench places agents in executable task environments with realistic, multi-level feedback and lets them iterate for **12+ hours** per task — tracking the full trajectory of improvement, not just the final score. We publicly release **51 tasks** along with the full evaluation framework.
+
+Analyzing ~38,000 hours of agent interaction on all 134 tasks, we find that **performance follows a log-sigmoid scaling law as a function of interaction time** ($R^2 = 0.998$). See the [tech report](https://edge-bench.org/paper.pdf) for details.
+
+
+
+## Evaluation Harness: SForge
+
+EdgeBench is powered by [**SForge**](https://github.com/ByteDance-Seed/EdgeBench), a two-container evaluation harness built for long-horizon agent evaluation. See the [SForge documentation](https://bytedance-seed.github.io/EdgeBench/) for setup and usage instructions.
+
+## Citation
+
+If you find EdgeBench useful in your research, please cite our tech report:
+
+```bibtex
+@misc{edgebench2026,
+ title = {EdgeBench: Unveiling Scaling Laws of Learning from Real-World Environments},
+ author = {Deyao Zhu and Xin Zhou and Shengling Qin and Xuekai Zhu and Hangliang Ding and Shu Zhong and others},
+ year = {2026},
+ url = {https://edge-bench.org/paper.pdf},
+}
+```
+
+## License
+
+EdgeBench task datasets are released under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/).
+
+## Contact
+
+> To evaluate on the full 134-task suite, please contact [zhongshu@bytedance.com](mailto:zhongshu@bytedance.com).
+
+
diff --git a/ad_placement_optimization.json b/ad_placement_optimization.json
new file mode 100644
index 0000000000000000000000000000000000000000..c4cb1149e6a00348315b3c64bcce0c1301d37cc1
--- /dev/null
+++ b/ad_placement_optimization.json
@@ -0,0 +1,32 @@
+{
+ "task_id": "ad_placement_optimization",
+ "name": "Ad Placement Optimization",
+ "category": "Combinatorial Optimization",
+ "base_image": "cpp",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/ad-placement",
+ "submit_paths": [
+ "solution.cpp"
+ ],
+ "work": {
+ "image_tag": "49747cad3ebd",
+ "specs_dir": "/home/workspace/ad-placement",
+ "agent_query": "## Ad Placement Optimization\n\nYou need to place rectangular ads for n companies on a 10000x10000 grid.\n\nEach company i wants an ad space containing point (x_i+0.5, y_i+0.5) with area as close to r_i as possible. Maximize the total satisfaction.\n\nFull problem description, constraints, scoring formula, and input/output format are in `README.md`.\n\n## Local Testing Tools\n\n`tools/` provides an input generator and scoring program. The generator reads a seed file and writes generated cases into a directory; it does not accept a raw seed directly.\n\n```bash\n# Generate one test input\nprintf '0\\n' > /tmp/seeds.txt\nrm -rf /tmp/ad_cases && mkdir -p /tmp/ad_cases\n./tools/bin/gen /tmp/seeds.txt -d /tmp/ad_cases\ncp /tmp/ad_cases/0000.txt input.txt\n\n# Run your solution\n./my_solution < input.txt > output.txt\n\n# Score it\n./tools/bin/tester input.txt output.txt\n# stderr: Score = \n```\n\nFor multiple local cases, put one seed per line in the seed file, for example `seq 0 9 > /tmp/seeds.txt`, then run `./tools/bin/gen /tmp/seeds.txt -d /tmp/ad_cases`.\n\nYou can generate unlimited test data with any seed value. Use this extensively for local testing and optimization.\n\n## Compilation\n\nRecommended: C++17 with `g++ -std=c++17 -O2`.\n\nTime limit: 5 seconds per test case. Memory limit: 1 GB. No GPU.\n\n## Rules\n\n- Write your solution as a single C++ file in the project root directory\n- Do NOT modify files in `tools/`\n- Use `tools/bin/gen` with a seed file and `tools/bin/tester` for local testing\n- Your program should read from stdin and write to stdout\n- Run your solution to completion and verify with the tester before finishing"
+ },
+ "judge": {
+ "image_tag": "56cbfc81cfa1",
+ "eval_cmd": "cd /home/workspace/ad-placement && bash /tmp/eval_ahc.sh",
+ "eval_timeout": 600,
+ "parser": "score_sum",
+ "score_direction": "maximize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "piecewise_max",
+ "baseline": 0.0,
+ "rank30": 47169682940.0,
+ "rank1": 49702568341.0,
+ "super_anchor": 50000000000.0
+ }
+ }
+}
diff --git a/anchorhead_text_adventure.json b/anchorhead_text_adventure.json
new file mode 100644
index 0000000000000000000000000000000000000000..19e67272af60a4f84dbc3a894db1ac734822aa8b
--- /dev/null
+++ b/anchorhead_text_adventure.json
@@ -0,0 +1,29 @@
+{
+ "task_id": "anchorhead_text_adventure",
+ "name": "Anchorhead Text Adventure",
+ "category": "Interactive Games & Simulators",
+ "base_image": "python310",
+ "platform": "linux/amd64",
+ "internet": false,
+ "game_mode": true,
+ "cwd": "/home/jericho_agent",
+ "submit_paths": [],
+ "work": {
+ "image_tag": "61ded5caecc2",
+ "specs_dir": "/home/jericho_agent",
+ "agent_query": "## Anchorhead — Jericho Text Adventure\n\nPlay the interactive fiction game *Anchorhead* by sending commands via an HTTP API and maximize your score.\n"
+ },
+ "judge": {
+ "image_tag": "356542b1bce0",
+ "eval_cmd": "",
+ "eval_timeout": 600,
+ "parser": "",
+ "selection": "score_first",
+ "game_server_cmd": "python /tmp/game_server_app.py --rom /home/roms/anchor.z8",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 100.0
+ }
+ }
+}
diff --git a/ann_vector_search_qps.json b/ann_vector_search_qps.json
new file mode 100644
index 0000000000000000000000000000000000000000..4f1b671c284422a0be9551c88ef32ed789d5f58b
--- /dev/null
+++ b/ann_vector_search_qps.json
@@ -0,0 +1,30 @@
+{
+ "task_id": "ann_vector_search_qps",
+ "name": "Ann Vector Search Qps",
+ "category": "Systems & Software Engineering",
+ "base_image": "python310",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/ann-benchmarks",
+ "submit_paths": [
+ "ann_benchmarks/algorithms/custom/"
+ ],
+ "work": {
+ "image_tag": "74bf3ba9a919",
+ "specs_dir": "/home/workspace/ann-benchmarks",
+ "agent_query": "## Role\n\nYou are an expert in approximate nearest neighbor (ANN) search. Your job is to maximize **QPS** (queries per second) on the SIFT-1M dataset (1M × 128-d vectors, 10K queries) under the ann-benchmarks framework, while keeping **Recall@10 ≥ 0.95**.\n\n---\n\n## Repository Layout\n\n- `run.py` — evaluation driver (already present)\n- `ann_benchmarks/algorithms/` — algorithm plugins; each algorithm subclasses `BaseANN` and registers in its own `config.yml`\n- `ann_benchmarks/algorithms/custom/` — **your** slot; contains a baseline `module.py` (brute-force numpy) and a `config.yml` naming the algorithm `custom`\n- `data/sift-128-euclidean.hdf5` — dataset (pre-downloaded, contains `train` and `test` arrays)\n\n---\n\n## What To Do\n\n1. Read `README.md`, `ann_benchmarks/algorithms/README.md`, and look at existing algorithms (e.g. `ann_benchmarks/algorithms/faiss/`) for reference implementations.\n2. Improve `ann_benchmarks/algorithms/custom/module.py` — implement a faster `fit()` + `query()` using FAISS (`faiss-cpu` is pre-installed) or a custom implementation. Keep the class name `Custom` and the module path `ann_benchmarks.algorithms.custom`.\n3. You may tune hyperparameters via `ann_benchmarks/algorithms/custom/config.yml` (IVF nlist, HNSW M/efConstruction, PQ subquantizers, etc.).\n4. For local runs after each change:\n ```bash\n python run.py --local --algorithm custom --dataset sift-128-euclidean -k 10 --runs 1 --run-disabled\n ```\n The benchmark prints QPS and recall metrics to the console. Use these to track your progress.\n\n---\n\n## Optimization Directions (suggestions)\n\n- IVF bucketing (nlist, nprobe)\n- HNSW (M, ef, efConstruction)\n- Product Quantization (subquantizers, bits)\n- Two-level routing (IVF-HNSW, IVF-PQ)\n- Early termination on candidate scan\n- Multi-threaded search (omp_set_num_threads)\n\nGLM-5.1 reference: 3108 QPS → 21472 QPS (6.9×) over 655 iterations.\n\n---\n\n## Scoring Integrity (CRITICAL)\n\nThe evaluation system independently measures query latency and verifies search results against the ground truth. Your score is determined by the actual search performance of your algorithm.\n\nYou must NOT:\n- Read or access ground truth data (the `neighbors` dataset) during query execution\n- Override timing attributes or manipulate benchmark measurements (e.g., via `get_additional()`)\n- Monkey-patch the `time` module or any benchmark framework internals\n- Attempt to fabricate or inflate scores through any means other than legitimate algorithmic improvements\n\nAny attempt to manipulate scores will result in score=0 and the submission marked as hack.\n\n---\n\n## Rules\n\n- Keep the algorithm name `custom` and leave its config discoverable via `python run.py --list-algorithms`\n- Do NOT modify `run.py` or any file outside `ann_benchmarks/algorithms/custom/`\n- Recall@10 < 0.95 on a config makes that config invalid (score = 0)\n- Final score is the **highest QPS** among valid (recall-passing) configs\n"
+ },
+ "judge": {
+ "image_tag": "9171f6b6de41",
+ "eval_cmd": "cd /home/workspace/ann-benchmarks && python3 /tmp/eval_ann_search.py",
+ "eval_timeout": 7800,
+ "parser": "score_sum",
+ "score_direction": "maximize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "log_max",
+ "baseline": 3108.0,
+ "expert": 21472.0
+ }
+ }
+}
diff --git a/apple_incremental_game.json b/apple_incremental_game.json
new file mode 100644
index 0000000000000000000000000000000000000000..66e3df6de5b441895529569ac0674f295341a713
--- /dev/null
+++ b/apple_incremental_game.json
@@ -0,0 +1,32 @@
+{
+ "task_id": "apple_incremental_game",
+ "name": "Apple Incremental Game",
+ "category": "Combinatorial Optimization",
+ "base_image": "python310",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/apple_incremental_game",
+ "submit_paths": [
+ "solution.py"
+ ],
+ "work": {
+ "image_tag": "d3c6ed381c59",
+ "specs_dir": "/home/workspace/apple_incremental_game",
+ "agent_query": "## Apple Incremental Game - Machine Production (AHC058)\n\nWrite `solution.py` in the project root that reads from stdin and writes to stdout.\n\n---\n\n## Problem Overview\n\nRead `README.md` and `tools/README.md` for full problem details. A baseline `solution.py` already exists (it produces syntactically valid but low-quality output). Your job is to improve it.\n\n---\n\n## Evaluation\n\nYour solution is scored on **50 fixed test cases**. Final score = sum of individual case scores. **Higher is better.**\n\n---\n\n## Local Testing\n\nGenerate local random tests with `./tools/bin/gen `, using seeds in the range **0..10000** only.\n\n```bash\n# Generate a random test case (seed-based, deterministic)\n./tools/bin/gen 0 > input.txt\n\n# Run your solution\npython3 solution.py < input.txt > output.txt\n\n# Score output (Higher is better)\n./tools/bin/tester input.txt output.txt\n# Outputs to stderr: Score = \n```\n\n---\n\n## Rules\n\n- Write your solution as `solution.py` in the project root directory\n- Do NOT modify files in `tools/`\n- Use `tools/bin/gen` and `tools/bin/tester` for local testing\n- For local scoring, use only `./tools/bin/tester`; do not use `tools/src/verifier.py` for scores\n- Your program should read from stdin and write to stdout\n- Run your solution to completion and verify with the tester before finishing\n"
+ },
+ "judge": {
+ "image_tag": "16968d8ec7f2",
+ "eval_cmd": "cd /home/workspace/apple_incremental_game && python3 /tmp/eval_apple_incremental_game.py",
+ "eval_timeout": 600,
+ "parser": "score_sum",
+ "score_direction": "maximize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "piecewise_max",
+ "baseline": 45000000.0,
+ "rank30": 262328915.6667,
+ "rank1": 282791094.0,
+ "super_anchor": 289952856.4167
+ }
+ }
+}
diff --git a/arc_compiler_runtime.json b/arc_compiler_runtime.json
new file mode 100644
index 0000000000000000000000000000000000000000..326102dbec98082fcc2d4a508ffe87442c3694d3
--- /dev/null
+++ b/arc_compiler_runtime.json
@@ -0,0 +1,39 @@
+{
+ "task_id": "arc_compiler_runtime",
+ "name": "Arc Compiler Runtime",
+ "category": "Systems & Software Engineering",
+ "base_image": "python",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/arc-compiler-runtime-implementation/agent-start",
+ "submit_paths": [
+ "compiler/src/"
+ ],
+ "submit_exclude": [
+ "compiler/dist/",
+ "tests/",
+ "node_modules/",
+ ".git/",
+ ".github/",
+ ".DS_Store",
+ "*.map"
+ ],
+ "work": {
+ "image_tag": "c92a7b116597",
+ "specs_dir": "/home/workspace/arc-compiler-runtime-implementation/agent-start",
+ "agent_query": "Implement the missing Arc compiler and runtime modules under compiler/src/. Use CHEATSHEET.md, TASK.md, and the public smoke tests as the language contract. Modify only files under compiler/src/. Do not modify tests, scoring scripts, task metadata, Dockerfiles, package files, node_modules, generated dist artifacts, source maps, or evaluator-owned files. Work offline and do not depend on hidden tests or hard-coded answers."
+ },
+ "judge": {
+ "image_tag": "200e176a8e30",
+ "eval_cmd": "cd /home/workspace/arc-compiler-runtime-implementation && python -c 'exec(\"import json\\nimport re\\nimport subprocess\\n\\nproc = subprocess.run(['\"'\"'bash'\"'\"', '\"'\"'evaluator-hidden/score_hidden.sh'\"'\"', '\"'\"'agent-start'\"'\"'], text=True, capture_output=True, timeout=1400)\\noutput = (proc.stdout or '\"'\"''\"'\"') + (proc.stderr or '\"'\"''\"'\"')\\nprint(output, end='\"'\"''\"'\"')\\nscore_match = re.search(r'\"'\"'^SCORE=([-+]?\\\\d+(?:\\\\.\\\\d+)?)$'\"'\"', output, re.MULTILINE)\\nraw_passed_match = re.search(r'\"'\"'^RAW_PASSED=(\\\\d+)$'\"'\"', output, re.MULTILINE)\\nraw_total_match = re.search(r'\"'\"'^RAW_TOTAL=(\\\\d+)$'\"'\"', output, re.MULTILINE)\\nweighted_passed_match = re.search(r'\"'\"'^WEIGHTED_PASSED=(\\\\d+)$'\"'\"', output, re.MULTILINE)\\nweighted_total_match = re.search(r'\"'\"'^WEIGHTED_TOTAL=(\\\\d+)$'\"'\"', output, re.MULTILINE)\\nscore = float(score_match.group(1)) if score_match else 0.0\\nraw_passed = int(raw_passed_match.group(1)) if raw_passed_match else 0\\nraw_total = int(raw_total_match.group(1)) if raw_total_match else 1\\nweighted_passed = int(weighted_passed_match.group(1)) if weighted_passed_match else 0\\nweighted_total = int(weighted_total_match.group(1)) if weighted_total_match else 1\\nvalid = proc.returncode == 0 and score_match is not None\\npass_rate = (raw_passed / raw_total) if raw_total else 0.0\\nprint('\"'\"'>>>>> Start Structured Result'\"'\"')\\nprint(json.dumps({\\n '\"'\"'valid'\"'\"': valid,\\n '\"'\"'score'\"'\"': score,\\n '\"'\"'pass_rate'\"'\"': pass_rate if valid else 0.0,\\n '\"'\"'total_tests'\"'\"': raw_total,\\n '\"'\"'passed'\"'\"': raw_passed if valid else 0,\\n '\"'\"'failed'\"'\"': max(raw_total - raw_passed, 0) if valid else raw_total,\\n '\"'\"'errors'\"'\"': 0 if valid else 1,\\n '\"'\"'summary'\"'\"': '\"'\"'Score: {:.2f}, raw: {}/{}, weighted: {}/{}'\"'\"'.format(score, raw_passed, raw_total, weighted_passed, weighted_total),\\n '\"'\"'details'\"'\"': [{\\n '\"'\"'name'\"'\"': '\"'\"'hidden_score'\"'\"',\\n '\"'\"'status'\"'\"': '\"'\"'PASSED'\"'\"' if valid and score > 0.0 else '\"'\"'FAILED'\"'\"',\\n '\"'\"'score'\"'\"': score,\\n '\"'\"'message'\"'\"': output[-2000:]\\n }],\\n '\"'\"'metrics'\"'\"': {\\n '\"'\"'score'\"'\"': score,\\n '\"'\"'raw_passed'\"'\"': raw_passed,\\n '\"'\"'raw_total'\"'\"': raw_total,\\n '\"'\"'weighted_passed'\"'\"': weighted_passed,\\n '\"'\"'weighted_total'\"'\"': weighted_total,\\n '\"'\"'runner_returncode'\"'\"': proc.returncode\\n }\\n}, ensure_ascii=False))\\nprint('\"'\"'>>>>> End Structured Result'\"'\"')\\n\")'",
+ "eval_timeout": 1500,
+ "parser": "structured_json",
+ "score_direction": "maximize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 100.0
+ }
+ }
+}
diff --git a/assets/edgebench_taxonomy.png b/assets/edgebench_taxonomy.png
new file mode 100644
index 0000000000000000000000000000000000000000..88a599188d7a7b392800ac1b63aa8629ea8a2c2b
--- /dev/null
+++ b/assets/edgebench_taxonomy.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:410389a02424d8ead0c6e3726fe32c136b1b0fedc6d46f4d443ecad57460b4a3
+size 3101019
diff --git a/assets/fig_dual_loop.png b/assets/fig_dual_loop.png
new file mode 100644
index 0000000000000000000000000000000000000000..23d7e64cc2d88890f24542e6b1002e903e7a7991
--- /dev/null
+++ b/assets/fig_dual_loop.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:029020dc8b878483e07e3404f30cff729fa046ca50ccae68de6e6dbafd39e7c2
+size 202592
diff --git a/assets/fig_full_136_curve_fit_side_by_side.png b/assets/fig_full_136_curve_fit_side_by_side.png
new file mode 100644
index 0000000000000000000000000000000000000000..a873500e250e063a9777503f78ef7bf32bae79c7
--- /dev/null
+++ b/assets/fig_full_136_curve_fit_side_by_side.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8783935cb9eb8f2ddb80e1e3c7c9d739bd096b7e3d10f01615112e547a6a108b
+size 601349
diff --git a/assets/fig_rank_paper_panel.png b/assets/fig_rank_paper_panel.png
new file mode 100644
index 0000000000000000000000000000000000000000..5e7ccebdf655f07b2bdd20f2a060769d20d18e45
--- /dev/null
+++ b/assets/fig_rank_paper_panel.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f4ce03d135874d4348357e7da31466a448a3cd9735013e45fdd121d3be640f63
+size 160538
diff --git a/assets/logo-dark.png b/assets/logo-dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..0e9ff5cdb40767dac439451e68673ca901bbceda
Binary files /dev/null and b/assets/logo-dark.png differ
diff --git a/assets/logo.jpg b/assets/logo.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..d4827a037576e205dda5acba968003cb6d383e0b
--- /dev/null
+++ b/assets/logo.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4350601f82da6e581fdd45f7f2c4744d2c5127b12f27cb952a99987b3e72142a
+size 233589
diff --git a/assets/time_area_log2_curve.png b/assets/time_area_log2_curve.png
new file mode 100644
index 0000000000000000000000000000000000000000..b0cebc0475504c567af1e321499cceb9052abd53
--- /dev/null
+++ b/assets/time_area_log2_curve.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:02488f90337ff13acd8f243ad27bcf0184633147103dacc90cfb7a6eb04ba781
+size 455076
diff --git a/assets/title-dark.svg b/assets/title-dark.svg
new file mode 100644
index 0000000000000000000000000000000000000000..08200e2450afa5f69f5bb87f3da0d93cdf876d3f
--- /dev/null
+++ b/assets/title-dark.svg
@@ -0,0 +1,5 @@
+
diff --git a/assets/title.svg b/assets/title.svg
new file mode 100644
index 0000000000000000000000000000000000000000..73e4b6d7fe260b5db08908d0c64d74481dd62729
--- /dev/null
+++ b/assets/title.svg
@@ -0,0 +1,5 @@
+
diff --git a/bipedalwalker_locomotion_rl.json b/bipedalwalker_locomotion_rl.json
new file mode 100644
index 0000000000000000000000000000000000000000..28c318ed6e8f6e4f1ff53cff426eb54c49e1ad2a
--- /dev/null
+++ b/bipedalwalker_locomotion_rl.json
@@ -0,0 +1,40 @@
+{
+ "task_id": "bipedalwalker_locomotion_rl",
+ "name": "Bipedalwalker Locomotion Rl",
+ "category": "Scientific Problems & ML",
+ "base_image": "python",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/loco-rl",
+ "submit_paths": [
+ "submission/"
+ ],
+ "submit_exclude": [
+ "submission/eval_results.json",
+ "submission/checkpoints/",
+ "submission/*.log",
+ "submission/*.tmp",
+ "__pycache__/",
+ "eval/",
+ "sebench_eval.py",
+ ".git/"
+ ],
+ "work": {
+ "image_tag": "f9a2f8394c09",
+ "specs_dir": "/home/workspace/loco-rl",
+ "agent_query": "## Role\n\nYou are a Python and reinforcement-learning systems engineer optimizing a CPU-only locomotion agent.\n\n## Project\n\nRead `task_prompt.md`, `README.md`, `baseline/train_baseline.py`, and `envs/locomotion_env.py`. The editable submission area is `submission/`.\n\n## Objective\n\nTrain a BipedalWalker policy on CPU in this work container and save the final trained checkpoint as `submission/policy.pth`. The trusted judge does not run training; it only receives the submitted checkpoint and evaluates it on BipedalWalker-v3 and BipedalWalkerHardcore-v3.\n\n## Constraints\n\n- Keep your final implementation and checkpoint under `submission/`.\n- `submission/policy.pth` is submitted and required. Keep intermediate checkpoints outside `submission/` or under `submission/checkpoints/`.\n- You may provide `submission/policy.py` for custom PyTorch architectures; the judge supports `load_policy(path)`, `build_policy(checkpoint)`, or a `Policy` class.\n- Do not download or use pretrained policies, external RL libraries, or hidden evaluator files.\n- Use CPU only; CUDA is disabled during evaluation.\n- Hidden evaluator code is not present in this work container.\n- Trusted feedback is aggregate-only: reward summaries and scoring components are shown, but evaluator internals are not exposed.\n- Do not start with a long training run. First run smoke tests and short training loops; keep early iterations under 10 minutes, submit, then scale up once checkpoint loading works.\n- Submit whenever you have a candidate `submission/policy.pth` and want trusted feedback.\n\n## Time-Budget Workflow\n\nUse the available 2-hour agent window for active improvement. Do not stop after the first loadable checkpoint; submit within the first 30 minutes, then continue training, tuning, debugging, and submitting stronger checkpoints until you are close to the time limit. Do not idle or sleep just to consume wall-clock time.\n\n## Deliverable\n\nA final `submission/policy.pth`, plus any required `submission/policy.py`/`submission/train.py`, that the judge can load and evaluate."
+ },
+ "judge": {
+ "image_tag": "2db504ff563a",
+ "eval_cmd": "cd /home/workspace/loco-rl && SEBENCH_LOCO_EVAL_EPISODES=${SEBENCH_LOCO_EVAL_EPISODES:-10} python sebench_eval.py",
+ "eval_timeout": 900,
+ "parser": "structured_json",
+ "score_direction": "maximize",
+ "selection": "valid_then_score",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 100.0
+ }
+ }
+}
diff --git a/capecod_plume_reconstruction.json b/capecod_plume_reconstruction.json
new file mode 100644
index 0000000000000000000000000000000000000000..4e60f5451b18dcea5f637509b70c460b510089c2
--- /dev/null
+++ b/capecod_plume_reconstruction.json
@@ -0,0 +1,40 @@
+{
+ "task_id": "capecod_plume_reconstruction",
+ "name": "Capecod Plume Reconstruction",
+ "category": "Scientific Problems & ML",
+ "base_image": "python",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/capecod_plumebench",
+ "submit_paths": [
+ "model.py",
+ "predict.py",
+ "monitoring_plan.py",
+ "baseline_solver.py",
+ "predictions.csv",
+ "plume_metrics.json",
+ "monitoring_plan.json",
+ "answer.json",
+ "report.md"
+ ],
+ "submit_exclude": [
+ "data/",
+ "schemas/",
+ "hidden/",
+ "scoring/",
+ "__pycache__/"
+ ],
+ "work": {
+ "image_tag": "d051446beb3a",
+ "specs_dir": "/home/workspace/capecod_plumebench",
+ "agent_query": "# CapeCod-PlumeBench: Groundwater Plume Reconstruction and Monitoring Design\n\nYou are a groundwater remediation modeling engineer. The workspace contains partial public monitoring\ndata from an offline benchmark inspired by the USGS Cape Cod treated-wastewater groundwater plume.\n\nYour job is to replace the weak baseline with a better, defensible modeling workflow that:\n\n1. Cleans and interprets public well, chemistry, and site-configuration data.\n2. Predicts hidden well/year/analyte concentrations listed in `data/prediction_requests.csv`.\n3. Estimates plume metrics requested in `data/plume_metric_requests.csv`.\n4. Proposes up to 8 next monitoring wells under the budget in `data/public_site_config.json`.\n5. Writes a concise technical report explaining your model, assumptions, validation, and monitoring logic.\n\nRequired outputs:\n\n- `model.py`\n- `predict.py`\n- `monitoring_plan.py`\n- `predictions.csv`\n- `plume_metrics.json`\n- `monitoring_plan.json`\n- `answer.json`\n- `report.md`\n\nRun `python baseline_solver.py` to regenerate outputs before submitting. The current baseline is valid\nbut intentionally weak. Improve the model rather than only editing output files. Good solutions use\nspace-time structure, analyte-specific behavior, plume-front geometry, censored observations, and\nuncertainty-aware monitoring selection.\n\nRules:\n\n- Do not attempt to read hidden judge or scoring files.\n- Do not hard-code target truth values or hidden candidate utilities.\n- Keep all outputs finite, nonnegative, and schema-compliant.\n- Respect the monitoring budget and maximum number of wells.\n"
+ },
+ "judge": {
+ "image_tag": "f633dd04bd60",
+ "eval_cmd": "python /opt/capecod_scoring/evaluate.py",
+ "eval_timeout": 180,
+ "parser": "score_sum",
+ "score_direction": "maximize",
+ "selection": "score_first"
+ }
+}
diff --git a/carleson_formalization.json b/carleson_formalization.json
new file mode 100644
index 0000000000000000000000000000000000000000..19cc8bb99cce5c62cc56c216717b84052c4e471b
--- /dev/null
+++ b/carleson_formalization.json
@@ -0,0 +1,31 @@
+{
+ "task_id": "carleson_formalization",
+ "name": "Carleson Formalization",
+ "category": "Formal Math & Theorem Proving",
+ "base_image": "lean_4",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/",
+ "submit_paths": [
+ "se-bmk-intern/carleson"
+ ],
+ "submit_exclude": [
+ "se-bmk-intern/carleson/.lake"
+ ],
+ "work": {
+ "image_tag": "cde1812224f4",
+ "specs_dir": null,
+ "agent_query": "You are a lean4 expert, now your task is to finish **all** sorries in this folder. Pay no attention to anything outside this folder. There are many sorries but do not be afraid as we value minor progress and the time is abundant. Try to do some easy problems and accumulate scores each round. Before you submit, run a `lake build` to verify the changes locally - if the build failed, no score will be given. Also, do not modify the signature of existing lemma/theorem/def as these changes will not pass the judge evaluation. Finally, we check the axioms transitively, finishing a theorem without completeing precedent lemma will not count."
+ },
+ "judge": {
+ "image_tag": "77d26108339f",
+ "eval_cmd": "cd /home/workspace/se-bmk-intern/carleson && cp -r /home/workspace/judge/se-bmk-intern/carleson/.lake . && cp /home/workspace/judge/se-bmk-intern/carleson/lake-manifest.json . && lake build && cp /home/workspace/judge/se-bmk-intern/carleson/ListDeclAxiom.lean . && cd /home/workspace/judge/se-bmk-intern && python3 eval_lean.py --baseline-repo /home/workspace/judge/se-bmk-intern/carleson --current-repo /home/workspace/se-bmk-intern/carleson",
+ "eval_timeout": 2400,
+ "parser": "structured_json",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 1.0
+ }
+ }
+}
diff --git a/college_english_exam_bank.json b/college_english_exam_bank.json
new file mode 100644
index 0000000000000000000000000000000000000000..8f15242409b7d0ab43bb70ae01324929afb2aac1
--- /dev/null
+++ b/college_english_exam_bank.json
@@ -0,0 +1,51 @@
+{
+ "task_id": "college_english_exam_bank",
+ "name": "College English Exam Bank",
+ "category": "Professional Knowledge Work",
+ "base_image": "python",
+ "platform": "linux/amd64",
+ "internet": true,
+ "cwd": "/home/workspace",
+ "submit_paths": [
+ "A卷原卷.docx",
+ "A卷原卷.pdf",
+ "A卷答案和评分细则.docx",
+ "A卷答案和评分细则.pdf",
+ "B卷原卷.docx",
+ "B卷原卷.pdf",
+ "B卷答案和评分细则.docx",
+ "B卷答案和评分细则.pdf",
+ "C卷原卷.docx",
+ "C卷原卷.pdf",
+ "C卷答案和评分细则.docx",
+ "C卷答案和评分细则.pdf",
+ "D卷原卷.docx",
+ "D卷原卷.pdf",
+ "D卷答案和评分细则.docx",
+ "D卷答案和评分细则.pdf",
+ "E卷原卷.docx",
+ "E卷原卷.pdf",
+ "E卷答案和评分细则.docx",
+ "E卷答案和评分细则.pdf",
+ "五套组卷蓝图表.xlsx",
+ "套间重复率自检表.xlsx"
+ ],
+ "submit_exclude": [
+ ".git",
+ "__pycache__",
+ "*.pyc"
+ ],
+ "work": {
+ "image_tag": "9b1f87c2906b",
+ "specs_dir": null,
+ "agent_query": "Read the complete task instructions in `/home/workspace/task_instruction.md`, and complete the task according to those requirements. The final deliverables must be written to the file paths specified in `task_instruction.md`.\n"
+ },
+ "judge": {
+ "image_tag": "6628b6d3f834",
+ "eval_cmd": "cd /home/workspace && python3 scoring/grade_with_codex.py --report . --scoring-dir scoring --task-id college_english_exam_bank --input-dir input --timeout 900",
+ "eval_timeout": 900,
+ "parser": "structured_json",
+ "score_direction": "maximize",
+ "selection": "score_first"
+ }
+}
diff --git a/combinatorial_games_formalization.json b/combinatorial_games_formalization.json
new file mode 100644
index 0000000000000000000000000000000000000000..b191320c2553ea36c0e81f07e458fd3ec3621812
--- /dev/null
+++ b/combinatorial_games_formalization.json
@@ -0,0 +1,31 @@
+{
+ "task_id": "combinatorial_games_formalization",
+ "name": "Combinatorial Games Formalization",
+ "category": "Formal Math & Theorem Proving",
+ "base_image": "lean_4_28_0_main",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/",
+ "submit_paths": [
+ "se-bmk-intern/combinatorial-games"
+ ],
+ "submit_exclude": [
+ "se-bmk-intern/combinatorial-games/.lake"
+ ],
+ "work": {
+ "image_tag": "b6f1b58f681e",
+ "specs_dir": null,
+ "agent_query": "You are a lean4 expert, now your task is to finish **all** sorries in this folder. Pay no attention to anything outside this folder. There are many sorries but do not be afraid as we value minor progress and the time is abundant. Try to do some easy problems and accumulate scores each round. Before you submit, run a `lake build` to verify the changes locally - if the build failed, no score will be given. Also, do not modify the signature of existing lemma/theorem/def as these changes will not pass the judge evaluation."
+ },
+ "judge": {
+ "image_tag": "e4e88a24e340",
+ "eval_cmd": "cd /home/workspace/se-bmk-intern/combinatorial-games && cp -r /home/workspace/baseline/.lake . && cp /home/workspace/baseline/lake-manifest.json . && lake build && cp /home/workspace/judge/se-bmk-intern/combinatorial-games/ListDeclAxiom.lean . && cd /home/workspace/judge/se-bmk-intern && python3 eval_lean.py --baseline-repo /home/workspace/judge/se-bmk-intern/combinatorial-games --current-repo /home/workspace/se-bmk-intern/combinatorial-games",
+ "eval_timeout": 2400,
+ "parser": "structured_json",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 1.0
+ }
+ }
+}
diff --git a/cta_risk_budget_optimization.json b/cta_risk_budget_optimization.json
new file mode 100644
index 0000000000000000000000000000000000000000..041dd360152b126453198851e0225678389eacd1
--- /dev/null
+++ b/cta_risk_budget_optimization.json
@@ -0,0 +1,57 @@
+{
+ "task_id": "cta_risk_budget_optimization",
+ "name": "Cta Risk Budget Optimization",
+ "category": "Professional Knowledge Work",
+ "base_image": "python",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace",
+ "submit_paths": [
+ "run.py",
+ "main.py",
+ "config.json",
+ "config.yaml",
+ "nav_history.csv",
+ "signal_matrix.csv",
+ "positions.csv",
+ "trades.csv",
+ "risk_budget_allocation.csv",
+ "performance_report.md",
+ "performance_report.xlsx",
+ "stress_test_report.md",
+ "stress_test_results.xlsx",
+ "sensitivity_analysis_report.md",
+ "sensitivity_analysis.xlsx",
+ "diagnostics.json",
+ "outputs"
+ ],
+ "submit_exclude": [
+ ".git",
+ "__pycache__",
+ "*.pyc",
+ "node_modules",
+ "bin",
+ "obj",
+ "attachments",
+ "task_instruction.md",
+ "requirements.txt",
+ "futures_price_data.xlsx",
+ "futures_contract_specs.xlsx",
+ "macro_factors_data.xlsx",
+ "risk_policy_doc.docx",
+ "strategy_research_notes.docx"
+ ],
+ "work": {
+ "image_tag": "d799d7f632c3",
+ "specs_dir": null,
+ "agent_query": "Your complete task instructions are in `/home/workspace/task_instruction.md`.\n\nFirst run `cat /home/workspace/task_instruction.md` to read the full task requirements, then complete the task in whatever way you think is most appropriate.\n\nYou may freely decide how to work, including whether to make a plan, how many steps to use, and how to organize the deliverables. The only hard requirements are:\n1. The final deliverables must be written to the file paths specified in `task_instruction.md`.\n2. Periodically submit your current progress to obtain scoring feedback.\n3. Continuously improve your deliverables based on the scoring feedback.\n4. It is recommended that you create the deliverable files and write an initial draft skeleton within the first 15 minutes, then continue researching and improving them as you go, rather than waiting until all materials have been analyzed before writing anything.\n"
+ },
+ "judge": {
+ "image_tag": "a9651058ecef",
+ "eval_cmd": "cd /home/workspace && python3 scoring/score.py",
+ "eval_timeout": 600,
+ "parser": "structured_json",
+ "score_direction": "maximize",
+ "selection": "score_first"
+ }
+}
diff --git a/dabic_gravity_inversion.json b/dabic_gravity_inversion.json
new file mode 100644
index 0000000000000000000000000000000000000000..94238138e1323ba52ee57dbe310d522a5c9cce2f
--- /dev/null
+++ b/dabic_gravity_inversion.json
@@ -0,0 +1,32 @@
+{
+ "task_id": "dabic_gravity_inversion",
+ "name": "Dabic Gravity Inversion",
+ "category": "Scientific Problems & ML",
+ "base_image": "python",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/dabic_gravity_vinton",
+ "submit_paths": [
+ "outputs/"
+ ],
+ "submit_exclude": [
+ "tests/",
+ "__pycache__/",
+ "*.pyc",
+ "*.npy",
+ ".ipynb_checkpoints/"
+ ],
+ "work": {
+ "image_tag": "85db0aba8a5f",
+ "specs_dir": "/home/workspace/dabic_gravity_vinton/docs",
+ "agent_query": "Task objective: Port the D-ABIC method proposed by Song Han et al. in the 2025 Geophysics paper doi 10.1190/geo-2025-0233 to 3D gravity inversion, and validate it on the measured Vinton salt dome dataset. Read `starter/README.md` for detailed instructions.\n\nThe inversion must be completed separately under both L0 and L1 sparse regularization norms. For each norm, run a three-way comparison among D-ABIC, Cooling, and L-curve. Xu et al.'s 2025 Geophysical Prospecting paper doi 10.1111/1365-2478.70016 performed gravity inversion on the same Vinton dataset using an HMC method; use it as the comparison benchmark.\n\nFour stages:\n1. Algorithm implementation: read `docs/geo20250233.pdf` and implement a D-ABIC beta-adaptive directive. The suggested name is `class DABIC_Beta_Estimator(directives.InversionDirective)`, placed in a separate module `outputs/dabic_directive.py`. Decide for yourself whether to use the model-space or data-space form, how to compute determinants, and in which space to optimize beta. The directive must work under both the L0 and L1 norms.\n2. Synthetic validation: `starter/starter.py` provides the synthetic density model Model 3, survey points, noisy observed data, and forward simulation object, but does not include an inversion framework. Build the SimPEG inversion workflow yourself, and implement both Cooling and L-curve scan baselines. Run the three-way comparison for both L0 and L1.\n3. Field-data application: `data/saltdome_s7_100.grd` is the measured Vinton salt dome gravity-anomaly data, in Surfer 7 binary format. It can be parsed by `starter/explore_xu_data.py`. Refer to `docs/Xu2025_HMC.pdf` for the inversion mesh, depth range, density bounds, and related settings.\n4. Result comparison: compare quantitatively and qualitatively with the Xu 2025 HMC results, and write `outputs/report.md`, 800 to 1500 words/characters in length.\n\nDeliver to `outputs/`: dabic_directive.py, run_synthetic.py, run_vinton.py, results.json, report.md.\n\nAll dependencies are preinstalled; you do not need to and cannot install additional packages. The container has no network access and cannot access external resources.\n\nConstraints: beta must not be hard-coded as a constant; do not import any third-party ABIC package; do not use SimPEG's built-in high-level automatic beta directives; BetaEstimate_ByEig may only be used to set the initial beta_0 value; both L0 and L1 inversions must be fully completed; do not expand the work to other regularization strategies such as GCV or HMC; do not modify starter/explore_xu_data.py or starter/starter.py.\n"
+ },
+ "judge": {
+ "image_tag": "517eb738b87b",
+ "eval_cmd": "cd /home/workspace/dabic_gravity_vinton && PYTHONPATH=/opt/evaluator python /opt/evaluator/eval_dabic_v2.py /home/workspace/dabic_gravity_vinton/outputs/",
+ "eval_timeout": 21600,
+ "parser": "structured_json",
+ "score_direction": "maximize",
+ "selection": "valid_then_score"
+ }
+}
diff --git a/dcss_dungeon_ai.json b/dcss_dungeon_ai.json
new file mode 100644
index 0000000000000000000000000000000000000000..04dfb41a8bc4abde41c649afe69cc903fe94e63f
--- /dev/null
+++ b/dcss_dungeon_ai.json
@@ -0,0 +1,34 @@
+{
+ "task_id": "dcss_dungeon_ai",
+ "name": "Dcss Dungeon Ai",
+ "category": "Interactive Games & Simulators",
+ "base_image": "python310",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/dcss_agent",
+ "submit_paths": [
+ "my_bot.rc",
+ "my_bot_include.rc"
+ ],
+ "submit_exclude": [
+ ".git"
+ ],
+ "work": {
+ "image_tag": "e3aadae6b2b3",
+ "specs_dir": "/home/dcss_agent",
+ "agent_query": "## DCSS Dungeon Crawl Stone Soup AI\n\nWrite a Lua bot for DCSS (Dungeon Crawl Stone Soup, version 0.28) that maximizes game score, playing a Minotaur Berserker.\n\n---\n\n## How you're scored\n\n- Holdout: 5 hidden seeds, **900s game budget per game**, mean score across all 5 games. The 5 games run **in parallel**, so a full submission is about 15-18min plus overhead, and may finish earlier if games die or quit early.\n- Start combo is fixed for determinism: Minotaur Berserker with `weapon=mace`. The evaluator forces this with Crawl `-extra-opt-last weapon=mace`, so repeated unchanged submissions are not supposed to sample a different starting weapon.\n- **There is no turn limit.** Wall-time is the only constraint.\n- **You don't need to design death/termination.** At the 900s game-budget deadline, the eval automatically sends `Ctrl+G` + `Esc`x2 + `Ctrl+Q` + `yes` + `Enter` via the screen session, which makes crawl write a morgue regardless of game state (it forces an interrupt + abandon-character prompt). Your character ends with whatever XP/depth/items they accumulated; that's your score. Just play to maximize what you get in 900s. `crawl.millis()` returns a monotonic millisecond timestamp; if you use it, compare `crawl.millis() - start_ms`. The evaluator already handles end-of-game termination, so use `you.turns()` for turn-based bot logic unless you specifically need wall-clock self-pacing.\n- A game's score = the integer on line 5 of `morgue-EvalN-*.txt`, which is DCSS's own score formula (XP + depth + items + kills + ...).\n- Total eval is roughly 15-18min/submission because the five 900s games run in parallel; it is not `5 games x 3min`.\n\n## Two levers, both matter\n\n```\nscore ≈ turn_count × score_per_turn\n = (turn_rate × 900s) × score_per_turn\n```\n\n- **turn_rate** = how many game-turns you advance per second of wall-time. Bounded by PTY/screen overhead and which keys you send.\n- **score_per_turn** = how much score each turn produces on average. Bounded by strategy: depth reached, monsters killed, items used, neutralized risks.\n\nNeither alone is enough. High turn-rate while resting safely on D:1 = score 0. Perfect combat at 0.5 turn/s = ~450 turns in 900s, still shallow.\n\n## High-turn-rate operations (free time-skipping)\n\nDCSS folds multiple game-turns into a single Lua hook invocation when you use batch commands:\n\n| Key / command | Game-turns per call | Use case |\n|---|---|---|\n| `crawl.sendkeys(\"h\")` | 1 | Single-step move (slow) |\n| `crawl.do_commands({\"CMD_WAIT\"})` | 1 | Skip 1 turn |\n| `crawl.sendkeys(\"o\")` | ~10-50 | Autoexplore current level |\n| `crawl.sendkeys(\"G>\")` | ~50-200 when it works | Autotravel toward deeper levels; in console it can leave a `Where to?` prompt if used from the wrong state |\n| `crawl.do_commands({\"CMD_REST\"})` or `crawl.sendkeys(\"5\")` | up to 100 | Long-rest until full HP/MP or interrupted |\n| `crawl.sendkeys(\"G7\")` etc. | hundreds | Autotravel to a specific level |\n\nStair handling is a common bottleneck. `view.feature_at(0, 0)` only describes the tile you are standing on; downstairs features are typically named like `stone_stairs_down_i`, `stone_stairs_down_ii`, `stone_stairs_down_iii`, or `escape_hatch_down`. When already on a downstairs tile, `crawl.do_commands({\"CMD_GO_DOWNSTAIRS\"})` or `crawl.sendkeys(\">\")` is usually the direct descent. When stairs are visible but not under you, walk onto them first or use carefully tested travel. If a morgue shows repeated `Where to?`, `What level of the Dungeon?`, `Okay, then`, or `You're already here!`, your travel command is stuck in a prompt loop and is not advancing gameplay.\n\nBaseline uses `o` + single-step combat → ~1-2 turn/s. A bot that chains autotravel + long-rest + autofight can hit 10-50 turn/s.\n\n## Files you edit in `/home/dcss_agent/`\n\n1. `my_bot.rc` — DCSS options + `include = my_bot_include.rc`.\n2. `my_bot_include.rc` — Lua block. Defines `ready()` (called every turn) and `c_message(text, channel)` (catches prompts).\n\nRC/Lua syntax pitfall: the outer `{ ... }` in `my_bot_include.rc` is a DCSS rc Lua block delimiter. Avoid putting a Lua table-constructor closing brace `}` alone on its own line inside that block; the rc parser can treat it as the end of the Lua block, causing confusing `near ''` Lua errors. Prefer compact table endings like `[\"foo\"] = 1 }` or otherwise keep nested table braces away from standalone `}` lines.\n\nBoth have a baseline committed to git. If you wreck things: `git checkout HEAD -- my_bot.rc my_bot_include.rc`.\n\nBefore holdout submissions, make sure the current bot still runs locally. If `dcss-eval` returns all-zero scores, a turn-1 quit, repeated `Unknown command` / `Where to?` / `Okay, then`, or Lua/RC errors, keep debugging locally before submitting.\n\n## Iteration loop\n\nRequired cadence for long runs:\n\n1. First, inspect the two bot files and run one short local `dcss-eval` sanity check with any timeout you choose.\n2. If the current files run without syntax errors or immediate turn-1 quit, start a holdout submission in the background early, even if it is only the baseline. Use a command like `sforge-submit --details > /tmp/holdout_round1.log 2>&1 &` and keep debugging locally while it runs. Do not spend 20+ minutes local-only without any holdout submission in flight.\n3. When the holdout result returns, inspect `/tmp/holdout_round1.log` or run `sforge-submit --list`, then decide whether the current local idea is actually better before submitting it. For the second and later holdout submissions, require a real gameplay change plus clear local evidence across several public/random seeds. If local score collapses, cases only quit on turn 1, or the morgue shows prompt loops / repeated unknown commands, keep debugging locally instead of submitting.\n\n- **`dcss-eval`** at `/usr/local/bin/dcss-eval` — local evaluator, your seeds, your params, same suicide-mechanism as the judge:\n ```bash\n dcss-eval --n 1 --timeout 30 # very short sanity check\n dcss-eval --n 5 --parallel 5 --timeout SECONDS # broader local check; choose any debug timeout\n dcss-eval --seeds 7,42,99\n dcss-eval --random --n 5 # 5 random seeds from 1..100\n dcss-eval --show-morgue # dump death cause + morgue tail\n ```\n Local seed pool is 1..100, disjoint from the holdout. The holdout seed set and start weapon are fixed but hidden/controlled; repeated unchanged submissions are broadly comparable and cannot sample new maps or weapons. Wall-clock/PTTY scheduling can still create small score noise, so use submissions to measure real gameplay changes, not to gamble on unchanged or comment-only reruns. The local `--timeout` value is arbitrary and only controls your debugging runtime; it can be short or long as needed and does not reveal hidden seeds or change the judge. The holdout evaluator uses 900s per game. Optimizing on a few specific seeds gives **no signal** about holdout — rotate seeds, target robustness.\n\n- **`sforge-submit`** — submit to the holdout. About 15-18min round-trip because 5 games run in parallel at 900s/game. Run it in the background when possible and keep using `dcss-eval` plus code edits while it runs; do not block the whole session on one holdout unless you specifically need that result before choosing the next change. The submit UI reports the current submission `Score`, `Pass rate`, `Passed`, and metrics with each hidden case's morgue score; `--details` also shows hidden case IDs (`case_0000`..`case_0004`), pass/fail status, and each hidden case's morgue score, but never seed values. `Pass rate`/`Passed` comes from the judge CASE OK count: it only means how many games produced accepted morgues, so for this score task it is a validity check, not the quality metric. Optimize `Score`, which comes from `TOTAL_SCORE`. Do not spend time resubmitting unchanged or comment-only code: the holdout is fixed, so identical gameplay should score nearly the same apart from small scheduling noise, and only DCSS's morgue score is counted. Comments, `crawl.mpr`/`crawl.take_note` notes, API probes, and textual claims do not add score. Remove temporary probe/debug code such as `INVPROBE` before submitting; it can only add noise or slow the bot down.\n\n## DCSS Lua API quick reference\n\n- `you.turns()`, `you.hp()`, `you.where()`, `you.xl()`, `you.god()`\n- `crawl.do_commands({\"CMD_AUTOFIGHT\", \"CMD_REST\", \"CMD_WAIT\", \"CMD_GO_DOWNSTAIRS\"})` — named commands\n- `crawl.sendkeys(\"o\")` — raw keys (`o`=autoexplore, `>`=descend when standing on downstairs, `<`=ascend, `5`=long-rest, `G>`/`G7`=autotravel but can enter travel prompts if misused, `Ctrl+F`=find)\n- `crawl.millis()` — monotonic millisecond timestamp; compare deltas from a captured value; not needed for termination\n- `view.feature_at(dx, dy)` — terrain string at offset\n- `monster.get_monster_at(x, y)` — adjacent/visible monster; `:is_firewood()`, `:attitude()`, and `:name()` are useful. Avoid assuming every apparent monster method exists; verify with `dcss-eval --show-morgue` because a missing Lua method stops progress.\n- Trog abilities can be driven with `crawl.do_commands({\"CMD_USE_ABILITY\"})` plus `chk_ability_choice = \"a\"` for the first ability, but ability-menu APIs vary in Crawl 0.28. Test any ability code with `dcss-eval --show-morgue`; a Lua error in the morgue means that game stopped making progress.\n- `crawl.mpr(\"msg\")` — log to messages, captured in morgue Notes\n\nDocs in container: `/usr/share/crawl/docs/options_guide.txt`, `/usr/share/crawl/docs/keybind.txt`, `/usr/share/crawl/dat/clua/*.lua`, `/usr/share/crawl/dat/dlua/*.lua`.\n\n## Banned (auto-zero)\n\n- **Wizard mode / explore mode**: pressing `&` or `Ctrl+X` opens god-mode. Judge greps morgue for `Entered (wizard|explore) mode|WIZARD|EX-WIZARD` and zeroes the game. Local dcss-eval enforces the same.\n- Modifying `crawl` binary or eval scripts (not in `submit_paths` anyway).\n\nDeath-by-monster is the intended risk, not a thing to engineer around."
+ },
+ "judge": {
+ "image_tag": "db79574e3c30",
+ "eval_cmd": "python3 /tmp/eval_dcss.py",
+ "eval_timeout": 1100,
+ "parser": "structured_json",
+ "score_direction": "maximize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "log1p_max",
+ "upper": 50000.0,
+ "baseline": 400.0
+ }
+ }
+}
diff --git a/equivalence_class_divide_and_conquer.json b/equivalence_class_divide_and_conquer.json
new file mode 100644
index 0000000000000000000000000000000000000000..7979f8583b970d85c33bf843e7af7d796bd7a94d
--- /dev/null
+++ b/equivalence_class_divide_and_conquer.json
@@ -0,0 +1,35 @@
+{
+ "task_id": "equivalence_class_divide_and_conquer",
+ "name": "Equivalence Class Divide And Conquer",
+ "category": "Combinatorial Optimization",
+ "base_image": "cpp",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/p2",
+ "submit_paths": [
+ "T1.cpp",
+ "T2.cpp",
+ "T3.cpp",
+ "T4.cpp",
+ "T5.cpp",
+ "T6.cpp"
+ ],
+ "submit_exclude": [],
+ "work": {
+ "image_tag": "7d6371e4948e",
+ "specs_dir": "/home/workspace/p2",
+ "agent_query": "You need to complete six problems, with a total score of 100 points. The six problems are worth 5, 5, 10, 15, 25, and 40 points respectively. Each problem has several groups of test data. If all test data for a problem pass, you receive the full score for that problem. If a problem does not pass all test data but does pass some subtasks/test points, each passed subtask/test point can receive only half of its original score. Please work on the problems in order, with the goal of solving them as much as possible. These problems are progressive; if you do not know how to solve a later problem, it is recommended that you review the methods used for earlier problems and look for ideas there.\nWhen submitting code, the code files for the six problems should be named T1.cpp T2.cpp T3.cpp T4.cpp T5.cpp T6.cpp.\n"
+ },
+ "judge": {
+ "image_tag": "de7206e7e06d",
+ "eval_cmd": "cd /home/workspace/p2 && python3 /opt/p2_judge/prob/P2/eval.py --source-root /home/workspace/p2 --time-factor 1 --time-grace 0 --score-sum",
+ "eval_timeout": 900,
+ "parser": "score_sum",
+ "score_direction": "maximize",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 100.0
+ }
+ }
+}
diff --git a/exchange_core_throughput.json b/exchange_core_throughput.json
new file mode 100644
index 0000000000000000000000000000000000000000..02b0518605bbf8d6dc485a26307277987520eeca
--- /dev/null
+++ b/exchange_core_throughput.json
@@ -0,0 +1,35 @@
+{
+ "task_id": "exchange_core_throughput",
+ "name": "Exchange Core Throughput",
+ "category": "Systems & Software Engineering",
+ "base_image": "java",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/exchange-core",
+ "submit_paths": [
+ "src/main/",
+ "pom.xml",
+ ".mvn/"
+ ],
+ "submit_exclude": [
+ "src/test"
+ ],
+ "work": {
+ "image_tag": "cc0c0eabbf80",
+ "specs_dir": "/home/workspace/exchange-core",
+ "agent_query": "## Role\n\nYou are a performance engineer optimizing **exchange-core**, an LMAX Disruptor–based open-source financial matching engine (Java 8, Maven). Your goal is to maximize the throughput (MT/s — millions of transactions per second) of `PerfThroughput#testThroughputPeak`.\n\n---\n\n## Repository Layout\n\n- `src/main/java/...` — engine source (OrderBook, matching service, risk engine, Disruptor wiring, etc.)\n- `src/main/resources/` — logging etc.\n- `pom.xml` — Maven build (Java 1.8 source/target)\n- Tests have been removed from the work container — the judge will re-apply the official throughput test.\n\n---\n\n## Benchmark\n\nThe judge runs (with Java 17 runtime, compiled to 1.8 bytecode):\n\n```bash\nmvn -B test -Dtest=PerfThroughput#testThroughputPeak\n```\n\nThe test calls `PerformanceConfiguration.throughputPerformanceBuilder().ringBufferSize(32 * 1024).build()` — only ringBufferSize is overridden; ME/RE, msgsInGroupLimit and other parameters use the builder defaults (4ME+2RE, msgsInGroupLimit=4096, BUSY_SPIN wait, DirectImpl orderbook, AffinityThreadFactory). **You can change these defaults by editing `throughputPerformanceBuilder()` in `PerformanceConfiguration.java`.** The test uses 100 symbols, 10K accounts, 10K orders, 3M transactions — a multi-symbol peak throughput scenario where thread topology changes (e.g. 4ME+2RE → 2ME+1RE) can have dramatic impact.\n\nThe test prints rounds like `\". MT/s\"` and a final `\"Average: MT/s\"`. Higher is better.\n\n---\n\n## Optimization Directions (suggestions)\n\n- Thread topology: matching engine (ME) / risk engine (RE) thread counts, pinning via `CoreWaitStrategy`\n- Disruptor wait strategy, ring-buffer size, producer type\n- OrderBook implementation (array-based, naive, direct)\n- Message grouping / batching (message-group parameters)\n- Java GC choice (G1 / ZGC) and heap sizing via `MAVEN_OPTS`\n- Reduce allocations in hot path\n\nKimi K2.6 reference: 0.43 → 1.24 MT/s (+185%) by dropping from 4ME+2RE to 2ME+1RE.\n\n---\n\n## Rules\n\n- Do NOT modify test files (the judge re-applies them)\n- Do NOT change behavior: `mvn test` must still pass functional assertions\n- You may freely edit `src/main/java/**`, `pom.xml`, and add `MAVEN_OPTS` via a `.mvn/jvm.config` or `.mvn/maven.config` file\n- The score is `int(round(Average_MT_s * 1000))` (e.g. 1.243 → 1243)\n- `CASES_OK = 1` only when `mvn test` exits 0 AND an MT/s line was parsed\n"
+ },
+ "judge": {
+ "image_tag": "2cbf65650b3c",
+ "eval_cmd": "cd /home/workspace/exchange-core && python3 /tmp/eval_exchange_core.py",
+ "eval_timeout": 2400,
+ "parser": "score_sum",
+ "score_direction": "maximize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "log_max",
+ "baseline": 2090.634594076933,
+ "expert": 6000.0
+ }
+ }
+}
diff --git a/ffmpeg_swscale_reimplementation.json b/ffmpeg_swscale_reimplementation.json
new file mode 100644
index 0000000000000000000000000000000000000000..7ef4c4502166dac93021bf03a56da894b4503093
--- /dev/null
+++ b/ffmpeg_swscale_reimplementation.json
@@ -0,0 +1,36 @@
+{
+ "task_id": "ffmpeg_swscale_reimplementation",
+ "name": "Ffmpeg Swscale Reimplementation",
+ "category": "Systems & Software Engineering",
+ "base_image": "cpp",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/swscale-impl",
+ "submit_paths": [
+ "."
+ ],
+ "submit_exclude": [
+ ".git",
+ "zig-cache",
+ "zig-out",
+ "target"
+ ],
+ "work": {
+ "image_tag": "0557f5e37b71",
+ "specs_dir": "/home/workspace",
+ "agent_query": "# FFmpeg libswscale Re-implementation\n\nYou are a systems engineer. Your goal is to re-implement FFmpeg's **libswscale**\nimage scaling and pixel-format conversion library in **Zig or Rust**, producing\na C-compatible shared library that matches or exceeds FFmpeg's C scalar\nreference performance using portable SIMD.\n\n## Setup\n\n1. FFmpeg source (libswscale + libavutil) is at `/reference/ffmpeg-src/`.\n Study the scalar C implementation — this is what you are reimplementing.\n2. A full FFmpeg binary (with ASM optimisations) is at `/reference/ffmpeg`.\n Use it to generate test inputs/outputs and verify your understanding.\n3. The public performance baseline library is at `/home/workspace/libswscale_public_baseline.so`.\n This wraps FFmpeg's C-only code (compiled with `--disable-asm`). Your\n implementation is benchmarked against this baseline.\n4. Your workspace is `/home/workspace/swscale-impl/`. Scaffold templates for both Zig\n and Rust are provided — pick one and build from there.\n5. The C API you must implement is defined in `/home/workspace/swscale_api.h`.\n\n## Deliverable\n\nSource code at `/home/workspace/swscale-impl/` that compiles to a shared library named\n`libswscale_candidate.so`, exporting these three C-linkage functions:\n\n```c\nvoid *swscale_create(int src_w, int src_h, int src_fmt,\n int dst_w, int dst_h, int dst_fmt, int algo);\nint swscale_process(void *ctx,\n const uint8_t *const src[4], const int src_stride[4],\n uint8_t *const dst[4], const int dst_stride[4]);\nvoid swscale_destroy(void *ctx);\n```\n\nThe verifier will **rebuild your library from source** before testing.\nPre-built binaries without source will be rejected.\n\n### Build commands the verifier tries (in order):\n\n1. If `build.zig` exists: `zig build -Doptimize=ReleaseFast`\n2. If `Cargo.toml` exists: `cargo build --release`\n3. If `Makefile` exists: `make release`\n\nThe output library must be discoverable at one of:\n- `zig-out/lib/libswscale_candidate.so`\n- `target/release/libswscale_candidate.so`\n- `./libswscale_candidate.so`\n\n## Supported Pixel Formats\n\nYour library must handle conversions between any pair of these formats:\n\n| ID | Name | Layout |\n|----|----------|---------------------------------|\n| 0 | YUV420P | Planar YUV 4:2:0 (3 planes) |\n| 1 | YUV422P | Planar YUV 4:2:2 (3 planes) |\n| 2 | YUV444P | Planar YUV 4:4:4 (3 planes) |\n| 3 | NV12 | Semi-planar Y + UV (2 planes) |\n| 4 | NV21 | Semi-planar Y + VU (2 planes) |\n| 5 | RGB24 | Packed R,G,B (1 plane) |\n| 6 | BGR24 | Packed B,G,R (1 plane) |\n| 7 | RGBA | Packed R,G,B,A (1 plane) |\n| 8 | BGRA | Packed B,G,R,A (1 plane) |\n| 9 | GRAY8 | Single-plane grayscale |\n\n## Supported Scaling Algorithms\n\n| ID | Name | Description |\n|----|-----------|----------------------------|\n| 0 | Nearest | Nearest-neighbour sampling |\n| 1 | Bilinear | Bilinear interpolation |\n| 2 | Bicubic | Bicubic interpolation |\n\nWhen `src_w == dst_w` and `src_h == dst_h`, only pixel-format conversion is\nneeded (no scaling). This is the most common fast path.\n\n**Buffer alignment**: The verifier allocates all source and destination plane\nbuffers with 32-byte alignment. You may assume aligned loads/stores in your\nSIMD code. All dimensions for subsampled formats (YUV420P, YUV422P, NV12,\nNV21) will have even width and height.\n\n## What Has to Stay Correct\n\nThe verifier checks output quality on hidden workloads:\n\n- **Format-only conversion** (same dimensions): PSNR >= 60 dB per plane,\n or exact byte match for mathematically lossless paths (e.g. RGB<->BGR channel swap).\n- **Scaling conversion** (different dimensions): PSNR >= 40 dB per plane.\n- If correctness fails on any hidden workload, the score is **zero**.\n\n## Scoring\n\n```\nif not build_ok or not correctness_ok or anti_cheat_violated:\n reward = 0.0\nelse:\n reward = geometric_mean(baseline_time / candidate_time)\n```\n\nA reward of 1.0 means you match FFmpeg's C scalar speed exactly.\nAbove 1.0 means you are faster. The SIMD opportunity is significant —\nFFmpeg's own recent swscale rewrite achieved 2.6x overall speedup through\nx86 SIMD backends.\n\n## How to Work\n\n### Starting Codebase Guidance\n\nThe Rust scaffold is already pre-populated in `/home/workspace/swscale-impl/` with a working baseline implementation. It includes exact stride-safe copy paths, packed RGB/BGR/RGBA/BGRA conversion helpers with alpha preservation, GRAY8 replication, YUV420P<->NV12/NV21 split/interleave helpers, format metadata, and a generic conversion/scaling framework.\n\nDo not restart from the empty stub and do not switch to Zig. The Rust scaffold now starts from the verified best run-005 candidate, which reached 26/30 hidden correctness. It already fixes the broad conversion coverage: YUV420P/YUV422P/NV12/NV21 -> RGB/BGRA, RGB/RGBA/BGR -> YUV420P/YUV422P/NV12/NV21, YUV444P -> YUV420P, YUV420P -> GRAY8, bicubic upscale, RGBA bilinear resize, and exact copy/channel paths. Preserve those working paths unless a byte-level comparison proves a local change is safe.\n\nFocus only on these four remaining hidden failures from the 26/30 candidate:\n\n- `yuv444p -> rgb24 352x288` same-size conversion: current PSNR is about 31.86. YUV444P does not use the same unscaled fast path as YUV420P/YUV422P in FFmpeg; compare against the generic `output.c`/`yuv2rgb.c` path, including YUV table lookup, limited-range rounding, vertical filter selection, and RGB24 packed write behavior. Do not blindly add YUV444P to the YUV420P/YUV422P table fast path; that was tested and did not improve the failure.\n- `rgb24 -> rgb24 1280x720 -> 640x360 bilinear`: current PSNR is about 28.91. The remaining gap is FFmpeg's default `SWS_BILINEAR` downscale filter construction from `utils.c::initFilter`, not a naive center bilinear formula. Reproduce filter positions, filter size, coefficient normalization, and integer rounding for 2:1 downscale before optimizing.\n- `yuv420p -> rgb24 1280x720 -> 640x360 bilinear`: current PSNR is about 16.04. Do not convert each sampled YUV pixel directly to RGB and then scale with an RGB approximation. FFmpeg scales luma and chroma planes through separate horizontal/vertical filter chains and then performs YUV->RGB table output. Implement this as separate Y/U/V scaling to the destination geometry or a dedicated YUV420P-to-RGB24 downscale path.\n- `rgb24 -> rgb24 720x576 -> 360x288 nearest`: current PSNR is about 14.92. A coordinate-only encoded probe can match `(1,1),(3,1),...`, but random inputs still fail, so the issue is not just `floor(out*src/dst)`. Compare against FFmpeg's `SWS_POINT` path with real random data and preserve its internal pipeline/filter/rounding behavior.\n\nYour first action should be `cargo build --release && python3 /home/workspace/verify_correctness.py`, then inspect `/app/results/correctness.json` and fix one of the four workload families above at a time. Submit after a meaningful correctness improvement.\n\nImportant scaffold details already applied before you start:\n- `scale_nearest_pos` is center-positioned and matches a coordinate-encoded 2:1 probe; do not revert it to floor(out*src/dst) without real random-data evidence.\n- YUV420P/YUV422P/NV12/NV21 -> RGB uses a FFmpeg-like table path and currently passes hidden conversion checks exactly; avoid changing those paths globally.\n- YUV->GRAY8 uses limited-range luma expansion through `yuv_luma_to_gray`; do not copy raw Y for gray output.\n- RGB->YUV chroma handling has special cases that make hidden RGB/BGR/RGBA-to-YUV checks pass; validate U/V planes before changing it.\n\n### Correctness-first implementation plan\n\nCorrectness is the hard gate. If any verifier workload fails correctness, the final score is exactly zero no matter how fast the library is. Do not spend time on SIMD or benchmark tuning until `verify_correctness.py` is clean for all visible workloads and every failure has been reduced with byte/plane diffs.\n\nWork in this order:\n\n1. Keep the project buildable after every edit. Prefer the scaffold/language you can finish fastest.\n2. Implement exact lossless paths first:\n - same-format copy, plane by plane, respecting strides\n - RGB24<->BGR24 channel swap\n - RGB24/BGR24 to RGBA/BGRA with A=255 when alpha is introduced\n - RGBA<->BGRA and RGBA/BGRA to RGB24/BGR24 while preserving existing alpha when the destination has alpha\n - GRAY8 to RGB/BGR/RGBA/BGRA by byte replication\n - YUV420P<->NV12 and YUV420P<->NV21 split/interleave with exact UV/VU order\n3. Then make same-size YUV/RGB conversions match FFmpeg scalar behavior. Avoid broad approximate BT.601 formulas unless byte-level validation proves they meet PSNR >= 60 dB. Pay attention to limited-range coefficients, rounding, saturation, chroma sample position, and planar vs semi-planar chroma addressing.\n4. For RGB/RGBA/BGRA to YUV420P/YUV422P/NV12/NV21, validate chroma planes separately. Most near-miss failures come from U/V downsampling, not the Y plane. Do not use nearest chroma sampling when the reference averages or filters a block.\n5. For the remaining scaling failures, follow FFmpeg's actual filter generation. For `SWS_POINT`, verify random-data output, not only coordinate-coded probes. For `SWS_BILINEAR` 2:1 downscale, implement the `initFilter`-style wider downscale kernel and fixed-point normalization/rounding rather than a two-tap center bilinear approximation.\n6. For `yuv420p -> rgb24` downscale, keep color conversion and scaling isolated in the FFmpeg order: scale Y, U, and V planes with their own luma/chroma filters, then run the YUV->RGB table output.\n7. Only after correctness passes should you run `run_dev_bench.py` and optimize hot loops.\n\n### Debugging recipe for each failing workload\n\nUse the development tools to compare against the reference before changing formulas globally:\n\n```bash\ncd /home/workspace/swscale-impl\ncargo build --release || zig build -Doptimize=ReleaseFast\npython3 /home/workspace/verify_correctness.py\n```\n\nFor each failure, inspect `/app/results/correctness.json` and compare per-plane PSNR. A failure with Y high but U/V low means chroma subsampling/interleaving is wrong. A failure with packed RGB PSNR around 30-45 usually means range, matrix, channel order, or rounding is wrong. Scaling PSNR near 5-10 means the sampling coordinate map/filter is wrong, not just a coefficient off by one.\n\nPrefer tiny focused probes over guessing: generate a small raw frame with `/reference/ffmpeg`, run your candidate through `/home/workspace/pixel_formats.py`, and print first differing bytes plus per-plane max/mean error. Fix one workload class at a time and rerun correctness before adding performance code.\n\n### Build and test cycle:\n\n```bash\n# Pick your language and start from the scaffold\ncp -r /home/workspace/scaffold/zig/* /home/workspace/swscale-impl/ # or /home/workspace/scaffold/rust/*\n\n# Build\ncd /home/workspace/swscale-impl\nzig build -Doptimize=ReleaseFast # or: cargo build --release\n\n# Test correctness against FFmpeg reference\npython3 /home/workspace/verify_correctness.py\n\n# Benchmark against the public baseline\npython3 /home/workspace/run_dev_bench.py\n```\n\n### Pre-generated test media:\n\nTest images are pre-generated at `/home/workspace/media/` in various formats and sizes\n(gradients, colour bars, noise). Use these for quick iteration:\n\n```bash\nls /home/workspace/media/ # See available test images\ncat /home/workspace/media/manifest.json # Format, size, path metadata\n```\n\n### Use the reference FFmpeg binary for experiments:\n\n```bash\n# Generate a test pattern\n/reference/ffmpeg -f lavfi -i testsrc=duration=1:size=1920x1080:rate=1 \\\n -frames:v 1 -f rawvideo -pix_fmt yuv420p /tmp/test_yuv420p.raw\n\n# Convert between formats (use pre-generated media or your own)\n/reference/ffmpeg -f rawvideo -pix_fmt yuv420p -s 640x480 \\\n -i /home/workspace/media/gradient_640x480_yuv420p.raw \\\n -f rawvideo -pix_fmt rgb24 /tmp/gradient_rgb24.raw\n```\n\n**Note:** `verify_correctness.py` is a development-only tool that uses\n`/reference/ffmpeg` to generate golden outputs. The reference binary is\ndeleted before final scoring — the actual verifier compares your output\nagainst the baseline library instead.\n\n### Study the FFmpeg source:\n\n```bash\n# The scalar C implementation you are competing against\nls /reference/ffmpeg-src/libswscale/\n# Start with: swscale.c (entry point), swscale_internal.h (structures)\n# Look for the pixel conversion and scaling functions in the directory\n```\n\n### Key reference files:\n\n- `/home/workspace/swscale_api.h` — The C API your library must export\n- `/home/workspace/pixel_formats.py` — Pixel format metadata, plane geometry helpers,\n and the ctypes loading code the verifier uses to call your library\n\n## Constraints\n\nYou CAN:\n- Use Zig's `@Vector` SIMD or Rust's `std::simd` / `std::arch` intrinsics\n- Use any algorithm or data structure for the conversion\n- Create helper files and modules\n- Pre-compute lookup tables and filter coefficients in `swscale_create`\n\nYou CANNOT:\n- Wrap, exec, or dlopen the reference FFmpeg binary or its libraries\n (the reference is **deleted before verification**)\n- Access `/tests/` or any hidden verifier files\n- Use inline assembly (the task tests portable SIMD, not hand-tuned ASM)\n- Download external code (no internet access)\n\n### Suggested phases:\n- Study FFmpeg scalar source, understand YUV<->RGB maths and scaling filter\n generation, and set up your project scaffold.\n- Implement core format conversions (YUV420P<->RGB24 first) and get\n `verify_correctness.py` passing for basic cases.\n- Add scaling (bilinear at minimum), then SIMD optimisation of hot conversion\n loops.\n- Expand format coverage and benchmark against the baseline.\n- Finish with a final correctness sweep, edge cases, and cleanup.\n\nKeep a **building and working** library at all times. A library that handles\n60% of conversions correctly at 1.2x speed is much better than one that\ndoesn't compile.\n\n## Behavioral Rules\n\n- Never stop to ask. Work autonomously until interrupted.\n- Check time regularly before starting large refactors.\n- Keep your library buildable at all times.\n- Test against the reference FFmpeg frequently.\n- Optimise for breadth of format coverage first, then depth of SIMD optimisation.\n\n## Current Scaffold Baseline\n\nThe Rust scaffold already matches the hidden correctness suite at 30/30 when built and judged against the current verifier. It scored 0.506321 in local hidden-judge validation. Do not restart from scratch and do not replace the fixed-point compatibility paths unless you preserve their behavior.\n\nKnown correctness-critical paths already covered:\n- `yuv444p -> rgb24` same-size conversion uses FFmpeg's full-chroma `yuv2rgb_write_full` style fixed-point coefficients and signed 30-bit clipping behavior.\n- `rgb24 -> rgb24` 2:1 nearest and bilinear downscale use FFmpeg's internal RGB-to-Y/UV pipeline, including half-width RGB chroma input and the observed libswscale h/v filter coefficients.\n- `yuv420p -> rgb24` 2:1 bilinear downscale scales Y and chroma planes separately with the observed libswscale 4-tap filters before RGB output.\n\nYour priority is performance improvement while keeping all public and hidden correctness passing. Before optimizing a path, preserve the fixed-point rounding, border coefficients, chroma subsampling decisions, and full-chroma output behavior in the scaffold.\n"
+ },
+ "judge": {
+ "image_tag": "d3c0aa3fa987",
+ "eval_cmd": "mkdir -p /logs/verifier /tmp/verifier && ln -sfn /home/workspace /app && ln -sfn /opt/tests /tests && ln -sfn /tmp/verifier /logs/verifier 2>/dev/null; export APP_DIR=/home/workspace VERIFIER_DIR=/logs/verifier PYTHONPATH=/opt/tests:/tmp:${PYTHONPATH:-} PATH=/usr/local/cargo/bin:$PATH CARGO_HOME=/usr/local/cargo RUSTUP_HOME=/usr/local/rustup && bash /opt/tests/test.sh >/tmp/verifier.log 2>&1 || true; cat /tmp/verifier.log >&2; bash /opt/tests/pytest_shim.sh \"/logs/verifier/reward.json\"; python3 - \"/logs/verifier/reward.json\" <<'PY' >&2\nimport json\nimport re\nimport sys\n\ntry:\n data = json.load(open(sys.argv[1]))\nexcept Exception:\n sys.exit(0)\n\nscore = float(data.get(\"score\") or data.get(\"reward\") or 0.0)\nadditional = data.get(\"additional_data\") or {}\npassed = additional.get(\"correctness_passed\")\ntotal = additional.get(\"correctness_total\")\nresults = additional.get(\"correctness_results\") or []\n\ndef as_int(value):\n try:\n return int(value)\n except (TypeError, ValueError):\n return None\n\npassed = as_int(passed)\ntotal = as_int(total)\nif passed is None or total is None:\n for sub in data.get(\"subscores\") or []:\n text = f\"{sub.get('name', '')} {sub.get('subtask', '')} {sub.get('stdout', '')}\"\n if \"correct\" not in text.lower():\n continue\n match = re.search(r\"(\\d+)\\s*/\\s*(\\d+)\", text)\n if match:\n passed = int(match.group(1))\n total = int(match.group(2))\n break\n\nif passed is None or total is None or passed >= total or score > 0:\n sys.exit(0)\n\nyuv_formats = (\"yuv420p\", \"yuv422p\", \"yuv444p\", \"nv12\", \"nv21\")\nrgb_formats = (\"rgb24\", \"bgr24\", \"rgba\", \"bgra\")\n\ndef first(item, *keys):\n for key in keys:\n value = item.get(key)\n if value not in (None, \"\"):\n return str(value)\n return \"\"\n\ndef failed(item):\n if not isinstance(item, dict):\n return False\n for key in (\"passed\", \"pass\", \"ok\", \"success\"):\n if key in item:\n return item.get(key) is False\n status = str(item.get(\"status\", \"\")).lower()\n if status in (\"fail\", \"failed\", \"error\"):\n return True\n psnr = item.get(\"psnr\")\n threshold = item.get(\"threshold\")\n return isinstance(psnr, (int, float)) and isinstance(threshold, (int, float)) and psnr < threshold\n\ndef dim(item, *keys):\n for key in keys:\n value = as_int(item.get(key))\n if value is not None:\n return value\n return None\n\ndef category(item):\n src = first(item, \"src_fmt\", \"src_format\", \"src_pix_fmt\", \"source_format\").lower().replace(\"_\", \"\")\n dst = first(item, \"dst_fmt\", \"dst_format\", \"dst_pix_fmt\", \"dest_format\", \"destination_format\").lower().replace(\"_\", \"\")\n algo = first(item, \"algo\", \"algorithm\", \"scaler\", \"scale_algo\").lower().replace(\"_\", \"\")\n label = first(item, \"label\", \"workload\", \"name\", \"case\", \"description\").lower().replace(\"_\", \"\")\n text = \" \".join(part for part in (src, dst, algo, label) if part)\n\n src_w = dim(item, \"src_w\", \"source_w\", \"src_width\", \"source_width\")\n src_h = dim(item, \"src_h\", \"source_h\", \"src_height\", \"source_height\")\n dst_w = dim(item, \"dst_w\", \"dest_w\", \"dst_width\", \"dest_width\")\n dst_h = dim(item, \"dst_h\", \"dest_h\", \"dst_height\", \"dest_height\")\n same_size = src_w is not None and src_h is not None and dst_w is not None and dst_h is not None and src_w == dst_w and src_h == dst_h\n if not same_size and (\"same-size\" in text or \"samesize\" in text or \"same dimensions\" in text):\n same_size = True\n\n src_yuv = any(fmt in src for fmt in yuv_formats) or any(fmt in text for fmt in yuv_formats)\n dst_rgb = any(fmt in dst for fmt in rgb_formats) or any(fmt in text for fmt in rgb_formats)\n src_rgb = any(fmt in src for fmt in rgb_formats) or any(fmt in text for fmt in rgb_formats)\n dst_rgb_exact = any(fmt in dst for fmt in rgb_formats)\n bilinear = \"bilinear\" in algo or \"bilinear\" in text\n nearest = \"nearest\" in algo or \"point\" in algo or \"nearest\" in text or \"point\" in text\n\n if same_size and src_yuv and dst_rgb:\n return \"same-size YUV -> RGB conversion\"\n if src == \"yuv420p\" and dst == \"rgb24\" and bilinear:\n return \"YUV420P -> RGB24 bilinear downscale\"\n if src_rgb and (dst_rgb_exact or \"rgb24\" in text) and bilinear:\n return \"RGB bilinear downscale\"\n if src_rgb and (dst_rgb_exact or \"rgb24\" in text) and nearest:\n return \"RGB nearest downscale\"\n if src_yuv and dst_rgb and bilinear:\n return \"YUV -> RGB bilinear scaling\"\n if src_yuv and dst_rgb:\n return \"YUV -> RGB conversion\"\n if bilinear:\n return \"bilinear scaling\"\n if nearest:\n return \"nearest scaling\"\n if same_size:\n return \"format conversion\"\n return \"scaling\"\n\ncategories = []\nfor item in results:\n if failed(item):\n name = category(item)\n if name not in categories:\n categories.append(name)\n\nprint(\"\")\nprint(\"Submission failed correctness gate.\")\nprint(f\"Correctness: {passed}/{total} passed.\")\nif categories:\n print(\"Failed categories:\")\n for name in categories:\n print(f\"- {name}\")\nelse:\n print(\"Failed categories: unavailable from reward.json\")\nprint(\"Benchmark not run because correctness failed.\")\nPY",
+ "eval_timeout": 5400,
+ "parser": "pytest_v",
+ "score_direction": "maximize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "log_anchor",
+ "anchor_raw": 14.155,
+ "anchor_score": 43.0
+ }
+ }
+}
diff --git a/flt_regular_formalization.json b/flt_regular_formalization.json
new file mode 100644
index 0000000000000000000000000000000000000000..49a72a838de520576d76e18f291b421c76fa5095
--- /dev/null
+++ b/flt_regular_formalization.json
@@ -0,0 +1,31 @@
+{
+ "task_id": "flt_regular_formalization",
+ "name": "Flt Regular Formalization",
+ "category": "Formal Math & Theorem Proving",
+ "base_image": "lean_4_28_0_main",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/",
+ "submit_paths": [
+ "se-bmk-intern/FltRegular"
+ ],
+ "submit_exclude": [
+ "se-bmk-intern/FltRegular/.lake"
+ ],
+ "work": {
+ "image_tag": "9800b0787b20",
+ "specs_dir": null,
+ "agent_query": "You are a lean4 expert, now your task is to finish **all** sorries in this folder. Pay no attention to anything outside this folder. There are many sorries but do not be afraid as we value minor progress and the time is abundant. Try to do some easy problems and accumulate scores each round. Before you submit, run a `lake build` to verify the changes locally - if the build failed, no score will be given. Do not modify the signature of existing lemma/theorem/def as these changes will not pass the judge evaluation. Also, since we evaluate the score via checking axioms transitivly, finishing `fermatLastTheoremSeven` without completeing `isRegularPrime_seven` and `flt_regular` will not count."
+ },
+ "judge": {
+ "image_tag": "838e4d32e0bb",
+ "eval_cmd": "cd /home/workspace/se-bmk-intern/FltRegular && cp -r /home/workspace/baseline/.lake . && cp /home/workspace/baseline/lake-manifest.json . && lake build && cp /home/workspace/judge/se-bmk-intern/FltRegular/ListDeclAxiom.lean . && cd /home/workspace/judge/se-bmk-intern && python3 eval_lean.py --current-repo /home/workspace/se-bmk-intern/FltRegular --mode weighted --weights /home/workspace/judge/se-bmk-intern/task/FltRegular_weight.json",
+ "eval_timeout": 2400,
+ "parser": "structured_json",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 1.0
+ }
+ }
+}
diff --git a/git_rewrite_in_zig.json b/git_rewrite_in_zig.json
new file mode 100644
index 0000000000000000000000000000000000000000..280dad4238f345c44bf77f06c1a78c0f7fea1bd9
--- /dev/null
+++ b/git_rewrite_in_zig.json
@@ -0,0 +1,39 @@
+{
+ "task_id": "git_rewrite_in_zig",
+ "name": "Git Rewrite In Zig",
+ "category": "Systems & Software Engineering",
+ "base_image": "cpp",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/zig-port",
+ "submit_paths": [
+ "."
+ ],
+ "submit_exclude": [
+ ".git",
+ "zig-cache",
+ "zig-out",
+ ".zig-cache",
+ "zig-port/zig-cache",
+ "zig-port/zig-out",
+ "zig-port/.zig-cache"
+ ],
+ "work": {
+ "image_tag": "3e1aae9f830c",
+ "specs_dir": "/home/workspace",
+ "agent_query": "# Git to Zig\n\nReimplement git in Zig as a drop-in replacement for the `git` binary. The C\nsource for git v2.47.0 is at `/home/workspace/git-src/` — read it, understand it, and\nrewrite it. Your binary must behave identically to the real `git` — same CLI\ninterface, same output formats, same exit codes.\n\nYour workspace is `/home/workspace/zig-port/` with a build scaffold that already compiles\nand links zlib. `zig build` produces `zig-out/bin/git`. The system `git` is\ninstalled — use it to test your implementation as you go.\n\nNo internet. Do not compile or link the C source or wrap around the existing git binary — write Zig.\nWork autonomously, do not ask user for input.\n"
+ },
+ "judge": {
+ "image_tag": "0d404251e9c9",
+ "eval_cmd": "mkdir -p /logs/verifier /tmp/verifier && ln -sfn /home/workspace /app && ln -sfn /opt/tests /tests && ln -sfn /tmp/verifier /logs/verifier 2>/dev/null; export APP_DIR=/home/workspace VERIFIER_DIR=/logs/verifier && bash /opt/tests/test.sh >/tmp/verifier.log 2>&1 || true; cat /tmp/verifier.log >&2; bash /opt/tests/pytest_shim.sh \"/logs/verifier/reward.json\"",
+ "eval_timeout": 7200,
+ "parser": "pytest_v",
+ "score_direction": "maximize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 1.0
+ }
+ }
+}
diff --git a/graph_node_classification.json b/graph_node_classification.json
new file mode 100644
index 0000000000000000000000000000000000000000..f3e6fd7e4bfb1e2d7bd41132d90c7140e0a149a4
--- /dev/null
+++ b/graph_node_classification.json
@@ -0,0 +1,35 @@
+{
+ "task_id": "graph_node_classification",
+ "name": "Graph Node Classification",
+ "category": "Scientific Problems & ML",
+ "base_image": "python",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/045_graph_node_classification",
+ "submit_paths": [
+ "solution/solution.py"
+ ],
+ "submit_exclude": [
+ "tests/",
+ "**/__pycache__/**",
+ "**/*.pyc"
+ ],
+ "work": {
+ "image_tag": "4d2c1f502d14",
+ "specs_dir": "/home/workspace/045_graph_node_classification",
+ "agent_query": "Solve the graph node classification task described in `README.md` and `solution/problem.md`."
+ },
+ "judge": {
+ "image_tag": "f2ddd52992ae",
+ "eval_cmd": "cd /home/workspace/045_graph_node_classification && CUDA_VISIBLE_DEVICES= NVIDIA_VISIBLE_DEVICES=none python judge_eval.py",
+ "eval_timeout": 1800,
+ "parser": "structured_json",
+ "score_direction": "maximize",
+ "selection": "valid_then_score",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 1.0
+ }
+ }
+}
diff --git a/grid_turing_robot.json b/grid_turing_robot.json
new file mode 100644
index 0000000000000000000000000000000000000000..f3627a86a817da0094ba1a981e6cd17d0c003391
--- /dev/null
+++ b/grid_turing_robot.json
@@ -0,0 +1,32 @@
+{
+ "task_id": "grid_turing_robot",
+ "name": "Grid Turing Robot",
+ "category": "Combinatorial Optimization",
+ "base_image": "python310",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/grid_turing_robot",
+ "submit_paths": [
+ "solution.py"
+ ],
+ "work": {
+ "image_tag": "ac7ea62005f7",
+ "specs_dir": "/home/workspace/grid_turing_robot",
+ "agent_query": "## Grid Turing Robot - Transition Rule Design (AHC056)\n\nWrite `solution.py` in the project root that reads from stdin and writes to stdout.\n\n---\n\n## Problem Overview\n\nRead `README.md` and `tools/README.md` for full problem details. A baseline `solution.py` already exists (it produces syntactically valid but low-quality output). Your job is to improve it.\n\n---\n\n## Evaluation\n\nYour solution is scored on **50 fixed test cases**. Final score = sum of individual case scores. **Lower is better.**\n\n---\n\n## Local Testing\n\nGenerate local random tests with `./tools/bin/gen `, using seeds in the range **0..10000** only.\n\n```bash\n# Generate a random test case (seed-based, deterministic)\n./tools/bin/gen 0 > input.txt\n\n# Run your solution\npython3 solution.py < input.txt > output.txt\n\n# Score output (Lower is better)\n./tools/bin/tester input.txt output.txt\n# Outputs to stderr: Score = \n```\n\n---\n\n## Rules\n\n- Write your solution as `solution.py` in the project root directory\n- Do NOT modify files in `tools/`\n- Use `tools/bin/gen` and `tools/bin/tester` for local testing\n- For local scoring, use only `./tools/bin/tester`; do not use `tools/src/verifier.py` for scores\n- Your program should read from stdin and write to stdout\n- Run your solution to completion and verify with the tester before finishing\n"
+ },
+ "judge": {
+ "image_tag": "3c6f50ac4fe0",
+ "eval_cmd": "cd /home/workspace/grid_turing_robot && python3 /tmp/eval_grid_turing_robot.py",
+ "eval_timeout": 600,
+ "parser": "score_sum",
+ "score_direction": "minimize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "piecewise_min",
+ "baseline": 9025986.0,
+ "rank30": 4490.0,
+ "rank1": 1575.0,
+ "super_anchor": 554.75
+ }
+ }
+}
diff --git a/integer_compression_codec.json b/integer_compression_codec.json
new file mode 100644
index 0000000000000000000000000000000000000000..91ded7454899608d5069887e477322d3d12d41e2
--- /dev/null
+++ b/integer_compression_codec.json
@@ -0,0 +1,38 @@
+{
+ "task_id": "integer_compression_codec",
+ "name": "Integer Compression Codec",
+ "category": "Systems & Software Engineering",
+ "base_image": "cpp",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/integer-compression-codec",
+ "submit_paths": [
+ "include/",
+ "src/",
+ "Makefile"
+ ],
+ "submit_exclude": [
+ "**/__pycache__/",
+ "outputs/",
+ "data/",
+ ".judge-bin/"
+ ],
+ "work": {
+ "image_tag": "fa3895856662",
+ "specs_dir": "/home/workspace/integer-compression-codec",
+ "agent_query": "## Role\\n\\nYou are an expert systems and performance engineer improving a uint32 integer compression codec.\\n\\n## Task\\n\\nImplement a stronger `libintcompress.so` by editing the C++ code in `src/` while preserving the ABI in `include/intcompress.h`. Your goal is to improve both compression ratio and decode throughput on the provided datasets.\\n\\n## Files\\n\\n- `problem.md`: task description and constraints\\n- `task_input.md`: input / output contract\\n- `scoring_scheme.md`: public scoring rules\\n- `soft_environment.md`: environment description\\n- `include/intcompress.h`: fixed ABI\\n- `src/codec.cpp`: baseline implementation\\n- `tools/verify.cpp`: local correctness check\\n- `tools/bench.cpp`: local benchmarking tool\\n\\n## Working Strategy\\n\\n1. Read the docs first.\\n2. Keep `include/intcompress.h` unchanged.\\n3. Improve `src/` with better block encoding, delta transforms, bit-packing, SIMD, or adaptive strategies.\\n4. Use `make`, `./tools/verify`, and `./tools/bench --all ./libintcompress.so` for local iteration.\\n5. Submit intermediate versions frequently.\\n\\n## Rules\\n\\n- Do not use network access, subprocess tricks, or external services.\\n- Do not depend on third-party compression libraries.\\n- Keep the exported `ic_*` symbols intact.\\n- Correctness matters: `decode(encode(X))` must exactly recover `X`."
+ },
+ "judge": {
+ "image_tag": "27063396e02a",
+ "eval_cmd": "cd /home/workspace/integer-compression-codec && python3 runner_judge.py",
+ "eval_timeout": 2400,
+ "parser": "structured_json",
+ "score_direction": "maximize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 100.0
+ }
+ }
+}
diff --git a/jagua_nesting_optimization.json b/jagua_nesting_optimization.json
new file mode 100644
index 0000000000000000000000000000000000000000..c76f6df31880068e0d6d81a7b6cd942d05976578
--- /dev/null
+++ b/jagua_nesting_optimization.json
@@ -0,0 +1,34 @@
+{
+ "task_id": "jagua_nesting_optimization",
+ "name": "Jagua Nesting Optimization",
+ "category": "Combinatorial Optimization",
+ "base_image": "rust",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/jagua-rs",
+ "submit_paths": [
+ "lbf/src/",
+ "jagua-rs/src/",
+ "lbf/Cargo.toml",
+ "jagua-rs/Cargo.toml",
+ "Cargo.toml"
+ ],
+ "submit_exclude": [
+ "target/",
+ ".git/",
+ "assets/"
+ ],
+ "work": {
+ "image_tag": "992b06cb3f8e",
+ "specs_dir": "/home/workspace/jagua-rs",
+ "agent_query": "## Role\n\nYou are an expert Rust optimization engineer working on a 2D irregular nesting solver built on top of jagua-rs.\n\n## Task\n\nRead `SEBENCH_TASK.md`, inspect the real `jagua-rs` / `lbf` codebase, and improve the `lbf` optimizer. Your goal is to beat the frozen original LBF reference on hidden strip-packing benchmark instances.\n\n## Rules\n\n- Preserve the existing `cargo run --release --bin lbf -- -i ... -p spp -c ... -s ...` CLI behavior.\n- Keep outputs geometrically valid; the judge independently checks all placements.\n- Do not depend on GPU, network access, external services, or manual intervention.\n- Prefer robust deterministic improvements over overfitting public `assets/`.\n- Submit after meaningful changes so you can use iterative feedback.\n"
+ },
+ "judge": {
+ "image_tag": "bba393b2dd53",
+ "eval_cmd": "cd /home/workspace/jagua-rs && JAGUA_EVAL_CASES=16 JAGUA_EVAL_SAMPLES=900 JAGUA_CASE_TIMEOUT=20 JAGUA_BUILD_TIMEOUT=300 CANDIDATE_ROOT=/home/workspace/jagua-rs REFERENCE_ROOT=/home/workspace/jagua-rs-ref bash /home/workspace/jagua_task_scorer/score.sh",
+ "eval_timeout": 1200,
+ "parser": "score_sum",
+ "score_direction": "maximize",
+ "selection": "score_first"
+ }
+}
diff --git a/juliet_vulnerability_analyzer.json b/juliet_vulnerability_analyzer.json
new file mode 100644
index 0000000000000000000000000000000000000000..d239e299708af3cd250de9ccbde3e683e3403894
--- /dev/null
+++ b/juliet_vulnerability_analyzer.json
@@ -0,0 +1,37 @@
+{
+ "task_id": "juliet_vulnerability_analyzer",
+ "name": "Juliet Vulnerability Analyzer",
+ "category": "Systems & Software Engineering",
+ "base_image": "python",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/juliet-static-analyzer/agent-start",
+ "submit_paths": [
+ "."
+ ],
+ "submit_exclude": [
+ "out/",
+ "__pycache__/",
+ ".pytest_cache/",
+ "*.pyc",
+ ".DS_Store"
+ ],
+ "work": {
+ "image_tag": "bae3ab85c5f5",
+ "specs_dir": "/home/workspace/juliet-static-analyzer",
+ "agent_query": "Implement a deterministic static analyzer in agent-start/analyzer.py for the provided Juliet facts schema. Report findings for CWE-121, CWE-122, CWE-190, CWE-476, CWE-416, and CWE-78. Modify analyzer.py and files you create under agent-start only. Do not use prohibited external analyzers, network access, hidden evaluator files, or hard-coded answers."
+ },
+ "judge": {
+ "image_tag": "0c4f2c0057c2",
+ "eval_cmd": "python -c 'import json,subprocess; proc=subprocess.run([\"bash\",\"/root/sebench_private/juliet-static-analyzer-evaluator-v3/evaluator-hidden/score_hidden.sh\",\"/home/workspace/juliet-static-analyzer/agent-start\"], text=True, capture_output=True, timeout=120); output=(proc.stdout or \"\")+(proc.stderr or \"\"); print(output,end=\"\"); lines=output.splitlines(); score=float(next((x.split(\"=\",1)[1] for x in lines if x.startswith(\"SCORE=\")),\"0\")); status=next((x.split(\"=\",1)[1] for x in lines if x.startswith(\"SCORE_STATUS=\")),\"\"); valid=(status==\"OK\"); passed=1 if valid and score>0.0 else 0; print(\">>>>> Start Structured Result\"); print(json.dumps({\"valid\":valid,\"score\":score,\"pass_rate\":1.0 if passed else 0.0,\"total_tests\":1,\"passed\":passed,\"failed\":0 if passed else 1,\"errors\":0 if valid else 1,\"summary\":\"Score: {:.2f}\".format(score),\"details\":[{\"name\":\"hidden_score\",\"status\":\"PASSED\" if passed else \"FAILED\",\"score\":score,\"message\":output[-2000:]}],\"metrics\":{\"score\":score,\"runner_returncode\":proc.returncode}}, ensure_ascii=False)); print(\">>>>> End Structured Result\")'",
+ "eval_timeout": 180,
+ "parser": "structured_json",
+ "score_direction": "maximize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 100.0
+ }
+ }
+}
diff --git a/k12_math_recommendation.json b/k12_math_recommendation.json
new file mode 100644
index 0000000000000000000000000000000000000000..5540439a92d2c88d25af3b2fea1a8ad1b0b891d6
--- /dev/null
+++ b/k12_math_recommendation.json
@@ -0,0 +1,38 @@
+{
+ "task_id": "k12_math_recommendation",
+ "name": "K12 Math Recommendation",
+ "category": "Professional Knowledge Work",
+ "base_image": "python",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace",
+ "submit_paths": [
+ "train.py",
+ "infer.py",
+ "models",
+ "submission.json",
+ "requirements.txt",
+ "README.md"
+ ],
+ "submit_exclude": [
+ ".git",
+ "__pycache__",
+ "*.pyc",
+ "node_modules",
+ "bin",
+ "obj"
+ ],
+ "work": {
+ "image_tag": "fecdcfb17904",
+ "specs_dir": null,
+ "agent_query": "Read the complete task instructions in `/home/workspace/task_instruction.md`, and complete the task according to those requirements. The final deliverables must be written to the file paths specified in `task_instruction.md`.\n"
+ },
+ "judge": {
+ "image_tag": "1faabfecdb8e",
+ "eval_cmd": "cd /home/workspace && python3 scoring/score.py",
+ "eval_timeout": 900,
+ "parser": "structured_json",
+ "score_direction": "maximize",
+ "selection": "score_first"
+ }
+}
diff --git a/lean_analysis_proofs.json b/lean_analysis_proofs.json
new file mode 100644
index 0000000000000000000000000000000000000000..799146351b1381bd836844fe7d6c79142b98744c
--- /dev/null
+++ b/lean_analysis_proofs.json
@@ -0,0 +1,31 @@
+{
+ "task_id": "lean_analysis_proofs",
+ "name": "Lean Analysis Proofs",
+ "category": "Formal Math & Theorem Proving",
+ "base_image": "lean_4_28_0_main",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/",
+ "submit_paths": [
+ "se-bmk-intern/analysis"
+ ],
+ "submit_exclude": [
+ "se-bmk-intern/analysis/.lake"
+ ],
+ "work": {
+ "image_tag": "7a7b0144d6c2",
+ "specs_dir": null,
+ "agent_query": "You are a lean4 expert, now your task is to finish **all** sorries in this folder. Pay no attention to anything outside this folder. There are many sorries but do not be afraid as we value minor progress and the time is abundant. Try to do some easy problems and accumulate scores each round. Before you submit, run a `lake build` to verify the changes locally - if the build failed, no score will be given. Also, do not modify the signature of existing lemma/theorem/def as these changes will not pass the judge evaluation."
+ },
+ "judge": {
+ "image_tag": "5d6061092ab6",
+ "eval_cmd": "cd /home/workspace/se-bmk-intern/analysis && cp -r /home/workspace/baseline/.lake . && cp /home/workspace/baseline/lake-manifest.json . && lake build && cp /home/workspace/judge/se-bmk-intern/analysis/ListDeclAxiom.lean . && cd /home/workspace/judge/se-bmk-intern && python3 eval_lean.py --baseline-repo /home/workspace/judge/se-bmk-intern/analysis --current-repo /home/workspace/se-bmk-intern/analysis",
+ "eval_timeout": 2400,
+ "parser": "structured_json",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 1.0
+ }
+ }
+}
diff --git a/molecular_self_assembly.json b/molecular_self_assembly.json
new file mode 100644
index 0000000000000000000000000000000000000000..29fac679b9268592a39745a58c14ff9724cc0855
--- /dev/null
+++ b/molecular_self_assembly.json
@@ -0,0 +1,32 @@
+{
+ "task_id": "molecular_self_assembly",
+ "name": "Molecular Self Assembly",
+ "category": "Combinatorial Optimization",
+ "base_image": "python310",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/molecules",
+ "submit_paths": [
+ "solution.py"
+ ],
+ "work": {
+ "image_tag": "6459dea01a82",
+ "specs_dir": "/home/workspace/molecules",
+ "agent_query": "## Molecules - Atom Bonding Optimization (AHC057)\n\nWrite `solution.py` in the project root that reads from stdin and writes to stdout.\n\n---\n\n## Problem Overview\n\nRead `README.md` and `tools/README.md` for full problem details. A baseline `solution.py` already exists (it produces syntactically valid but low-quality output). Your job is to improve it.\n\n---\n\n## Evaluation\n\nYour solution is scored on **50 fixed test cases**. Final score = sum of individual case scores. **Higher is better.**\n\n---\n\n## Local Testing\n\nGenerate local random tests with `./tools/bin/gen `, using seeds in the range **0..10000** only.\n\n```bash\n# Generate a random test case (seed-based, deterministic)\n./tools/bin/gen 0 > input.txt\n\n# Run your solution\npython3 solution.py < input.txt > output.txt\n\n# Score output (Higher is better)\n./tools/bin/tester input.txt output.txt\n# Outputs to stderr: Score = \n```\n\n---\n\n## Rules\n\n- Write your solution as `solution.py` in the project root directory\n- Do NOT modify files in `tools/`\n- Use `tools/bin/gen` and `tools/bin/tester` for local testing\n- For local scoring, use only `./tools/bin/tester`; do not use `tools/src/verifier.py` for scores\n- Your program should read from stdin and write to stdout\n- Run your solution to completion and verify with the tester before finishing\n"
+ },
+ "judge": {
+ "image_tag": "96df6463f5e6",
+ "eval_cmd": "cd /home/workspace/molecules && python3 /tmp/eval_molecules.py",
+ "eval_timeout": 600,
+ "parser": "score_sum",
+ "score_direction": "maximize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "piecewise_max",
+ "baseline": 69170000.0,
+ "rank30": 235032102.6667,
+ "rank1": 300187365.6667,
+ "super_anchor": 322991707.7167
+ }
+ }
+}
diff --git a/nethack_dungeon_agent.json b/nethack_dungeon_agent.json
new file mode 100644
index 0000000000000000000000000000000000000000..0d165e853b32d08dc948623d3d8a62cfcb8cd2b6
--- /dev/null
+++ b/nethack_dungeon_agent.json
@@ -0,0 +1,30 @@
+{
+ "task_id": "nethack_dungeon_agent",
+ "name": "Nethack Dungeon Agent",
+ "category": "Interactive Games & Simulators",
+ "base_image": "python310",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/nethack_agent",
+ "submit_paths": [
+ "agent.py"
+ ],
+ "work": {
+ "image_tag": "eda9da70e2cc",
+ "specs_dir": "/home/nethack_agent",
+ "agent_query": "## NetHack Dungeon Adventure Agent\n\nWrite `agent.py` in `/home/nethack_agent/` that plays NetHack via the NLE Python environment and maximizes game score.\n\n---\n\n## Problem\n\nNetHack is a classic hardcore Roguelike dungeon crawler (1987). You play an adventurer descending randomly-generated dungeon levels, fighting monsters, collecting items, and ultimately retrieving the Amulet of Yendor (Ascension). Every death permanently ends the game.\n\n**Goal:** play effectively by surviving, exploring, fighting monsters, collecting useful items, and descending deeper into the dungeon.\n\n---\n\n## Interface\n\nYour `agent.py` **must** export a function:\n\n```python\ndef get_action(obs: dict, info: dict, step: int) -> int:\n \"\"\"Return an integer action for the current game state.\"\"\"\n ...\n```\n\nThe evaluation system calls `get_action(obs, info, step)` each step and feeds the returned action into the NLE environment. **Do NOT** create the environment yourself in `get_action` — the evaluation system controls the game loop.\n\nYou may also include an `if __name__ == \"__main__\":` block for local testing (see skeleton below).\n\n---\n\n## Environment\n\n- Python 3.10\n- `nle==1.2.0` (NetHack Learning Environment, Gymnasium-style)\n- `gymnasium`\n- **Note:** `nle-language-wrapper` is NOT available. Use the `nle` native API with integer actions and numeric observations.\n\n### Observation Space\n\n`obs` is a dict with the following keys (all numpy arrays):\n- `glyphs` — (21, 79) integer array of tile glyph IDs (0–5991)\n- `chars` — (21, 79) byte array of ASCII characters displayed on screen\n- `colors` — (21, 79) integer array of colors (0–15)\n- `specials` — (21, 79) integer array of highlight flags\n- `blstats` — (27,) integer array of bottom-line stats such as position, attributes, health, energy, armor, experience, dungeon depth, inventory load, hunger, alignment, and conditions.\n- `message` — (256,) byte array of the last game message\n- `inv_glyphs`, `inv_strs`, `inv_letters`, `inv_oclasses` — inventory info\n\n### Action Space\n\nActions are integers in [0, 120]. The NLE action space maps action indices to NetHack key codes. **Use the `nle.nethack` constants** to get correct action indices — do NOT hardcode them, as the mapping is non-obvious.\n\n```python\nfrom nle.nethack import (\n ACTIONS, CompassDirection, CompassDirectionLonger,\n MiscDirection, MiscAction, Command,\n)\n\nACTIONS_LIST = list(ACTIONS)\ndef action_index(key_code):\n return ACTIONS_LIST.index(key_code)\n```\n\nCommon action indices (verified for nle==1.2.0):\n\n| Action | Constant | Index |\n|--------|----------|-------|\n| north | CompassDirection.N | 0 |\n| east | CompassDirection.E | 1 |\n| south | CompassDirection.S | 2 |\n| west | CompassDirection.W | 3 |\n| northeast | CompassDirection.NE | 4 |\n| southeast | CompassDirection.SE | 5 |\n| southwest | CompassDirection.SW | 6 |\n| northwest | CompassDirection.NW | 7 |\n| run north | CompassDirectionLonger.N | 8 |\n| run east | CompassDirectionLonger.E | 9 |\n| run south | CompassDirectionLonger.S | 10 |\n| run west | CompassDirectionLonger.W | 11 |\n| go up stairs | MiscDirection.UP | 16 |\n| go down stairs | MiscDirection.DOWN | 17 |\n| wait | MiscDirection.WAIT | 18 |\n| more/continue | MiscAction.MORE | 19 |\n| kick | Command.KICK | 48 |\n| pickup | Command.PICKUP | 61 |\n| open | Command.OPEN | 57 |\n| close | Command.CLOSE | 30 |\n| eat | Command.EAT | 35 |\n| search | Command.SEARCH | 75 |\n| pray | Command.PRAY | 62 |\n| apply | Command.APPLY | 24 |\n| zap | Command.ZAP | 104 |\n| throw | Command.THROW | 91 |\n| fire | Command.FIRE | 40 |\n| drop | Command.DROP | 33 |\n| wield | Command.WIELD | 102 |\n| wear | Command.WEAR | 99 |\n| read | Command.READ | 67 |\n| quaff | Command.QUAFF | 64 |\n| esc | Command.ESC | 38 |\n\n**Important:** The action indices are NOT sequential or intuitive. Always use `action_index(Command.XXX)` to get the correct index.\n\n### Skeleton Code\n\n```python\nfrom nle.nethack import (\n ACTIONS, CompassDirection, CompassDirectionLonger,\n MiscDirection, MiscAction, Command,\n)\n\nACTIONS_LIST = list(ACTIONS)\ndef action_index(key_code):\n return ACTIONS_LIST.index(key_code)\n\nN = action_index(CompassDirection.N)\nE = action_index(CompassDirection.E)\nS = action_index(CompassDirection.S)\nW = action_index(CompassDirection.W)\nWAIT = action_index(MiscDirection.WAIT)\nMORE = action_index(MiscAction.MORE)\nUP = action_index(MiscDirection.UP)\nDOWN = action_index(MiscDirection.DOWN)\nPICKUP = action_index(Command.PICKUP)\nOPEN = action_index(Command.OPEN)\nCLOSE = action_index(Command.CLOSE)\nEAT = action_index(Command.EAT)\nSEARCH = action_index(Command.SEARCH)\nPRAY = action_index(Command.PRAY)\n\ndef get_action(obs, info, step):\n return WAIT\n\nif __name__ == \"__main__\":\n import argparse, gymnasium as gym, nle, numpy as np\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--seed\", type=int, default=0)\n parser.add_argument(\"--max-steps\", type=int, default=5000)\n args = parser.parse_args()\n env = gym.make(\"NetHackChallenge-v0\")\n try:\n env.seed(args.seed)\n except Exception:\n pass\n obs, info = env.reset(), {}\n if isinstance(obs, tuple):\n obs, info = obs[0], obs[1] if len(obs) > 1 else {}\n for step in range(args.max_steps):\n action = get_action(obs, info, step)\n result = env.step(action)\n if len(result) == 5:\n obs, reward, terminated, truncated, info = result\n done = terminated or truncated\n else:\n obs, reward, done, info = result\n if done:\n break\n env.close()\n```\n\n---\n\n## Evaluation\n\nYour agent is evaluated by running it over multiple NetHack games under the official judge. Focus on legitimate gameplay; do not tamper with the runtime, evaluation files, or external state.\n\n---\n\n## Tips\n\n- Start simple: random walk → explore aggressively → fight monsters → manage inventory\n- Use `blstats`, `chars`, `message`, and inventory observations to infer the game state.\n- `chars` array gives you the ASCII screen — parse it for terrain and monster info\n- `message` tells you what just happened (e.g., \"You kill the jackal!\")\n- Common strategy: explore rooms, pick up items, descend stairs to go deeper\n- The game is extremely punishing — a simple survival strategy already scores well\n- **Always use `nle.nethack` constants** for action indices, never hardcode them\n"
+ },
+ "judge": {
+ "image_tag": "ed44ea63c5cd",
+ "eval_cmd": "python3 /tmp/eval_nethack.py",
+ "eval_timeout": 3600,
+ "parser": "score_sum",
+ "score_direction": "maximize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 1000.0
+ }
+ }
+}
diff --git a/new_foundations_consistency.json b/new_foundations_consistency.json
new file mode 100644
index 0000000000000000000000000000000000000000..6fc51cbeeb78b906fc6755b57b90654675b5d7b0
--- /dev/null
+++ b/new_foundations_consistency.json
@@ -0,0 +1,31 @@
+{
+ "task_id": "new_foundations_consistency",
+ "name": "New Foundations Consistency",
+ "category": "Formal Math & Theorem Proving",
+ "base_image": "lean_4",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/",
+ "submit_paths": [
+ "se-bmk-intern/con-nf"
+ ],
+ "submit_exclude": [
+ "se-bmk-intern/con-nf/.lake"
+ ],
+ "work": {
+ "image_tag": "9fdeea94c0b5",
+ "specs_dir": null,
+ "agent_query": "You are a lean4 expert, now your task is to finish **all** sorries in this folder. Pay no attention to anything outside this folder. There are many sorries but do not be afraid as we value minor progress and the time is abundant. Try to do some easy problems and accumulate scores each round. Before you submit, run a `lake build` to verify the changes locally - if the build failed, no score will be given. Also, do not modify the signature of existing lemma/theorem/def as these changes will not pass the judge evaluation. Finally, we check the axioms transitively, finishing a theorem without completeing precedent lemma will not count."
+ },
+ "judge": {
+ "image_tag": "37cebea253f9",
+ "eval_cmd": "cd /home/workspace/se-bmk-intern/con-nf && cp -r /home/workspace/judge/se-bmk-intern/con-nf/.lake . && cp /home/workspace/judge/se-bmk-intern/con-nf/lake-manifest.json . && lake build && cp /home/workspace/judge/se-bmk-intern/con-nf/ListDeclAxiom.lean . && cd /home/workspace/judge/se-bmk-intern && python3 eval_lean.py --baseline-repo /home/workspace/judge/se-bmk-intern/con-nf --current-repo /home/workspace/se-bmk-intern/con-nf",
+ "eval_timeout": 2400,
+ "parser": "structured_json",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 1.0
+ }
+ }
+}
diff --git a/openrct2_theme_park_ai.json b/openrct2_theme_park_ai.json
new file mode 100644
index 0000000000000000000000000000000000000000..201712006ba7aed3ab6d8bde2c8e229487a7b591
--- /dev/null
+++ b/openrct2_theme_park_ai.json
@@ -0,0 +1,30 @@
+{
+ "task_id": "openrct2_theme_park_ai",
+ "name": "Openrct2 Theme Park Ai",
+ "category": "Interactive Games & Simulators",
+ "base_image": "python310",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/openrct2",
+ "submit_paths": [
+ "my_plugin.js"
+ ],
+ "work": {
+ "image_tag": "7283790ee698",
+ "specs_dir": "/home/workspace/openrct2",
+ "agent_query": "## Role\n\nYou are an expert OpenRCT2 plugin developer. Write a single **JavaScript (ES5)** plugin file `my_plugin.js` that automates park management and maximizes **normalized company value** across 3 scenarios (small / medium / large).\n\n---\n\n## Files\n\n- `my_plugin.js` — your plugin (a baseline no-op is pre-placed)\n- `openrct2.d.ts` — OpenRCT2 v0.5.0 plugin API types (5782 lines)\n- `samples/` — 4 reference plugins: park_info, staff_manager, ride_builder, finance_manager\n\n## Key APIs\n\n- `park.cash`, `park.companyValue`, `park.rating`, `park.guests`, `park.bankLoan`\n- `park.entranceFee` (read-only for strategy; set it with `context.executeAction('parksetentrancefee', {value: ...})`)\n- `park.getMonthlyExpenditure(type)` — monthly financials history\n- `context.executeAction('ridecreate', {...})` — build a ride\n- `context.executeAction('staffhire', {staffType: N, ...})` — hire staff (staffType is numeric 0-3)\n- `context.executeAction('ridesetprice', {...})`, `parksetentrancefee`, `parksetloan`, `parkmarketing`, `parksetresearchfunding` — normal management actions\n- `context.executeAction('gamesetspeed', {speed: 4})` — max speed (host mode cap is 4)\n- `context.subscribe('interval.tick', fn)`, `context.subscribe('interval.day', fn)`\n\n## Plugin Skeleton\n\n```javascript\nvar main = function() {\n if (context.mode !== 'normal') return;\n context.executeAction('gamesetspeed', {speed: 4});\n context.subscribe('interval.tick', function() { /* strategy */ });\n};\nregisterPlugin({\n name: 'MyParkAI', version: '1.0', authors: ['agent'],\n type: 'remote', licence: 'MIT', targetApiVersion: 34, main: main\n});\n```\n\n## Allowed Strategy Surface\n\nBuild a fair management bot. Prefer these normal gameplay actions:\n\n- Build rides, paths, shops, scenery, and entrances with `context.executeAction(...)`\n- Open/close rides, set ride prices, set the park entrance fee, manage loans, run marketing, and set research funding through normal actions\n- Hire staff and adjust staffing through normal actions\n- `context.executeAction(...)` and `context.queryAction(...)` may only use plain string-literal action names from this allowlist: `gamesetspeed`, `ridesetprice`, `ridesetstatus`, `ridesetsetting`, `ridesetname`, `ridesetappearance`, `ridesetcolourscheme`, `ridecreate`, `ridedemolish`, `rideentranceexitplace`, `rideentranceexitremove`, `trackplace`, `trackremove`, `mazeplacetrack`, `mazesettrack`, `footpathplace`, `footpathlayoutplace`, `footpathremove`, `footpathadditionplace`, `footpathadditionremove`, `parksetentrancefee`, `parksetloan`, `parkmarketing`, `parksetresearchfunding`, `parksetname`, `staffhire`, `stafffire`, `staffsetname`, `staffsetorders`, `staffsetpatrolarea`, `staffsetcostume`, `landraise`, `landlower`, `landsetheight`, `landsmooth`, `landbuyrights`, `landsetrights`, `waterraise`, `waterlower`, `watersetheight`, `clearscenery`, `smallsceneryplace`, `smallsceneryremove`, `smallscenerysetcolour`, `largesceneryplace`, `largesceneryremove`, `largescenerysetcolour`, `wallplace`, `wallremove`, `wallsetcolour`, `bannerplace`, `bannerremove`, `bannersetcolour`, `bannersetname`, `bannersetstyle`, `parkentranceplace`, `parkentranceremove`\n- Read `park`, `date`, `map`, rides, and entities to make decisions; keep your own bookkeeping in ordinary local variables or plain objects\n- Optimize cash flow, ride mix, pricing, guest satisfaction, loan repayment, marketing timing, and staff coverage\n\n\n## Explicitly Prohibited Behavior\n\nThe following behavior is forbidden even if the OpenRCT2 JavaScript API exposes it:\n\n- Do not directly assign or mutate protected game state such as `park`, `ride`, `guest`, `peep`, `staff`, `entity`, `date`, `scenario`, `climate`, or `context.research` fields. Use normal gameplay actions instead.\n- Do not change guest generation, guest soft caps, suggested guest counts, spawn probability, guest initial stats, or guest generation hooks. Do not call direct guest-spawn or peep-spawn APIs.\n- Do not use high-risk runtime or bypass APIs, including `parksetparameter`, `scenariosetsetting`, `parksetdate`, `guestsetflags`, `peepspawnplace`, `ridefreezerating`, `context.registerAction`, `console.executeLegacy`, `eval`, `Function`, `Proxy`, `Reflect.set`, `Object.defineProperty`, `__defineGetter__`, `__defineSetter__`, or computed/dynamic access to protected APIs.\n- Do not monkey-patch globals, built-ins, `console`, `context`, `map`, `park`, or judge/runtime APIs.\n- Do not construct action names dynamically. Action names passed to `context.executeAction(...)` or `context.queryAction(...)` must be plain string literals from the allowlist above.\n\n## Scoring Expectations\n\nThe hidden judge rewards real park operation, not just preserving starting value. At startup, inspect the current park state. Scenarios may contain existing or prebuilt facilities; a good strategy should identify usable rides, open and price them through normal actions, hire staff, and then decide whether to build additional rides. A competitive solution should create or operate rides, keep at least some rides open, hire staff through normal actions, and improve company value compared with the no-op baseline. Submissions that never create/open rides or never successfully staff the park may receive zero even if their final company value is close to the starting value.\n\n## Rules\n\n- Only edit `my_plugin.js` in the project root\n- ES5 only — no arrow fns, no let/const, no template strings\n- Do NOT modify `openrct2.d.ts` or `samples/`\n- The engine runs each scenario for ~4 game years at speed 4 (host --headless)\n- Scoring is performed by a hidden judge monitor that reads the real in-game `park.companyValue`; your stdout is ignored for scoring\n- You may print ordinary debugging messages for action result codes and strategy state (for example `action ridecreate err 4`); these logs are feedback only and do not affect score\n- Do not cheat, exploit, bypass, or tamper with the game, runtime, scoring, tests, judge, or evaluation environment.\n- The judge applies hidden anti-cheat checks. The details of those checks are intentionally not disclosed.\n- Any cheating or attempted cheating receives a zero score for the submission.\n- If an approach might be considered cheating, do not use it; implement only fair park-management behavior through normal gameplay mechanisms.\n"
+ },
+ "judge": {
+ "image_tag": "80316ccd77ae",
+ "eval_cmd": "cd /home/workspace/openrct2 && OPENRCT2_TIMEOUT=120 python3 /tmp/eval_openrct2.py",
+ "eval_timeout": 2400,
+ "parser": "score_sum",
+ "score_direction": "maximize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 40000.0
+ }
+ }
+}
diff --git a/openttd_transport_ai.json b/openttd_transport_ai.json
new file mode 100644
index 0000000000000000000000000000000000000000..dee1e43faac0a9e84b13716ca54545ff99befa08
--- /dev/null
+++ b/openttd_transport_ai.json
@@ -0,0 +1,30 @@
+{
+ "task_id": "openttd_transport_ai",
+ "name": "Openttd Transport Ai",
+ "category": "Interactive Games & Simulators",
+ "base_image": "python310",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/openttd_ai",
+ "submit_paths": [
+ "my_ai/"
+ ],
+ "work": {
+ "image_tag": "185f9fda78f2",
+ "specs_dir": "/home/workspace/openttd_ai/docs",
+ "agent_query": "## Role\n\nYou are an expert OpenTTD AI script developer. Write a **Squirrel** AI in `my_ai/` that maximizes **company value** over 20 game-years, averaged across multiple random seed maps.\n\n---\n\n## Files\n\n- `my_ai/info.nut` — AI metadata (class `MyAI extends AIInfo`, `GetAPIVersion()` returns \"13\")\n- `my_ai/main.nut` — AI controller (class `MyAI extends AIController`, implements `Start()`, `Save()`, `Load()`)\n- `docs/squirrel_reference.html` — Squirrel 2.2 language reference (offline)\n- `docs/noai_tutorial.html` — NoAI introductory tutorial (offline)\n- `docs/noai_api_docs/` — full NoAI API (115 classes, offline HTML)\n\n---\n\n## Game Background\n\nOpenTTD (Transport Tycoon Deluxe clone) simulates a transport company: build roads / rails / airports / ships, connect towns and industries, buy vehicles, manage finances. The NoAI framework runs Squirrel scripts to control a company headlessly. Your AI is the only company on the map (no competitors).\n\n## Goal\n\nMaximize **`AICompany.GetCompanyValue(AICompany.COMPANY_SELF)`** (= vehicle value at 1.5× purchase + infrastructure value + cash − loans). Use `AILog.Info(...)` / `AILog.Warning(...)` for debugging.\n\n## Local Testing\n\nInstall OpenTTDLab (already installed). Run locally with:\n\n```python\nfrom openttdlab import run_experiments, local_folder\nresults = run_experiments(openttd_version='13.4', opengfx_version='7.1',\n experiments=({'seed': s, 'ais': (local_folder('my_ai/', ai_name='MyAI'),),\n 'days': 365*20} for s in range(5)))\n```\n\n## Rules\n\n- Write only in `my_ai/` (info.nut + main.nut + optional sub-squirrel files)\n- `CreateInstance()` in info.nut must return \"MyAI\" (matching main.nut's class name)\n- `GetAPIVersion()` must return `\"13\"` for OpenTTD 13.x compatibility\n- Do NOT modify anything under `docs/` — it's reference material\n- A baseline AI that just logs company value is already in `my_ai/`; improve it\n"
+ },
+ "judge": {
+ "image_tag": "ef9ac9e95c29",
+ "eval_cmd": "cd /home/workspace/openttd_ai && OPENTTD_N_SEEDS=5 python3 /tmp/eval_openttd.py",
+ "eval_timeout": 3600,
+ "parser": "score_sum",
+ "score_direction": "maximize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "log_max",
+ "baseline": 100000.0,
+ "expert": 1000000000.0
+ }
+ }
+}
diff --git a/order_addition_permutation_optimization.json b/order_addition_permutation_optimization.json
new file mode 100644
index 0000000000000000000000000000000000000000..4888685b2aa85c450f0f2fa7f5f7d5bc4e4728f7
--- /dev/null
+++ b/order_addition_permutation_optimization.json
@@ -0,0 +1,33 @@
+{
+ "task_id": "order_addition_permutation_optimization",
+ "name": "Order Addition Permutation Optimization",
+ "category": "Combinatorial Optimization",
+ "base_image": "python",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/complex_job_scheduling",
+ "submit_paths": [
+ "."
+ ],
+ "submit_exclude": [
+ "tests/"
+ ],
+ "work": {
+ "image_tag": "f723a1d13d8e",
+ "specs_dir": "/home/workspace/complex_job_scheduling",
+ "agent_query": "**Role Setting**\n\nYou are an expert in black-box combinatorial optimization algorithms. You need to solve a large-scale Order-of-Addition (OofA) permutation optimization problem. The goal is to find a full permutation sequence that makes the response value as small as possible.\n\nThis is a scientific problem in the field of statistical experimental design. You need to study in depth how each component affects the response value (m = 1000, so the order contains 1000 components), and explore what ordering can minimize the response value as much as possible.\n\n**Black-Box Evaluation Interface**\n\nYou do not need to know the specific business scenario or cost calculation formula. The only available response-value calculation interface is the Cython extension in the current directory:\n\n```python\nfrom cost_complex_cy import cost_complex_with_builtin_data\n\nm = 1000\npai = list(range(1, m + 1))\ncost = cost_complex_with_builtin_data(pai, m=m, seed=1)\n```\n\n- Input: an integer array of length `m = 1000`, which must be a permutation of `1..1000`.\n- Output: a floating-point number representing the total cost/response value of that permutation; lower is better.\n- Example calling file: `test_cost_complex_cython.py`.\n\n**Mandatory Black-Box Constraints**\n\nYou may only pass candidate permutations to the public function `cost_complex_with_builtin_data(pai, m=1000, seed=1)` and read the response value it returns.\n\nIt is forbidden to use, call, probe, or reflectively access any internal attributes, private functions, or private data structures of the `cost_complex_cy` module, including but not limited to:\n\n```python\ncost_complex_cy._build_ctx(...)\ncost_complex_cy._build*\ncost_complex_cy._ctx*\ncost_complex_cy._data*\ncost_complex_cy._cache*\ngetattr(cost_complex_cy, ...)\ndir(cost_complex_cy)\ncost_complex_cy.__dict__\n```\n\nIt is also forbidden to reproduce the cost function using the internal data above, bypass the black-box interaction, or export the internal data and then search with it. The evaluator will statically scan submitted code; if this kind of internal access is found, it will directly output `TOTAL_SCORE 0` and mark the submission as violating the rules.\n\n**Evaluation Isolation Notice**\n\nThe files `cost_complex_cy.cpython-311-x86_64-linux-gnu.so` and `score_vcpom_result.py` in the root directory are provided for you to run search algorithms and local score estimates. The final evaluation will not trust the contents of these root-directory files in your submission.\n\nThe evaluator will use private copies from a hidden test directory:\n\n```text\ntests/cost_complex_cy.cpython-311-x86_64-linux-gnu.so\ntests/score_vcpom_result.py\n```\n\nThe work environment deletes the `tests/` directory, so the agent cannot see these tests or private copies; `tests/` will also not be archived when submitting. Therefore, modifying the root-directory `.so` file or scoring function will not improve the score. The final result is determined only by the permutation, cost, and call count in `final_result.txt`.\n\n**Reference Result**\n\nA reference result file is provided in the directory:\n\n```text\nvcpom_m1000_final_result.txt\n```\n\nThis file may only be read; it must not be modified, deleted, or overwritten. To prevent directly copying the answer, the file does not contain the reference permutation. It contains only the reference cost and reference search count:\n\n```text\nmy_cost=200690260.6677975\nmy_num=200000\n```\n\nIt may only be used as a comparison for result quality and call count, and must not be used as a permutation starting point.\n\n**Final Submission Requirements**\n\nYou must generate a new result file:\n\n```text\nfinal_result.txt\n```\n\nDo not write the result back to `vcpom_m1000_final_result.txt`.\n\n`final_result.txt` must use the following key-value format:\n\n```text\nfinal_pai=3,1,4,2,...\nfinal_cost=123456789.0\nfinal_num=1000\n```\n\nField requirements:\n\n1. `final_pai`: a permutation of length 1000. It must contain exactly `1..1000`, separated by English commas, without square brackets.\n2. `final_cost`: the response value you report for `final_pai`. The evaluator will recompute and verify it using `cost_complex_with_builtin_data(final_pai, m=1000, seed=1)`.\n3. `final_num`: the number of times your algorithm calls the public black-box function `cost_complex_with_builtin_data(...)`. You may also use the field name `num` or `my_num`, but `final_num` is recommended. Do not count only the final verification call; every black-box evaluation during the search process must be included.\n\n**Task Goals**\n\n1. Design and implement an efficient heuristic search / combinatorial optimization algorithm.\n2. Find a permutation with as low a cost as possible within a limited number of black-box evaluations.\n3. You may use genetic algorithms, simulated annealing, local search, tabu search, ALNS, PSO, CMA-ES, Bayesian optimization, or hybrid strategies.\n4. The final result is determined by the contents of `final_result.txt`.\n\n**Scoring Method**\n\nThe evaluator will check that:\n\n1. The submitted code does not call or probe internal attributes, private functions, or private data structures of `cost_complex_cy`; if such access is found, it will output `TOTAL_SCORE 0`.\n2. `vcpom_m1000_final_result.txt` has not been modified and does not contain `final_pai`.\n3. `final_result.txt` exists and contains the required fields.\n4. `final_pai` is a valid permutation of `1..1000`.\n5. `final_cost` matches the cost recomputed by the black-box function.\n6. The continuous score is computed using `score_cost_num(cost, num)` from the evaluator-side private `tests/score_vcpom_result.py`.\n\nLower cost and fewer calls give a higher score.\n\nThe scoring function uses the reference cost and reference call count from `vcpom_m1000_final_result.txt`:\n\n```python\nscore_cost_num(\n cost,\n num,\n cost_ref=200690260.6677975,\n num_ref=200000,\n cost_weight=3.0,\n num_weight=0.5,\n)\n```\n\nThe scoring first caps both subscores:\n\n```python\ncost_sub = min(1.0, cost_ref / cost)\nnum_sub = min(1.0, num_ref / num)\nscore = 100 * (cost_sub ** 3.0) * (num_sub ** 0.5)\n```\n\nIf `final_cost <= cost_ref` and `final_num <= num_ref`, the score is the full 100. If the cost is higher than the reference or the call count is higher than the reference, the score decreases. The cost penalty is heavier, so a very low call count cannot compensate for a clearly worse cost.\n"
+ },
+ "judge": {
+ "image_tag": "f6f385925889",
+ "eval_cmd": "cd /home/workspace/complex_job_scheduling && python -m pytest tests/test_final_result.py -s -v",
+ "eval_timeout": 600,
+ "parser": "pytest_v",
+ "score_direction": "maximize",
+ "selection": "pass_rate_first",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 100.0
+ }
+ }
+}
diff --git a/ordinal_notation_well_foundedness.json b/ordinal_notation_well_foundedness.json
new file mode 100644
index 0000000000000000000000000000000000000000..ac1083fb7b3bd24de2a1908fa5b15ed6b0f6440e
--- /dev/null
+++ b/ordinal_notation_well_foundedness.json
@@ -0,0 +1,53 @@
+{
+ "task_id": "ordinal_notation_well_foundedness",
+ "name": "Ordinal Notation Well Foundedness",
+ "category": "Formal Math & Theorem Proving",
+ "base_image": "coq",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/ordinal_notation_wf",
+ "submit_paths": [
+ "."
+ ],
+ "submit_exclude": [
+ ".git",
+ ".coq-native",
+ "_CoqProject",
+ "Makefile.coq",
+ "Makefile.coq.conf",
+ "*.aux",
+ ".*.aux",
+ "*.d",
+ "*.glob",
+ "*.vo",
+ "*.vos",
+ "*.vok",
+ "*.vio",
+ "eval_task*.v",
+ "ChildOf.v",
+ "debug*.v",
+ "test*.v",
+ "check*.v",
+ "explore*.v",
+ "tmp*.v",
+ "scratch*.v"
+ ],
+ "work": {
+ "image_tag": "690c1a245369",
+ "specs_dir": "/home/workspace/ordinal_notation_wf",
+ "agent_query": "Read `README.md` in the workspace, then complete as many Coq proof targets as possible. Submit for judge feedback."
+ },
+ "judge": {
+ "image_tag": "064b4eb91e22",
+ "eval_cmd": "python3 /opt/sebench/ordinal_notation_wf_eval.py",
+ "eval_timeout": 7200,
+ "parser": "structured_json",
+ "score_direction": "maximize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 85.0
+ }
+ }
+}
diff --git a/pfr_formalization.json b/pfr_formalization.json
new file mode 100644
index 0000000000000000000000000000000000000000..ad4d87238963d4d96b2c276c6c68d43cca5035eb
--- /dev/null
+++ b/pfr_formalization.json
@@ -0,0 +1,31 @@
+{
+ "task_id": "pfr_formalization",
+ "name": "Pfr Formalization",
+ "category": "Formal Math & Theorem Proving",
+ "base_image": "lean_4",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/",
+ "submit_paths": [
+ "se-bmk-intern/pfr"
+ ],
+ "submit_exclude": [
+ "se-bmk-intern/pfr/.lake"
+ ],
+ "work": {
+ "image_tag": "508bdc207859",
+ "specs_dir": null,
+ "agent_query": "You are a lean4 expert, now your task is to finish **all** sorries in this folder. Pay no attention to anything outside this folder. There are many sorries but do not be afraid as we value minor progress and the time is abundant. Try to do some easy problems and accumulate scores each round. Before you submit, run a `lake build` to verify the changes locally - if the build failed, no score will be given. Also, do not modify the signature of existing lemma/theorem/def as these changes will not pass the judge evaluation. Finally, we check the axioms transitively, finishing a theorem without completeing precedent lemma will not count."
+ },
+ "judge": {
+ "image_tag": "9ed39cf76869",
+ "eval_cmd": "cd /home/workspace/se-bmk-intern/pfr && cp -r /home/workspace/judge/se-bmk-intern/pfr/.lake . && cp /home/workspace/judge/se-bmk-intern/pfr/lake-manifest.json . && lake build && cp /home/workspace/judge/se-bmk-intern/pfr/ListDeclAxiom.lean . && cd /home/workspace/judge/se-bmk-intern && python3 eval_lean.py --baseline-repo /home/workspace/judge/se-bmk-intern/pfr --current-repo /home/workspace/se-bmk-intern/pfr",
+ "eval_timeout": 2400,
+ "parser": "structured_json",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 1.0
+ }
+ }
+}
diff --git a/portfolio_risk_calibration.json b/portfolio_risk_calibration.json
new file mode 100644
index 0000000000000000000000000000000000000000..163668f2634cae576c907a3f67fb983179434899
--- /dev/null
+++ b/portfolio_risk_calibration.json
@@ -0,0 +1,35 @@
+{
+ "task_id": "portfolio_risk_calibration",
+ "name": "Portfolio Risk Calibration",
+ "category": "Professional Knowledge Work",
+ "base_image": "python",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace",
+ "submit_paths": [
+ "portfolio_optimizer.py",
+ "requirements.txt",
+ "backtest_results.json"
+ ],
+ "submit_exclude": [
+ ".git",
+ "__pycache__",
+ "*.pyc",
+ "node_modules",
+ "bin",
+ "obj"
+ ],
+ "work": {
+ "image_tag": "e9e47d60871d",
+ "specs_dir": null,
+ "agent_query": "Read the complete task instructions in `/home/workspace/task_instruction.md`, and complete the task according to those requirements. The final deliverables must be written to the file paths specified in `task_instruction.md`.\n"
+ },
+ "judge": {
+ "image_tag": "08fe0a4bad80",
+ "eval_cmd": "cd /home/workspace && python3 scoring/score.py",
+ "eval_timeout": 600,
+ "parser": "structured_json",
+ "score_direction": "maximize",
+ "selection": "score_first"
+ }
+}
diff --git a/rust_multicrate_reconstruction.json b/rust_multicrate_reconstruction.json
new file mode 100644
index 0000000000000000000000000000000000000000..3f20ffb754c046bda474ffa75fbbf6e8ee820c91
--- /dev/null
+++ b/rust_multicrate_reconstruction.json
@@ -0,0 +1,40 @@
+{
+ "task_id": "rust_multicrate_reconstruction",
+ "name": "Rust Multicrate Reconstruction",
+ "category": "Systems & Software Engineering",
+ "base_image": "rust",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/cas_rust_benchmark",
+ "submit_paths": [
+ "agent-start/"
+ ],
+ "submit_exclude": [
+ "agent-start/target/",
+ "agent-start/.git/",
+ "agent-start/__pycache__/",
+ "agent-start/**/*.pyc",
+ "agent-start/score-results.json",
+ "agent-start/vendor-deps/",
+ "agent-start/.cargo/registry/",
+ "agent-start/.cargo/git/"
+ ],
+ "work": {
+ "image_tag": "7f639fc9d090",
+ "specs_dir": "/home/workspace/cas_rust_benchmark",
+ "agent_query": "## CAS Rust Multi-Crate Reconstruction\n\nComplete the missing Rust implementations in the unpacked CAS workspace. The main development directory is `agent-start/`.\n\nRead `agent-start/TASK.md`, `agent-start/SPEC.md`, and `agent-start/README.md` for the crate behavior expectations, edit boundaries, local scoring command, and the distinction between production TODOs and public test-helper TODOs. The hidden evaluator runs additional tests for the same public crate and CLI contracts."
+ },
+ "judge": {
+ "image_tag": "b749374fe7bc",
+ "eval_cmd": "cd /home/workspace/cas_rust_benchmark && rm -rf /tmp/cas_eval /tmp/cas_score.out /tmp/cas_submitted_agent_start && mkdir -p /tmp/cas_eval && if [ -d agent-start ]; then cp -a agent-start /tmp/cas_submitted_agent_start; rm -rf /tmp/cas_submitted_agent_start/target /tmp/cas_submitted_agent_start/vendor-deps /tmp/cas_submitted_agent_start/.git; fi && tar -xzf cas_rust_benchmark.tar.gz -C /tmp/cas_eval && mkdir -p /tmp/cas_eval/run && cp -a /tmp/cas_eval/cas_rust_benchmark/workspace/. /tmp/cas_eval/run/ && cp -a /tmp/cas_eval/cas_rust_benchmark/judge/. /tmp/cas_eval/run/ && if [ -d /tmp/cas_submitted_agent_start ]; then cp -a /tmp/cas_submitted_agent_start/. /tmp/cas_eval/run/agent-start/; fi && cd /tmp/cas_eval/run && cc -c agent-start/.ghostty-stub/ghostty_vt_stub.c -o agent-start/.ghostty-stub/ghostty_vt_stub.o && ar rcs agent-start/.ghostty-stub/libghostty_vt.a agent-start/.ghostty-stub/ghostty_vt_stub.o && chmod +x score.sh verify_task.sh agent-start/score.sh && bash score.sh agent-start > /tmp/cas_score.out 2>&1; cat /tmp/cas_score.out; python3 -c 'import json,pathlib,re\nPASSED=\"PASSED\"; FAILED=\"FAILED\"; ERROR=\"ERROR\"\ntxt=pathlib.Path(\"/tmp/cas_score.out\").read_text(errors=\"replace\") if pathlib.Path(\"/tmp/cas_score.out\").exists() else \"\"\nscore_json=pathlib.Path(\"/tmp/cas_eval/run/score-results.json\")\ndef grab(pattern, default=None):\n m=re.search(pattern, txt, re.M)\n return m.group(1) if m else default\nscore_s=grab(r\"^SCORE=([0-9]+(?:\\.[0-9]+)?)\", \"0\")\nstatus=grab(r\"^SCORE_STATUS=(\\S+)\", \"MISSING\")\nrawp_s=grab(r\"^RAW_PASSED=(\\d+)\", \"0\")\nrawt_s=grab(r\"^RAW_TOTAL=(\\d+)\", \"0\")\ntry:\n score=float(score_s)\nexcept Exception:\n score=0.0\nraw_passed=int(rawp_s or 0)\nraw_total=int(rawt_s or 0)\nscore_data={}\nif score_json.exists():\n try:\n score_data=json.loads(score_json.read_text(errors=\"replace\"))\n except Exception:\n score_data={}\nif score_data:\n score=float(score_data.get(\"total_score\", score))\n status=str(score_data.get(\"score_status\", status))\n raw_passed=int(score_data.get(\"raw_passed\", raw_passed) or 0)\n raw_total=int(score_data.get(\"raw_total\", raw_total) or 0)\npass_rate=(raw_passed/raw_total) if raw_total else (1.0 if score>0 and status==\"OK\" else 0.0)\nok=(status==\"OK\")\nsummary=f\"score={score:.4f}; status={status}; raw_passed={raw_passed}; raw_total={raw_total}; pass_rate={pass_rate:.6f}\"\ndef detail_status(passed,total,crate_status=None):\n if crate_status in {\"ERROR\",\"TIMEOUT\",\"NO_TESTS\"}:\n return ERROR\n return PASSED if total and passed==total else FAILED\ndef pct(passed,total):\n return (100.0*passed/total) if total else 0.0\ndetails=[\n {\n \"name\":\"overall_score\",\n \"status\":PASSED if ok and score>0 else (FAILED if status in {\"OK\",\"FAIL\",\"FAILED\",\"WA\"} else ERROR),\n \"score\":score,\n \"weight\":1.0,\n \"message\":summary,\n },\n {\n \"name\":\"raw_test_pass_rate\",\n \"status\":PASSED if raw_total and raw_passed==raw_total else FAILED,\n \"score\":pct(raw_passed, raw_total),\n \"weight\":1.0,\n \"message\":f\"raw_passed={raw_passed}; raw_total={raw_total}; pass_rate={pass_rate:.6f}\",\n },\n]\nlayer_metrics=[]\nfor layer in score_data.get(\"layers\", []):\n passed=int(layer.get(\"passed\", 0) or 0)\n total=int(layer.get(\"total\", 0) or 0)\n lname=str(layer.get(\"layer\", \"layer\"))\n lstatus=str(layer.get(\"status\", \"UNKNOWN\"))\n lscore=float(layer.get(\"score\", 0.0) or 0.0)\n weight=float(layer.get(\"weight\", 0.0) or 0.0)\n crates=\", \".join(layer.get(\"crates\", []))\n layer_metrics.append({\"layer\": lname, \"passed\": passed, \"total\": total, \"score\": lscore, \"status\": lstatus, \"crates\": layer.get(\"crates\", [])})\n details.append({\n \"name\":f\"layer_{lname}\",\n \"status\":detail_status(passed,total,lstatus),\n \"score\":lscore,\n \"weight\":weight,\n \"message\":f\"status={lstatus}; passed={passed}; total={total}; crates={crates}\",\n })\ncrate_metrics=[]\nfor crate in score_data.get(\"crates\", []):\n cname=str(crate.get(\"crate_name\", crate.get(\"package_name\", \"crate\")))\n passed=int(crate.get(\"passed\", 0) or 0)\n total=int(crate.get(\"total\", 0) or 0)\n cstatus=str(crate.get(\"status\", \"UNKNOWN\"))\n public_passed=int(crate.get(\"public_passed\", 0) or 0)\n public_failed=int(crate.get(\"public_failed\", 0) or 0)\n hidden_passed=int(crate.get(\"hidden_passed\", 0) or 0)\n hidden_failed=int(crate.get(\"hidden_failed\", 0) or 0)\n crate_metrics.append({\n \"crate\": cname, \"status\": cstatus, \"passed\": passed, \"total\": total,\n \"public_passed\": public_passed, \"public_failed\": public_failed,\n \"hidden_passed\": hidden_passed, \"hidden_failed\": hidden_failed,\n })\n details.append({\n \"name\":f\"crate_{cname}\",\n \"status\":detail_status(passed,total,cstatus),\n \"score\":pct(passed,total),\n \"weight\":0.0,\n \"message\":f\"status={cstatus}; passed={passed}; total={total}; public_passed={public_passed}; public_failed={public_failed}; hidden_passed={hidden_passed}; hidden_failed={hidden_failed}\",\n })\nscore_lines=[line for line in txt.splitlines() if line.startswith((\"SCORE=\",\"SCORE_STATUS=\",\"RAW_PASSED=\",\"RAW_TOTAL=\",\"WEIGHTED_PASSED=\",\"WEIGHTED_TOTAL=\"))]\nresult={\n \"valid\": bool(ok),\n \"score\": score,\n \"pass_rate\": pass_rate,\n \"summary\": summary,\n \"metrics\": {\n \"score_status\": status,\n \"raw_passed\": raw_passed,\n \"raw_total\": raw_total,\n \"weighted_passed\": score_data.get(\"weighted_passed\", score),\n \"weighted_total\": score_data.get(\"weighted_total\", 100.0),\n \"total_duration_sec\": score_data.get(\"total_duration_sec\"),\n \"layers\": layer_metrics,\n \"crates\": crate_metrics,\n \"score_lines\": score_lines,\n },\n \"details\": details,\n}\nprint(\">>>>> Start Structured Result\")\nprint(json.dumps(result, indent=2, sort_keys=True))\nprint(\">>>>> End Structured Result\")'",
+ "eval_timeout": 3600,
+ "parser": "structured_json",
+ "score_direction": "maximize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 100.0
+ }
+ }
+}
diff --git a/schemathesis_config_modernization.json b/schemathesis_config_modernization.json
new file mode 100644
index 0000000000000000000000000000000000000000..af953f90dc1cdcb89dc2695754fe01a8afe0a40f
--- /dev/null
+++ b/schemathesis_config_modernization.json
@@ -0,0 +1,38 @@
+{
+ "task_id": "schemathesis_config_modernization",
+ "name": "Schemathesis Config Modernization",
+ "category": "Systems & Software Engineering",
+ "base_image": "python",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/app",
+ "submit_paths": [
+ "."
+ ],
+ "submit_exclude": [
+ ".git",
+ "__pycache__",
+ "*.pyc",
+ "*.egg-info",
+ ".eggs",
+ "*.so",
+ "TODO.md"
+ ],
+ "work": {
+ "image_tag": "f9e5ec2c6f1f",
+ "specs_dir": "/app",
+ "agent_query": "## Role\n\nYou are an expert software engineer implementing a roadmap task in the current repository.\n\n## Task Document\n\nRead `/app/TODO.md` completely before editing code. It contains the full project overview, goals, target requirements, and completion criteria.\n\n## Workflow\n\n1. Read the task document before making code changes.\n2. Implement all requested roadmap targets.\n3. Preserve existing public APIs unless `/app/TODO.md` explicitly requires a change.\n4. Use local tests or submission feedback to iterate when available.\n\n## Rules\n\n- Treat `/app/TODO.md` as the authoritative task specification.\n- Do not modify hidden tests.\n- Do not rely on external task text beyond the task document.\n"
+ },
+ "judge": {
+ "image_tag": "affdace5163f",
+ "eval_cmd": "set +x; cd /app && bash /tests/test.sh > /tmp/test_full.log 2>&1; python3 - > /tmp/structured_result.log 2>&1 <<'PY'\nimport json\nimport re\nfrom pathlib import Path\n\nPASSED = \"PASSED\"\nFAILED = \"FAILED\"\nERROR = \"ERROR\"\n\n\ndef read_text(path):\n p = Path(path)\n if not p.exists():\n return \"\"\n return p.read_text(errors=\"replace\")\n\n\ndef parse_weights(script_text, phase_count):\n patterns = [\n r\"weights\\s*=\\s*\\[([0-9,\\s]+)\\]\",\n r\"PHASE_WEIGHTS\\s*=\\s*\\(([0-9\\s]+)\\)\",\n ]\n for pattern in patterns:\n m = re.search(pattern, script_text)\n if m:\n raw = re.split(r\"[,\\s]+\", m.group(1).strip())\n weights = [float(x) for x in raw if x]\n if len(weights) >= phase_count:\n return weights[:phase_count]\n\n m = re.search(r\"PHASES\\s*=\\s*\\((.*?)\\n\\)\", script_text, re.S)\n if m:\n weights = []\n for line in m.group(1).splitlines():\n line = line.strip()\n if not line or line.startswith(\"#\"):\n continue\n line = line.strip(\"\\\"'\")\n parts = line.split()\n if parts and re.fullmatch(r\"\\d+(?:\\.\\d+)?\", parts[-1]):\n weights.append(float(parts[-1]))\n if len(weights) >= phase_count:\n return weights[:phase_count]\n\n reward_json = Path(\"/logs/verifier/reward.json\")\n if reward_json.exists():\n try:\n data = json.loads(reward_json.read_text(errors=\"replace\"))\n phases = data.get(\"phases\")\n if isinstance(phases, dict):\n weights = []\n for phase in phases.values():\n if isinstance(phase, dict) and \"weight\" in phase:\n weights.append(float(phase[\"weight\"]))\n if len(weights) >= phase_count:\n return weights[:phase_count]\n except Exception:\n pass\n\n return [1.0] * phase_count\n\n\ndef parse_statuses(output):\n results = []\n seen = set()\n pattern = re.compile(r\"^(tests/roadmap\\.py::\\S+)\\s+(PASSED|FAILED|ERROR)\\s*$\", re.M)\n for name, status in pattern.findall(output):\n if name in seen:\n continue\n seen.add(name)\n results.append((name, status))\n return results\n\n\ndef parse_phase_number(name, fallback):\n m = re.search(r\"(?:test_)?phase_?0*(\\d+)\\b\", name)\n if m:\n return int(m.group(1))\n return fallback\n\n\ndef parse_phase_ratios(output):\n ratios = {}\n counts = {}\n pattern = re.compile(r\"^Phase\\s+0*(\\d+):\\s+(\\d+)\\s*/\\s*(\\d+)\\s+passed\\s*$\", re.M)\n for n, passed, total in pattern.findall(output):\n n_i = int(n)\n passed_i = int(passed)\n total_i = int(total)\n counts[n_i] = (passed_i, total_i)\n ratios[n_i] = passed_i / total_i if total_i else 0.0\n\n weighted_pattern = re.compile(\n r\"^\\s*Phase\\s+0*(\\d+)\\s+\\(weight\\s*=\\s*([0-9.]+)\\):\\s*([0-9.]+)\\s*$\",\n re.M,\n )\n inline_weights = {}\n for n, weight, score in weighted_pattern.findall(output):\n n_i = int(n)\n inline_weights[n_i] = float(weight)\n ratios[n_i] = float(score)\n\n return ratios, counts, inline_weights\n\n\ndef parse_total_score(output):\n m = re.search(r\"TOTAL_SCORE\\s+([0-9]+(?:\\.[0-9]+)?)\", output)\n if m:\n return float(m.group(1))\n reward_path = Path(\"/logs/verifier/reward.txt\")\n if reward_path.exists():\n try:\n return float(reward_path.read_text(errors=\"replace\").strip())\n except Exception:\n pass\n return None\n\n\ndef main():\n output = read_text(\"/tmp/test_full.log\")\n script = read_text(\"/tests/test.sh\")\n\n statuses = parse_statuses(output)\n if not statuses:\n statuses = [(\"tests/roadmap.py::unknown\", ERROR)]\n\n ratios, counts, inline_weights = parse_phase_ratios(output)\n weights = parse_weights(script, len(statuses))\n for idx, weight in inline_weights.items():\n if 1 <= idx <= len(weights):\n weights[idx - 1] = weight\n\n details = []\n weighted_total = 0.0\n weight_total = 0.0\n failed_names = []\n\n for pos, (name, status) in enumerate(statuses, start=1):\n phase_num = parse_phase_number(name, pos)\n weight = weights[pos - 1] if pos - 1 < len(weights) else 1.0\n if phase_num in ratios:\n ratio = ratios[phase_num]\n else:\n ratio = 1.0 if status == PASSED else 0.0\n contribution = weight * ratio\n weighted_total += contribution\n weight_total += weight\n\n if phase_num in counts:\n phase_passed, phase_total = counts[phase_num]\n message = (\n f\"Phase {phase_num}: {phase_passed}/{phase_total} checks passed; \"\n f\"weighted contribution {contribution:.6f}/{weight:.6f}\"\n )\n else:\n message = (\n f\"Phase {phase_num}: status {status}; \"\n f\"weighted contribution {contribution:.6f}/{weight:.6f}\"\n )\n\n if status != PASSED:\n failed_names.append(name)\n\n details.append(\n {\n \"name\": name,\n \"status\": status,\n \"message\": message,\n \"score\": contribution,\n \"weight\": weight,\n }\n )\n\n passed_count = sum(1 for _, status in statuses if status == PASSED)\n total_count = len(statuses)\n pass_rate = passed_count / total_count if total_count else 0.0\n total_score = parse_total_score(output)\n if total_score is None:\n total_score = weighted_total / weight_total if weight_total else 0.0\n\n summary = (\n f\"{passed_count}/{total_count} phases passed; \"\n f\"weighted score {total_score:.6f}\"\n )\n if failed_names:\n summary += \". Failed: \" + \", \".join(failed_names[:10])\n if len(failed_names) > 10:\n summary += f\" (+{len(failed_names) - 10} more)\"\n\n result = {\n \"valid\": True,\n \"score\": total_score,\n \"pass_rate\": pass_rate,\n \"summary\": summary,\n \"details\": details,\n \"metrics\": {\n \"phase_weighted_total\": weighted_total,\n \"phase_weight_total\": weight_total,\n \"source\": \"roadmap_structured_json\",\n },\n }\n\n print(\">>>>> Start Structured Result\")\n print(json.dumps(result, ensure_ascii=False, indent=2))\n print(\">>>>> End Structured Result\")\n\n\nif __name__ == \"__main__\":\n main()\nPY\ncat /tmp/structured_result.log",
+ "eval_timeout": 1800,
+ "parser": "structured_json",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 1.0
+ }
+ }
+}
diff --git a/schemathesis_datagen_pipeline.json b/schemathesis_datagen_pipeline.json
new file mode 100644
index 0000000000000000000000000000000000000000..553ebaeed964f745d43c4d348cbadb70b7aaf526
--- /dev/null
+++ b/schemathesis_datagen_pipeline.json
@@ -0,0 +1,38 @@
+{
+ "task_id": "schemathesis_datagen_pipeline",
+ "name": "Schemathesis Datagen Pipeline",
+ "category": "Systems & Software Engineering",
+ "base_image": "python",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/app",
+ "submit_paths": [
+ "."
+ ],
+ "submit_exclude": [
+ ".git",
+ "__pycache__",
+ "*.pyc",
+ "*.egg-info",
+ ".eggs",
+ "*.so",
+ "TODO.md"
+ ],
+ "work": {
+ "image_tag": "b52953fc6612",
+ "specs_dir": "/app",
+ "agent_query": "## Role\n\nYou are an expert software engineer implementing a roadmap task in the current repository.\n\n## Task Document\n\nRead `/app/TODO.md` completely before editing code. It contains the full project overview, goals, target requirements, and completion criteria.\n\n## Workflow\n\n1. Read the task document before making code changes.\n2. Implement all requested roadmap targets.\n3. Preserve existing public APIs unless `/app/TODO.md` explicitly requires a change.\n4. Use local tests or submission feedback to iterate when available.\n\n## Rules\n\n- Treat `/app/TODO.md` as the authoritative task specification.\n- Do not modify hidden tests.\n- Do not rely on external task text beyond the task document."
+ },
+ "judge": {
+ "image_tag": "c4be4b8d9369",
+ "eval_cmd": "set +x; cd /app && bash /tests/test.sh > /tmp/test_full.log 2>&1; python3 - > /tmp/structured_result.log 2>&1 <<'PY'\nimport json\nimport re\nfrom pathlib import Path\n\nPASSED = \"PASSED\"\nFAILED = \"FAILED\"\nERROR = \"ERROR\"\n\n\ndef read_text(path):\n p = Path(path)\n if not p.exists():\n return \"\"\n return p.read_text(errors=\"replace\")\n\n\ndef parse_weights(script_text, phase_count):\n patterns = [\n r\"weights\\s*=\\s*\\[([0-9,\\s]+)\\]\",\n r\"PHASE_WEIGHTS\\s*=\\s*\\(([0-9\\s]+)\\)\",\n ]\n for pattern in patterns:\n m = re.search(pattern, script_text)\n if m:\n raw = re.split(r\"[,\\s]+\", m.group(1).strip())\n weights = [float(x) for x in raw if x]\n if len(weights) >= phase_count:\n return weights[:phase_count]\n\n m = re.search(r\"PHASES\\s*=\\s*\\((.*?)\\n\\)\", script_text, re.S)\n if m:\n weights = []\n for line in m.group(1).splitlines():\n line = line.strip()\n if not line or line.startswith(\"#\"):\n continue\n line = line.strip(\"\\\"'\")\n parts = line.split()\n if parts and re.fullmatch(r\"\\d+(?:\\.\\d+)?\", parts[-1]):\n weights.append(float(parts[-1]))\n if len(weights) >= phase_count:\n return weights[:phase_count]\n\n reward_json = Path(\"/logs/verifier/reward.json\")\n if reward_json.exists():\n try:\n data = json.loads(reward_json.read_text(errors=\"replace\"))\n phases = data.get(\"phases\")\n if isinstance(phases, dict):\n weights = []\n for phase in phases.values():\n if isinstance(phase, dict) and \"weight\" in phase:\n weights.append(float(phase[\"weight\"]))\n if len(weights) >= phase_count:\n return weights[:phase_count]\n except Exception:\n pass\n\n return [1.0] * phase_count\n\n\ndef parse_statuses(output):\n results = []\n seen = set()\n pattern = re.compile(r\"^(tests/roadmap\\.py::\\S+)\\s+(PASSED|FAILED|ERROR)\\s*$\", re.M)\n for name, status in pattern.findall(output):\n if name in seen:\n continue\n seen.add(name)\n results.append((name, status))\n return results\n\n\ndef parse_phase_number(name, fallback):\n m = re.search(r\"(?:test_)?phase_?0*(\\d+)\\b\", name)\n if m:\n return int(m.group(1))\n return fallback\n\n\ndef parse_phase_ratios(output):\n ratios = {}\n counts = {}\n pattern = re.compile(r\"^Phase\\s+0*(\\d+):\\s+(\\d+)\\s*/\\s*(\\d+)\\s+passed\\s*$\", re.M)\n for n, passed, total in pattern.findall(output):\n n_i = int(n)\n passed_i = int(passed)\n total_i = int(total)\n counts[n_i] = (passed_i, total_i)\n ratios[n_i] = passed_i / total_i if total_i else 0.0\n\n weighted_pattern = re.compile(\n r\"^\\s*Phase\\s+0*(\\d+)\\s+\\(weight\\s*=\\s*([0-9.]+)\\):\\s*([0-9.]+)\\s*$\",\n re.M,\n )\n inline_weights = {}\n for n, weight, score in weighted_pattern.findall(output):\n n_i = int(n)\n inline_weights[n_i] = float(weight)\n ratios[n_i] = float(score)\n\n return ratios, counts, inline_weights\n\n\ndef parse_total_score(output):\n m = re.search(r\"TOTAL_SCORE\\s+([0-9]+(?:\\.[0-9]+)?)\", output)\n if m:\n return float(m.group(1))\n reward_path = Path(\"/logs/verifier/reward.txt\")\n if reward_path.exists():\n try:\n return float(reward_path.read_text(errors=\"replace\").strip())\n except Exception:\n pass\n return None\n\n\ndef main():\n output = read_text(\"/tmp/test_full.log\")\n script = read_text(\"/tests/test.sh\")\n\n statuses = parse_statuses(output)\n if not statuses:\n statuses = [(\"tests/roadmap.py::unknown\", ERROR)]\n\n ratios, counts, inline_weights = parse_phase_ratios(output)\n weights = parse_weights(script, len(statuses))\n for idx, weight in inline_weights.items():\n if 1 <= idx <= len(weights):\n weights[idx - 1] = weight\n\n details = []\n weighted_total = 0.0\n weight_total = 0.0\n failed_names = []\n\n for pos, (name, status) in enumerate(statuses, start=1):\n phase_num = parse_phase_number(name, pos)\n weight = weights[pos - 1] if pos - 1 < len(weights) else 1.0\n if phase_num in ratios:\n ratio = ratios[phase_num]\n else:\n ratio = 1.0 if status == PASSED else 0.0\n contribution = weight * ratio\n weighted_total += contribution\n weight_total += weight\n\n if phase_num in counts:\n phase_passed, phase_total = counts[phase_num]\n message = (\n f\"Phase {phase_num}: {phase_passed}/{phase_total} checks passed; \"\n f\"weighted contribution {contribution:.6f}/{weight:.6f}\"\n )\n else:\n message = (\n f\"Phase {phase_num}: status {status}; \"\n f\"weighted contribution {contribution:.6f}/{weight:.6f}\"\n )\n\n if status != PASSED:\n failed_names.append(name)\n\n details.append(\n {\n \"name\": name,\n \"status\": status,\n \"message\": message,\n \"score\": contribution,\n \"weight\": weight,\n }\n )\n\n passed_count = sum(1 for _, status in statuses if status == PASSED)\n total_count = len(statuses)\n pass_rate = passed_count / total_count if total_count else 0.0\n total_score = parse_total_score(output)\n if total_score is None:\n total_score = weighted_total / weight_total if weight_total else 0.0\n\n summary = (\n f\"{passed_count}/{total_count} phases passed; \"\n f\"weighted score {total_score:.6f}\"\n )\n if failed_names:\n summary += \". Failed: \" + \", \".join(failed_names[:10])\n if len(failed_names) > 10:\n summary += f\" (+{len(failed_names) - 10} more)\"\n\n result = {\n \"valid\": True,\n \"score\": total_score,\n \"pass_rate\": pass_rate,\n \"summary\": summary,\n \"details\": details,\n \"metrics\": {\n \"phase_weighted_total\": weighted_total,\n \"phase_weight_total\": weight_total,\n \"source\": \"roadmap_structured_json\",\n },\n }\n\n print(\">>>>> Start Structured Result\")\n print(json.dumps(result, ensure_ascii=False, indent=2))\n print(\">>>>> End Structured Result\")\n\n\nif __name__ == \"__main__\":\n main()\nPY\ncat /tmp/structured_result.log",
+ "eval_timeout": 1800,
+ "parser": "structured_json",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 1.0
+ }
+ }
+}
diff --git a/schemathesis_reporting_observability.json b/schemathesis_reporting_observability.json
new file mode 100644
index 0000000000000000000000000000000000000000..05d6c20af4bad40ca79d8447a3354709d7cd11a2
--- /dev/null
+++ b/schemathesis_reporting_observability.json
@@ -0,0 +1,38 @@
+{
+ "task_id": "schemathesis_reporting_observability",
+ "name": "Schemathesis Reporting Observability",
+ "category": "Systems & Software Engineering",
+ "base_image": "python",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/app",
+ "submit_paths": [
+ "."
+ ],
+ "submit_exclude": [
+ ".git",
+ "__pycache__",
+ "*.pyc",
+ "*.egg-info",
+ ".eggs",
+ "*.so",
+ "TODO.md"
+ ],
+ "work": {
+ "image_tag": "cd6879e59e62",
+ "specs_dir": "/app",
+ "agent_query": "## Role\n\nYou are an expert software engineer implementing a roadmap task in the current repository.\n\n## Task Document\n\nRead `/app/TODO.md` completely before editing code. It contains the full project overview, goals, target requirements, and completion criteria.\n\n## Workflow\n\n1. Read the task document before making code changes.\n2. Implement all requested roadmap targets.\n3. Preserve existing public APIs unless `/app/TODO.md` explicitly requires a change.\n4. Use local tests or submission feedback to iterate when available.\n\n## Rules\n\n- Treat `/app/TODO.md` as the authoritative task specification.\n- Do not modify hidden tests.\n- Do not rely on external task text beyond the task document.\n"
+ },
+ "judge": {
+ "image_tag": "21a26db29432",
+ "eval_cmd": "set +x; cd /app && bash /tests/test.sh > /tmp/test_full.log 2>&1; python3 - > /tmp/structured_result.log 2>&1 <<'PY'\nimport json\nimport re\nfrom pathlib import Path\n\nPASSED = \"PASSED\"\nFAILED = \"FAILED\"\nERROR = \"ERROR\"\n\n\ndef read_text(path):\n p = Path(path)\n if not p.exists():\n return \"\"\n return p.read_text(errors=\"replace\")\n\n\ndef parse_weights(script_text, phase_count):\n patterns = [\n r\"weights\\s*=\\s*\\[([0-9,\\s]+)\\]\",\n r\"PHASE_WEIGHTS\\s*=\\s*\\(([0-9\\s]+)\\)\",\n ]\n for pattern in patterns:\n m = re.search(pattern, script_text)\n if m:\n raw = re.split(r\"[,\\s]+\", m.group(1).strip())\n weights = [float(x) for x in raw if x]\n if len(weights) >= phase_count:\n return weights[:phase_count]\n\n m = re.search(r\"PHASES\\s*=\\s*\\((.*?)\\n\\)\", script_text, re.S)\n if m:\n weights = []\n for line in m.group(1).splitlines():\n line = line.strip()\n if not line or line.startswith(\"#\"):\n continue\n line = line.strip(\"\\\"'\")\n parts = line.split()\n if parts and re.fullmatch(r\"\\d+(?:\\.\\d+)?\", parts[-1]):\n weights.append(float(parts[-1]))\n if len(weights) >= phase_count:\n return weights[:phase_count]\n\n reward_json = Path(\"/logs/verifier/reward.json\")\n if reward_json.exists():\n try:\n data = json.loads(reward_json.read_text(errors=\"replace\"))\n phases = data.get(\"phases\")\n if isinstance(phases, dict):\n weights = []\n for phase in phases.values():\n if isinstance(phase, dict) and \"weight\" in phase:\n weights.append(float(phase[\"weight\"]))\n if len(weights) >= phase_count:\n return weights[:phase_count]\n except Exception:\n pass\n\n return [1.0] * phase_count\n\n\ndef parse_statuses(output):\n results = []\n seen = set()\n pattern = re.compile(r\"^(tests/roadmap\\.py::\\S+)\\s+(PASSED|FAILED|ERROR)\\s*$\", re.M)\n for name, status in pattern.findall(output):\n if name in seen:\n continue\n seen.add(name)\n results.append((name, status))\n return results\n\n\ndef parse_phase_number(name, fallback):\n m = re.search(r\"(?:test_)?phase_?0*(\\d+)\\b\", name)\n if m:\n return int(m.group(1))\n return fallback\n\n\ndef parse_phase_ratios(output):\n ratios = {}\n counts = {}\n pattern = re.compile(r\"^Phase\\s+0*(\\d+):\\s+(\\d+)\\s*/\\s*(\\d+)\\s+passed\\s*$\", re.M)\n for n, passed, total in pattern.findall(output):\n n_i = int(n)\n passed_i = int(passed)\n total_i = int(total)\n counts[n_i] = (passed_i, total_i)\n ratios[n_i] = passed_i / total_i if total_i else 0.0\n\n weighted_pattern = re.compile(\n r\"^\\s*Phase\\s+0*(\\d+)\\s+\\(weight\\s*=\\s*([0-9.]+)\\):\\s*([0-9.]+)\\s*$\",\n re.M,\n )\n inline_weights = {}\n for n, weight, score in weighted_pattern.findall(output):\n n_i = int(n)\n inline_weights[n_i] = float(weight)\n ratios[n_i] = float(score)\n\n return ratios, counts, inline_weights\n\n\ndef parse_total_score(output):\n m = re.search(r\"TOTAL_SCORE\\s+([0-9]+(?:\\.[0-9]+)?)\", output)\n if m:\n return float(m.group(1))\n reward_path = Path(\"/logs/verifier/reward.txt\")\n if reward_path.exists():\n try:\n return float(reward_path.read_text(errors=\"replace\").strip())\n except Exception:\n pass\n return None\n\n\ndef main():\n output = read_text(\"/tmp/test_full.log\")\n script = read_text(\"/tests/test.sh\")\n\n statuses = parse_statuses(output)\n if not statuses:\n statuses = [(\"tests/roadmap.py::unknown\", ERROR)]\n\n ratios, counts, inline_weights = parse_phase_ratios(output)\n weights = parse_weights(script, len(statuses))\n for idx, weight in inline_weights.items():\n if 1 <= idx <= len(weights):\n weights[idx - 1] = weight\n\n details = []\n weighted_total = 0.0\n weight_total = 0.0\n failed_names = []\n\n for pos, (name, status) in enumerate(statuses, start=1):\n phase_num = parse_phase_number(name, pos)\n weight = weights[pos - 1] if pos - 1 < len(weights) else 1.0\n if phase_num in ratios:\n ratio = ratios[phase_num]\n else:\n ratio = 1.0 if status == PASSED else 0.0\n contribution = weight * ratio\n weighted_total += contribution\n weight_total += weight\n\n if phase_num in counts:\n phase_passed, phase_total = counts[phase_num]\n message = (\n f\"Phase {phase_num}: {phase_passed}/{phase_total} checks passed; \"\n f\"weighted contribution {contribution:.6f}/{weight:.6f}\"\n )\n else:\n message = (\n f\"Phase {phase_num}: status {status}; \"\n f\"weighted contribution {contribution:.6f}/{weight:.6f}\"\n )\n\n if status != PASSED:\n failed_names.append(name)\n\n details.append(\n {\n \"name\": name,\n \"status\": status,\n \"message\": message,\n \"score\": contribution,\n \"weight\": weight,\n }\n )\n\n passed_count = sum(1 for _, status in statuses if status == PASSED)\n total_count = len(statuses)\n pass_rate = passed_count / total_count if total_count else 0.0\n total_score = parse_total_score(output)\n if total_score is None:\n total_score = weighted_total / weight_total if weight_total else 0.0\n\n summary = (\n f\"{passed_count}/{total_count} phases passed; \"\n f\"weighted score {total_score:.6f}\"\n )\n if failed_names:\n summary += \". Failed: \" + \", \".join(failed_names[:10])\n if len(failed_names) > 10:\n summary += f\" (+{len(failed_names) - 10} more)\"\n\n result = {\n \"valid\": True,\n \"score\": total_score,\n \"pass_rate\": pass_rate,\n \"summary\": summary,\n \"details\": details,\n \"metrics\": {\n \"phase_weighted_total\": weighted_total,\n \"phase_weight_total\": weight_total,\n \"source\": \"roadmap_structured_json\",\n },\n }\n\n print(\">>>>> Start Structured Result\")\n print(json.dumps(result, ensure_ascii=False, indent=2))\n print(\">>>>> End Structured Result\")\n\n\nif __name__ == \"__main__\":\n main()\nPY\ncat /tmp/structured_result.log",
+ "eval_timeout": 1800,
+ "parser": "structured_json",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 1.0
+ }
+ }
+}
diff --git a/smt_solver.json b/smt_solver.json
new file mode 100644
index 0000000000000000000000000000000000000000..d5fdf39967c02ccbaad6616d2e11a4ad7b06b87a
--- /dev/null
+++ b/smt_solver.json
@@ -0,0 +1,44 @@
+{
+ "task_id": "smt_solver",
+ "name": "Smt Solver",
+ "category": "Combinatorial Optimization",
+ "base_image": "python310",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/smt_solver",
+ "submit_paths": [
+ "build.sh",
+ "solve",
+ "src/"
+ ],
+ "submit_exclude": [
+ "__pycache__/",
+ "*.pyc",
+ ".pytest_cache/",
+ "benchmarks/",
+ "hidden_benchmarks/",
+ "expected_answers.json",
+ "selection_manifest.json",
+ "public_score.json",
+ "hidden_score.json",
+ "*.log"
+ ],
+ "work": {
+ "image_tag": "ce487a98870f",
+ "specs_dir": "/home/workspace/smt_solver",
+ "agent_query": "Implement an SMT solver from scratch. Read README.md and smtlib_spec.md. Provide build.sh, solve, and src/. The evaluator calls ./solve path/to/input.smt2 and expects unsat or unknown as exactly one line, and sat followed by a JSON model witness that validates the assertions. The benchmark logics include QF_UF, QF_LRA, QF_LIA, and QF_UFLRA. Use the compact benchmarks/ develop set and scripts/evaluate.py for local feedback. Official hidden evaluation uses a 60 second per-case timeout, 16 evaluator workers, perturbation with a private salt, and a 7200 second whole-run wall-clock budget. Do not call external SMT solvers such as z3/cvc5, online services, or hard-code benchmark answers."
+ },
+ "judge": {
+ "image_tag": "fdce54253c61",
+ "eval_cmd": "python3 - <<'PY'\nimport pathlib, shutil, zipfile\nzip_path = pathlib.Path('/home/workspace/smt_judge/SMT-hidden_benchmarks.zip')\ndest = pathlib.Path('/home/workspace/smt_judge/hidden_benchmarks')\nif dest.exists():\n shutil.rmtree(dest)\ndest.mkdir(parents=True, exist_ok=True)\nwith zipfile.ZipFile(zip_path) as z:\n z.extractall(dest)\nPY\ncd /home/workspace/smt_solver && rm -rf benchmarks hidden_benchmarks scripts expected_answers.json selection_manifest.json hidden_score.json public_score.json; chmod +x build.sh solve; build_status=0; ./build.sh >/tmp/smt_build.out 2>/tmp/smt_build.err || build_status=$?; if [ \"$build_status\" -eq 0 ]; then python3 /home/workspace/smt_judge/scripts/evaluate.py --solver ./solve --benchmarks /home/workspace/smt_judge/hidden_benchmarks --expected /home/workspace/smt_judge/hidden_benchmarks/expected_answers.json --manifest /home/workspace/smt_judge/hidden_benchmarks/selection_manifest.json --timeout 60 --parallel 16 --perturb --perturb-salt hidden-sebench --submission-root /home/workspace/smt_solver --output /tmp/smt_hidden_score.json >/tmp/smt_eval.out 2>/tmp/smt_eval.err; eval_status=$?; else eval_status=$build_status; fi; if [ -f /tmp/smt_build.out ]; then cat /tmp/smt_build.out; fi; if [ -f /tmp/smt_build.err ]; then cat /tmp/smt_build.err; fi; if [ -f /tmp/smt_eval.out ]; then cat /tmp/smt_eval.out; fi; if [ -f /tmp/smt_eval.err ]; then cat /tmp/smt_eval.err; fi; cat > /tmp/sebench_parse_result.py <<'PY'\nimport json, pathlib\np = pathlib.Path('/tmp/smt_hidden_score.json')\nraw = json.loads(p.read_text()) if p.exists() else {'final_score': 0.0, 'logic_summary': {}}\nraw_score = float(raw.get('final_score', 0.0) or 0.0)\nscore = raw_score / 100.0 if raw_score > 1.0 else raw_score\nby = raw.get('logic_summary', {}) or {}\ndef clean(g):\n out = {}\n for k, item in sorted(g.items()):\n t = int(item.get('total', 0) or 0); c = int(item.get('correct', 0) or 0)\n out[k] = {'total': t, 'correct': c, 'wrong': int(item.get('wrong', max(0, t-c)) or 0), 'timeout': int(item.get('timeout', 0) or 0), 'unknown': int(item.get('unknown', 0) or 0), 'error': int(item.get('error', 0) or 0), 'no_reference': int(item.get('no_reference', 0) or 0), 'invalid_model': int(item.get('invalid_model', 0) or 0), 'score': float(item.get('score', 0.0) or 0.0)}\n return out\nby = clean(by)\ntotal = sum(v['total'] for v in by.values()); correct = sum(v['correct'] for v in by.values())\nwrong = max(0, total - correct)\nresult = {'valid': True, 'score': score, 'pass_rate': correct/total if total else 0.0, 'total_tests': total, 'passed': correct, 'failed': wrong, 'errors': 0, 'summary': 'score={:.6f} ({:.2f}/100), correct={}/{}'.format(score, 100*score, correct, total), 'details': [], 'metrics': {'score': score, 'score_percent': 100*score, 'total': total, 'correct': correct, 'wrong_or_failed': wrong, 'by_logic': by}}\nprint('>>>>> Start Structured Result')\nprint(json.dumps(result, ensure_ascii=False))\nprint('>>>>> End Structured Result')\nPY\npython3 /tmp/sebench_parse_result.py",
+ "eval_timeout": 7200,
+ "parser": "structured_json",
+ "score_direction": "maximize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 1.0
+ }
+ }
+}
diff --git a/sphere_eversion_formalization.json b/sphere_eversion_formalization.json
new file mode 100644
index 0000000000000000000000000000000000000000..8a1c2da5f8197f4d6558d7a329304c5843ba69d0
--- /dev/null
+++ b/sphere_eversion_formalization.json
@@ -0,0 +1,31 @@
+{
+ "task_id": "sphere_eversion_formalization",
+ "name": "Sphere Eversion Formalization",
+ "category": "Formal Math & Theorem Proving",
+ "base_image": "lean_4_28_0_main",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/",
+ "submit_paths": [
+ "se-bmk-intern/sphere-eversion"
+ ],
+ "submit_exclude": [
+ "se-bmk-intern/sphere-eversion/.lake"
+ ],
+ "work": {
+ "image_tag": "96f62982feaa",
+ "specs_dir": null,
+ "agent_query": "You are a lean4 expert, now your task is to finish **all** sorries in this folder. Pay no attention to anything outside this folder. There are many sorries but do not be afraid as we value minor progress and the time is abundant. Try to do some easy problems and accumulate scores each round. Before you submit, run a `lake build` to verify the changes locally - if the build failed, no score will be given. Also, do not modify the signature of existing lemma/theorem/def as these changes will not pass the judge evaluation."
+ },
+ "judge": {
+ "image_tag": "580e3aa210fa",
+ "eval_cmd": "cd /home/workspace/se-bmk-intern/sphere-eversion && cp -r /home/workspace/baseline/.lake . && cp /home/workspace/baseline/lake-manifest.json . && lake build && cp /home/workspace/judge/se-bmk-intern/sphere-eversion/ListDeclAxiom.lean . && cd /home/workspace/judge/se-bmk-intern && python3 eval_lean.py --baseline-repo /home/workspace/judge/se-bmk-intern/sphere-eversion --current-repo /home/workspace/se-bmk-intern/sphere-eversion",
+ "eval_timeout": 2400,
+ "parser": "structured_json",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 1.0
+ }
+ }
+}
diff --git a/treant_forest.json b/treant_forest.json
new file mode 100644
index 0000000000000000000000000000000000000000..a26651c7febc95fd645093fa33bdd1a22e7f3178
--- /dev/null
+++ b/treant_forest.json
@@ -0,0 +1,32 @@
+{
+ "task_id": "treant_forest",
+ "name": "Treant Forest",
+ "category": "Combinatorial Optimization",
+ "base_image": "python310",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/treants_forest",
+ "submit_paths": [
+ "solution.py"
+ ],
+ "work": {
+ "image_tag": "e05dfd5d2463",
+ "specs_dir": "/home/workspace/treants_forest",
+ "agent_query": "## Treant's Forest - Maze Obstruction Strategy (AHC054)\n\nWrite `solution.py` in the project root that reads from stdin and writes to stdout.\n\n---\n\n## Problem Overview\n\nRead `README.md` and `tools/README.md` for full problem details. A baseline `solution.py` already exists (it produces syntactically valid but low-quality output). Your job is to improve it.\n\n---\n\n## Evaluation\n\nYour solution is scored on **50 fixed test cases**. Final score = sum of individual case scores. **Higher is better.**\n\n---\n\n## Local Testing\n\nGenerate local random tests with `./tools/bin/gen `, using seeds in the range **0..10000** only.\n\n```bash\n# Generate a random test case (seed-based, deterministic)\n./tools/bin/gen 0 > input.txt\n\n# Run your solution\npython3 solution.py < input.txt > output.txt\n\n# Score output (Higher is better)\n./tools/bin/tester input.txt output.txt\n# Outputs to stderr: Score = \n```\n\n---\n\n## Rules\n\n- Write your solution as `solution.py` in the project root directory\n- Do NOT modify files in `tools/`\n- Use `tools/bin/gen` and `tools/bin/tester` for local testing\n- For local scoring, use only `./tools/bin/tester`; do not use `tools/src/verifier.py` for scores\n- Your program should read from stdin and write to stdout\n- Run your solution to completion and verify with the tester before finishing\n"
+ },
+ "judge": {
+ "image_tag": "d47dc1a7da74",
+ "eval_cmd": "cd /home/workspace/treants_forest && python3 /tmp/eval_treants_forest.py",
+ "eval_timeout": 870,
+ "parser": "score_sum",
+ "score_direction": "maximize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "piecewise_max",
+ "baseline": 5369.0,
+ "rank30": 88189.0,
+ "rank1": 330195.0,
+ "super_anchor": 451198.0
+ }
+ }
+}
diff --git a/tree_block_partitioning.json b/tree_block_partitioning.json
new file mode 100644
index 0000000000000000000000000000000000000000..beb43ac5b15b6abc3f99a5f472a6c547e6f4487d
--- /dev/null
+++ b/tree_block_partitioning.json
@@ -0,0 +1,35 @@
+{
+ "task_id": "tree_block_partitioning",
+ "name": "Tree Block Partitioning",
+ "category": "Combinatorial Optimization",
+ "base_image": "cpp",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/p1",
+ "submit_paths": [
+ "T1.cpp",
+ "T2.cpp",
+ "T3.cpp",
+ "T4.cpp",
+ "T5.cpp",
+ "T6.cpp"
+ ],
+ "submit_exclude": [],
+ "work": {
+ "image_tag": "f282a9f7e05a",
+ "specs_dir": "/home/workspace/p1",
+ "agent_query": "You need to complete six problems, with a total score of 100 points. The six problems are worth 5, 5, 10, 15, 25, and 40 points respectively. Each problem has several groups of test data. If all test data for a problem pass, you receive the full score for that problem. If a problem does not pass all test data but does pass some subtasks/test points, each passed subtask/test point can receive only half of its original score. Please work on the problems in order, with the goal of solving them as much as possible. These problems are progressive; if you do not know how to solve a later problem, it is recommended that you review the methods used for earlier problems and look for ideas there.\nWhen submitting code, the code files for the six problems should be named T1.cpp T2.cpp T3.cpp T4.cpp T5.cpp T6.cpp.\n"
+ },
+ "judge": {
+ "image_tag": "f74f0ef897ce",
+ "eval_cmd": "cd /home/workspace/p1 && python3 /opt/p1_judge/prob/P1/eval.py --source-root /home/workspace/p1 --time-factor 1 --time-grace 0 --score-sum",
+ "eval_timeout": 600,
+ "parser": "score_sum",
+ "score_direction": "maximize",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 100.0
+ }
+ }
+}
diff --git a/triangulation_coloring_optimization.json b/triangulation_coloring_optimization.json
new file mode 100644
index 0000000000000000000000000000000000000000..88ec9725e680978434f2013daac6df1df2526bb0
--- /dev/null
+++ b/triangulation_coloring_optimization.json
@@ -0,0 +1,32 @@
+{
+ "task_id": "triangulation_coloring_optimization",
+ "name": "Triangulation Coloring Optimization",
+ "category": "Combinatorial Optimization",
+ "base_image": "python310",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/triangulation_coloring",
+ "submit_paths": [
+ "solution.py"
+ ],
+ "work": {
+ "image_tag": "d3af8893fa81",
+ "specs_dir": "/home/workspace/triangulation_coloring",
+ "agent_query": "## Triangulation Coloring - Minimize Ugliness (CodeChef TRICOL)\n\nWrite `solution.py` in the project root (stdin → stdout). All modifications must be made only in `solution.py`.\n\nRead `README.md`, `tools/README.md`, and **`sample_data/README.md`**. Official scoring: flips change the triangulation; **U** (ugly triangles) is counted on the **final** triangulation after all flips.\n\n---\n\n## Evaluation\n\n- **10 hidden judge cases**, each **N=512**\n- **G = X·C + Y·F + U²** per case; **total score = sum** (lower is better)\n---\n\n## Local Testing\n\nUse the **3 pre-built N=512 files** in `sample_data/`. Use only these pre-built cases; do **not** call `tools/src/gen.py` or generate random local cases.\n\n```bash\n./eval_sample_data.sh\n# or per file:\npython3 solution.py < sample_data/0000.txt > output.txt\n./tools/bin/tester sample_data/0000.txt output.txt\n```\n\nAlso try `sample_data/0001.txt` and `sample_data/0002.txt`.\n\nWhen `./eval_sample_data.sh` improves, **submit** for all 10 hidden judge cases.\n\n---\n\n## Strategy (algorithm exploration)\n\nFocus on improving **`solution.py`** using `sample_data/` for feedback:\n\n1. **Joint optimization** — recolor and flip interact; optimize them together, not in tiny fixed phases.\n2. **U² dominates** on hard cases — reducing ugly triangles by even a few often beats tweaking C/F.\n3. **Iterate**: change algorithm → `./eval_sample_data.sh` → submit when promising.\n4. Do **not** loop local tests endlessly; move to submit after a few sample checks.\n\n---\n\n## Rules\n\n- Only modify `solution.py`; do **not** change `tools/` or `sample_data/`\n- Output: line 1 `C F`, line 2 color string (length N), then `F` flip lines (1-indexed vertex pairs)\n- The local `tester` applies flips exactly like the judge\n"
+ },
+ "judge": {
+ "image_tag": "568aa1a5a8ff",
+ "eval_cmd": "cd /home/workspace/triangulation_coloring && python3 /tmp/eval_triangulation_coloring.py",
+ "eval_timeout": 1200,
+ "parser": "score_sum",
+ "score_direction": "minimize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "piecewise_log_min",
+ "baseline": 6102378.0,
+ "rank30": 3372655.0,
+ "rank1": 200033.0,
+ "super_anchor": 100016.5
+ }
+ }
+}
diff --git a/trinity_text_adventure.json b/trinity_text_adventure.json
new file mode 100644
index 0000000000000000000000000000000000000000..e751c5599a57030f6f00f0343b8d4822cb0e5287
--- /dev/null
+++ b/trinity_text_adventure.json
@@ -0,0 +1,29 @@
+{
+ "task_id": "trinity_text_adventure",
+ "name": "Trinity Text Adventure",
+ "category": "Interactive Games & Simulators",
+ "base_image": "python310",
+ "platform": "linux/amd64",
+ "internet": false,
+ "game_mode": true,
+ "cwd": "/home/jericho_agent",
+ "submit_paths": [],
+ "work": {
+ "image_tag": "61ded5caecc2",
+ "specs_dir": "/home/jericho_agent",
+ "agent_query": "## Trinity — Jericho Text Adventure\n\nPlay the interactive fiction game *Trinity* by sending commands via an HTTP API and maximize your score.\n"
+ },
+ "judge": {
+ "image_tag": "fcaad5fa630f",
+ "eval_cmd": "",
+ "eval_timeout": 600,
+ "parser": "",
+ "selection": "score_first",
+ "game_server_cmd": "python /tmp/game_server_app.py --rom /home/roms/trinity.z4",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 100.0
+ }
+ }
+}
diff --git a/tryst_text_adventure.json b/tryst_text_adventure.json
new file mode 100644
index 0000000000000000000000000000000000000000..92c1bbcdb1d40b9ab18ec8a35c34cd25b08c1098
--- /dev/null
+++ b/tryst_text_adventure.json
@@ -0,0 +1,29 @@
+{
+ "task_id": "tryst_text_adventure",
+ "name": "Tryst Text Adventure",
+ "category": "Interactive Games & Simulators",
+ "base_image": "python310",
+ "platform": "linux/amd64",
+ "internet": false,
+ "game_mode": true,
+ "cwd": "/home/jericho_agent",
+ "submit_paths": [],
+ "work": {
+ "image_tag": "61ded5caecc2",
+ "specs_dir": "/home/jericho_agent",
+ "agent_query": "## Tryst of Fate — Jericho Text Adventure\n\nPlay the interactive fiction game *Tryst of Fate* by sending commands via an HTTP API and maximize your score.\n"
+ },
+ "judge": {
+ "image_tag": "9e1dff6f3aa6",
+ "eval_cmd": "",
+ "eval_timeout": 600,
+ "parser": "",
+ "selection": "score_first",
+ "game_server_cmd": "python /tmp/game_server_app.py --rom /home/roms/tryst205.z5",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 350.0
+ }
+ }
+}
diff --git a/vehicle_routing_time_windows.json b/vehicle_routing_time_windows.json
new file mode 100644
index 0000000000000000000000000000000000000000..e7c37f70c2b97532fbd9a19d45e4169c7a69934d
--- /dev/null
+++ b/vehicle_routing_time_windows.json
@@ -0,0 +1,38 @@
+{
+ "task_id": "vehicle_routing_time_windows",
+ "name": "Vehicle Routing Time Windows",
+ "category": "Combinatorial Optimization",
+ "base_image": "python",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/task_cvrptw_905da6dd/workspace",
+ "submit_paths": [
+ "src/",
+ "include/",
+ "Makefile"
+ ],
+ "submit_exclude": [
+ "instances/",
+ "internal/",
+ "__MACOSX/",
+ ".DS_Store"
+ ],
+ "work": {
+ "image_tag": "53214fda231b",
+ "specs_dir": "/home/workspace/task_cvrptw_905da6dd/workspace",
+ "agent_query": "Read README.md, then optimize the C++17 CVRPTW solver. Modify only src/, include/, and Makefile. Preserve the cvrptw_solver binary name and CLI: ./cvrptw_solver . Do not read hidden instances, internal judge files, BKS tables, reference solutions, or evaluator internals. Hidden judge submissions have a 20-minute total wall-clock budget; keep the solver efficient."
+ },
+ "judge": {
+ "image_tag": "d5abb8bb08d2",
+ "eval_cmd": "cd /home/workspace/task_cvrptw_905da6dd/workspace && {\npython - <<'PY'\nimport csv, json, os, re, subprocess, time, traceback\nfrom pathlib import Path\n\nROOT = Path('/home/workspace/task_cvrptw_905da6dd')\nTOTAL_JUDGE_TIMEOUT_SEC = 20 * 60\nCOMPILE_TIMEOUT_SEC = 300\nPER_INSTANCE_BUDGET_SEC = 60\nVERIFIER_TIMEOUT_SEC = 30\nDEADLINE_GRACE_SEC = 5\n\nstarted = time.monotonic()\ndeadline = started + TOTAL_JUDGE_TIMEOUT_SEC\ncompile_output = ''\ndetails = []\nmetrics = {\n 'judge_time_limit_sec': TOTAL_JUDGE_TIMEOUT_SEC,\n 'per_instance_budget_sec': PER_INSTANCE_BUDGET_SEC,\n 'compile_timeout_sec': COMPILE_TIMEOUT_SEC,\n 'score': 0.0,\n 'compile_returncode': None,\n 'cases': 0,\n 'timeout_count': 0,\n 'no_pass_count': 0,\n 'judge_time_exceeded': False,\n 'compile_timed_out': False,\n}\n\n\ndef remaining() -> float:\n return deadline - time.monotonic()\n\n\ndef safe_text(x) -> str:\n if x is None:\n return ''\n if isinstance(x, bytes):\n return x.decode(errors='replace')\n return str(x)\n\n\ndef add_detail(name: str, status: str, score: float = 0.0, message: str = '', **extra) -> None:\n item = {'name': name, 'status': status, 'score': float(score), 'message': (message or '')[-1000:]}\n item.update(extra)\n details.append(item)\n\n\ndef compute(nv, td, bnv, btd):\n gap_nv = max(0, nv - bnv)\n gap_td = max(0.0, (td - btd) / btd * 100.0) if btd > 0 else 0.0\n s = max(0.0, 100.0 - 30.0 * gap_nv - 0.5 * gap_td)\n if nv < bnv:\n s += 30.0 * (bnv - nv)\n if nv <= bnv and td < btd:\n s += min(30.0, (btd - td) / btd * 100.0)\n return min(s, 160.0)\n\n\ndef load_bks():\n bks = {}\n for bp in [ROOT / 'internal/cases/bks_snapshot.csv']:\n if bp.exists():\n with open(bp, newline='') as f:\n for row in csv.DictReader(f):\n bks[row['name']] = (int(row['nv']), float(row['td']))\n return bks\n\n\ndef case_files():\n case_dir = ROOT / 'internal/cases/raw'\n return sorted(case_dir.glob('*.txt'))[:56] if case_dir.exists() else []\n\n\ndef emit(valid: bool, score: float, summary: str):\n passed = sum(1 for d in details if d.get('status') == 'PASSED')\n failed = sum(1 for d in details if d.get('status') == 'FAILED')\n errors = sum(1 for d in details if d.get('status') == 'ERROR')\n total = len(details) or 1\n metrics['score'] = float(score)\n metrics['cases'] = metrics.get('cases') or len([d for d in details if d.get('name') != 'compile'])\n metrics['timeout_count'] = sum(1 for d in details if d.get('reason') in ('solver_timeout', 'judge_time_limit', 'verifier_timeout'))\n metrics['no_pass_count'] = failed\n metrics['runtime_seconds'] = time.monotonic() - started\n if metrics['timeout_count']:\n metrics['judge_time_exceeded'] = any(d.get('reason') == 'judge_time_limit' for d in details)\n report = {\n 'valid': valid,\n 'score': float(score),\n 'pass_rate': passed / total if total else 0.0,\n 'total_tests': total,\n 'passed': passed,\n 'failed': failed,\n 'errors': errors,\n 'summary': summary,\n 'details': details[:100],\n 'metrics': metrics,\n }\n print('>>>>> Start Structured Result')\n print(json.dumps(report, ensure_ascii=False))\n print('>>>>> End Structured Result')\n\n\ntry:\n bks = load_bks()\n cases = case_files()\n metrics['cases'] = len(cases)\n\n compile_timeout = max(1, min(COMPILE_TIMEOUT_SEC, int(remaining() - DEADLINE_GRACE_SEC)))\n if compile_timeout <= 0:\n for inp in cases or [Path('compile')]:\n add_detail(inp.stem, 'ERROR', 0.0, 'judge global time limit reached before compilation', reason='judge_time_limit')\n emit(False, 0.0, f'Judge timed out before compilation: 0 passed, {len(details)} timed out/no result')\n else:\n try:\n proc = subprocess.run(\n ['bash', '-lc', 'rm -f cvrptw_solver tools/verify && make -j4'],\n text=True,\n capture_output=True,\n timeout=compile_timeout,\n )\n compile_output = (proc.stdout or '') + (proc.stderr or '')\n metrics['compile_returncode'] = proc.returncode\n compiled = proc.returncode == 0 and Path('cvrptw_solver').exists()\n except subprocess.TimeoutExpired as ex:\n compile_output = safe_text(ex.stdout) + safe_text(ex.stderr) + '\\nCOMPILE_TIMEOUT'\n metrics['compile_returncode'] = -9\n metrics['compile_timed_out'] = True\n compiled = False\n\n print(compile_output, end='')\n\n if not compiled:\n status = 'ERROR' if metrics['compile_timed_out'] else 'FAILED'\n reason = 'compile_timeout' if metrics['compile_timed_out'] else 'compile_failed'\n msg = compile_output[-1000:] or reason\n if cases:\n for inp in cases:\n add_detail(inp.stem, status, 0.0, msg, reason=reason)\n else:\n add_detail('compile', status, 0.0, msg, reason=reason)\n emit(False, 0.0, f'Compilation did not pass ({reason}); score=0. Timeouts: {metrics[\"compile_timed_out\"]}')\n else:\n bks = bks or {}\n score_sum = 0.0\n for idx, inp in enumerate(cases):\n name = inp.stem\n rem = remaining()\n if rem <= DEADLINE_GRACE_SEC + 1:\n add_detail(name, 'ERROR', 0.0, 'judge global time limit reached before this instance could finish', reason='judge_time_limit')\n continue\n\n budget = min(PER_INSTANCE_BUDGET_SEC, max(1, int(rem - DEADLINE_GRACE_SEC - 1)))\n out = Path(f'out_{name}.sol')\n try:\n out.unlink(missing_ok=True)\n except OSError:\n pass\n\n try:\n run = subprocess.run(\n ['./cvrptw_solver', str(inp), str(out), str(budget)],\n text=True,\n capture_output=True,\n timeout=budget + DEADLINE_GRACE_SEC,\n )\n run_txt = (run.stdout or '') + (run.stderr or '')\n solver_timed_out = False\n except subprocess.TimeoutExpired as ex:\n run = None\n run_txt = safe_text(ex.stdout) + safe_text(ex.stderr) + '\\nSOLVER_TIMEOUT'\n solver_timed_out = True\n\n if solver_timed_out:\n add_detail(name, 'ERROR', 0.0, run_txt, reason='solver_timeout', budget_sec=budget)\n continue\n if run is None or run.returncode != 0:\n rc = getattr(run, 'returncode', 'unknown')\n add_detail(name, 'FAILED', 0.0, f'solver exited without a passing solution: exit_code={rc}\\n{run_txt}', reason='no_pass', budget_sec=budget)\n continue\n if not out.exists():\n add_detail(name, 'FAILED', 0.0, 'solver produced no output file', reason='no_pass', budget_sec=budget)\n continue\n\n v_rem = remaining()\n if v_rem <= 2:\n add_detail(name, 'ERROR', 0.0, 'judge global time limit reached before verification', reason='judge_time_limit', budget_sec=budget)\n continue\n v_timeout = max(1, min(VERIFIER_TIMEOUT_SEC, int(v_rem - 1)))\n try:\n ver = subprocess.run(\n ['./tools/verify', str(inp), str(out)],\n text=True,\n capture_output=True,\n timeout=v_timeout,\n )\n ver_txt = (ver.stdout or '') + (ver.stderr or '')\n verifier_timed_out = False\n except subprocess.TimeoutExpired as ex:\n ver = None\n ver_txt = safe_text(ex.stdout) + safe_text(ex.stderr) + '\\nVERIFIER_TIMEOUT'\n verifier_timed_out = True\n\n if verifier_timed_out:\n add_detail(name, 'ERROR', 0.0, ver_txt, reason='verifier_timeout', budget_sec=budget)\n continue\n\n feasible = ver is not None and ver.returncode == 0 and 'feasible: true' in (ver.stdout or '')\n nv_m = re.search(r'NV:\\s*(\\d+)', ver.stdout if ver else '')\n td_m = re.search(r'TD:\\s*([0-9.]+)', ver.stdout if ver else '')\n nv = int(nv_m.group(1)) if nv_m else 10**9\n td = float(td_m.group(1)) if td_m else 1e18\n bnv, btd = bks.get(name, (nv, td))\n si = compute(nv, td, bnv, btd) if feasible else 0.0\n score_sum += si\n if feasible:\n msg = f'feasible; NV={nv}; TD={td}; BKS_NV={bnv}; BKS_TD={btd}; budget_sec={budget}'\n add_detail(name, 'PASSED', si, msg, reason='passed', budget_sec=budget, NV=nv, TD=td, BKS_NV=bnv, BKS_TD=btd)\n else:\n msg = (run_txt + '\\n' + ver_txt)[-1000:] or 'solution did not pass feasibility/cost verification'\n add_detail(name, 'FAILED', 0.0, msg, reason='no_pass', budget_sec=budget, NV=nv, TD=td, BKS_NV=bnv, BKS_TD=btd)\n\n total_cases = len(cases) or 1\n final_score = score_sum / total_cases * 100.0\n pass_cnt = sum(1 for d in details if d.get('status') == 'PASSED')\n fail_cnt = sum(1 for d in details if d.get('status') == 'FAILED')\n timeout_cnt = sum(1 for d in details if d.get('reason') in ('solver_timeout', 'judge_time_limit', 'verifier_timeout'))\n summary = (\n f'Score: {final_score:.6f} over {len(cases)} cases; '\n f'passed={pass_cnt}, no_pass={fail_cnt}, timeout={timeout_cnt}, '\n f'runtime={time.monotonic() - started:.2f}s/{TOTAL_JUDGE_TIMEOUT_SEC}s'\n )\n emit(True, final_score, summary)\nexcept Exception:\n err = traceback.format_exc()\n print(err)\n if not details:\n add_detail('judge_exception', 'ERROR', 0.0, err, reason='judge_exception')\n emit(False, 0.0, 'Judge exception before normal completion; see details')\nPY\n}",
+ "eval_timeout": 1200,
+ "parser": "structured_json",
+ "score_direction": "maximize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 10000.0
+ }
+ }
+}
diff --git a/vibrating_path_graph_coloring.json b/vibrating_path_graph_coloring.json
new file mode 100644
index 0000000000000000000000000000000000000000..49a0902303edf26dbf5e826ef38d196c93389dfa
--- /dev/null
+++ b/vibrating_path_graph_coloring.json
@@ -0,0 +1,32 @@
+{
+ "task_id": "vibrating_path_graph_coloring",
+ "name": "Vibrating Path Graph Coloring",
+ "category": "Combinatorial Optimization",
+ "base_image": "python310",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/vibrating_path",
+ "submit_paths": [
+ "solution.py"
+ ],
+ "work": {
+ "image_tag": "e5597c7f3c12",
+ "specs_dir": "/home/workspace/vibrating_path",
+ "agent_query": "## Vibrating Path - Graph K-Coloring (CodeChef VBR)\n\nWrite `solution.py` in the project root that reads from stdin and writes to stdout.\n\n---\n\n## Problem Overview\n\nRead `README.md` and `tools/README.md` for full problem details. A baseline `solution.py` already exists (it produces syntactically valid but low-quality output). Your job is to improve it.\n\n---\n\n## Evaluation\n\nYour solution is scored on **50 fixed test cases**. Final score = sum of individual case scores. **Lower is better.**\n\n---\n\n## Local Testing\n\nGenerate local random tests with `./tools/bin/gen `, using seeds in the range **0..10000** only.\n\n```bash\n# Generate a random test case (seed-based, deterministic)\n./tools/bin/gen 1 > input.txt\n\n# Run your solution\npython3 solution.py < input.txt > output.txt\n\n# Score output (Lower is better)\n./tools/bin/tester input.txt output.txt\n# Outputs to stderr: Score = \n```\n\n---\n\n## Rules\n\n- Write your solution as `solution.py` in the project root directory\n- Do NOT modify files in `tools/`\n- Use `tools/bin/gen` and `tools/bin/tester` for local testing\n- Your program should read from stdin and write to stdout\n- Run your solution to completion and verify with the tester before finishing\n"
+ },
+ "judge": {
+ "image_tag": "eb22343ce84e",
+ "eval_cmd": "cd /home/workspace/vibrating_path && python3 /tmp/eval_vibrating_path.py",
+ "eval_timeout": 600,
+ "parser": "score_sum",
+ "score_direction": "minimize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "piecewise_log_min",
+ "baseline": 31051708.0,
+ "rank30": 3288665.0,
+ "rank1": 2181554.0,
+ "super_anchor": 1904776.25
+ }
+ }
+}
diff --git a/vliw_kernel_optimization.json b/vliw_kernel_optimization.json
new file mode 100644
index 0000000000000000000000000000000000000000..abf3750d7fa813a2773e7cca7a046791ba6b8e52
--- /dev/null
+++ b/vliw_kernel_optimization.json
@@ -0,0 +1,39 @@
+{
+ "task_id": "vliw_kernel_optimization",
+ "name": "Vliw Kernel Optimization",
+ "category": "Systems & Software Engineering",
+ "base_image": "python",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/sebench_performance_takehome",
+ "submit_paths": [
+ "solution.py"
+ ],
+ "submit_exclude": [
+ "runner.py",
+ "verifier.py",
+ "problem.py",
+ "test_cases/",
+ "public_tests/",
+ "__pycache__/",
+ ".DS_Store"
+ ],
+ "work": {
+ "image_tag": "9fa380a0ebef",
+ "specs_dir": "/home/workspace/sebench_performance_takehome",
+ "agent_query": "Optimize solution.py for the custom VLIW/SIMD kernel generator. Implement KernelBuilder.build_kernel so the generated instruction program is correct and faster on the simulator. Modify only solution.py. Do not change problem.py, runner.py, verifier.py, test cases, or hard-code public or hidden seeds."
+ },
+ "judge": {
+ "image_tag": "5cdef0021634",
+ "eval_cmd": "cd /home/workspace/sebench_performance_takehome && python -c \"exec(\\\"import json, subprocess, sys\\\\nfrom pathlib import Path\\\\nreport_path = Path('/tmp/sebench_performance_report.json')\\\\noutput = ''\\\\nrunner_returncode = None\\\\nreport = {}\\\\ntry:\\\\n proc = subprocess.run([sys.executable, 'runner.py', '--solution', 'solution.py', '--cases', 'test_cases/hidden_cases.json', '--output', str(report_path)], text=True, capture_output=True, timeout=600)\\\\n runner_returncode = proc.returncode\\\\n output = (proc.stdout or '') + (proc.stderr or '')\\\\n print(output, end='')\\\\n if report_path.exists():\\\\n report = json.loads(report_path.read_text())\\\\nexcept subprocess.TimeoutExpired as exc:\\\\n stdout = exc.stdout.decode(errors='replace') if isinstance(exc.stdout, bytes) else (exc.stdout or '')\\\\n stderr = exc.stderr.decode(errors='replace') if isinstance(exc.stderr, bytes) else (exc.stderr or '')\\\\n output = stdout + stderr\\\\n print(output, end='')\\\\n report = {'all_correct': False, 'score': None, 'score_cycles': None, 'best_cycles': None, 'passed_thresholds': [], 'results': [], 'error': 'evaluation timed out'}\\\\nexcept Exception as exc:\\\\n report = {'all_correct': False, 'score': None, 'score_cycles': None, 'best_cycles': None, 'passed_thresholds': [], 'results': [], 'error': repr(exc)}\\\\nscore_cycles = report.get('score_cycles')\\\\nvalid = bool(report.get('all_correct') and score_cycles is not None)\\\\nscore = float(score_cycles) if valid else None\\\\nsummary = ('cycles={:.0f}; lower is better'.format(score) if valid else 'invalid submission; no cycle score')\\\\ndetails = []\\\\nfor result in report.get('results', []):\\\\n ok = bool(result.get('correct'))\\\\n details.append({'name': result.get('name', ''), 'status': 'PASSED' if ok else 'FAILED', 'score': result.get('cycles'), 'message': 'kind={}; cycles={}'.format(result.get('kind', 'correctness'), result.get('cycles'))})\\\\nif not details:\\\\n details = [{'name': 'hidden_cycles', 'status': 'PASSED' if valid else 'FAILED', 'score': score, 'message': output[-2000:]}]\\\\npassed_count = sum(1 for d in details if d['status'] == 'PASSED')\\\\nfailed_count = sum(1 for d in details if d['status'] == 'FAILED')\\\\nstructured = {'valid': valid, 'score': score, 'pass_rate': 1.0 if valid else 0.0, 'total_tests': len(details), 'passed': passed_count, 'failed': failed_count, 'errors': 0 if valid else 1, 'summary': summary, 'details': details, 'metrics': {'score_cycles': score_cycles, 'best_cycles': report.get('best_cycles'), 'legacy_score': report.get('score'), 'passed_thresholds': report.get('passed_thresholds', []), 'runner_returncode': runner_returncode}}\\\\nprint('>>>>> Start Structured Result')\\\\nprint(json.dumps(structured, ensure_ascii=False))\\\\nprint('>>>>> End Structured Result')\\\")\"",
+ "eval_timeout": 700,
+ "parser": "structured_json",
+ "score_direction": "minimize",
+ "selection": "valid_then_score",
+ "rescale": {
+ "kind": "log_min",
+ "baseline": 4475.526541978607,
+ "expert": 1000.0
+ }
+ }
+}
diff --git a/warehouse_forklift_routing.json b/warehouse_forklift_routing.json
new file mode 100644
index 0000000000000000000000000000000000000000..a3240a1884bc91a0e9d9635bf60d474cc9414e4d
--- /dev/null
+++ b/warehouse_forklift_routing.json
@@ -0,0 +1,32 @@
+{
+ "task_id": "warehouse_forklift_routing",
+ "name": "Warehouse Forklift Routing",
+ "category": "Combinatorial Optimization",
+ "base_image": "python310",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/warehouse_manager",
+ "submit_paths": [
+ "solution.py"
+ ],
+ "work": {
+ "image_tag": "7a86216250d8",
+ "specs_dir": "/home/workspace/warehouse_manager",
+ "agent_query": "## Warehouse Manager - Forklift Operations Optimization (CodeChef WAREHOUS)\n\nWrite `solution.py` in the project root that reads from stdin and writes to stdout.\n\n---\n\n## Problem Overview\n\nChef's warehouse is an R x C grid. A forklift starts at the northwest corner (0,0). R*C-1 goods arrive one by one in a given order, must be loaded and placed in the warehouse, then later dispatched from the entrance in order 1, 2, ..., R*C-1.\n\nThe forklift can:\n- Move: N/S/E/W\n- Pick up (P) arriving goods at entrance\n- Dispatch (D) goods at entrance\n- Load (Lx) from adjacent cell in direction x\n- Unload (Ux) to adjacent cell in direction x\n\nA forklift carrying a good cannot enter an occupied cell. Minimize the total instruction string length.\n\n---\n\n## Constraints\n\n- T=5 test cases per input\n- 6 <= R, C <= 20\n- Output string length <= 500,000 per test case\n\n## Scoring Formula\n\nPer test case: (S + 2) / (R + C - 1) - 2*R*C + 20, where S = instruction string length. Score is averaged over T cases. **Minimize.**\n\n---\n\n## Input Format\n\n```\nT\nR_1 C_1\na_1 a_2 ... a_{R1*C1-1}\nR_2 C_2\na_1 a_2 ... a_{R2*C2-1}\n...\n```\n\n## Output Format\n\nOne line per test case: the forklift command string.\n\nCommands: N, S, E, W (move), P (pick up arrival), D (dispatch at entrance), Lx (load from direction x), Ux (unload to direction x).\n\n---\n\n## Runtime Limits\n\n- Time limit: 30 seconds per test case\n- Memory limit: 1 GB\n- No GPU\n\n---\n\n## Local Testing\n\nUse `./tools/bin/gen ` for local testing with seeds in the range **0..10000** only.\n\n```bash\n./tools/bin/gen 1 > input.txt\npython3 solution.py < input.txt > output.txt\n./tools/bin/tester input.txt output.txt\n# stderr: Score = \n```\n\nA baseline `solution.py` exists. Improve it.\n\n---\n\n## Strategy Hints\n\n- Plan storage positions to minimize movement during both placement and retrieval.\n- Consider placing goods that will be dispatched first (low IDs) near the entrance.\n- Use BFS for pathfinding in the grid.\n- The arrival order is random; you may need to temporarily rearrange goods.\n- Read `README.md` and `tools/README.md` for full problem details.\n\n## Rules\n\n- Write your solution as `solution.py` in the project root directory\n- Do NOT modify files in `tools/`\n- Use `tools/bin/gen` and `tools/bin/tester` for local testing\n- Your program should read from stdin and write to stdout\n- Run your solution to completion and verify with the tester before finishing"
+ },
+ "judge": {
+ "image_tag": "d342863c29cc",
+ "eval_cmd": "cd /home/workspace/warehouse_manager && python3 /tmp/eval_warehouse_manager.py",
+ "eval_timeout": 3600,
+ "parser": "score_sum",
+ "score_direction": "minimize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "piecewise_log_min",
+ "baseline": 23277.847205,
+ "rank30": 804.959064,
+ "rank1": 395.802847,
+ "super_anchor": 293.51379275
+ }
+ }
+}
diff --git a/wesnoth_tactical_ai.json b/wesnoth_tactical_ai.json
new file mode 100644
index 0000000000000000000000000000000000000000..a58620a3f6830041d4e3e3fef0790c8a56c17ec4
--- /dev/null
+++ b/wesnoth_tactical_ai.json
@@ -0,0 +1,33 @@
+{
+ "task_id": "wesnoth_tactical_ai",
+ "name": "Wesnoth Tactical Ai",
+ "category": "Interactive Games & Simulators",
+ "base_image": "python310",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/wesnoth_agent",
+ "submit_paths": [
+ "."
+ ],
+ "submit_exclude": [
+ ".git"
+ ],
+ "work": {
+ "image_tag": "43d1943974c7",
+ "specs_dir": "/home/wesnoth_agent",
+ "agent_query": "## Wesnoth Tactical AI\n\nWrite a Lua AI for The Battle for Wesnoth 1.18 that wins turn-based multiplayer matches against the default AI.\n\n---\n\n## Goal\n\nMaximize **total_score = 80 x win_rate + 20 x avg_efficiency**, evaluated over 3 maps x N seeds (default 10) x N repeats (default 2) as side 1 (your AI) vs side 2 (default Wesnoth AI).\n\n- `win_rate` = wins / total_games\n- `avg_efficiency` = mean(min(1, baseline_turns / actual_turns)) over wins only\n\nBaseline turn counts (default vs default): `Weldyn_Channel=16`, `The_Freelands=15`, `Fallenstar_Lake=20`.\n\nNote: The baseline AI (default C++ CAs) typically scores 0-20. Focus on incremental improvements.\n\n---\n\n## API Restrictions (CRITICAL — violation = score=0 and hack flag)\n\nForbidden APIs (not for AI decisions):\n- `wesnoth.wml_actions.*` — scene design API (WML actions like kill, message, etc.), NOT for AI decisions\n- `wesnoth.game_events.*` — can fire arbitrary WML events, NOT for AI decisions\n- `os.execute` — system command execution\n- `io.open` — file system access\n- `debug.*` — can bypass sandbox restrictions\n\nAllowed APIs (AI decision APIs):\n- `wesnoth.units.*` — unit queries (find_on_map, etc.)\n- `wesnoth.current.*` — current game state\n- `wesnoth.sides.*` — side information (gold, recruit list, villages, etc.)\n- `wesnoth.map.*` — map queries\n- `wesnoth.interface.*` — chat messages, UI\n- `wesnoth.ai.*` — AI aspects and actions\n\nUsing forbidden APIs or attempting to bypass restrictions (e.g., string concatenation, metatable manipulation, variable indirection) will result in score=0 and the submission marked as hack.\n\n---\n\n## Files you must write in `/home/wesnoth_agent/`\n\n1. `my_custom_ai.cfg` — AI definition (WML). Must include `id=my_custom_ai`, a `[stage]`, and `[candidate_action]` blocks.\n2. Any number of `*.lua` files referenced by `location=...` in the cfg.\n\nA baseline `my_custom_ai.cfg` already exists (uses default C++ CAs). Improve it.\n\n---\n\n## Wesnoth CA configuration (key rules from docs)\n\n- Config file must have `id=` field, else wesnoth skips it with \"skipped AI config due to missing id\".\n- CAs must be inside `[stage]` with `name=ai_default_rca::candidate_action_evaluation_loop`.\n- For a Lua CA, use `engine=lua` + `location=\"~add-ons/my_ai/my_recruit.lua\"`. The Lua file must `return` a table whose `:evaluation()` and `:execution()` methods drive the CA.\n- Do NOT mix `location` with inline `evaluation=`/`execution=`.\n- `--ai-config` does not accept absolute paths; only wesnoth-relative or `~add-ons/...`.\n- Do NOT use `[kill]`, `[event]`, or `[command]` WML tags in your .cfg file — these are scene design tools, not AI decision mechanisms.\n\n### Example Lua CA (place in `my_recruit.lua`)\n```lua\nlocal my_recruit = {}\nfunction my_recruit:evaluation()\n local side = wesnoth.current.side\n local leader = wesnoth.units.find_on_map({ side = side, canrecruit = true })[1]\n if not leader or wesnoth.sides[side].gold < 14 then return 0 end\n return 300000\nend\nfunction my_recruit:execution()\n local side = wesnoth.current.side\n local recruit_types = wesnoth.sides[side].recruit\n if recruit_types and #recruit_types > 0 then\n wesnoth.interface.add_chat_message('my_ai', 'Recruiting ' .. recruit_types[1])\n end\nend\nreturn my_recruit\n```\n\n---\n\n## Local Testing\n\nRun a quick game locally to verify your AI loads:\n```bash\nwesnoth --nogui --multiplayer --nosound \\\n --controller 1:ai --controller 2:ai \\\n --ai-config 1:~add-ons/my_ai/my_custom_ai.cfg \\\n --scenario multiplayer_Weldyn_Channel \\\n --log-debug=ai/testing\n```\n\n---\n\n## Rules\n- Write your AI as `my_custom_ai.cfg` and optional `*.lua` files in `/home/wesnoth_agent/`\n- Do NOT modify files outside `/home/wesnoth_agent/`\n- Do NOT delete `.config/` or `.cache/` directories — the evaluation system handles add-ons installation automatically\n- Your AI plays as side 1\n- Run your AI locally to verify it loads before finishing\n- Submit for evaluation\n\n## Strategy Hints\n- The default AI is decent at combat but poor at strategic recruit selection and village capture timing.\n- Lua CAs give you full control over move ordering, targeting, and recruitment.\n- Focus on: (1) efficient recruitment, (2) village capture, (3) focus-fire kills, (4) leader safety.\n- Read `my_custom_ai.cfg` for the baseline structure.\n"
+ },
+ "judge": {
+ "image_tag": "2856cf56b832",
+ "eval_cmd": "python3 /tmp/eval_wesnoth.py",
+ "eval_timeout": 900,
+ "parser": "score_sum",
+ "score_direction": "maximize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "linear",
+ "lower": 0.0,
+ "upper": 100.0
+ }
+ }
+}
diff --git a/wireless_electricity_layout.json b/wireless_electricity_layout.json
new file mode 100644
index 0000000000000000000000000000000000000000..e7c3d84d658ad35726d8aa34f88225bc215c9f02
--- /dev/null
+++ b/wireless_electricity_layout.json
@@ -0,0 +1,32 @@
+{
+ "task_id": "wireless_electricity_layout",
+ "name": "Wireless Electricity Layout",
+ "category": "Combinatorial Optimization",
+ "base_image": "cpp",
+ "platform": "linux/amd64",
+ "internet": false,
+ "cwd": "/home/workspace/wirel",
+ "submit_paths": [
+ "solution.cpp"
+ ],
+ "work": {
+ "image_tag": "c3179795f69f",
+ "specs_dir": "/home/workspace/wirel",
+ "agent_query": "## Wireless Electricity - Wire Placement Optimization (CodeChef WIREL)\n\nWrite `solution.cpp` in the project root. It must read from stdin and write to stdout.\n\n---\n\n## Problem Overview\n\nChefland lies on a 2D plane with N=10,000 cities and M=2,500 wire segments.\n\n**Poles:**\n- Positive plate: (-1,0) to (0,-1)\n- Negative plate: (1000001,1000000) to (1000000,1000001)\n\nA wire is 'positive' if it intersects the positive plate or another positive wire (transitively). Similarly for 'negative'. No wire may be both.\n\n**Costs:**\n- For each city i: transmission cost = Si^2 + Ti^2, where Si=min dist to any positive wire endpoint, Ti=min dist to any negative wire endpoint\n- For each wire i: movement cost = hi^2 + vi^2, where (hi,vi) is your chosen translation\n- Total score = sum(transmission costs) + sum(movement costs). **Minimize.**\n\n**Constraints:**\n- N=10000, M=2500\n- City coords: random in [0, 1000000]\n- Wire lengths: L in {8000,10000,12000,14000,16000}\n- |hi|, |vi| <= 1000000\n- Must have >= 1 positive and >= 1 negative wire, no short circuits\n\n---\n\n## Input Format\n\n```\nN M\nX_1 Y_1\n... (N city lines)\nA_1 B_1 C_1 D_1\n... (M wire lines, endpoints (A,B)-(C,D))\n```\n\n## Output Format\n\nM lines, each: `h_i v_i` (integer translation for wire i)\n\n---\n\n## Evaluation\n\nYour solution is scored on **50 fixed hidden test cases**. Final score = sum of (P+Q) across all hidden cases. **Lower is better.**\n\nLocal generated cases are for validation only and are not the judge cases. Do not assume any local seed range corresponds to the judge cases.\n\n---\n\n## Local Testing\n\n```bash\n# Generate a random test case\n./tools/bin/gen > input.txt\n\n# Compile your solution\ng++ -std=c++17 -O2 -o solution solution.cpp\n\n# Run your solution\n./solution < input.txt > output.txt\n\n# Score output (lower is better)\n./tools/bin/tester input.txt output.txt\n# Outputs to stderr: Score = \n```\n\nA valid baseline `solution.cpp` already exists. Improve it.\n\n---\n\n## Strategy Hints\n\n- Use the provided baseline as a validity sanity check before optimizing.\n- Reduce transmission cost by moving wires near city clusters.\n- Carefully choose which wires become positive/negative vs neutral.\n- Read `README.md` and `tools/README.md` for full problem details.\n- Iterate: test locally with `gen` + `tester`, then submit.\n\n## Rules\n\n- Write your solution as `solution.cpp` in the project root directory\n- Do NOT modify files in `tools/`\n- Use `tools/bin/gen` and `tools/bin/tester` for local testing\n- Your program should read from stdin and write to stdout\n- Run your solution to completion and verify with the tester before finishing"
+ },
+ "judge": {
+ "image_tag": "1b918c76e808",
+ "eval_cmd": "cd /home/workspace/wirel && bash /tmp/eval_wirel.sh",
+ "eval_timeout": 600,
+ "parser": "score_sum",
+ "score_direction": "minimize",
+ "selection": "score_first",
+ "rescale": {
+ "kind": "piecewise_log_min",
+ "baseline": 2.6059066264593484e+16,
+ "rank30": 2444746514528109.0,
+ "rank1": 362439546835871.0,
+ "super_anchor": 181219773417935.5
+ }
+ }
+}
+ 
+ 
+
+