Datasets:

jmarceno
/

elixir-preference

@@ -1,60 +1,3 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text

+# Keep bytes exactly as built so metadata/sha256sums.txt stays valid.
+*.jsonl -text
+*.json -text

LICENSE ADDED Viewed

	@@ -0,0 +1,201 @@

+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+   1. Definitions.
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+   END OF TERMS AND CONDITIONS
+   APPENDIX: How to apply the Apache License to your work.
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+   Copyright [yyyy] [name of copyright owner]
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+       http://www.apache.org/licenses/LICENSE-2.0
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md ADDED Viewed

	@@ -0,0 +1,250 @@

+---
+pretty_name: Elixir preference optimization — DPO and KTO sets
+license: apache-2.0
+language:
+  - en
+tags:
+  - elixir
+  - code
+  - code-generation
+  - preference-optimization
+  - dpo
+  - kto
+  - rlhf
+  - otp
+task_categories:
+  - text-generation
+size_categories:
+  - n<1K
+configs:
+  - config_name: dpo-failv0
+    data_files: data/dpo/dpo_failv0.jsonl
+    default: true
+  - config_name: kto-v0
+    data_files: data/kto/kto_v0.jsonl
+  - config_name: onpolicy-micro-dpo-v1
+    data_files: data/onpolicy/qwen25c3b_micro_dpo_v1.jsonl
+  - config_name: onpolicy-round02-dpo
+    data_files: data/onpolicy/qwen25c3b_micro_round2_dpo.jsonl
+  - config_name: onpolicy-round04-dpo
+    data_files: data/onpolicy/qwen25c3b_micro_round4_dpo.jsonl
+  - config_name: onpolicy-round13-dpo
+    data_files: data/onpolicy/qwen25c3b_micro_round13_dpo.jsonl
+  - config_name: onpolicy-round03-kto
+    data_files: data/onpolicy/qwen25c3b_micro_round3_kto.jsonl
+  - config_name: onpolicy-round06-kto
+    data_files: data/onpolicy/qwen25c3b_micro_round6_kto.jsonl
+  - config_name: onpolicy-round11-kto
+    data_files: data/onpolicy/qwen25c3b_micro_round11_kto.jsonl
+---
+# Elixir preference optimization — DPO and KTO sets
+**909 preference rows in 9 configs** for Elixir code models: 654 DPO pairs, 76 balanced
+KTO examples, and 179 rows from the on-policy Qwen2.5-Coder-3B refinement rounds. Every
+chosen completion was executed and passed the project's isolated Elixir scorer (compile +
+ExUnit + static contract checks); every rejected completion was confirmed to fail the
+intended gate. The frozen evaluation packs are held out: measured prompt-level and
+module-level collisions are **zero** for every config.
+> **Do not execute the rejected completions.** They are deliberately broken, and some
+> contain intentional defects (swallowed errors, wrong endianness, unsafe state handling).
+> Treat every `rejected` field as hostile input.
+## What "preference" means here
+These pairs are not style opinions. They encode **executable correctness and static
+contracts** for Elixir:
+- `preference_kind: correctness` — the chosen module compiles and passes its tests; the
+  rejected one fails to compile, fails a test, or drops a required contract.
+- `preference_kind: functional-style` — both sides may behave correctly, but the rejected
+  side uses process state, side effects or a non-idiomatic construct where the task
+  explicitly asked for pure functional code. The rejection is a violated static gate, not
+  a matter of taste.
+The failure modes were mined from real model output, then re-targeted onto original tasks
+with new module names and specifications, so no benchmark task is copied into the data.
+## Configs
+| config | rows | format | what it is |
+| --- | ---: | --- | --- |
+| `dpo-failv0` | 654 | DPO pairs | Mined from evaluation failures of `gemma12b-elixir-cpt-q4` (40/128) and `qwen35-9b-elixir-cpt-sft-q5` (46/128). 534 correctness pairs + 120 functional-style pairs. |
+| `kto-v0` | 76 | KTO | Balanced 38 accepted / 38 rejected. Each original task contributes exactly one accepted and one rejected completion; 40 functional-style + 36 correctness rows. |
+| `onpolicy-micro-dpo-v1` | 36 | DPO pairs | First on-policy DPO round for the Qwen2.5-Coder-3B depth-expanded checkpoint. |
+| `onpolicy-round02-dpo` | 25 | DPO pairs | Round 2: up to three fresh, scorer-gated prompts per construction weakness; format-only pairs excluded. |
+| `onpolicy-round04-dpo` | 11 | DPO pairs | Round 4. |
+| `onpolicy-round13-dpo` | 17 | DPO pairs | Round 13. |
+| `onpolicy-round03-kto` | 34 | KTO | Round 3 KTO: OTP and bit-syntax focus. |
+| `onpolicy-round06-kto` | 22 | KTO | Round 6 KTO: functional-style focus (12 functional rows). |
+| `onpolicy-round11-kto` | 34 | KTO | Round 11 KTO: four rows per family. |
+DPO family coverage (`dpo-failv0`): otp 134, functional 120, binaries 119, beam 66,
+stdlib 49, errors 47, abstractions 41, core 41, collections 37. The weakness taxonomy is
+distilled from the failing completions — the largest buckets are `format-hygiene` (114),
+`enum-state` (99), `err-swallow` (42), `edge-empty` (42), `functional-style-process-state`
+(40), `functional-style-agent-state` (40), `bin-size-guard` (33) and `bin-endian` (24);
+the complete per-weakness counts are in `metadata/dataset_stats.json`.
+KTO family coverage: functional 40, otp 12, binaries 10, protocol 4, stdlib 4, errors 2,
+core 2, format 2.
+The `onpolicy-*` configs are **checkpoint-specific** artifacts of one model's targeted
+rounds; each round's build manifest (base checkpoint, selection rules, counts, validation)
+is in `metadata/manifests/`. If you want a single general preference set, use
+`dpo-failv0` (or `kto-v0` for the balanced KTO formulation).
+## Row schemas
+DPO (`dpo-failv0` and the on-policy DPO configs) — ShareGPT prompt plus two string
+completions:
+```json
+{
+  "id": "dpo.binaries.s16be.bin-endian",
+  "family": "binaries",
+  "source": "elixir_dpo_failv0",
+  "weakness": "bin-endian",
+  "origin": "designed",
+  "preference_kind": "correctness",
+  "models": ["gemma12b-elixir-cpt-q4", "qwen35-9b-elixir-cpt-sft-q5"],
+  "conversations": [
+    {"from": "system", "value": "You are a friendly coding assistant ..."},
+    {"from": "human", "value": "Write a module `S16BE` with: ..."}
+  ],
+  "chosen": "```elixir\ndefmodule S16BE do ... end\n```",
+  "rejected": "```elixir\ndefmodule S16BE do ... end\n```"
+}
+```
+KTO (`kto-v0` and the on-policy KTO configs) — TRL conversational schema with a boolean
+label:
+```json
+{
+  "id": "kto.functional.map-pipeline.chosen",
+  "family": "functional",
+  "label": true,
+  "preference_kind": "functional-style",
+  "weakness": "functional-pipeline",
+  "prompt": [
+    {"role": "system", "content": "You are a friendly coding assistant ..."},
+    {"role": "user", "content": "Write a module `KtoFnMapPipeline` with: ..."}
+  ],
+  "completion": [{"role": "assistant", "content": "```elixir ... ```"}]
+}
+```
+In DPO files, `models` records which checkpoints' failures motivated the pair and
+`origin` distinguishes `designed`, `handmade` and `functional-style` rows. The on-policy
+files carry the same fields plus the round-specific annotations.
+## Loading
+```python
+from datasets import load_dataset
+dpo = load_dataset("jmarceno/elixir-preference", "dpo-failv0", split="train")
+kto = load_dataset("jmarceno/elixir-preference", "kto-v0", split="train")
+print(dpo[0]["chosen"][:200])
+print(kto[0]["label"], kto[0]["prompt"])
+```
+Raw JSONL:
+```python
+from huggingface_hub import hf_hub_download
+path = hf_hub_download(
+    "jmarceno/elixir-preference", "data/dpo/dpo_failv0.jsonl", repo_type="dataset"
+)
+```
+Shaping the DPO file for TRL `DPOTrainer`:
+```python
+from datasets import load_dataset
+ROLE = {"system": "system", "human": "user", "gpt": "assistant"}
+def to_dpo(row):
+    return {
+        "prompt": [
+            {"role": ROLE[turn["from"]], "content": turn["value"]}
+            for turn in row["conversations"]
+        ],
+        "chosen": [{"role": "assistant", "content": row["chosen"]}],
+        "rejected": [{"role": "assistant", "content": row["rejected"]}],
+    }
+ds = load_dataset("jmarceno/elixir-preference", "dpo-failv0", split="train")
+ds = ds.map(to_dpo, remove_columns=ds.column_names)
+```
+The KTO configs already match the TRL `KTOTrainer` columns (`prompt`, `completion`,
+`label`) and need no conversion.
+## Quality gates
+- Every `chosen` completion was executed through the real scorer: compile, generated ExUnit
+  tests, and static contract checks. A row only ships when the chosen side has zero test
+  failures and a clean static result; compile warnings are counted and reported.
+- Every `rejected` completion fails the declared gate for a reason recorded in `weakness`.
+  For functional-style pairs, the rejected side is behaviourally correct and fails only the
+  declared style gate — that is the teaching signal.
+- Ids are unique per file, and prompts are unique per file.
+- Zero exact prompt collisions and zero module-name collisions against both frozen
+  evaluation packs.
+- `metadata/sha256sums.txt` lets you confirm the bytes you downloaded are the bytes that
+  passed those gates.
+## Intended use and limitations
+- **Intended:** DPO or KTO preference tuning of Elixir code models that already produce
+  working code, especially for OTP timeouts, error handling, edge cases, bit syntax and
+  functional style.
+- **Not intended:** as a standalone fine-tuning dataset (use an SFT set first), for
+  instruction-following evaluation, for multi-turn agent data, or for any non-Elixir
+  language.
+- 909 rows is small by design. These sets target specific failure families observed in this
+  project's models; they are not a general Elixir preference corpus and will not teach
+  unrelated skills.
+- Rejected completions are broken on purpose; never execute them in an unsandboxed process.
+- Do not treat the size of a configuration as its importance: the on-policy rounds exist to
+  document a training loop, not to be pooled blindly into a new run.
+## Provenance and licensing
+Rows were authored for this project and mined from this project's own model evaluations on
+original tasks. No benchmark task and no upstream repository code is redistributed here.
+The CPT corpora (which do contain upstream Elixir/Erlang sources) are published separately.
+Released under **Apache-2.0**. "Elixir" and "Erlang" are trademarks of their respective
+owners; this dataset is not affiliated with or endorsed by the Elixir or Erlang teams.
+## Repository layout
+```
+data/dpo/dpo_failv0.jsonl                        dpo-failv0
+data/kto/kto_v0.jsonl                            kto-v0
+data/onpolicy/qwen25c3b_micro_*_dpo.jsonl        onpolicy-*-dpo configs
+data/onpolicy/qwen25c3b_micro_*_kto.jsonl        onpolicy-*-kto configs
+metadata/dataset_stats.json                      per-file rows, hashes, families, pack overlap
+metadata/sha256sums.txt                          data-file checksums
+metadata/provenance.json                         source commit, exclusions, build note
+metadata/manifests/*.json                        per-round build manifests
+```
+## Citation
+```bibtex
+@dataset{jmarceno_elixir_preference_2026,
+  author    = {jmarceno},
+  title     = {Elixir preference optimization — DPO and KTO sets},
+  year      = {2026},
+  publisher = {Hugging Face},
+  url       = {https://huggingface.co/datasets/jmarceno/elixir-preference},
+  note      = {Apache-2.0}
+}
+```

data/dpo/dpo_failv0.jsonl ADDED Viewed

The diff for this file is too large to render. See raw diff

data/kto/kto_v0.jsonl ADDED Viewed

	@@ -0,0 +1,76 @@

+{"id": "kto.functional.map-pipeline.chosen", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-pipeline", "preference_kind": "functional-style", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnMapPipeline` with:\n\nDefine `normalize/1` for a list of names. Trim whitespace, discard\nempty names, and lowercase the remaining names. Prefer a pipeline\nof pure `Enum` transformations and immutable values; do not use\nprocess state or a side-effecting iteration function.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnMapPipeline do\n  @spec normalize([String.t()]) :: [String.t()]\n  def normalize(names) when is_list(names) do\n    names\n    |> Enum.map(&String.trim/1)\n    |> Enum.reject(&(&1 == \"\"))\n    |> Enum.map(&String.downcase/1)\n  end\nend\n```"}]}
+{"id": "kto.functional.map-pipeline.rejected", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-pipeline", "preference_kind": "functional-style", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnMapPipeline` with:\n\nDefine `normalize/1` for a list of names. Trim whitespace, discard\nempty names, and lowercase the remaining names. Prefer a pipeline\nof pure `Enum` transformations and immutable values; do not use\nprocess state or a side-effecting iteration function.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnMapPipeline do\n  @spec normalize([String.t()]) :: [String.t()]\n  def normalize(names) when is_list(names) do\n    key = {__MODULE__, make_ref()}\n    Process.put(key, [])\n\n    Enum.each(names, fn name ->\n      trimmed = String.trim(name)\n\n      if trimmed != \"\" do\n        Process.put(key, [String.downcase(trimmed) | Process.get(key, [])])\n      end\n    end)\n\n    result = key |> Process.get([]) |> Enum.reverse()\n    Process.delete(key)\n    result\n  end\nend\n```"}]}
+{"id": "kto.functional.frequency-reduce.chosen", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-reduce", "preference_kind": "functional-style", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnFrequency` with:\n\nDefine `count/1` to return a map of item frequencies. Thread the\naccumulator explicitly through `Enum.reduce/3`; keep the function\npure and do not use the process dictionary, an Agent, or ETS.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnFrequency do\n  @spec count([term()]) :: %{optional(term()) => non_neg_integer()}\n  def count(items) when is_list(items) do\n    Enum.reduce(items, %{}, fn item, counts ->\n      Map.update(counts, item, 1, &(&1 + 1))\n    end)\n  end\nend\n```"}]}
+{"id": "kto.functional.frequency-reduce.rejected", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-reduce", "preference_kind": "functional-style", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnFrequency` with:\n\nDefine `count/1` to return a map of item frequencies. Thread the\naccumulator explicitly through `Enum.reduce/3`; keep the function\npure and do not use the process dictionary, an Agent, or ETS.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnFrequency do\n  @spec count([term()]) :: map()\n  def count(items) when is_list(items) do\n    key = {__MODULE__, make_ref()}\n    Process.put(key, %{})\n\n    Enum.each(items, fn item ->\n      Process.put(key, Map.update(Process.get(key), item, 1, &(&1 + 1)))\n    end)\n\n    result = Process.get(key)\n    Process.delete(key)\n    result\n  end\nend\n```"}]}
+{"id": "kto.functional.map-reduce.chosen", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-state-threading", "preference_kind": "functional-style", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnMapReduce` with:\n\nDefine `scale/2` to return `{scaled_values, total}`. Use\n`Enum.map_reduce/3` so the transformed collection and accumulated\nstate are returned together, without an externally mutated total.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnMapReduce do\n  @spec scale([number()], number()) :: {[number()], number()}\n  def scale(values, factor) when is_list(values) do\n    Enum.map_reduce(values, 0, fn value, total ->\n      scaled = value * factor\n      {scaled, total + scaled}\n    end)\n  end\nend\n```"}]}
+{"id": "kto.functional.map-reduce.rejected", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-state-threading", "preference_kind": "functional-style", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnMapReduce` with:\n\nDefine `scale/2` to return `{scaled_values, total}`. Use\n`Enum.map_reduce/3` so the transformed collection and accumulated\nstate are returned together, without an externally mutated total.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnMapReduce do\n  @spec scale([number()], number()) :: {[number()], number()}\n  def scale(values, factor) when is_list(values) do\n    scaled = Enum.map(values, &(&1 * factor))\n    {scaled, Enum.sum(scaled)}\n  end\nend\n```"}]}
+{"id": "kto.functional.reduce-while.chosen", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-early-halt", "preference_kind": "functional-style", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnFirstError` with:\n\nDefine `first_invalid/1`. Return `:ok` when all integers are\nnon-negative, otherwise return `{:error, value}` for the first\nnegative value. Use `Enum.reduce_while/3` to halt as soon as the\nfirst invalid value is found.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnFirstError do\n  @spec first_invalid([integer()]) :: :ok | {:error, integer()}\n  def first_invalid(values) when is_list(values) do\n    Enum.reduce_while(values, :ok, fn value, :ok ->\n      if value >= 0 do\n        {:cont, :ok}\n      else\n        {:halt, {:error, value}}\n      end\n    end)\n  end\nend\n```"}]}
+{"id": "kto.functional.reduce-while.rejected", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-early-halt", "preference_kind": "functional-style", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnFirstError` with:\n\nDefine `first_invalid/1`. Return `:ok` when all integers are\nnon-negative, otherwise return `{:error, value}` for the first\nnegative value. Use `Enum.reduce_while/3` to halt as soon as the\nfirst invalid value is found.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnFirstError do\n  @spec first_invalid([integer()]) :: :ok | {:error, integer()}\n  def first_invalid(values) when is_list(values) do\n    Enum.reduce(values, :ok, fn value, result ->\n      case result do\n        :ok -> if value >= 0, do: :ok, else: {:error, value}\n        {:error, _value} = error -> error\n      end\n    end)\n  end\nend\n```"}]}
+{"id": "kto.functional.stable-unique.chosen", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-immutable-accumulator", "preference_kind": "functional-style", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnStableUnique` with:\n\nDefine `run/1` to remove duplicates while preserving the first\noccurrence order. Use an immutable `{seen, output}` accumulator and\nreturn the reversed output at the end.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnStableUnique do\n  @spec run([term()]) :: [term()]\n  def run(items) when is_list(items) do\n    {_seen, output} =\n      Enum.reduce(items, {MapSet.new(), []}, fn item, {seen, output} ->\n        if MapSet.member?(seen, item) do\n          {seen, output}\n        else\n          {MapSet.put(seen, item), [item | output]}\n        end\n      end)\n\n    Enum.reverse(output)\n  end\nend\n```"}]}
+{"id": "kto.functional.stable-unique.rejected", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-immutable-accumulator", "preference_kind": "functional-style", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnStableUnique` with:\n\nDefine `run/1` to remove duplicates while preserving the first\noccurrence order. Use an immutable `{seen, output}` accumulator and\nreturn the reversed output at the end.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnStableUnique do\n  @spec run([term()]) :: [term()]\n  def run(items) when is_list(items) do\n    {_seen, output} =\n      Enum.reduce(items, {MapSet.new(), []}, fn item, {seen, output} ->\n        if MapSet.member?(seen, item) do\n          {seen, output}\n        else\n          {MapSet.put(seen, item), output ++ [item]}\n        end\n      end)\n\n    output\n  end\nend\n```"}]}
+{"id": "kto.functional.with-parse.chosen", "family": "functional", "source": "elixir_kto_v0", "weakness": "err-with-else", "preference_kind": "functional-style", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnParsePair` with:\n\nDefine `sum/2` for two decimal strings. Return `{:ok, sum}` only\nwhen both strings contain an integer with no trailing characters;\notherwise return `{:error, :invalid}`. Use `with` with an explicit\nfallback instead of rescuing all exceptions into success.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnParsePair do\n  @spec sum(String.t(), String.t()) :: {:ok, integer()} | {:error, :invalid}\n  def sum(left, right) when is_binary(left) and is_binary(right) do\n    with {left_number, \"\"} <- Integer.parse(left),\n         {right_number, \"\"} <- Integer.parse(right) do\n      {:ok, left_number + right_number}\n    else\n      _ -> {:error, :invalid}\n    end\n  end\nend\n```"}]}
+{"id": "kto.functional.with-parse.rejected", "family": "functional", "source": "elixir_kto_v0", "weakness": "err-with-else", "preference_kind": "functional-style", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnParsePair` with:\n\nDefine `sum/2` for two decimal strings. Return `{:ok, sum}` only\nwhen both strings contain an integer with no trailing characters;\notherwise return `{:error, :invalid}`. Use `with` with an explicit\nfallback instead of rescuing all exceptions into success.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnParsePair do\n  @spec sum(String.t(), String.t()) :: {:ok, integer()} | {:error, :invalid}\n  def sum(left, right) when is_binary(left) and is_binary(right) do\n    try do\n      {:ok, String.to_integer(left) + String.to_integer(right)}\n    rescue\n      ArgumentError -> {:error, :invalid}\n    end\n  end\nend\n```"}]}
+{"id": "kto.functional.keyword-fetch.chosen", "family": "functional", "source": "elixir_kto_v0", "weakness": "edge-absent-key", "preference_kind": "functional-style", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnKeywordMode` with:\n\nDefine `mode/1` for keyword options. Return `{:ok, value}` when\n`:mode` is present, and `{:error, :missing}` when it is absent.\nPreserve the distinction between a missing key and a key whose\nvalue is `nil` by using `Keyword.fetch/2`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnKeywordMode do\n  @spec mode(keyword()) :: {:ok, term()} | {:error, :missing}\n  def mode(options) when is_list(options) do\n    case Keyword.fetch(options, :mode) do\n      {:ok, value} -> {:ok, value}\n      :error -> {:error, :missing}\n    end\n  end\nend\n```"}]}
+{"id": "kto.functional.keyword-fetch.rejected", "family": "functional", "source": "elixir_kto_v0", "weakness": "edge-absent-key", "preference_kind": "functional-style", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnKeywordMode` with:\n\nDefine `mode/1` for keyword options. Return `{:ok, value}` when\n`:mode` is present, and `{:error, :missing}` when it is absent.\nPreserve the distinction between a missing key and a key whose\nvalue is `nil` by using `Keyword.fetch/2`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnKeywordMode do\n  @spec mode(keyword()) :: {:ok, term()} | {:error, :missing}\n  def mode(options) when is_list(options) do\n    if Keyword.has_key?(options, :mode) do\n      {:ok, Keyword.get(options, :mode)}\n    else\n      {:error, :missing}\n    end\n  end\nend\n```"}]}
+{"id": "kto.functional.nested-update.chosen", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-nested-update", "preference_kind": "functional-style", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnNestedUpdate` with:\n\nDefine `add_score/2` for a profile containing\n`%{stats: %{score: integer}}`. Add the delta to the nested score,\npreserving every other key through an immutable nested update.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnNestedUpdate do\n  @spec add_score(map(), integer()) :: map()\n  def add_score(profile, delta) when is_map(profile) and is_integer(delta) do\n    update_in(profile, [:stats, :score], &(&1 + delta))\n  end\nend\n```"}]}
+{"id": "kto.functional.nested-update.rejected", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-nested-update", "preference_kind": "functional-style", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnNestedUpdate` with:\n\nDefine `add_score/2` for a profile containing\n`%{stats: %{score: integer}}`. Add the delta to the nested score,\npreserving every other key through an immutable nested update.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnNestedUpdate do\n  @spec add_score(map(), integer()) :: map()\n  def add_score(profile, delta) when is_map(profile) and is_integer(delta) do\n    stats = Map.fetch!(profile, :stats)\n    score = Map.fetch!(stats, :score)\n    Map.put(profile, :stats, Map.put(stats, :score, score + delta))\n  end\nend\n```"}]}
+{"id": "kto.functional.pattern-clauses.chosen", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-pattern-clauses", "preference_kind": "functional-style", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnPatternClauses` with:\n\nDefine `kind/1` so `{:ok, value}` returns `{:value, value}`,\n`{:error, reason}` returns `{:failure, reason}`, and every other\nterm returns `:unknown`. Express the shapes as function clauses.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnPatternClauses do\n  @spec kind(term()) :: {:value, term()} | {:failure, term()} | :unknown\n  def kind({:ok, value}), do: {:value, value}\n  def kind({:error, reason}), do: {:failure, reason}\n  def kind(_other), do: :unknown\nend\n```"}]}
+{"id": "kto.functional.pattern-clauses.rejected", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-pattern-clauses", "preference_kind": "functional-style", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnPatternClauses` with:\n\nDefine `kind/1` so `{:ok, value}` returns `{:value, value}`,\n`{:error, reason}` returns `{:failure, reason}`, and every other\nterm returns `:unknown`. Express the shapes as function clauses.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnPatternClauses do\n  @spec kind(term()) :: {:value, term()} | {:failure, term()} | :unknown\n  def kind(value) do\n    case value do\n      {:ok, inner} -> {:value, inner}\n      {:error, reason} -> {:failure, reason}\n      _other -> :unknown\n    end\n  end\nend\n```"}]}
+{"id": "kto.functional.pure-transition.chosen", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-pure-transition", "preference_kind": "functional-style", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnPureTransition` with:\n\nDefine `step/2` for `%{count: integer}`. `:increment` returns a\nstate with count increased by one and `:reset` returns count zero.\nKeep it as a pure transition with event-pattern clauses.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnPureTransition do\n  @spec step(map(), :increment | :reset) :: map()\n  def step(state, :increment), do: %{state | count: state.count + 1}\n  def step(state, :reset), do: %{state | count: 0}\nend\n```"}]}
+{"id": "kto.functional.pure-transition.rejected", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-pure-transition", "preference_kind": "functional-style", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnPureTransition` with:\n\nDefine `step/2` for `%{count: integer}`. `:increment` returns a\nstate with count increased by one and `:reset` returns count zero.\nKeep it as a pure transition with event-pattern clauses.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnPureTransition do\n  @spec step(map(), :increment | :reset) :: map()\n  def step(state, event) do\n    {:ok, holder} = Agent.start_link(fn -> state end)\n\n    Agent.update(holder, fn current ->\n      case event do\n        :increment -> %{current | count: current.count + 1}\n        :reset -> %{current | count: 0}\n      end\n    end)\n\n    result = Agent.get(holder, & &1)\n    Agent.stop(holder)\n    result\n  end\nend\n```"}]}
+{"id": "kto.functional.linear-recursion.chosen", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-linear-recursion", "preference_kind": "functional-style", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnLinearRecursion` with:\n\nDefine `double/1` recursively for a list of integers. Build the\nresult by prepending to an accumulator and reverse once; avoid\nrepeated list concatenation.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnLinearRecursion do\n  @spec double([integer()]) :: [integer()]\n  def double(values) when is_list(values), do: loop(values, [])\n\n  defp loop([], reversed), do: Enum.reverse(reversed)\n  defp loop([head | tail], reversed), do: loop(tail, [head * 2 | reversed])\nend\n```"}]}
+{"id": "kto.functional.linear-recursion.rejected", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-linear-recursion", "preference_kind": "functional-style", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnLinearRecursion` with:\n\nDefine `double/1` recursively for a list of integers. Build the\nresult by prepending to an accumulator and reverse once; avoid\nrepeated list concatenation.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnLinearRecursion do\n  @spec double([integer()]) :: [integer()]\n  def double([]), do: []\n  def double([head | tail]), do: [head * 2] ++ double(tail)\nend\n```"}]}
+{"id": "kto.functional.comprehension.chosen", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-comprehension", "preference_kind": "functional-style", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnComprehension` with:\n\nDefine `pairs/2` to return `{left, right}` for every combination\nwhose integer sum is even. Preserve input iteration order and use\na comprehension with a filter.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnComprehension do\n  @spec pairs([integer()], [integer()]) :: [{integer(), integer()}]\n  def pairs(left, right) when is_list(left) and is_list(right) do\n    for l <- left, r <- right, rem(l + r, 2) == 0, do: {l, r}\n  end\nend\n```"}]}
+{"id": "kto.functional.comprehension.rejected", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-comprehension", "preference_kind": "functional-style", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnComprehension` with:\n\nDefine `pairs/2` to return `{left, right}` for every combination\nwhose integer sum is even. Preserve input iteration order and use\na comprehension with a filter.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnComprehension do\n  @spec pairs([integer()], [integer()]) :: [{integer(), integer()}]\n  def pairs(left, right) when is_list(left) and is_list(right) do\n    Enum.reduce(left, [], fn l, output ->\n      Enum.reduce(right, output, fn r, inner ->\n        if rem(l + r, 2) == 0, do: inner ++ [{l, r}], else: inner\n      end)\n    end)\n  end\nend\n```"}]}
+{"id": "kto.functional.lazy-stream.chosen", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-lazy-stream", "preference_kind": "functional-style", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnLazyStream` with:\n\nDefine `first_even/2` to lazily filter an enumerable for even\nintegers and return at most the requested number of values.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnLazyStream do\n  @spec first_even([integer()] | Range.t(), non_neg_integer()) :: [integer()]\n  def first_even(values, count) do\n    values\n    |> Stream.filter(&(rem(&1, 2) == 0))\n    |> Enum.take(count)\n  end\nend\n```"}]}
+{"id": "kto.functional.lazy-stream.rejected", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-lazy-stream", "preference_kind": "functional-style", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnLazyStream` with:\n\nDefine `first_even/2` to lazily filter an enumerable for even\nintegers and return at most the requested number of values.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnLazyStream do\n  @spec first_even([integer()] | Range.t(), non_neg_integer()) :: [integer()]\n  def first_even(values, count) do\n    values\n    |> Enum.filter(&(rem(&1, 2) == 0))\n    |> Enum.take(count)\n  end\nend\n```"}]}
+{"id": "kto.functional.partition-one-pass.chosen", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-single-pass", "preference_kind": "functional-style", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnPartition` with:\n\nDefine `split/1` to return `{non_negative, negative}` lists while\npreserving order. Thread both outputs through one reduction and\nreverse each accumulator once.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnPartition do\n  @spec split([integer()]) :: {[integer()], [integer()]}\n  def split(values) when is_list(values) do\n    {positive, negative} =\n      Enum.reduce(values, {[], []}, fn value, {positive, negative} ->\n        if value >= 0,\n          do: {[value | positive], negative},\n          else: {positive, [value | negative]}\n      end)\n\n    {Enum.reverse(positive), Enum.reverse(negative)}\n  end\nend\n```"}]}
+{"id": "kto.functional.partition-one-pass.rejected", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-single-pass", "preference_kind": "functional-style", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnPartition` with:\n\nDefine `split/1` to return `{non_negative, negative}` lists while\npreserving order. Thread both outputs through one reduction and\nreverse each accumulator once.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnPartition do\n  @spec split([integer()]) :: {[integer()], [integer()]}\n  def split(values) when is_list(values) do\n    {Enum.filter(values, &(&1 >= 0)), Enum.filter(values, &(&1 < 0))}\n  end\nend\n```"}]}
+{"id": "kto.functional.tagged-fetch.chosen", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-tagged-flow", "preference_kind": "functional-style", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnTaggedFetch` with:\n\nDefine `full_name/1` for a map. Return `{:ok, name}` when both\n`:first` and `:last` exist and `{:error, :missing}` otherwise.\nCompose the tagged fetch results with `with`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnTaggedFetch do\n  @spec full_name(map()) :: {:ok, String.t()} | {:error, :missing}\n  def full_name(person) when is_map(person) do\n    with {:ok, first} <- Map.fetch(person, :first),\n         {:ok, last} <- Map.fetch(person, :last) do\n      {:ok, first <> \" \" <> last}\n    else\n      :error -> {:error, :missing}\n    end\n  end\nend\n```"}]}
+{"id": "kto.functional.tagged-fetch.rejected", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-tagged-flow", "preference_kind": "functional-style", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnTaggedFetch` with:\n\nDefine `full_name/1` for a map. Return `{:ok, name}` when both\n`:first` and `:last` exist and `{:error, :missing}` otherwise.\nCompose the tagged fetch results with `with`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnTaggedFetch do\n  @spec full_name(map()) :: {:ok, String.t()} | {:error, :missing}\n  def full_name(person) when is_map(person) do\n    if Map.has_key?(person, :first) and Map.has_key?(person, :last) do\n      {:ok, Map.get(person, :first) <> \" \" <> Map.get(person, :last)}\n    else\n      {:error, :missing}\n    end\n  end\nend\n```"}]}
+{"id": "kto.functional.set-difference.chosen", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-set-operation", "preference_kind": "functional-style", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnSetDifference` with:\n\nDefine `run/2` to return the unique values present in the first\nlist but absent from the second. Express the operation with\nimmutable `MapSet` values.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnSetDifference do\n  @spec run([term()], [term()]) :: [term()]\n  def run(left, right) when is_list(left) and is_list(right) do\n    left\n    |> MapSet.new()\n    |> MapSet.difference(MapSet.new(right))\n    |> MapSet.to_list()\n  end\nend\n```"}]}
+{"id": "kto.functional.set-difference.rejected", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-set-operation", "preference_kind": "functional-style", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnSetDifference` with:\n\nDefine `run/2` to return the unique values present in the first\nlist but absent from the second. Express the operation with\nimmutable `MapSet` values.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnSetDifference do\n  @spec run([term()], [term()]) :: [term()]\n  def run(left, right) when is_list(left) and is_list(right) do\n    left\n    |> Enum.reject(&Enum.member?(right, &1))\n    |> Enum.uniq()\n  end\nend\n```"}]}
+{"id": "kto.functional.iodata.chosen", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-iodata", "preference_kind": "functional-style", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnIodata` with:\n\nDefine `join/1` for a list of strings, placing a comma between\nentries. Build iodata and convert it once rather than repeatedly\nconcatenating a growing binary.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnIodata do\n  @spec join([String.t()]) :: String.t()\n  def join(parts) when is_list(parts) do\n    parts\n    |> Enum.intersperse(\",\")\n    |> IO.iodata_to_binary()\n  end\nend\n```"}]}
+{"id": "kto.functional.iodata.rejected", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-iodata", "preference_kind": "functional-style", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnIodata` with:\n\nDefine `join/1` for a list of strings, placing a comma between\nentries. Build iodata and convert it once rather than repeatedly\nconcatenating a growing binary.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnIodata do\n  @spec join([String.t()]) :: String.t()\n  def join(parts) when is_list(parts), do: Enum.join(parts, \",\")\nend\n```"}]}
+{"id": "kto.functional.unfold.chosen", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-unfold", "preference_kind": "functional-style", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnUnfold` with:\n\nDefine `countdown/1` for a non-negative integer, returning values\nfrom the integer down to one. Represent the state progression with\n`Stream.unfold/2` and then realize the result.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnUnfold do\n  @spec countdown(non_neg_integer()) :: [pos_integer()]\n  def countdown(value) when is_integer(value) and value >= 0 do\n    value\n    |> Stream.unfold(fn\n      0 -> nil\n      current -> {current, current - 1}\n    end)\n    |> Enum.to_list()\n  end\nend\n```"}]}
+{"id": "kto.functional.unfold.rejected", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-unfold", "preference_kind": "functional-style", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnUnfold` with:\n\nDefine `countdown/1` for a non-negative integer, returning values\nfrom the integer down to one. Represent the state progression with\n`Stream.unfold/2` and then realize the result.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnUnfold do\n  @spec countdown(non_neg_integer()) :: [pos_integer()]\n  def countdown(value) when is_integer(value) and value >= 0 do\n    if value == 0, do: [], else: Enum.to_list(value..1//-1)\n  end\nend\n```"}]}
+{"id": "kto.functional.zip-with.chosen", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-zip-with", "preference_kind": "functional-style", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnZipWith` with:\n\nDefine `add/2` to add corresponding integers until the shorter\nlist ends. Use `Enum.zip_with/3` so pairing and transformation are\none collection operation.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnZipWith do\n  @spec add([integer()], [integer()]) :: [integer()]\n  def add(left, right), do: Enum.zip_with(left, right, &+/2)\nend\n```"}]}
+{"id": "kto.functional.zip-with.rejected", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-zip-with", "preference_kind": "functional-style", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnZipWith` with:\n\nDefine `add/2` to add corresponding integers until the shorter\nlist ends. Use `Enum.zip_with/3` so pairing and transformation are\none collection operation.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnZipWith do\n  @spec add([integer()], [integer()]) :: [integer()]\n  def add(left, right) do\n    left\n    |> Enum.zip(right)\n    |> Enum.map(fn {l, r} -> l + r end)\n  end\nend\n```"}]}
+{"id": "kto.functional.get-and-update.chosen", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-get-and-update", "preference_kind": "functional-style", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnGetAndUpdate` with:\n\nDefine `take_token/1` for `%{session: %{token: value}}`. Return\n`{old_token, updated_state}` where the nested token becomes `nil`,\npreserving every other key. Use one `get_and_update_in/3` call.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnGetAndUpdate do\n  @spec take_token(map()) :: {term(), map()}\n  def take_token(state) when is_map(state) do\n    get_and_update_in(state, [:session, :token], &{&1, nil})\n  end\nend\n```"}]}
+{"id": "kto.functional.get-and-update.rejected", "family": "functional", "source": "elixir_kto_v0", "weakness": "functional-get-and-update", "preference_kind": "functional-style", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFnGetAndUpdate` with:\n\nDefine `take_token/1` for `%{session: %{token: value}}`. Return\n`{old_token, updated_state}` where the nested token becomes `nil`,\npreserving every other key. Use one `get_and_update_in/3` call.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFnGetAndUpdate do\n  @spec take_token(map()) :: {term(), map()}\n  def take_token(state) when is_map(state) do\n    token = get_in(state, [:session, :token])\n    {token, put_in(state, [:session, :token], nil)}\n  end\nend\n```"}]}
+{"id": "kto.otp.call-explicit-timeout.chosen", "family": "otp", "source": "elixir_kto_v0", "weakness": "otp-timeout", "preference_kind": "correctness", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpCounter` with:\n\nDefine a GenServer with `start_link/1` and `value/1`. Store the\ninitial value and read it through a synchronous `GenServer.call/3`\nwith an explicit module timeout. The callback must preserve state.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpCounter do\n  use GenServer\n\n  @timeout 1_000\n\n  @spec start_link(term()) :: GenServer.on_start()\n  def start_link(initial), do: GenServer.start_link(__MODULE__, initial)\n\n  @spec value(pid()) :: term()\n  def value(pid), do: GenServer.call(pid, :value, @timeout)\n\n  @impl true\n  def init(initial), do: {:ok, initial}\n\n  @impl true\n  def handle_call(:value, _from, state), do: {:reply, state, state}\nend\n```"}]}
+{"id": "kto.otp.call-explicit-timeout.rejected", "family": "otp", "source": "elixir_kto_v0", "weakness": "otp-timeout", "preference_kind": "correctness", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpCounter` with:\n\nDefine a GenServer with `start_link/1` and `value/1`. Store the\ninitial value and read it through a synchronous `GenServer.call/3`\nwith an explicit module timeout. The callback must preserve state.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpCounter do\n  use GenServer\n\n  @spec start_link(term()) :: GenServer.on_start()\n  def start_link(initial), do: GenServer.start_link(__MODULE__, initial)\n\n  @spec value(pid()) :: term()\n  def value(pid), do: GenServer.call(pid, :value)\n\n  @impl true\n  def init(initial), do: {:ok, initial}\n\n  @impl true\n  def handle_call(:value, _from, state), do: {:reply, state, state}\nend\n```"}]}
+{"id": "kto.otp.cast-callback.chosen", "family": "otp", "source": "elixir_kto_v0", "weakness": "otp-cast-call", "preference_kind": "correctness", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpCastState` with:\n\nDefine a GenServer cast callback that handles `{:set, value}` as an\nasynchronous state update and returns `{:noreply, new_state}`.\nKeep the callback contract separate from the synchronous reply\ncontract of `handle_call/3`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpCastState do\n  use GenServer\n\n  @impl true\n  def init(state), do: {:ok, state}\n\n  @impl true\n  def handle_cast({:set, value}, _state), do: {:noreply, value}\nend\n```"}]}
+{"id": "kto.otp.cast-callback.rejected", "family": "otp", "source": "elixir_kto_v0", "weakness": "otp-cast-call", "preference_kind": "correctness", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpCastState` with:\n\nDefine a GenServer cast callback that handles `{:set, value}` as an\nasynchronous state update and returns `{:noreply, new_state}`.\nKeep the callback contract separate from the synchronous reply\ncontract of `handle_call/3`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpCastState do\n  use GenServer\n\n  @impl true\n  def handle_call({:set, value}, _from, _state), do: {:reply, :ok, value}\nend\n```"}]}
+{"id": "kto.otp.handle-info.chosen", "family": "otp", "source": "elixir_kto_v0", "weakness": "otp-handle-info", "preference_kind": "correctness", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpInfo` with:\n\nDefine a GenServer `handle_info/2` clause for `:refresh`. It should\nset `:refreshed` to `true` in a map state and return\n`{:noreply, new_state}`. Do not route an out-of-band message through\nthe cast or call callback.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpInfo do\n  use GenServer\n\n  @impl true\n  def init(state), do: {:ok, state}\n\n  @impl true\n  def handle_info(:refresh, state) when is_map(state) do\n    {:noreply, Map.put(state, :refreshed, true)}\n  end\nend\n```"}]}
+{"id": "kto.otp.handle-info.rejected", "family": "otp", "source": "elixir_kto_v0", "weakness": "otp-handle-info", "preference_kind": "correctness", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpInfo` with:\n\nDefine a GenServer `handle_info/2` clause for `:refresh`. It should\nset `:refreshed` to `true` in a map state and return\n`{:noreply, new_state}`. Do not route an out-of-band message through\nthe cast or call callback.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpInfo do\n  use GenServer\n\n  @impl true\n  def handle_cast(:refresh, state) when is_map(state) do\n    {:noreply, Map.put(state, :refreshed, true)}\n  end\nend\n```"}]}
+{"id": "kto.otp.task-supervised-await.chosen", "family": "otp", "source": "elixir_kto_v0", "weakness": "otp-task-await", "preference_kind": "correctness", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpTaskRun` with:\n\nDefine `run/2` that accepts a `Task.Supervisor` pid and a zero-arity\nfunction. Start the work with `Task.Supervisor.async_nolink/2` and\nawait it with an explicit timeout of 1_000 milliseconds.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpTaskRun do\n  @timeout 1_000\n\n  @spec run(pid(), (() -> term())) :: term()\n  def run(supervisor, fun) when is_pid(supervisor) and is_function(fun, 0) do\n    task = Task.Supervisor.async_nolink(supervisor, fun)\n    Task.await(task, @timeout)\n  end\nend\n```"}]}
+{"id": "kto.otp.task-supervised-await.rejected", "family": "otp", "source": "elixir_kto_v0", "weakness": "otp-task-await", "preference_kind": "correctness", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpTaskRun` with:\n\nDefine `run/2` that accepts a `Task.Supervisor` pid and a zero-arity\nfunction. Start the work with `Task.Supervisor.async_nolink/2` and\nawait it with an explicit timeout of 1_000 milliseconds.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpTaskRun do\n  @spec run(pid(), (() -> term())) :: term()\n  def run(supervisor, fun) when is_pid(supervisor) and is_function(fun, 0) do\n    task = Task.Supervisor.async_nolink(supervisor, fun)\n    Task.await(task)\n  end\nend\n```"}]}
+{"id": "kto.otp.child-spec.chosen", "family": "otp", "source": "elixir_kto_v0", "weakness": "otp-supervision", "preference_kind": "correctness", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpWorker` with:\n\nDefine `start_link/1` and an explicit `child_spec/1`. The child\nspecification must use this module's start function, id from the\noptions, `restart: :transient`, `shutdown: 1_000`, and `type: :worker`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpWorker do\n  use GenServer\n\n  @spec start_link(keyword()) :: GenServer.on_start()\n  def start_link(options), do: GenServer.start_link(__MODULE__, options)\n\n  @spec child_spec(keyword()) :: Supervisor.child_spec()\n  def child_spec(options) do\n    %{\n      id: Keyword.fetch!(options, :id),\n      start: {__MODULE__, :start_link, [options]},\n      restart: :transient,\n      shutdown: 1_000,\n      type: :worker\n    }\n  end\n\n  @impl true\n  def init(options), do: {:ok, options}\nend\n```"}]}
+{"id": "kto.otp.child-spec.rejected", "family": "otp", "source": "elixir_kto_v0", "weakness": "otp-supervision", "preference_kind": "correctness", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpWorker` with:\n\nDefine `start_link/1` and an explicit `child_spec/1`. The child\nspecification must use this module's start function, id from the\noptions, `restart: :transient`, `shutdown: 1_000`, and `type: :worker`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpWorker do\n  use GenServer\n\n  @spec start_link(keyword()) :: GenServer.on_start()\n  def start_link(options), do: GenServer.start_link(__MODULE__, options)\n\n  @spec child_spec(keyword()) :: Supervisor.child_spec()\n  def child_spec(options) do\n    %{\n      id: Keyword.fetch!(options, :id),\n      start: {__MODULE__, :start_link, [options]},\n      restart: :permanent,\n      shutdown: 5_000,\n      type: :worker\n    }\n  end\n\n  @impl true\n  def init(options), do: {:ok, options}\nend\n```"}]}
+{"id": "kto.otp.immutable-state-update.chosen", "family": "otp", "source": "elixir_kto_v0", "weakness": "enum-state", "preference_kind": "correctness", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpTotals` with:\n\nDefine a GenServer callback for `{:add, key, amount}`. Update the\nmap state immutably with `Map.update/4`, reply with the new value,\nand keep the updated map as the next state.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpTotals do\n  use GenServer\n\n  @impl true\n  def init(state), do: {:ok, state}\n\n  @impl true\n  def handle_call({:add, key, amount}, _from, state) when is_map(state) do\n    new_state = Map.update(state, key, amount, &(&1 + amount))\n    {:reply, Map.fetch!(new_state, key), new_state}\n  end\nend\n```"}]}
+{"id": "kto.otp.immutable-state-update.rejected", "family": "otp", "source": "elixir_kto_v0", "weakness": "enum-state", "preference_kind": "correctness", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpTotals` with:\n\nDefine a GenServer callback for `{:add, key, amount}`. Update the\nmap state immutably with `Map.update/4`, reply with the new value,\nand keep the updated map as the next state.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpTotals do\n  use GenServer\n\n  @impl true\n  def handle_call({:add, key, amount}, _from, state) when is_map(state) do\n    current = Map.get(state, key, 0)\n    {:reply, current + amount, state}\n  end\nend\n```"}]}
+{"id": "kto.binary.exact-frame.chosen", "family": "binaries", "source": "elixir_kto_v0", "weakness": "bin-size-guard", "preference_kind": "correctness", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoBinFrame` with:\n\nDefine `encode/1` and `decode/1` for an unsigned-big 16-bit\nlength-prefixed binary. Decode must return `{:ok, payload}` only\nwhen the remaining byte count exactly equals the prefix; short and\ntrailing packets return `:error`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoBinFrame do\n  @spec encode(binary()) :: binary()\n  def encode(payload) when is_binary(payload) and byte_size(payload) <= 65_535 do\n    <<byte_size(payload)::unsigned-big-integer-size(16), payload::binary>>\n  end\n\n  @spec decode(binary()) :: {:ok, binary()} | :error\n  def decode(<<length::unsigned-big-integer-size(16), rest::binary>>) do\n    if byte_size(rest) == length, do: {:ok, rest}, else: :error\n  end\n\n  def decode(_other), do: :error\nend\n```"}]}
+{"id": "kto.binary.exact-frame.rejected", "family": "binaries", "source": "elixir_kto_v0", "weakness": "bin-size-guard", "preference_kind": "correctness", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoBinFrame` with:\n\nDefine `encode/1` and `decode/1` for an unsigned-big 16-bit\nlength-prefixed binary. Decode must return `{:ok, payload}` only\nwhen the remaining byte count exactly equals the prefix; short and\ntrailing packets return `:error`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoBinFrame do\n  @spec encode(binary()) :: binary()\n  def encode(payload) when is_binary(payload) and byte_size(payload) <= 65_535 do\n    <<byte_size(payload)::unsigned-big-integer-size(16), payload::binary>>\n  end\n\n  @spec decode(binary()) :: {:ok, binary()} | :error\n  def decode(<<length::unsigned-big-integer-size(16), rest::binary>>) do\n    if byte_size(rest) >= length, do: {:ok, binary_part(rest, 0, length)}, else: :error\n  end\n\n  def decode(_other), do: :error\nend\n```"}]}
+{"id": "kto.binary.safe-term.chosen", "family": "binaries", "source": "elixir_kto_v0", "weakness": "stdlib-safe-deserialization", "preference_kind": "correctness", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoBinTerm` with:\n\nDefine `decode/1` for a binary term. Use the safe Erlang decoding\noption so the function does not create atoms or other resources\nfrom untrusted input. Valid encoded terms should be returned.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoBinTerm do\n  @spec decode(binary()) :: term()\n  def decode(binary) when is_binary(binary) do\n    :erlang.binary_to_term(binary, [:safe])\n  end\nend\n```"}]}
+{"id": "kto.binary.safe-term.rejected", "family": "binaries", "source": "elixir_kto_v0", "weakness": "stdlib-safe-deserialization", "preference_kind": "correctness", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoBinTerm` with:\n\nDefine `decode/1` for a binary term. Use the safe Erlang decoding\noption so the function does not create atoms or other resources\nfrom untrusted input. Valid encoded terms should be returned.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoBinTerm do\n  @spec decode(binary()) :: term()\n  def decode(binary) when is_binary(binary) do\n    :erlang.binary_to_term(binary)\n  end\nend\n```"}]}
+{"id": "kto.binary.signed-integer.chosen", "family": "binaries", "source": "elixir_kto_v0", "weakness": "bin-signed", "preference_kind": "correctness", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoBinSigned16` with:\n\nDefine `decode/1` for exactly two bytes containing a signed\nbig-endian 16-bit integer. Return `{:ok, integer}` for the exact\nbinary and `:error` for all other sizes.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoBinSigned16 do\n  @spec decode(binary()) :: {:ok, integer()} | :error\n  def decode(<<value::signed-big-integer-size(16)>>), do: {:ok, value}\n  def decode(_other), do: :error\nend\n```"}]}
+{"id": "kto.binary.signed-integer.rejected", "family": "binaries", "source": "elixir_kto_v0", "weakness": "bin-signed", "preference_kind": "correctness", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoBinSigned16` with:\n\nDefine `decode/1` for exactly two bytes containing a signed\nbig-endian 16-bit integer. Return `{:ok, integer}` for the exact\nbinary and `:error` for all other sizes.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoBinSigned16 do\n  @spec decode(binary()) :: {:ok, integer()} | :error\n  def decode(<<value::unsigned-big-integer-size(16)>>), do: {:ok, value}\n  def decode(_other), do: :error\nend\n```"}]}
+{"id": "kto.binary.explicit-bitwise.chosen", "family": "binaries", "source": "elixir_kto_v0", "weakness": "bin-bitwise", "preference_kind": "correctness", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoBinFlags` with:\n\nDefine `toggle/2` that returns the bitwise XOR of two integers.\nCall the explicit `Bitwise.bxor/2` function rather than relying on\ndeprecated operators or arithmetic that happens to work for a\nnarrow sample.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoBinFlags do\n  @spec toggle(non_neg_integer(), non_neg_integer()) :: non_neg_integer()\n  def toggle(left, right) when is_integer(left) and is_integer(right) do\n    Bitwise.bxor(left, right)\n  end\nend\n```"}]}
+{"id": "kto.binary.explicit-bitwise.rejected", "family": "binaries", "source": "elixir_kto_v0", "weakness": "bin-bitwise", "preference_kind": "correctness", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoBinFlags` with:\n\nDefine `toggle/2` that returns the bitwise XOR of two integers.\nCall the explicit `Bitwise.bxor/2` function rather than relying on\ndeprecated operators or arithmetic that happens to work for a\nnarrow sample.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoBinFlags do\n  @spec toggle(non_neg_integer(), non_neg_integer()) :: non_neg_integer()\n  def toggle(left, right) when is_integer(left) and is_integer(right) do\n    Bitwise.band(left, right)\n  end\nend\n```"}]}
+{"id": "kto.binary.varint-empty-guard.chosen", "family": "binaries", "source": "elixir_kto_v0", "weakness": "edge-empty", "preference_kind": "correctness", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoBinVarint` with:\n\nDefine `decode/1` for an unsigned little-endian base-128 varint.\nReturn `{:ok, {value, rest}}`, return `:error` for empty or\ntruncated input, and reject more than five bytes. Use recursive\npattern matching with an explicit empty-binary clause.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoBinVarint do\n  @spec decode(binary()) :: {:ok, {non_neg_integer(), binary()}} | :error\n  def decode(binary) when is_binary(binary), do: decode_bytes(binary, 0, 0)\n\n  defp decode_bytes(_rest, _value, 5), do: :error\n  defp decode_bytes(<<>>, _value, _count), do: :error\n\n  defp decode_bytes(<<byte, rest::binary>>, value, count) do\n    low_bits = Bitwise.band(byte, 0x7F)\n    next_value = value + Bitwise.bsl(low_bits, 7 * count)\n\n    if Bitwise.band(byte, 0x80) == 0 do\n      {:ok, {next_value, rest}}\n    else\n      decode_bytes(rest, next_value, count + 1)\n    end\n  end\nend\n```"}]}
+{"id": "kto.binary.varint-empty-guard.rejected", "family": "binaries", "source": "elixir_kto_v0", "weakness": "edge-empty", "preference_kind": "correctness", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoBinVarint` with:\n\nDefine `decode/1` for an unsigned little-endian base-128 varint.\nReturn `{:ok, {value, rest}}`, return `:error` for empty or\ntruncated input, and reject more than five bytes. Use recursive\npattern matching with an explicit empty-binary clause.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoBinVarint do\n  @spec decode(binary()) :: {:ok, {non_neg_integer(), binary()}} | :error\n  def decode(binary) when is_binary(binary), do: decode_bytes(binary, 0, 0)\n\n  defp decode_bytes(_rest, _value, 5), do: :error\n\n  defp decode_bytes(<<byte, rest::binary>>, value, count) do\n    low_bits = Bitwise.band(byte, 0x7F)\n    next_value = value + Bitwise.bsl(low_bits, 7 * count)\n\n    if Bitwise.band(byte, 0x80) == 0 do\n      {:ok, {next_value, rest}}\n    else\n      decode_bytes(rest, next_value, count + 1)\n    end\n  end\nend\n```"}]}
+{"id": "kto.stdlib.string-length.chosen", "family": "stdlib", "source": "elixir_kto_v0", "weakness": "stdlib-byte-vs-grapheme", "preference_kind": "correctness", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoStdlibText` with:\n\nDefine `characters/1` to count user-visible Unicode graphemes in a\nstring. Use the String API rather than counting UTF-8 bytes.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoStdlibText do\n  @spec characters(String.t()) :: non_neg_integer()\n  def characters(text) when is_binary(text), do: String.length(text)\nend\n```"}]}
+{"id": "kto.stdlib.string-length.rejected", "family": "stdlib", "source": "elixir_kto_v0", "weakness": "stdlib-byte-vs-grapheme", "preference_kind": "correctness", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoStdlibText` with:\n\nDefine `characters/1` to count user-visible Unicode graphemes in a\nstring. Use the String API rather than counting UTF-8 bytes.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoStdlibText do\n  @spec characters(String.t()) :: non_neg_integer()\n  def characters(text) when is_binary(text), do: byte_size(text)\nend\n```"}]}
+{"id": "kto.stdlib.regex-nil.chosen", "family": "stdlib", "source": "elixir_kto_v0", "weakness": "edge-nil-result", "preference_kind": "correctness", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoStdlibDigits` with:\n\nDefine `extract/1` to return `{:ok, digits}` for the first run of\ndecimal digits in a string, or `:error` when there is no match.\nHandle the `nil` result from `Regex.run/3` explicitly.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoStdlibDigits do\n  @spec extract(String.t()) :: {:ok, String.t()} | :error\n  def extract(text) when is_binary(text) do\n    case Regex.run(~r/(\\d+)/, text, capture: :all_but_first) do\n      [digits] -> {:ok, digits}\n      nil -> :error\n    end\n  end\nend\n```"}]}
+{"id": "kto.stdlib.regex-nil.rejected", "family": "stdlib", "source": "elixir_kto_v0", "weakness": "edge-nil-result", "preference_kind": "correctness", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoStdlibDigits` with:\n\nDefine `extract/1` to return `{:ok, digits}` for the first run of\ndecimal digits in a string, or `:error` when there is no match.\nHandle the `nil` result from `Regex.run/3` explicitly.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoStdlibDigits do\n  @spec extract(String.t()) :: {:ok, String.t()} | :error\n  def extract(text) when is_binary(text) do\n    [digits] = Regex.run(~r/(\\d+)/, text, capture: :all_but_first)\n    {:ok, digits}\n  end\nend\n```"}]}
+{"id": "kto.errors.tagged-with.chosen", "family": "errors", "source": "elixir_kto_v0", "weakness": "err-with-else", "preference_kind": "correctness", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoErrorsSum` with:\n\nDefine `sum/2` for two strings containing integers. Return\n`{:ok, sum}` on success and `{:error, :invalid}` for malformed\ninput. Use tagged `with` branches and do not turn a parse failure\ninto a successful default.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoErrorsSum do\n  @spec sum(String.t(), String.t()) :: {:ok, integer()} | {:error, :invalid}\n  def sum(left, right) when is_binary(left) and is_binary(right) do\n    with {left_number, \"\"} <- Integer.parse(left),\n         {right_number, \"\"} <- Integer.parse(right) do\n      {:ok, left_number + right_number}\n    else\n      _ -> {:error, :invalid}\n    end\n  end\nend\n```"}]}
+{"id": "kto.errors.tagged-with.rejected", "family": "errors", "source": "elixir_kto_v0", "weakness": "err-with-else", "preference_kind": "correctness", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoErrorsSum` with:\n\nDefine `sum/2` for two strings containing integers. Return\n`{:ok, sum}` on success and `{:error, :invalid}` for malformed\ninput. Use tagged `with` branches and do not turn a parse failure\ninto a successful default.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoErrorsSum do\n  @spec sum(String.t(), String.t()) :: {:ok, integer()} | {:error, :invalid}\n  def sum(left, right) when is_binary(left) and is_binary(right) do\n    case Integer.parse(left) do\n      {left_number, _rest} -> {:ok, left_number + String.to_integer(right)}\n      :error -> {:ok, 0}\n    end\n  end\nend\n```"}]}
+{"id": "kto.protocol.explicit-implementation.chosen", "family": "protocol", "source": "elixir_kto_v0", "weakness": "protocol-behaviour", "preference_kind": "correctness", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoRender` with:\n\nDefine a `KtoRenderable` protocol with `render/1`, implement it\nfor integers, and expose `KtoRender.render/1` as the delegating\npublic function. Use the protocol/implementation boundary instead\nof a type-checking conditional in the public module.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefprotocol KtoRenderable do\n  @spec render(term()) :: String.t()\n  def render(value)\nend\n\ndefimpl KtoRenderable, for: Integer do\n  def render(value), do: Integer.to_string(value)\nend\n\ndefmodule KtoRender do\n  @spec render(term()) :: String.t()\n  def render(value), do: KtoRenderable.render(value)\nend\n```"}]}
+{"id": "kto.protocol.explicit-implementation.rejected", "family": "protocol", "source": "elixir_kto_v0", "weakness": "protocol-behaviour", "preference_kind": "correctness", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoRender` with:\n\nDefine a `KtoRenderable` protocol with `render/1`, implement it\nfor integers, and expose `KtoRender.render/1` as the delegating\npublic function. Use the protocol/implementation boundary instead\nof a type-checking conditional in the public module.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoRender do\n  @spec render(term()) :: String.t()\n  def render(value) when is_integer(value), do: Integer.to_string(value)\nend\n```"}]}
+{"id": "kto.protocol.behaviour-contract.chosen", "family": "protocol", "source": "elixir_kto_v0", "weakness": "protocol-behaviour", "preference_kind": "correctness", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoUpperFormatter` with:\n\nDefine a `KtoFormatter` behaviour with a `format/1` callback and an\nimplementation module `KtoUpperFormatter` that declares the\nbehaviour and uses `@impl true`. Formatting should uppercase text.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFormatter do\n  @callback format(String.t()) :: String.t()\nend\n\ndefmodule KtoUpperFormatter do\n  @behaviour KtoFormatter\n\n  @impl true\n  def format(text) when is_binary(text), do: String.upcase(text)\nend\n```"}]}
+{"id": "kto.protocol.behaviour-contract.rejected", "family": "protocol", "source": "elixir_kto_v0", "weakness": "protocol-behaviour", "preference_kind": "correctness", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoUpperFormatter` with:\n\nDefine a `KtoFormatter` behaviour with a `format/1` callback and an\nimplementation module `KtoUpperFormatter` that declares the\nbehaviour and uses `@impl true`. Formatting should uppercase text.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFormatter do\n  @callback format(String.t()) :: String.t()\nend\n\ndefmodule KtoUpperFormatter do\n  def format(text) when is_binary(text), do: String.upcase(text)\nend\n```"}]}
+{"id": "kto.core.function-clause-guard.chosen", "family": "core", "source": "elixir_kto_v0", "weakness": "fn-guard", "preference_kind": "correctness", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoCoreClassify` with:\n\nDefine `classify/1` with function clauses and guards: non-negative\nintegers return `:non_negative`, negative integers return\n`:negative`, and all other terms return `:other`. Keep type and\nrange checks in function heads rather than simulating a procedural\ndecision tree inside an anonymous function.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoCoreClassify do\n  @spec classify(term()) :: :non_negative | :negative | :other\n  def classify(value) when is_integer(value) and value >= 0, do: :non_negative\n  def classify(value) when is_integer(value), do: :negative\n  def classify(_value), do: :other\nend\n```"}]}
+{"id": "kto.core.function-clause-guard.rejected", "family": "core", "source": "elixir_kto_v0", "weakness": "fn-guard", "preference_kind": "correctness", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoCoreClassify` with:\n\nDefine `classify/1` with function clauses and guards: non-negative\nintegers return `:non_negative`, negative integers return\n`:negative`, and all other terms return `:other`. Keep type and\nrange checks in function heads rather than simulating a procedural\ndecision tree inside an anonymous function.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoCoreClassify do\n  @spec classify(term()) :: :non_negative | :negative | :other\n  def classify(value) do\n    if is_integer(value) do\n      if value >= 0, do: :non_negative, else: :negative\n    else\n      :other\n    end\n  end\nend\n```"}]}
+{"id": "kto.format.single-fence.chosen", "family": "format", "source": "elixir_kto_v0", "weakness": "format-hygiene", "preference_kind": "correctness", "label": true, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFormatAnswer` with:\n\nDefine `answer/0` returning `:ok`. The response must contain only\none Elixir fence and no explanation before or after it.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFormatAnswer do\n  def answer, do: :ok\nend\n```"}]}
+{"id": "kto.format.single-fence.rejected", "family": "format", "source": "elixir_kto_v0", "weakness": "format-hygiene", "preference_kind": "correctness", "label": false, "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoFormatAnswer` with:\n\nDefine `answer/0` returning `:ok`. The response must contain only\none Elixir fence and no explanation before or after it.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "Here is the requested module:\n\n```elixir\ndefmodule KtoFormatAnswer do\n  def answer, do: :ok\nend\n```\n\nThis keeps the answer concise."}]}

data/onpolicy/qwen25c3b_micro_dpo_v1.jsonl ADDED Viewed

	@@ -0,0 +1,36 @@

+{"id": "micro.qwen25c3b.dpo.otp.asynclongest.v3.otp-supervision", "family": "otp", "source": "qwen25c3b_micro_dpo_v1", "weakness": "otp-supervision", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `AsyncLongest03` with:\n\n@spec run(list()) :: term()\n    def run(list)\n\nCompute the longest string in the list inside `Task.async`. Await with timeout `5_000` and return the\nresult. Do not use `spawn`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule AsyncLongest03 do\n  @spec run(list()) :: term()\n  def run(list) when is_list(list) do\n    task = Task.async(fn -> Enum.max_by(list, &String.length/1) end)\n    Task.await(task, 5_000)\n  end\nend\n```", "rejected": "defmodule AsyncLongest03 do\n  @spec run(list()) :: term()\n  def run(list) when is_list(list) do\n    spawn(fn -> Enum.max_by(list, &String.length/1) end)\n    :ok\n  end\nend"}
+{"id": "micro.qwen25c3b.dpo.collections.deltarun.v2.edge-empty", "family": "collections", "source": "qwen25c3b_micro_dpo_v1", "weakness": "edge-empty", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `DeltaRun02` with:\n\n@spec deltas([number()]) :: [number()]\n    def deltas(list)\n\nConsecutive differences: `[a, b, c]` gives `[b - a, c - b]`. Empty and\nsingle-element lists give `[]`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule DeltaRun02 do\n  @spec deltas([number()]) :: [number()]\n  def deltas([]), do: []\n  def deltas([_only]), do: []\n  def deltas(list), do: Enum.zip_with(list, tl(list), fn a, b -> b - a end)\nend\n```", "rejected": "defmodule DeltaRun02 do\n  @spec deltas([number()]) :: [number()]\n  def deltas([]), do: []\n  def deltas([only]), do: [only - only]\n  def deltas(list), do: Enum.zip_with(list, tl(list), fn a, b -> b - a end)\nend"}
+{"id": "micro.qwen25c3b.dpo.collections.groupruns.v2.format-hygiene.h", "family": "collections", "source": "qwen25c3b_micro_dpo_v1", "weakness": "format-hygiene", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `GroupRuns02` with:\n\n@spec runs([term()]) :: [[term()]]\n    def runs(list)\n\nGroup CONSECUTIVE equal values into sublists, preserving order. Only adjacent\nequals merge.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule GroupRuns02 do\n  @spec runs([term()]) :: [[term()]]\n  def runs([]), do: []\n\n  def runs([head | rest]) do\n    {run, leftover} = split_run(rest, head, [head])\n    [run | runs(leftover)]\n  end\n\n  defp split_run([head | rest], head, acc), do: split_run(rest, head, [head | acc])\n  defp split_run(leftover, _value, acc), do: {Enum.reverse(acc), leftover}\nend\n```", "rejected": "Sure! Here is the module you asked for:\n\n```elixir\ndefmodule GroupRuns02 do\n  @spec runs([term()]) :: [[term()]]\n  def runs([]), do: []\n\n  def runs([head | rest]) do\n    {run, leftover} = split_run(rest, head, [head])\n    [run | runs(leftover)]\n  end\n\n  defp split_run([head | rest], head, acc), do: split_run(rest, head, [head | acc])\n  defp split_run(leftover, _value, acc), do: {Enum.reverse(acc), leftover}\nend\n```\n\nLet me know if you need changes."}
+{"id": "micro.qwen25c3b.dpo.stdlib.wordscan.err-swallow", "family": "stdlib", "source": "qwen25c3b_micro_dpo_v1", "weakness": "err-swallow", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `WordScan` with:\n\n@spec pairs(String.t()) :: [{String.t(), String.t()}]\n    def pairs(text)\n\nFind all `key=value` words (`\\w+` on both sides) and return `{key, value}`\ntuples in order.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule WordScan do\n  @spec pairs(String.t()) :: [{String.t(), String.t()}]\n  def pairs(text) when is_binary(text) do\n    Regex.scan(~r/(?<key>\\w+)=(?<value>\\w+)/, text, capture: :all_names)\n    |> Enum.map(fn [key, value] -> {key, value} end)\n  end\nend\n```", "rejected": "defmodule WordScan do\n  @spec pairs(String.t()) :: [{String.t(), String.t()}]\n  def pairs(text) when is_binary(text) do\n    Regex.scan(~r/\\w+=(?<value>\\w+)/, text, capture: :all_names)\n    |> Enum.map(fn [key, value] -> {key, value} end)\n  end\nend"}
+{"id": "micro.qwen25c3b.dpo.collections.groupruns.v2.enum-state", "family": "collections", "source": "qwen25c3b_micro_dpo_v1", "weakness": "enum-state", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `GroupRuns02` with:\n\n@spec runs([term()]) :: [[term()]]\n    def runs(list)\n\nGroup CONSECUTIVE equal values into sublists, preserving order. Only adjacent\nequals merge.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule GroupRuns02 do\n  @spec runs([term()]) :: [[term()]]\n  def runs([]), do: []\n\n  def runs([head | rest]) do\n    {run, leftover} = split_run(rest, head, [head])\n    [run | runs(leftover)]\n  end\n\n  defp split_run([head | rest], head, acc), do: split_run(rest, head, [head | acc])\n  defp split_run(leftover, _value, acc), do: {Enum.reverse(acc), leftover}\nend\n```", "rejected": "defmodule GroupRuns02 do\n  @spec runs([term()]) :: [[term()]]\n  def runs(list) when is_list(list) do\n    list\n    |> Enum.group_by(& &1)\n    |> Map.values()\n    |> Enum.sort()\n  end\nend"}
+{"id": "micro.qwen25c3b.dpo.beam.termblob.err-swallow.0", "family": "beam", "source": "qwen25c3b_micro_dpo_v1", "weakness": "err-swallow", "origin": "handmade", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `TermBlob` with:\n\n@spec wrap(term()) :: binary()\n    def wrap(term)\n\n    @spec unwrap(binary()) :: {:ok, term()} | :error\n    def unwrap(bin)\n\nSerialize with `:erlang.term_to_binary/1`. `unwrap/1` inverts it and returns\n`:error` for malformed input instead of crashing.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule TermBlob do\n  @spec wrap(term()) :: binary()\n  def wrap(term), do: :erlang.term_to_binary(term)\n\n  @spec unwrap(binary()) :: {:ok, term()} | :error\n  def unwrap(bin) when is_binary(bin) do\n    {:ok, :erlang.binary_to_term(bin, [:safe])}\n  rescue\n    ArgumentError -> :error\n  end\nend\n```", "rejected": "defmodule TermBlob do\n  @spec wrap(term()) :: binary()\n  def wrap(term), do: :erlang.term_to_binary(term)\n\n  @spec unwrap(binary()) :: {:ok, term()} | :error\n  def unwrap(bin) when is_binary(bin), do: {:ok, :erlang.binary_to_term(bin)}\nend"}
+{"id": "micro.qwen25c3b.dpo.stdlib.padcode.v3.enum-state", "family": "stdlib", "source": "qwen25c3b_micro_dpo_v1", "weakness": "enum-state", "origin": "handmade", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `PadCode03` with:\n\n@spec left(String.t(), non_neg_integer(), String.t()) :: String.t()\n    def left(text, width, pad)\n\n    @spec clip(String.t(), non_neg_integer()) :: String.t()\n    def clip(text, width)\n\n`left/3` pads on the leading side to EXACTLY `width` graphemes but never\ntruncates longer inputs. `clip/2` keeps at most the first `width`\ngraphemes.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule PadCode03 do\n  @spec left(String.t(), non_neg_integer(), String.t()) :: String.t()\n  def left(text, width, pad) when is_binary(text) and width >= 0 do\n    String.pad_leading(text, width, pad)\n  end\n\n  @spec clip(String.t(), non_neg_integer()) :: String.t()\n  def clip(text, width) when is_binary(text) and width >= 0 do\n    String.slice(text, 0, width)\n  end\nend\n```", "rejected": "defmodule PadCode03 do\n  @spec left(String.t(), non_neg_integer(), String.t()) :: String.t()\n  def left(text, width, pad) when is_binary(text) and width >= 0 do\n    String.pad_leading(text, width, pad)\n  end\n\n  @spec clip(String.t(), non_neg_integer()) :: String.t()\n  def clip(text, width) when is_binary(text) and width >= 0 do\n    String.slice(text, -width, width)\n  end\nend"}
+{"id": "micro.qwen25c3b.dpo.binaries.s24le.format-hygiene.h", "family": "binaries", "source": "qwen25c3b_micro_dpo_v1", "weakness": "format-hygiene", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `S24LE` with:\n\n@spec encode(-8388608..8388607) :: <<_::24>>\n    def encode(n)\n\n    @spec decode(binary()) :: {:ok, integer()} | :error\n    def decode(bin)\n\nUse bit syntax (`::signed-little-integer-size(24)`). `decode/1` returns\n`:error` unless the binary is exactly 3 byte(s).\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule S24LE do\n  @spec encode(-8388608..8388607) :: <<_::24>>\n  def encode(n) when is_integer(n) and n >= -8388608 and n <= 8388607 do\n    <<n::signed-little-integer-size(24)>>\n  end\n\n  @spec decode(binary()) :: {:ok, integer()} | :error\n  def decode(<<n::signed-little-integer-size(24)>>), do: {:ok, n}\n  def decode(_other), do: :error\nend\n```", "rejected": "Here is a draft:\n\n```elixir\ndefmodule S24LE do\n  @spec encode(-8388608..8388607) :: <<_::24>>\n  def encode(n) when is_integer(n) and n >= -8388608 and n <= 8388607 do\n    <<n::signed-little-integer-size(24)>>\n  end\n```\n\nFinal version:\n\n```elixir\ndefmodule S24LE do\n  @spec encode(-8388608..8388607) :: <<_::24>>\n  def encode(n) when is_integer(n) and n >= -8388608 and n <= 8388607 do\n    <<n::signed-little-integer-size(24)>>\n  end\n\n  @spec decode(binary()) :: {:ok, integer()} | :error\n  def decode(<<n::signed-little-integer-size(24)>>), do: {:ok, n}\n  def decode(_other), do: :error\nend\n```"}
+{"id": "micro.qwen25c3b.dpo.beam.localcache.v3.persistent-term", "family": "beam", "source": "qwen25c3b_micro_dpo_v1", "weakness": "persistent-term", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `LocalCache03` with:\n\n@spec new() :: :ets.table()\n    def new()\n\n    @spec put(:ets.table(), term(), term()) :: true\n    def put(table, key, value)\n\n    @spec get(:ets.table(), term(), term()) :: term()\n    def get(table, key, default)\n\nA public `:set` ETS table. `get/3` returns `default` for missing keys.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule LocalCache03 do\n  @spec new() :: :ets.table()\n  def new, do: :ets.new(__MODULE__, [:set, :public])\n\n  @spec put(:ets.table(), term(), term()) :: true\n  def put(table, key, value), do: :ets.insert(table, {key, value})\n\n  @spec get(:ets.table(), term(), term()) :: term()\n  def get(table, key, default) do\n    case :ets.lookup(table, key) do\n      [{^key, value}] -> value\n      [] -> default\n    end\n  end\nend\n```", "rejected": "defmodule LocalCache03 do\n  @spec new() :: :ets.table()\n  def new, do: :ets.new(__MODULE__, [:set, :public])\n\n  @spec put(:ets.table(), term(), term()) :: true\n  def put(table, key, value), do: :ets.insert(table, {key, value})\n\n  @spec get(:ets.table(), term(), term()) :: term()\n  def get(table, key, default) do\n    case :ets.lookup(table, key) do\n      {:ok, value} -> value\n      :error -> default\n    end\n  end\nend"}
+{"id": "micro.qwen25c3b.dpo.beam.atomicticks.v3.otp-supervision", "family": "beam", "source": "qwen25c3b_micro_dpo_v1", "weakness": "otp-supervision", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `AtomicTicks03` with:\n\n@spec new() :: :atomics.ref()\n    def new()\n\n    @spec tick(:atomics.ref()) :: non_neg_integer()\n    def tick(ref)\n\n    @spec read(:atomics.ref()) :: non_neg_integer()\n    def read(ref)\n\nAn unsigned `:atomics` counter. `tick/1` increments and returns the NEW count;\n`read/1` reads without changing it.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule AtomicTicks03 do\n  @spec new() :: :atomics.ref()\n  def new, do: :atomics.new(1, signed: false)\n\n  @spec tick(:atomics.ref()) :: non_neg_integer()\n  def tick(ref), do: :atomics.add_get(ref, 1, 1)\n\n  @spec read(:atomics.ref()) :: non_neg_integer()\n  def read(ref), do: :atomics.get(ref, 1)\nend\n```", "rejected": "defmodule AtomicTicks03 do\n  @spec new() :: :atomics.ref()\n  def new, do: {:ok, pid} = Agent.start_link(fn -> 0 end); pid\n\n  @spec tick(:atomics.ref()) :: non_neg_integer()\n  def tick(ref), do: Agent.get_and_update(ref, fn n -> {n + 1, n + 1} end)\n\n  @spec read(:atomics.ref()) :: non_neg_integer()\n  def read(ref), do: Agent.get(ref, & &1)\nend"}
+{"id": "micro.qwen25c3b.dpo.core.structmigrate.v3.edge-empty", "family": "core", "source": "qwen25c3b_micro_dpo_v1", "weakness": "edge-empty", "origin": "handmade", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `Profile03` with:\n\nStruct `%Profile03{name, email, plan: :free}`. `from_v1/1` builds it from an\nold plain map with keys `:name`, `:email`, and OPTIONAL `:plan` (defaults to\n`:free` only when absent).\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule Profile03 do\n  defstruct [:name, :email, plan: :free]\n\n  @type t :: %__MODULE__{name: term(), email: term(), plan: atom()}\n\n  @spec from_v1(map()) :: %__MODULE__{}\n  def from_v1(old) when is_map(old) do\n    %__MODULE__{\n      name: Map.get(old, :name),\n      email: Map.get(old, :email),\n      plan: Map.get(old, :plan, :free)\n    }\n  end\nend\n```", "rejected": "defmodule Profile03 do\n  defstruct [:name, :email, plan: :free]\n\n  @spec from_v1(map()) :: %__MODULE__{}\n  def from_v1(old) when is_map(old) do\n    %__MODULE__{\n      name: Map.fetch!(old, :name),\n      email: Map.fetch!(old, :email),\n      plan: Map.fetch!(old, :plan)\n    }\n  end\nend"}
+{"id": "micro.qwen25c3b.dpo.abstractions.attrinject.v3.protocol-behaviour", "family": "abstractions", "source": "qwen25c3b_micro_dpo_v1", "weakness": "protocol-behaviour", "origin": "handmade", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `Tagged03` with:\n\n`Tagged03` provides `__using__(tag: tag)` that injects a module attribute\n`@tag` set to the given value plus a zero-arity `tag/0` returning it.\n`Tagger` does `use Tagged03, tag: :alpha`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule Tagged03 do\n  defmacro __using__(opts) do\n    tag = Keyword.fetch!(opts, :tag)\n\n    quote do\n      @tag unquote(tag)\n\n      def tag, do: @tag\n    end\n  end\nend\n\ndefmodule Tagger do\n  use Tagged03, tag: :alpha\nend\n```", "rejected": "defmodule Tagged03 do\n  defmacro __using__(opts) do\n    quote do\n      @tag tag\n\n      def tag, do: @tag\n    end\n  end\nend\n\ndefmodule Tagger do\n  use Tagged03, tag: :alpha\nend"}
+{"id": "micro.qwen25c3b.dpo.abstractions.codecbehaviour.v2.protocol-behaviour.0", "family": "abstractions", "source": "qwen25c3b_micro_dpo_v1", "weakness": "protocol-behaviour", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `CodecBehaviour02` with:\n\nBehaviour `CodecBehaviour02` with callbacks `encode/1` (`term() -> binary()`)\nand `decode/1` (`binary() -> {:ok, term()} | :error`); `decode/1` is optional.\nAlso define `run/2` calling encode then decode on a module, plus a\n`TextCodec` implementation where encode is `to_string/1` and decode wraps in\n`{:ok, _}`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule CodecBehaviour02 do\n  @callback encode(term()) :: binary()\n  @callback decode(binary()) :: {:ok, term()} | :error\n\n  @optional_callbacks decode: 1\n\n  def run(module, value) do\n    value |> module.encode() |> module.decode()\n  end\nend\n\ndefmodule TextCodec do\n  @behaviour CodecBehaviour02\n\n  @impl true\n  def encode(value), do: to_string(value)\n\n  @impl true\n  def decode(bin), do: {:ok, bin}\nend\n```", "rejected": "defmodule CodecBehaviour02 do\n  @callback encode(term()) :: binary()\n  @callback decode(binary()) :: {:ok, term()} | :error\n\n  @optional_callbacks decode: 1\n\n  def run(module, value) do\n    value |> module.encode() |> module.decode()\n  end\nend\n\ndefmodule TextCodec do\n  @behaviour CodecBehaviour02\n\n  @impl true\n  def encode(value, _opts), do: to_string(value)\n\n  @impl true\n  def decode(bin), do: {:ok, bin}\nend"}
+{"id": "micro.qwen25c3b.dpo.beam.localcache.v3.ets-api", "family": "beam", "source": "qwen25c3b_micro_dpo_v1", "weakness": "ets-api", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `LocalCache03` with:\n\n@spec new() :: :ets.table()\n    def new()\n\n    @spec put(:ets.table(), term(), term()) :: true\n    def put(table, key, value)\n\n    @spec get(:ets.table(), term(), term()) :: term()\n    def get(table, key, default)\n\nA public `:set` ETS table. `get/3` returns `default` for missing keys.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule LocalCache03 do\n  @spec new() :: :ets.table()\n  def new, do: :ets.new(__MODULE__, [:set, :public])\n\n  @spec put(:ets.table(), term(), term()) :: true\n  def put(table, key, value), do: :ets.insert(table, {key, value})\n\n  @spec get(:ets.table(), term(), term()) :: term()\n  def get(table, key, default) do\n    case :ets.lookup(table, key) do\n      [{^key, value}] -> value\n      [] -> default\n    end\n  end\nend\n```", "rejected": "defmodule LocalCache03 do\n  @spec new() :: :ets.table()\n  def new, do: :ets.new(__MODULE__, [:set, :public])\n\n  @spec put(:ets.table(), term(), term()) :: true\n  def put(table, key, value), do: :ets.insert(table, {key, value})\n\n  @spec get(:ets.table(), term(), term()) :: term()\n  def get(table, key, default) do\n:ets.lookup_element(table, key, 2)\n  end\nend"}
+{"id": "micro.qwen25c3b.dpo.otp.asyncsumsq.v2.fn-guard", "family": "otp", "source": "qwen25c3b_micro_dpo_v1", "weakness": "fn-guard", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `AsyncSumSq02` with:\n\n@spec run(list()) :: term()\n    def run(list)\n\nCompute the sum of squares of the integers inside `Task.async`. Await with timeout `5_000` and return the\nresult. Do not use `spawn`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule AsyncSumSq02 do\n  @spec run(list()) :: term()\n  def run(list) when is_list(list) do\n    task = Task.async(fn -> list |> Enum.map(&(&1 * &1)) |> Enum.sum() end)\n    Task.await(task, 5_000)\n  end\nend\n```", "rejected": "defmodule AsyncSumSq02 do\n  @spec run(list()) :: term()\n  def run(list) when is_list(list) do\n    task = Task.async(fn list when is_list(list) -> list |> Enum.map(&(&1 * &1)) |> Enum.sum() end)\n    Task.await(task, 5_000)\n  end\nend"}
+{"id": "micro.qwen25c3b.dpo.binaries.s16be.bin-size-guard", "family": "binaries", "source": "qwen25c3b_micro_dpo_v1", "weakness": "bin-size-guard", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `S16BE` with:\n\n@spec encode(-32768..32767) :: <<_::16>>\n    def encode(n)\n\n    @spec decode(binary()) :: {:ok, integer()} | :error\n    def decode(bin)\n\nUse bit syntax (`::signed-big-integer-size(16)`). `decode/1` returns\n`:error` unless the binary is exactly 2 byte(s).\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule S16BE do\n  @spec encode(-32768..32767) :: <<_::16>>\n  def encode(n) when is_integer(n) and n >= -32768 and n <= 32767 do\n    <<n::signed-big-integer-size(16)>>\n  end\n\n  @spec decode(binary()) :: {:ok, integer()} | :error\n  def decode(<<n::signed-big-integer-size(16)>>), do: {:ok, n}\n  def decode(_other), do: :error\nend\n```", "rejected": "defmodule S16BE do\n  @spec encode(-32768..32767) :: <<_::16>>\n  def encode(n) when is_integer(n) and n >= -32768 and n <= 32767 do\n    <<n::signed-big-integer-size(16)>>\n  end\n\n  @spec decode(binary()) :: {:ok, integer()} | :error\n  def decode(<<n::signed-big-integer-size(16), _rest::binary>>), do: {:ok, n}\n  def decode(_other), do: :error\nend"}
+{"id": "micro.qwen25c3b.dpo.stdlib.graphemecut.stdlib-misuse.0", "family": "stdlib", "source": "qwen25c3b_micro_dpo_v1", "weakness": "stdlib-misuse", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `GraphemeCut` with:\n\n@spec head(String.t(), non_neg_integer()) :: String.t()\n    def head(text, n)\n\n    @spec size_bytes(String.t()) :: non_neg_integer()\n    def size_bytes(text)\n\n`head/2` keeps the first `n` GRAPHEMES. `size_bytes/1` counts BYTES, not\ncharacters.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule GraphemeCut do\n  @spec head(String.t(), non_neg_integer()) :: String.t()\n  def head(text, n) when is_binary(text) and n >= 0 do\n    text |> String.graphemes() |> Enum.take(n) |> Enum.join()\n  end\n\n  @spec size_bytes(String.t()) :: non_neg_integer()\n  def size_bytes(text) when is_binary(text), do: byte_size(text)\nend\n```", "rejected": "defmodule GraphemeCut do\n  @spec head(String.t(), non_neg_integer()) :: String.t()\n  def head(text, n) when is_binary(text) and n >= 0 do\n    text |> String.graphemes() |> Enum.take(n) |> Enum.join()\n  end\n\n  @spec size_bytes(String.t()) :: non_neg_integer()\n  def size_bytes(text) when is_binary(text), do: String.length(text)\nend"}
+{"id": "micro.qwen25c3b.dpo.beam.refbadge.stdlib-misuse", "family": "beam", "source": "qwen25c3b_micro_dpo_v1", "weakness": "stdlib-misuse", "origin": "handmade", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `RefBadge` with:\n\n@spec fresh() :: reference()\n    def fresh()\n\nReturn a brand-new unique reference on every call (`make_ref/0`).\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule RefBadge do\n  @spec fresh() :: reference()\n  def fresh, do: make_ref()\nend\n```", "rejected": "defmodule RefBadge do\n  @spec fresh() :: reference()\n  def fresh, do: :erlang.unique_integer()\nend"}
+{"id": "micro.qwen25c3b.dpo.binaries.zigzag16.v3.bin-signed", "family": "binaries", "source": "qwen25c3b_micro_dpo_v1", "weakness": "bin-signed", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `Zigzag1603` with:\n\n@spec encode(-2_147_483_648..2_147_483_647) :: non_neg_integer()\n    def encode(n)\n\n    @spec decode(non_neg_integer()) :: integer()\n    def decode(z)\n\nZigzag mapping used by protobuf varints: `0, -1, 1, -2, 2 ...` map to\n`0, 1, 2, 3, 4 ...`. Use Bitwise shifts.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule Zigzag1603 do\n  @spec encode(-2_147_483_648..2_147_483_647) :: non_neg_integer()\n  def encode(n) when is_integer(n) and n >= -2_147_483_648 and n <= 2_147_483_647 do\n    import Bitwise\n    bxor(n <<< 1, n >>> 31)\n  end\n\n  @spec decode(non_neg_integer()) :: integer()\n  def decode(z) when is_integer(z) and z >= 0 do\n    import Bitwise\n    bxor(z >>> 1, -(z &&& 1))\n  end\nend\n```", "rejected": "defmodule Zigzag1603 do\n  @spec encode(-2_147_483_648..2_147_483_647) :: non_neg_integer()\n  def encode(n) when is_integer(n) and n >= -2_147_483_648 and n <= 2_147_483_647 do\n    import Bitwise\n    abs(n) * 2\n  end\n\n  @spec decode(non_neg_integer()) :: integer()\n  def decode(z) when is_integer(z) and z >= 0 do\n    import Bitwise\n    bxor(z >>> 1, -(z &&& 1))\n  end\nend"}
+{"id": "micro.qwen25c3b.dpo.binaries.s24le.v3.bin-signed", "family": "binaries", "source": "qwen25c3b_micro_dpo_v1", "weakness": "bin-signed", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `S24LE03` with:\n\n@spec encode(-8388608..8388607) :: <<_::24>>\n    def encode(n)\n\n    @spec decode(binary()) :: {:ok, integer()} | :error\n    def decode(bin)\n\nUse bit syntax (`::signed-little-integer-size(24)`). `decode/1` returns\n`:error` unless the binary is exactly 3 byte(s).\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule S24LE03 do\n  @spec encode(-8388608..8388607) :: <<_::24>>\n  def encode(n) when is_integer(n) and n >= -8388608 and n <= 8388607 do\n    <<n::signed-little-integer-size(24)>>\n  end\n\n  @spec decode(binary()) :: {:ok, integer()} | :error\n  def decode(<<n::signed-little-integer-size(24)>>), do: {:ok, n}\n  def decode(_other), do: :error\nend\n```", "rejected": "defmodule S24LE03 do\n  @spec encode(-8388608..8388607) :: <<_::24>>\n  def encode(n) when is_integer(n) and n >= -8388608 and n <= 8388607 do\n    <<n::signed-little-integer-size(24)>>\n  end\n\n  @spec decode(binary()) :: {:ok, integer()} | :error\n  def decode(<<n::unsigned-little-integer-size(24)>>), do: {:ok, n}\n  def decode(_other), do: :error\nend"}
+{"id": "micro.qwen25c3b.dpo.otp.asyncmedian.v2.otp-task-await", "family": "otp", "source": "qwen25c3b_micro_dpo_v1", "weakness": "otp-task-await", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `AsyncMedian02` with:\n\n@spec run(list()) :: term()\n    def run(list)\n\nCompute the median of the list (middle of the sorted list) inside `Task.async`. Await with timeout `5_000` and return the\nresult. Do not use `spawn`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule AsyncMedian02 do\n  @spec run(list()) :: term()\n  def run(list) when is_list(list) do\n    task = Task.async(fn -> Enum.sort(list) |> then(&Enum.at(&1, div(length(&1), 2))) end)\n    Task.await(task, 5_000)\n  end\nend\n```", "rejected": "defmodule AsyncMedian02 do\n  @spec run(list()) :: term()\n  def run(list) when is_list(list) do\n    Task.async(fn -> Enum.sort(list) |> then(&Enum.at(&1, div(length(&1), 2))) end)\n  end\nend"}
+{"id": "micro.qwen25c3b.dpo.beam.pdflag.v3.persistent-term", "family": "beam", "source": "qwen25c3b_micro_dpo_v1", "weakness": "persistent-term", "origin": "handmade", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `ProcFlag03` with:\n\n@spec put(term()) :: :ok\n    def put(value)\n\n    @spec get() :: {:ok, term()} | :error\n    def get()\n\n    @spec clear() :: :ok\n    def clear()\n\nPer-process flag stored in the PROCESS DICTIONARY under a module-specific\nkey (`Process.put/2`). Absent means `:error`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule ProcFlag03 do\n  @key :pdflag_value\n\n  @spec put(term()) :: :ok\n  def put(value) do\n    Process.put(@key, value)\n    :ok\n  end\n\n  @spec get() :: {:ok, term()} | :error\n  def get do\n    case Process.get(@key) do\n      nil -> :error\n      value -> {:ok, value}\n    end\n  end\n\n  @spec clear() :: :ok\n  def clear do\n    Process.delete(@key)\n    :ok\n  end\nend\n```", "rejected": "defmodule ProcFlag03 do\n  @key {__MODULE__, :pdflag_value}\n\n  @spec put(term()) :: :ok\n  def put(value) do\n    :persistent_term.put(@key, value)\n    :ok\n  end\n\n  @spec get() :: {:ok, term()} | :error\n  def get do\n    case :persistent_term.get(@key, :absent) do\n      :absent -> :error\n      value -> {:ok, value}\n    end\n  end\n\n  @spec clear() :: :ok\n  def clear do\n    :persistent_term.erase(@key)\n    :ok\n  end\nend"}
+{"id": "micro.qwen25c3b.dpo.core.guardband.v2.fn-guard", "family": "core", "source": "qwen25c3b_micro_dpo_v1", "weakness": "fn-guard", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `GuardBand02` with:\n\n@spec band(integer()) :: :low | :mid | :high | :out\n    def band(n)\n\nDefine `defguard is_band/1` (integer 0..100). Values below 34 are `:low`,\nbelow 67 `:mid`, within range otherwise `:high`, everything else `:out`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule GuardBand02 do\n  defguard is_band(n) when is_integer(n) and n >= 0 and n <= 100\n\n  @spec band(integer()) :: :low | :mid | :high | :out\n  def band(n) when is_band(n) and n < 34, do: :low\n  def band(n) when is_band(n) and n < 67, do: :mid\n  def band(n) when is_band(n), do: :high\n  def band(_n), do: :out\nend\n```", "rejected": "defmodule GuardBand02 do\n  @spec band(integer()) :: :low | :mid | :high | :out\n  def band(n) do\n    classifier = fn\n      x when is_integer(x), acc when x in 0..100 -> classify(x)\n      _x, _acc -> :out\n    end\n\n    classifier.(n, :unused)\n  end\n\n  defp classify(n) when n < 34, do: :low\n  defp classify(n) when n < 67, do: :mid\n  defp classify(_n), do: :high\nend"}
+{"id": "micro.qwen25c3b.dpo.otp.notice.v2.otp-cast-call", "family": "otp", "source": "qwen25c3b_micro_dpo_v1", "weakness": "otp-cast-call", "origin": "handmade", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `Notice02` with:\n\n@spec start_link() :: {:ok, pid()}\n    def start_link()\n\n    @spec join(pid(), term()) :: :ok\n    def join(pid, who)\n\n    @spec broadcast(pid(), term()) :: :ok\n    def broadcast(pid, msg)\n\nPub-sub GenServer. `join/2` registers any term (usually a pid). `broadcast/2`\nsends `{:notice, msg}` to every subscriber with `send/2`. Calls use timeout\n`5_000`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule Notice02 do\n  use GenServer\n\n  @timeout 5_000\n\n  @spec start_link() :: {:ok, pid()}\n  def start_link, do: GenServer.start_link(__MODULE__, %{})\n\n  @spec join(pid(), term()) :: :ok\n  def join(pid, who), do: GenServer.call(pid, {:join, who}, @timeout)\n\n  @spec broadcast(pid(), term()) :: :ok\n  def broadcast(pid, msg), do: GenServer.call(pid, {:broadcast, msg}, @timeout)\n\n  @impl true\n  def init(subscribers), do: {:ok, subscribers}\n\n  @impl true\n  def handle_call({:join, who}, _from, subscribers),\n    do: {:reply, :ok, Map.put(subscribers, who, true)}\n\n  def handle_call({:broadcast, msg}, _from, subscribers) do\n    Enum.each(Map.keys(subscribers), fn who -> send(who, {:notice, msg}) end)\n    {:reply, :ok, subscribers}\n  end\nend\n```", "rejected": "defmodule Notice02 do\n  use GenServer\n\n  @timeout 5_000\n\n  @spec start_link() :: {:ok, pid()}\n  def start_link, do: GenServer.start_link(__MODULE__, %{})\n\n  @spec join(pid(), term()) :: :ok\n  def join(pid, who), do: GenServer.call(pid, {:join, who}, @timeout)\n\n  @spec broadcast(pid(), term()) :: :ok\n  def broadcast(pid, msg), do: GenServer.cast(pid, {:broadcast, msg})\n\n  @impl true\n  def init(subscribers), do: {:ok, subscribers}\n\n  @impl true\n  def handle_call({:join, who}, _from, subscribers),\n    do: {:reply, :ok, Map.put(subscribers, who, true)}\n\n  def handle_cast({:broadcast, msg}, subscribers) do\n    Enum.each(Map.keys(subscribers), fn who -> send(who, {:notice, msg}) end)\n    {:noreply, subscribers}\n  end\nend"}
+{"id": "micro.qwen25c3b.dpo.binaries.u64be.v3.bin-endian", "family": "binaries", "source": "qwen25c3b_micro_dpo_v1", "weakness": "bin-endian", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `U64BE03` with:\n\n@spec encode(0..18446744073709551615) :: <<_::64>>\n    def encode(n)\n\n    @spec decode(binary()) :: {:ok, integer()} | :error\n    def decode(bin)\n\nUse bit syntax (`::unsigned-big-integer-size(64)`). `decode/1` returns\n`:error` unless the binary is exactly 8 byte(s).\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule U64BE03 do\n  @spec encode(0..18446744073709551615) :: <<_::64>>\n  def encode(n) when is_integer(n) and n >= 0 and n <= 18446744073709551615 do\n    <<n::unsigned-big-integer-size(64)>>\n  end\n\n  @spec decode(binary()) :: {:ok, integer()} | :error\n  def decode(<<n::unsigned-big-integer-size(64)>>), do: {:ok, n}\n  def decode(_other), do: :error\nend\n```", "rejected": "defmodule U64BE03 do\n  @spec encode(0..18446744073709551615) :: <<_::64>>\n  def encode(n) when is_integer(n) and n >= 0 and n <= 18446744073709551615 do\n    <<n::unsigned-big-integer-size(64)>>\n  end\n\n  @spec decode(binary()) :: {:ok, integer()} | :error\n  def decode(<<n::unsigned-little-integer-size(64)>>), do: {:ok, n}\n  def decode(_other), do: :error\nend"}
+{"id": "micro.qwen25c3b.dpo.binaries.s16be.v3.bin-endian", "family": "binaries", "source": "qwen25c3b_micro_dpo_v1", "weakness": "bin-endian", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `S16BE03` with:\n\n@spec encode(-32768..32767) :: <<_::16>>\n    def encode(n)\n\n    @spec decode(binary()) :: {:ok, integer()} | :error\n    def decode(bin)\n\nUse bit syntax (`::signed-big-integer-size(16)`). `decode/1` returns\n`:error` unless the binary is exactly 2 byte(s).\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule S16BE03 do\n  @spec encode(-32768..32767) :: <<_::16>>\n  def encode(n) when is_integer(n) and n >= -32768 and n <= 32767 do\n    <<n::signed-big-integer-size(16)>>\n  end\n\n  @spec decode(binary()) :: {:ok, integer()} | :error\n  def decode(<<n::signed-big-integer-size(16)>>), do: {:ok, n}\n  def decode(_other), do: :error\nend\n```", "rejected": "defmodule S16BE03 do\n  @spec encode(-32768..32767) :: <<_::16>>\n  def encode(n) when is_integer(n) and n >= -32768 and n <= 32767 do\n    <<n::signed-big-integer-size(16)>>\n  end\n\n  @spec decode(binary()) :: {:ok, integer()} | :error\n  def decode(<<n::signed-little-integer-size(16)>>), do: {:ok, n}\n  def decode(_other), do: :error\nend"}
+{"id": "micro.qwen25c3b.dpo.otp.rollcall.otp-cast-call", "family": "otp", "source": "qwen25c3b_micro_dpo_v1", "weakness": "otp-cast-call", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `RollCall` with:\n\n@spec start_link() :: {:ok, pid()}\n    def start_link()\n\n    @spec arrive(pid(), term()) :: :ok\n    def arrive(pid, who)\n\n    @spec present?(pid(), term()) :: boolean()\n    def present?(pid, who)\n\n    @spec count(pid()) :: non_neg_integer()\n    def count(pid)\n\nAgent-backed set of arrivals.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule RollCall do\n  @spec start_link() :: {:ok, pid()}\n  def start_link, do: Agent.start_link(fn -> MapSet.new() end)\n\n  @spec arrive(pid(), term()) :: :ok\n  def arrive(pid, who), do: Agent.update(pid, &MapSet.put(&1, who))\n\n  @spec present?(pid(), term()) :: boolean()\n  def present?(pid, who), do: Agent.get(pid, &MapSet.member?(&1, who))\n\n  @spec count(pid()) :: non_neg_integer()\n  def count(pid), do: Agent.get(pid, &MapSet.size(&1))\nend\n```", "rejected": "defmodule RollCall do\n  @spec start_link() :: {:ok, pid()}\n  def start_link, do: Agent.start_link(fn -> MapSet.new() end)\n\n  @spec arrive(pid(), term()) :: :ok\n  def arrive(pid, who), do: Agent.update(pid, &MapSet.put(&1, who))\n\n  @spec present?(pid(), term()) :: boolean()\n  def present?(pid, who), do: Agent.get(pid, &Map.get(&1, who, false))\n\n  @spec count(pid()) :: non_neg_integer()\n  def count(pid), do: Agent.get(pid, &MapSet.size(&1))\nend"}
+{"id": "micro.qwen25c3b.dpo.errors.parsepair.v3.err-with-else", "family": "errors", "source": "qwen25c3b_micro_dpo_v1", "weakness": "err-with-else", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `ParsePairStrict03` with:\n\n@spec run(String.t()) :: {:ok, {integer(), integer()}} | {:error, :bad_pair}\n    def run(text)\n\n`\"a>b\"` with whole integers on both sides (trim whitespace). Use `with`.\nAnything else is `{:error, :bad_pair}`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule ParsePairStrict03 do\n  @spec run(String.t()) :: {:ok, {integer(), integer()}} | {:error, :bad_pair}\n  def run(text) when is_binary(text) do\n    with [left, right] <- String.split(text, \">\", parts: 2),\n         {a, \"\"} <- Integer.parse(String.trim(left)),\n         {b, \"\"} <- Integer.parse(String.trim(right)) do\n      {:ok, {a, b}}\n    else\n      _other -> {:error, :bad_pair}\n    end\n  end\nend\n```", "rejected": "defmodule ParsePairStrict03 do\n  @spec run(String.t()) :: {:ok, {integer(), integer()}} | {:error, :bad_pair}\n  def run(text) when is_binary(text) do\n    with [left, right] <- String.split(text, \">\", parts: 2),\n         {a, \"\"} <- Integer.parse(String.trim(left)),\n         {b, \"\"} <- Integer.parse(String.trim(right)) do\n      {:ok, {a, b}}\nend\n  end\nend"}
+{"id": "micro.qwen25c3b.dpo.otp.selectrecv.v2.err-with-else", "family": "otp", "source": "qwen25c3b_micro_dpo_v1", "weakness": "err-with-else", "origin": "handmade", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `SelectRecv02` with:\n\n@spec wait_for_done(non_neg_integer()) :: integer() | :timeout\n    def wait_for_done(ticks)\n\nFirst send `{:tick, n}` for n in 1..ticks to SELF, then `{:done, ticks * 10}`.\nThen selectively receive ONLY the `{:done, total}` message (skipping stale\nticks) and return `total`. Guard with `after 1_000`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule SelectRecv02 do\n  @spec wait_for_done(non_neg_integer()) :: integer() | :timeout\n  def wait_for_done(ticks) when is_integer(ticks) and ticks >= 0 do\n    for n <- 1..ticks, do: send(self(), {:tick, n})\n    send(self(), {:done, ticks * 10})\n\n    receive do\n      {:done, total} -> total\n    after\n      1_000 -> :timeout\n    end\n  end\nend\n```", "rejected": "defmodule SelectRecv02 do\n  @spec wait_for_done(non_neg_integer()) :: integer() | :timeout\n  def wait_for_done(ticks) when is_integer(ticks) and ticks >= 0 do\n    for n <- 1..ticks, do: send(self(), {:tick, n})\n    send(self(), {:done, ticks * 10})\n\n    receive do\n      {:done, total} -> total\n      {:tick, n} -> n\n    after\n      1_000 -> :timeout\n    end\n  end\nend"}
+{"id": "micro.qwen25c3b.dpo.beam.multibag.v2.ets-api", "family": "beam", "source": "qwen25c3b_micro_dpo_v1", "weakness": "ets-api", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `MultiBag02` with:\n\n@spec new() :: :ets.table()\n    def new()\n\n    @spec add(:ets.table(), term(), term()) :: true\n    def add(table, key, value)\n\n    @spec members(:ets.table(), term()) :: [term()]\n    def members(table, key)\n\nA `:bag` ETS table: repeated `add/3` calls with the same key accumulate.\n`members/1` returns the stored values sorted.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule MultiBag02 do\n  @spec new() :: :ets.table()\n  def new, do: :ets.new(__MODULE__, [:bag, :public])\n\n  @spec add(:ets.table(), term(), term()) :: true\n  def add(table, key, value), do: :ets.insert(table, {key, value})\n\n  @spec members(:ets.table(), term()) :: [term()]\n  def members(table, key) do\n    table |> :ets.lookup(key) |> Enum.map(&elem(&1, 1)) |> Enum.sort()\n  end\nend\n```", "rejected": "defmodule MultiBag02 do\n  @spec new() :: :ets.table()\n  def new, do: :ets.new(__MODULE__, [:set, :public])\n\n  @spec add(:ets.table(), term(), term()) :: true\n  def add(table, key, value), do: :ets.insert(table, {key, value})\n\n  @spec members(:ets.table(), term()) :: [term()]\n  def members(table, key) do\n    table |> :ets.lookup(key) |> Enum.map(&elem(&1, 1)) |> Enum.sort()\n  end\nend"}
+{"id": "micro.qwen25c3b.dpo.binaries.leb128.v3.bin-size-guard", "family": "binaries", "source": "qwen25c3b_micro_dpo_v1", "weakness": "bin-size-guard", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `Leb12803` with:\n\n@spec decode(binary()) :: {:ok, {non_neg_integer(), binary()}} | :error\n    def decode(bin)\n\nDecode an unsigned little-endian base-128 varint. Each byte contributes its\nlow 7 bits; bit 7 set means another byte follows. Return the value and the\nremaining bytes. More than 5 continuation bytes is `:error`, as is input that\nends mid-varint.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule Leb12803 do\n  @spec decode(binary()) :: {:ok, {non_neg_integer(), binary()}} | :error\n  def decode(bin) when is_binary(bin), do: dec(bin, 0, 0)\n\n  defp dec(_rest, _acc, 5), do: :error\n\n  defp dec(<<>>, _acc, _count), do: :error\n\n  defp dec(<<byte, rest::binary>>, acc, count) do\n    import Bitwise\n    next = acc + ((byte &&& 0x7F) <<< (7 * count))\n\n    if (byte &&& 0x80) == 0 do\n      {:ok, {next, rest}}\n    else\n      dec(rest, next, count + 1)\n    end\n  end\nend\n```", "rejected": "defmodule Leb12803 do\n  @spec decode(binary()) :: {:ok, {non_neg_integer(), binary()}} | :error\n  def decode(bin) when is_binary(bin), do: dec(bin, 0, 0)\n\n  defp dec(<<>>, _acc, _count), do: :error\n\n  defp dec(<<byte, rest::binary>>, acc, count) do\n    import Bitwise\n    next = acc + ((byte &&& 0x7F) <<< (7 * count))\n\n    if (byte &&& 0x80) == 0 do\n      {:ok, {next, rest}}\n    else\n      dec(rest, next, count + 1)\n    end\n  end\nend"}
+{"id": "micro.qwen25c3b.dpo.otp.asyncsumsq.v3.otp-task-await", "family": "otp", "source": "qwen25c3b_micro_dpo_v1", "weakness": "otp-task-await", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `AsyncSumSq03` with:\n\n@spec run(list()) :: term()\n    def run(list)\n\nCompute the sum of squares of the integers inside `Task.async`. Await with timeout `5_000` and return the\nresult. Do not use `spawn`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule AsyncSumSq03 do\n  @spec run(list()) :: term()\n  def run(list) when is_list(list) do\n    task = Task.async(fn -> list |> Enum.map(&(&1 * &1)) |> Enum.sum() end)\n    Task.await(task, 5_000)\n  end\nend\n```", "rejected": "defmodule AsyncSumSq03 do\n  @spec run(list()) :: term()\n  def run(list) when is_list(list) do\n    Task.async(fn -> list |> Enum.map(&(&1 * &1)) |> Enum.sum() end)\n  end\nend"}
+{"id": "micro.qwen25c3b.dpo.otp.notice.otp-timeout", "family": "otp", "source": "qwen25c3b_micro_dpo_v1", "weakness": "otp-timeout", "origin": "handmade", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `Notice` with:\n\n@spec start_link() :: {:ok, pid()}\n    def start_link()\n\n    @spec join(pid(), term()) :: :ok\n    def join(pid, who)\n\n    @spec broadcast(pid(), term()) :: :ok\n    def broadcast(pid, msg)\n\nPub-sub GenServer. `join/2` registers any term (usually a pid). `broadcast/2`\nsends `{:notice, msg}` to every subscriber with `send/2`. Calls use timeout\n`5_000`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule Notice do\n  use GenServer\n\n  @timeout 5_000\n\n  @spec start_link() :: {:ok, pid()}\n  def start_link, do: GenServer.start_link(__MODULE__, %{})\n\n  @spec join(pid(), term()) :: :ok\n  def join(pid, who), do: GenServer.call(pid, {:join, who}, @timeout)\n\n  @spec broadcast(pid(), term()) :: :ok\n  def broadcast(pid, msg), do: GenServer.call(pid, {:broadcast, msg}, @timeout)\n\n  @impl true\n  def init(subscribers), do: {:ok, subscribers}\n\n  @impl true\n  def handle_call({:join, who}, _from, subscribers),\n    do: {:reply, :ok, Map.put(subscribers, who, true)}\n\n  def handle_call({:broadcast, msg}, _from, subscribers) do\n    Enum.each(Map.keys(subscribers), fn who -> send(who, {:notice, msg}) end)\n    {:reply, :ok, subscribers}\n  end\nend\n```", "rejected": "defmodule Notice do\n  use GenServer\n\n  @spec start_link() :: {:ok, pid()}\n  def start_link, do: GenServer.start_link(__MODULE__, %{})\n\n  @spec join(pid(), term()) :: :ok\n  def join(pid, who), do: GenServer.call(pid, {:join, who})\n\n  @spec broadcast(pid(), term()) :: :ok\n  def broadcast(pid, msg), do: GenServer.call(pid, {:broadcast, msg})\n\n  @impl true\n  def init(subscribers), do: {:ok, subscribers}\n\n  @impl true\n  def handle_call({:join, who}, _from, subscribers),\n    do: {:reply, :ok, Map.put(subscribers, who, true)}\n\n  def handle_call({:broadcast, msg}, _from, subscribers) do\n    Enum.each(Map.keys(subscribers), fn who -> send(who, {:notice, msg}) end)\n    {:reply, :ok, subscribers}\n  end\nend"}
+{"id": "micro.qwen25c3b.dpo.binaries.zigzag16.v2.bin-bitwise", "family": "binaries", "source": "qwen25c3b_micro_dpo_v1", "weakness": "bin-bitwise", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `Zigzag1602` with:\n\n@spec encode(-2_147_483_648..2_147_483_647) :: non_neg_integer()\n    def encode(n)\n\n    @spec decode(non_neg_integer()) :: integer()\n    def decode(z)\n\nZigzag mapping used by protobuf varints: `0, -1, 1, -2, 2 ...` map to\n`0, 1, 2, 3, 4 ...`. Use Bitwise shifts.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule Zigzag1602 do\n  @spec encode(-2_147_483_648..2_147_483_647) :: non_neg_integer()\n  def encode(n) when is_integer(n) and n >= -2_147_483_648 and n <= 2_147_483_647 do\n    import Bitwise\n    bxor(n <<< 1, n >>> 31)\n  end\n\n  @spec decode(non_neg_integer()) :: integer()\n  def decode(z) when is_integer(z) and z >= 0 do\n    import Bitwise\n    bxor(z >>> 1, -(z &&& 1))\n  end\nend\n```", "rejected": "defmodule Zigzag1602 do\n  @spec encode(-2_147_483_648..2_147_483_647) :: non_neg_integer()\n  def encode(n) when is_integer(n) and n >= -2_147_483_648 and n <= 2_147_483_647 do\n    import Bitwise\n    bxor(n <<< 1, n >>> 31)\n  end\n\n  @spec decode(non_neg_integer()) :: integer()\n  def decode(z) when is_integer(z) and z >= 0 do\n    import Bitwise\n    div(z, 2) * (if rem(z, 2) == 0, do: 1, else: -1)\n  end\nend"}
+{"id": "micro.qwen25c3b.dpo.otp.drainqueue.v3.otp-timeout", "family": "otp", "source": "qwen25c3b_micro_dpo_v1", "weakness": "otp-timeout", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `DrainQueue03` with:\n\n@spec start_link() :: {:ok, pid()}\n    def start_link()\n\n    @spec push(pid(), term()) :: :ok\n    def push(pid, item)\n\n    @spec pull(pid()) :: {:ok, term()} | :empty\n    def pull(pid)\n\n    @spec size(pid()) :: non_neg_integer()\n    def size(pid)\n\nFIFO GenServer queue. Calls use timeout `5_000`; empty pulls are `:empty`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule DrainQueue03 do\n  use GenServer\n\n  @timeout 5_000\n\n  @spec start_link() :: {:ok, pid()}\n  def start_link, do: GenServer.start_link(__MODULE__, :queue.new())\n\n  @spec push(pid(), term()) :: :ok\n  def push(pid, item), do: GenServer.call(pid, {:push, item}, @timeout)\n\n  @spec pull(pid()) :: {:ok, term()} | :empty\n  def pull(pid), do: GenServer.call(pid, :pull, @timeout)\n\n  @spec size(pid()) :: non_neg_integer()\n  def size(pid), do: GenServer.call(pid, :size, @timeout)\n\n  @impl true\n  def init(q), do: {:ok, q}\n\n  @impl true\n  def handle_call({:push, item}, _from, q), do: {:reply, :ok, :queue.in(item, q)}\n\n  def handle_call(:pull, _from, q) do\n    case :queue.out(q) do\n      {{:value, item}, rest} -> {:reply, {:ok, item}, rest}\n      {:empty, rest} -> {:reply, :empty, rest}\n    end\n  end\n\n  def handle_call(:size, _from, q), do: {:reply, :queue.len(q), q}\nend\n```", "rejected": "defmodule DrainQueue03 do\n  use GenServer\n\n  @timeout 5_000\n\n  @spec start_link() :: {:ok, pid()}\n  def start_link, do: GenServer.start_link(__MODULE__, :queue.new())\n\n  @spec push(pid(), term()) :: :ok\n  def push(pid, item), do: GenServer.call(pid, {:push, item})\n\n  @spec pull(pid()) :: {:ok, term()} | :empty\n  def pull(pid), do: GenServer.call(pid, :pull)\n\n  @spec size(pid()) :: non_neg_integer()\n  def size(pid), do: GenServer.call(pid, :size)\n\n  @impl true\n  def init(q), do: {:ok, q}\n\n  @impl true\n  def handle_call({:push, item}, _from, q), do: {:reply, :ok, :queue.in(item, q)}\n\n  def handle_call(:pull, _from, q) do\n    case :queue.out(q) do\n      {{:value, item}, rest} -> {:reply, {:ok, item}, rest}\n      {:empty, rest} -> {:reply, :empty, rest}\n    end\n  end\n\n  def handle_call(:size, _from, q), do: {:reply, :queue.len(q), q}\nend"}
+{"id": "micro.qwen25c3b.dpo.binaries.leb128.bin-bitwise", "family": "binaries", "source": "qwen25c3b_micro_dpo_v1", "weakness": "bin-bitwise", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-sft2"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `Leb128` with:\n\n@spec decode(binary()) :: {:ok, {non_neg_integer(), binary()}} | :error\n    def decode(bin)\n\nDecode an unsigned little-endian base-128 varint. Each byte contributes its\nlow 7 bits; bit 7 set means another byte follows. Return the value and the\nremaining bytes. More than 5 continuation bytes is `:error`, as is input that\nends mid-varint.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule Leb128 do\n  @spec decode(binary()) :: {:ok, {non_neg_integer(), binary()}} | :error\n  def decode(bin) when is_binary(bin), do: dec(bin, 0, 0)\n\n  defp dec(_rest, _acc, 5), do: :error\n\n  defp dec(<<>>, _acc, _count), do: :error\n\n  defp dec(<<byte, rest::binary>>, acc, count) do\n    import Bitwise\n    next = acc + ((byte &&& 0x7F) <<< (7 * count))\n\n    if (byte &&& 0x80) == 0 do\n      {:ok, {next, rest}}\n    else\n      dec(rest, next, count + 1)\n    end\n  end\nend\n```", "rejected": "defmodule Leb128 do\n  @spec decode(binary()) :: {:ok, {non_neg_integer(), binary()}} | :error\n  def decode(bin) when is_binary(bin), do: dec(bin, 0, 0)\n\n  defp dec(_rest, _acc, 5), do: :error\n\n  defp dec(<<>>, _acc, _count), do: :error\n\n  defp dec(<<byte, rest::binary>>, acc, count) do\n    import Bitwise\n    next = acc + ((byte &&& 0xFF) <<< (7 * count))\n\n    if (byte &&& 0x80) == 0 do\n      {:ok, {next, rest}}\n    else\n      dec(rest, next, count + 1)\n    end\n  end\nend"}

data/onpolicy/qwen25c3b_micro_round11_kto.jsonl ADDED Viewed

	@@ -0,0 +1,34 @@

+{"id": "round11.qwen25c3b.core.head_or_fallback.chosen", "family": "core", "source": "qwen25c3b_micro_round11_kto", "weakness": "pattern-match-empty-case", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `HeadFallback.first/2`.\n\nReturn the first element of a non-empty list, or the supplied fallback for an\nempty list. Use function clauses and keep the fallback term unchanged.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule HeadFallback do\n  @spec first([term()], term()) :: term()\n  def first([head | _tail], _fallback), do: head\n  def first([], fallback), do: fallback\nend\n```"}], "label": true}
+{"id": "round11.qwen25c3b.core.head_or_fallback.rejected", "family": "core", "source": "qwen25c3b_micro_round11_kto", "weakness": "pattern-match-empty-case", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `HeadFallback.first/2`.\n\nReturn the first element of a non-empty list, or the supplied fallback for an\nempty list. Use function clauses and keep the fallback term unchanged.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule HeadFallback do\n  @spec first([term()], term()) :: term()\n  def first(values, _fallback), do: Enum.at(values, 0, nil)\nend\n```"}], "label": false}
+{"id": "round11.qwen25c3b.core.guard_window.chosen", "family": "core", "source": "qwen25c3b_micro_round11_kto", "weakness": "inclusive-guard-boundary", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `GuardWindow.inside?/3`.\n\nReturn `true` when an integer value is between the integer lower and upper\nbounds, inclusive. Return `false` for a value outside the interval. Express\nthe contract with a guard and handle an invalid interval as `false`.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule GuardWindow do\n  @spec inside?(integer(), integer(), integer()) :: boolean()\n  def inside?(value, lower, upper)\n      when is_integer(value) and is_integer(lower) and is_integer(upper) and lower <= upper,\n      do: value >= lower and value <= upper\n\n  def inside?(_value, _lower, _upper), do: false\nend\n```"}], "label": true}
+{"id": "round11.qwen25c3b.core.guard_window.rejected", "family": "core", "source": "qwen25c3b_micro_round11_kto", "weakness": "inclusive-guard-boundary", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `GuardWindow.inside?/3`.\n\nReturn `true` when an integer value is between the integer lower and upper\nbounds, inclusive. Return `false` for a value outside the interval. Express\nthe contract with a guard and handle an invalid interval as `false`.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule GuardWindow do\n  @spec inside?(integer(), integer(), integer()) :: boolean()\n  def inside?(value, lower, upper) when is_integer(value) and is_integer(lower) and is_integer(upper),\n    do: value > lower and value < upper\n\n  def inside?(_value, _lower, _upper), do: false\nend\n```"}], "label": false}
+{"id": "round11.qwen25c3b.collections.reduce_summary.chosen", "family": "collections", "source": "qwen25c3b_micro_round11_kto", "weakness": "reduce-nil-maximum", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `ReduceSummary.run/1`.\n\nFor a list of integers, return `{sum, maximum}` using one `Enum.reduce/3`.\nThe maximum is `nil` for an empty list, and negative values must remain\nnegative rather than being compared with a zero sentinel.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule ReduceSummary do\n  @spec run([integer()]) :: {integer(), integer() | nil}\n  def run(values) when is_list(values) do\n    Enum.reduce(values, {0, nil}, fn value, {sum, maximum} ->\n      next_maximum =\n        if is_nil(maximum) or value > maximum do\n          value\n        else\n          maximum\n        end\n\n      {sum + value, next_maximum}\n    end)\n  end\nend\n```"}], "label": true}
+{"id": "round11.qwen25c3b.collections.reduce_summary.rejected", "family": "collections", "source": "qwen25c3b_micro_round11_kto", "weakness": "reduce-nil-maximum", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `ReduceSummary.run/1`.\n\nFor a list of integers, return `{sum, maximum}` using one `Enum.reduce/3`.\nThe maximum is `nil` for an empty list, and negative values must remain\nnegative rather than being compared with a zero sentinel.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule ReduceSummary do\n  @spec run([integer()]) :: {integer(), integer() | nil}\n  def run(values) when is_list(values) do\n    Enum.reduce(values, {0, 0}, fn value, {sum, maximum} ->\n      {sum + value, max(maximum, value)}\n    end)\n  end\nend\n```"}], "label": false}
+{"id": "round11.qwen25c3b.collections.partition_order.chosen", "family": "collections", "source": "qwen25c3b_micro_round11_kto", "weakness": "reduce-order-preservation", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `PartitionOrder.split/2`.\n\nPartition a list into `%{keep: list, skip: list}` according to a one-argument\npredicate. Preserve the original order in both lists and use an immutable\nreduce accumulator.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule PartitionOrder do\n  @spec split([term()], (term() -> boolean())) :: %{keep: [term()], skip: [term()]}\n  def split(values, predicate) when is_list(values) and is_function(predicate, 1) do\n    {keep, skip} =\n      Enum.reduce(values, {[], []}, fn value, {keep, skip} ->\n        if predicate.(value) do\n          {[value | keep], skip}\n        else\n          {keep, [value | skip]}\n        end\n      end)\n\n    %{keep: Enum.reverse(keep), skip: Enum.reverse(skip)}\n  end\nend\n```"}], "label": true}
+{"id": "round11.qwen25c3b.collections.partition_order.rejected", "family": "collections", "source": "qwen25c3b_micro_round11_kto", "weakness": "reduce-order-preservation", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `PartitionOrder.split/2`.\n\nPartition a list into `%{keep: list, skip: list}` according to a one-argument\npredicate. Preserve the original order in both lists and use an immutable\nreduce accumulator.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule PartitionOrder do\n  @spec split([term()], (term() -> boolean())) :: %{keep: [term()], skip: [term()]}\n  def split(values, predicate) when is_list(values) and is_function(predicate, 1) do\n    Enum.reduce(values, %{keep: [], skip: []}, fn value, result ->\n      key = if predicate.(value), do: :keep, else: :skip\n      Map.update!(result, key, &[value | &1])\n    end)\n  end\nend\n```"}], "label": false}
+{"id": "round11.qwen25c3b.binaries.big_frame.chosen", "family": "binaries", "source": "qwen25c3b_micro_round11_kto", "weakness": "exact-big-endian-frame", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `BigFrame.pack/2` and `BigFrame.unpack/1`.\n\nPack a one-byte tag, a 16-bit unsigned big-endian payload length, and the\npayload. Unpack only an exact frame: a short header, short payload, or\ntrailing bytes must return `:error`.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule BigFrame do\n  @spec pack(byte(), binary()) :: binary()\n  def pack(tag, payload) when is_integer(tag) and is_binary(payload) do\n    <<tag, byte_size(payload)::unsigned-big-integer-size(16), payload::binary>>\n  end\n\n  @spec unpack(binary()) :: {:ok, byte(), binary()} | :error\n  def unpack(<<tag, size::unsigned-big-integer-size(16), payload::binary>>) do\n    if byte_size(payload) == size, do: {:ok, tag, payload}, else: :error\n  end\n\n  def unpack(_other), do: :error\nend\n```"}], "label": true}
+{"id": "round11.qwen25c3b.binaries.big_frame.rejected", "family": "binaries", "source": "qwen25c3b_micro_round11_kto", "weakness": "exact-big-endian-frame", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `BigFrame.pack/2` and `BigFrame.unpack/1`.\n\nPack a one-byte tag, a 16-bit unsigned big-endian payload length, and the\npayload. Unpack only an exact frame: a short header, short payload, or\ntrailing bytes must return `:error`.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule BigFrame do\n  @spec pack(byte(), binary()) :: binary()\n  def pack(tag, payload) when is_integer(tag) and is_binary(payload) do\n    <<tag, byte_size(payload)::unsigned-big-integer-size(16), payload::binary>>\n  end\n\n  @spec unpack(binary()) :: {:ok, byte(), binary()} | :error\n  def unpack(<<tag, size::unsigned-little-integer-size(16), payload::binary>>) do\n    if byte_size(payload) >= size, do: {:ok, tag, binary_part(payload, 0, size)}, else: :error\n  end\n\n  def unpack(_other), do: :error\nend\n```"}], "label": false}
+{"id": "round11.qwen25c3b.binaries.nibble_pair.chosen", "family": "binaries", "source": "qwen25c3b_micro_round11_kto", "weakness": "sub-byte-bit-syntax", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `NibblePair.encode/2` and `NibblePair.decode/1`.\n\nEncode two integers from 0 through 15 into one byte, with the first integer\nin the high four bits and the second in the low four bits. Decode exactly one\nbyte into `{high, low}` and return `:error` for every other binary size.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule NibblePair do\n  @spec encode(non_neg_integer(), non_neg_integer()) :: binary()\n  def encode(high, low) when high in 0..15 and low in 0..15 do\n    <<high::4, low::4>>\n  end\n\n  @spec decode(binary()) :: {:ok, {non_neg_integer(), non_neg_integer()}} | :error\n  def decode(<<high::4, low::4>>), do: {:ok, {high, low}}\n  def decode(_other), do: :error\nend\n```"}], "label": true}
+{"id": "round11.qwen25c3b.binaries.nibble_pair.rejected", "family": "binaries", "source": "qwen25c3b_micro_round11_kto", "weakness": "sub-byte-bit-syntax", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `NibblePair.encode/2` and `NibblePair.decode/1`.\n\nEncode two integers from 0 through 15 into one byte, with the first integer\nin the high four bits and the second in the low four bits. Decode exactly one\nbyte into `{high, low}` and return `:error` for every other binary size.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule NibblePair do\n  @spec encode(non_neg_integer(), non_neg_integer()) :: binary()\n  def encode(high, low) when high in 0..15 and low in 0..15, do: <<high, low>>\n\n  @spec decode(binary()) :: {:ok, {non_neg_integer(), non_neg_integer()}} | :error\n  def decode(<<high, low>>), do: {:ok, {high, low}}\n  def decode(_other), do: :error\nend\n```"}], "label": false}
+{"id": "round11.qwen25c3b.errors.strict_number.chosen", "family": "errors", "source": "qwen25c3b_micro_round11_kto", "weakness": "tagged-strict-parse", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `StrictNumber.parse/1`.\n\nReturn `{:ok, integer}` only when `Integer.parse/1` consumes the complete\nstring. Return `{:error, :invalid}` for an empty string, partial number, or\nnon-number without raising. Use a tagged `with` expression.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule StrictNumber do\n  @spec parse(String.t()) :: {:ok, integer()} | {:error, :invalid}\n  def parse(text) when is_binary(text) do\n    with {value, \"\"} <- Integer.parse(text) do\n      {:ok, value}\n    else\n      _ -> {:error, :invalid}\n    end\n  end\nend\n```"}], "label": true}
+{"id": "round11.qwen25c3b.errors.strict_number.rejected", "family": "errors", "source": "qwen25c3b_micro_round11_kto", "weakness": "tagged-strict-parse", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `StrictNumber.parse/1`.\n\nReturn `{:ok, integer}` only when `Integer.parse/1` consumes the complete\nstring. Return `{:error, :invalid}` for an empty string, partial number, or\nnon-number without raising. Use a tagged `with` expression.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule StrictNumber do\n  @spec parse(String.t()) :: {:ok, integer()} | {:error, :invalid}\n  def parse(text) when is_binary(text), do: {:ok, String.to_integer(text)}\nend\n```"}], "label": false}
+{"id": "round11.qwen25c3b.errors.rescue_cleanup.chosen", "family": "errors", "source": "qwen25c3b_micro_round11_kto", "weakness": "rescue-and-after", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `RescueCleanup.run/2`.\n\nCall a zero-arity `work` function. Return `{:ok, value}` on success, convert a\n`RuntimeError` into `{:error, message}`, and always call the zero-arity\n`cleanup` function. Do not swallow other exception types.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule RescueCleanup do\n  @spec run((() -> term()), (() -> term())) :: {:ok, term()} | {:error, String.t()}\n  def run(work, cleanup) when is_function(work, 0) and is_function(cleanup, 0) do\n    try do\n      {:ok, work.()}\n    rescue\n      error in RuntimeError -> {:error, Exception.message(error)}\n    after\n      cleanup.()\n    end\n  end\nend\n```"}], "label": true}
+{"id": "round11.qwen25c3b.errors.rescue_cleanup.rejected", "family": "errors", "source": "qwen25c3b_micro_round11_kto", "weakness": "rescue-and-after", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `RescueCleanup.run/2`.\n\nCall a zero-arity `work` function. Return `{:ok, value}` on success, convert a\n`RuntimeError` into `{:error, message}`, and always call the zero-arity\n`cleanup` function. Do not swallow other exception types.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule RescueCleanup do\n  @spec run((() -> term()), (() -> term())) :: {:ok, term()} | {:error, String.t()}\n  def run(work, cleanup) when is_function(work, 0) and is_function(cleanup, 0) do\n    try do\n      result = {:ok, work.()}\n      cleanup.()\n      result\n    rescue\n      error in RuntimeError -> {:error, Exception.message(error)}\n    end\n  end\nend\n```"}], "label": false}
+{"id": "round11.qwen25c3b.otp.mailbox.chosen", "family": "otp", "source": "qwen25c3b_micro_round11_kto", "weakness": "genserver-call-state", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `Mailbox.start_link/1`, `Mailbox.push/2`, and `Mailbox.drain/1`.\n\nUse a GenServer whose state is a list. `push/2` must synchronously prepend a\nvalue and return `:ok`; `drain/1` must synchronously return values in insertion\norder and reset the state to an empty list. Both calls must pass an explicit\nmodule timeout.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule Mailbox do\n  use GenServer\n\n  @timeout 1_000\n\n  @spec start_link(term()) :: GenServer.on_start()\n  def start_link(initial), do: GenServer.start_link(__MODULE__, [initial])\n\n  @spec push(pid(), term()) :: :ok\n  def push(pid, value), do: GenServer.call(pid, {:push, value}, @timeout)\n\n  @spec drain(pid()) :: [term()]\n  def drain(pid), do: GenServer.call(pid, :drain, @timeout)\n\n  @impl true\n  def init(values), do: {:ok, values}\n\n  @impl true\n  def handle_call({:push, value}, _from, state), do: {:reply, :ok, [value | state]}\n\n  @impl true\n  def handle_call(:drain, _from, state), do: {:reply, Enum.reverse(state), []}\nend\n```"}], "label": true}
+{"id": "round11.qwen25c3b.otp.mailbox.rejected", "family": "otp", "source": "qwen25c3b_micro_round11_kto", "weakness": "genserver-call-state", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `Mailbox.start_link/1`, `Mailbox.push/2`, and `Mailbox.drain/1`.\n\nUse a GenServer whose state is a list. `push/2` must synchronously prepend a\nvalue and return `:ok`; `drain/1` must synchronously return values in insertion\norder and reset the state to an empty list. Both calls must pass an explicit\nmodule timeout.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule Mailbox do\n  use GenServer\n\n  @timeout 1_000\n\n  def start_link(initial), do: GenServer.start_link(__MODULE__, [initial])\n  def push(pid, value), do: GenServer.cast(pid, {:push, value})\n  def drain(pid), do: GenServer.call(pid, :drain, @timeout)\n\n  @impl true\n  def init(values), do: {:ok, values}\n\n  @impl true\n  def handle_cast({:push, value}, state), do: {:noreply, [value | state]}\n\n  @impl true\n  def handle_call(:drain, _from, state), do: {:reply, state, []}\nend\n```"}], "label": false}
+{"id": "round11.qwen25c3b.otp.supervised_map.chosen", "family": "otp", "source": "qwen25c3b_micro_round11_kto", "weakness": "supervised-task-await", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `SupervisedMap.run/3`.\n\nRun a one-argument function for each value using\n`Task.Supervisor.async_nolink/2`. Await every task with an explicit timeout of\n1_000 milliseconds and return results in input order. Require a supervisor pid\nand a one-argument function.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule SupervisedMap do\n  @timeout 1_000\n\n  @spec run(pid(), [term()], (term() -> term())) :: [term()]\n  def run(supervisor, values, function)\n      when is_pid(supervisor) and is_list(values) and is_function(function, 1) do\n    values\n    |> Enum.map(fn value -> Task.Supervisor.async_nolink(supervisor, fn -> function.(value) end) end)\n    |> Enum.map(&Task.await(&1, @timeout))\n  end\nend\n```"}], "label": true}
+{"id": "round11.qwen25c3b.otp.supervised_map.rejected", "family": "otp", "source": "qwen25c3b_micro_round11_kto", "weakness": "supervised-task-await", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `SupervisedMap.run/3`.\n\nRun a one-argument function for each value using\n`Task.Supervisor.async_nolink/2`. Await every task with an explicit timeout of\n1_000 milliseconds and return results in input order. Require a supervisor pid\nand a one-argument function.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule SupervisedMap do\n  @timeout 1_000\n\n  @spec run(pid(), [term()], (term() -> term())) :: [term()]\n  def run(supervisor, values, function)\n      when is_pid(supervisor) and is_list(values) and is_function(function, 1) do\n    values\n    |> Enum.reverse()\n    |> Enum.map(fn value -> Task.async(fn -> function.(value) end) end)\n    |> Enum.map(&Task.await(&1, @timeout))\n  end\nend\n```"}], "label": false}
+{"id": "round11.qwen25c3b.beam.ets_fetch.chosen", "family": "beam", "source": "qwen25c3b_micro_round11_kto", "weakness": "ets-tagged-lookup", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `EtsFetch.open/0`, `EtsFetch.put/3`, and `EtsFetch.get/2`.\n\nUse an ETS set. `open/0` creates and returns a private table; `put/3` stores a\nkey/value pair and returns `:ok`; `get/2` returns `{:ok, value}` for an\nexisting key and `:error` for a missing key without raising.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule EtsFetch do\n  @spec open() :: :ets.tid()\n  def open, do: :ets.new(:ets_fetch_table, [:set, :private])\n\n  @spec put(:ets.tid(), term(), term()) :: :ok\n  def put(table, key, value) do\n    true = :ets.insert(table, {key, value})\n    :ok\n  end\n\n  @spec get(:ets.tid(), term()) :: {:ok, term()} | :error\n  def get(table, key) do\n    case :ets.lookup(table, key) do\n      [{^key, value}] -> {:ok, value}\n      [] -> :error\n    end\n  end\nend\n```"}], "label": true}
+{"id": "round11.qwen25c3b.beam.ets_fetch.rejected", "family": "beam", "source": "qwen25c3b_micro_round11_kto", "weakness": "ets-tagged-lookup", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `EtsFetch.open/0`, `EtsFetch.put/3`, and `EtsFetch.get/2`.\n\nUse an ETS set. `open/0` creates and returns a private table; `put/3` stores a\nkey/value pair and returns `:ok`; `get/2` returns `{:ok, value}` for an\nexisting key and `:error` for a missing key without raising.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule EtsFetch do\n  @spec open() :: :ets.tid()\n  def open, do: :ets.new(:ets_fetch_table, [:set, :private])\n\n  @spec put(:ets.tid(), term(), term()) :: :ok\n  def put(table, key, value) do\n    true = :ets.insert(table, {key, value})\n    :ok\n  end\n\n  @spec get(:ets.tid(), term()) :: {:ok, term()} | :error\n  def get(table, key), do: {:ok, :ets.lookup_element(table, key, 2)}\nend\n```"}], "label": false}
+{"id": "round11.qwen25c3b.beam.ref_timer.chosen", "family": "beam", "source": "qwen25c3b_micro_round11_kto", "weakness": "process-timer-reference", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `RefTimer.schedule/3`.\n\nSchedule the supplied message to a pid after a non-negative millisecond delay\nwith `Process.send_after/3`, and return the timer reference. Require a pid,\ninteger delay, and any message.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule RefTimer do\n  @spec schedule(pid(), non_neg_integer(), term()) :: reference()\n  def schedule(pid, delay, message) when is_pid(pid) and is_integer(delay) and delay >= 0 do\n    Process.send_after(pid, message, delay)\n  end\nend\n```"}], "label": true}
+{"id": "round11.qwen25c3b.beam.ref_timer.rejected", "family": "beam", "source": "qwen25c3b_micro_round11_kto", "weakness": "process-timer-reference", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `RefTimer.schedule/3`.\n\nSchedule the supplied message to a pid after a non-negative millisecond delay\nwith `Process.send_after/3`, and return the timer reference. Require a pid,\ninteger delay, and any message.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule RefTimer do\n  @spec schedule(pid(), non_neg_integer(), term()) :: reference()\n  def schedule(pid, delay, message) when is_pid(pid) and is_integer(delay) and delay >= 0 do\n    send(pid, message)\n  end\nend\n```"}], "label": false}
+{"id": "round11.qwen25c3b.abstractions.contract_call.chosen", "family": "abstractions", "source": "qwen25c3b_micro_round11_kto", "weakness": "behaviour-contract-arity", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `ContractCall.call/2` and declare its callback.\n\nDeclare `c:render/1` as a callback returning a term, then call that callback\non a provider module passed as the first argument. The call must pass the\nvalue as exactly one argument and return the provider result.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule ContractCall do\n  @callback render(term()) :: term()\n\n  @spec call(module(), term()) :: term()\n  def call(provider, value) when is_atom(provider), do: provider.render(value)\nend\n```"}], "label": true}
+{"id": "round11.qwen25c3b.abstractions.contract_call.rejected", "family": "abstractions", "source": "qwen25c3b_micro_round11_kto", "weakness": "behaviour-contract-arity", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `ContractCall.call/2` and declare its callback.\n\nDeclare `c:render/1` as a callback returning a term, then call that callback\non a provider module passed as the first argument. The call must pass the\nvalue as exactly one argument and return the provider result.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule ContractCall do\n  @callback render(term()) :: term()\n\n  @spec call(module(), term()) :: term()\n  def call(provider, _value) when is_atom(provider), do: provider.render(:ignored)\nend\n```"}], "label": false}
+{"id": "round11.qwen25c3b.abstractions.optional_callback.chosen", "family": "abstractions", "source": "qwen25c3b_micro_round11_kto", "weakness": "optional-callback-default", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `OptionalLabel.label/2`.\n\nCall `provider.label/1` when the provider module exports that one-argument\nfunction; otherwise return the supplied fallback. Check exports without\nraising and preserve the value passed to the provider.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule OptionalLabel do\n  @spec label(module(), term()) :: term()\n  def label(provider, fallback) when is_atom(provider) do\n    if function_exported?(provider, :label, 1) do\n      provider.label(fallback)\n    else\n      fallback\n    end\n  end\nend\n```"}], "label": true}
+{"id": "round11.qwen25c3b.abstractions.optional_callback.rejected", "family": "abstractions", "source": "qwen25c3b_micro_round11_kto", "weakness": "optional-callback-default", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `OptionalLabel.label/2`.\n\nCall `provider.label/1` when the provider module exports that one-argument\nfunction; otherwise return the supplied fallback. Check exports without\nraising and preserve the value passed to the provider.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule OptionalLabel do\n  @spec label(module(), term()) :: term()\n  def label(provider, fallback) when is_atom(provider) do\n    if function_exported?(provider, :label, 0) do\n      provider.label()\n    else\n      fallback\n    end\n  end\nend\n```"}], "label": false}
+{"id": "round11.qwen25c3b.stdlib.query_map.chosen", "family": "stdlib", "source": "qwen25c3b_micro_round11_kto", "weakness": "uri-query-decoding", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `QueryMap.decode/1`.\n\nDecode a URI query string into a map using the standard library. For example,\n`\"name=Ada&role=admin\"` becomes `%{\"name\" => \"Ada\", \"role\" => \"admin\"}`.\nAn empty query must return an empty map.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule QueryMap do\n  @spec decode(String.t()) :: map()\n  def decode(query) when is_binary(query), do: URI.decode_query(query)\nend\n```"}], "label": true}
+{"id": "round11.qwen25c3b.stdlib.query_map.rejected", "family": "stdlib", "source": "qwen25c3b_micro_round11_kto", "weakness": "uri-query-decoding", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `QueryMap.decode/1`.\n\nDecode a URI query string into a map using the standard library. For example,\n`\"name=Ada&role=admin\"` becomes `%{\"name\" => \"Ada\", \"role\" => \"admin\"}`.\nAn empty query must return an empty map.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule QueryMap do\n  @spec decode(String.t()) :: map()\n  def decode(query) when is_binary(query), do: URI.parse(query)\nend\n```"}], "label": false}
+{"id": "round11.qwen25c3b.stdlib.named_capture.chosen", "family": "stdlib", "source": "qwen25c3b_micro_round11_kto", "weakness": "regex-named-capture", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `NamedCapture.user/1`.\n\nExtract a lowercase username after an `@` from a string with a named regular\nexpression capture. Return the captured username as a string, or `:error` if\nthere is no match.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule NamedCapture do\n  @spec user(String.t()) :: String.t() | :error\n  def user(text) when is_binary(text) do\n    case Regex.named_captures(~r/@(?<user>[a-z][a-z0-9_]*)/, text) do\n      %{\"user\" => value} -> value\n      nil -> :error\n    end\n  end\nend\n```"}], "label": true}
+{"id": "round11.qwen25c3b.stdlib.named_capture.rejected", "family": "stdlib", "source": "qwen25c3b_micro_round11_kto", "weakness": "regex-named-capture", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `NamedCapture.user/1`.\n\nExtract a lowercase username after an `@` from a string with a named regular\nexpression capture. Return the captured username as a string, or `:error` if\nthere is no match.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule NamedCapture do\n  @spec user(String.t()) :: String.t() | :error\n  def user(text) when is_binary(text) do\n    case Regex.run(~r/@(?<user>[a-z][a-z0-9_]*)/, text) do\n      [value, _username] -> value\n      nil -> :error\n    end\n  end\nend\n```"}], "label": false}
+{"id": "round11.qwen25c3b.stdlib.date_delta.chosen", "family": "stdlib", "source": "qwen25c3b_micro_round11_kto", "weakness": "date-diff-direction", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `DateDelta.days/2`.\n\nReturn the signed number of calendar days from the first `Date` to the second\n`Date`, using the standard library. The result must be negative when the\nsecond date is earlier.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule DateDelta do\n  @spec days(Date.t(), Date.t()) :: integer()\n  def days(first, second) do\n    Date.diff(second, first)\n  end\nend\n```"}], "label": true}
+{"id": "round11.qwen25c3b.stdlib.date_delta.rejected", "family": "stdlib", "source": "qwen25c3b_micro_round11_kto", "weakness": "date-diff-direction", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"role": "user", "content": "Write `DateDelta.days/2`.\n\nReturn the signed number of calendar days from the first `Date` to the second\n`Date`, using the standard library. The result must be negative when the\nsecond date is earlier.\n\nReply with a single ```elixir fence containing only the requested module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule DateDelta do\n  @spec days(Date.t(), Date.t()) :: non_neg_integer()\n  def days(first, second) do\n    abs(Date.diff(first, second))\n  end\nend\n```"}], "label": false}

data/onpolicy/qwen25c3b_micro_round13_dpo.jsonl ADDED Viewed

	@@ -0,0 +1,17 @@

+{"id": "round13.qwen25c3b.round11.qwen25c3b.abstractions.contract_call", "family": "abstractions", "source": "qwen25c3b_micro_round13_dpo", "weakness": "behaviour-contract-arity", "origin": "fresh-authored-round11-repacked", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "conversations": [{"from": "system", "value": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"from": "user", "value": "Write `ContractCall.call/2` and declare its callback.\n\nDeclare `c:render/1` as a callback returning a term, then call that callback\non a provider module passed as the first argument. The call must pass the\nvalue as exactly one argument and return the provider result.\n\nReply with a single ```elixir fence containing only the requested module."}], "chosen": "```elixir\ndefmodule ContractCall do\n  @callback render(term()) :: term()\n\n  @spec call(module(), term()) :: term()\n  def call(provider, value) when is_atom(provider), do: provider.render(value)\nend\n```", "rejected": "```elixir\ndefmodule ContractCall do\n  @callback render(term()) :: term()\n\n  @spec call(module(), term()) :: term()\n  def call(provider, _value) when is_atom(provider), do: provider.render(:ignored)\nend\n```"}
+{"id": "round13.qwen25c3b.round11.qwen25c3b.abstractions.optional_callback", "family": "abstractions", "source": "qwen25c3b_micro_round13_dpo", "weakness": "optional-callback-default", "origin": "fresh-authored-round11-repacked", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "conversations": [{"from": "system", "value": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"from": "user", "value": "Write `OptionalLabel.label/2`.\n\nCall `provider.label/1` when the provider module exports that one-argument\nfunction; otherwise return the supplied fallback. Check exports without\nraising and preserve the value passed to the provider.\n\nReply with a single ```elixir fence containing only the requested module."}], "chosen": "```elixir\ndefmodule OptionalLabel do\n  @spec label(module(), term()) :: term()\n  def label(provider, fallback) when is_atom(provider) do\n    if function_exported?(provider, :label, 1) do\n      provider.label(fallback)\n    else\n      fallback\n    end\n  end\nend\n```", "rejected": "```elixir\ndefmodule OptionalLabel do\n  @spec label(module(), term()) :: term()\n  def label(provider, fallback) when is_atom(provider) do\n    if function_exported?(provider, :label, 0) do\n      provider.label()\n    else\n      fallback\n    end\n  end\nend\n```"}
+{"id": "round13.qwen25c3b.round11.qwen25c3b.beam.ets_fetch", "family": "beam", "source": "qwen25c3b_micro_round13_dpo", "weakness": "ets-tagged-lookup", "origin": "fresh-authored-round11-repacked", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "conversations": [{"from": "system", "value": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"from": "user", "value": "Write `EtsFetch.open/0`, `EtsFetch.put/3`, and `EtsFetch.get/2`.\n\nUse an ETS set. `open/0` creates and returns a private table; `put/3` stores a\nkey/value pair and returns `:ok`; `get/2` returns `{:ok, value}` for an\nexisting key and `:error` for a missing key without raising.\n\nReply with a single ```elixir fence containing only the requested module."}], "chosen": "```elixir\ndefmodule EtsFetch do\n  @spec open() :: :ets.tid()\n  def open, do: :ets.new(:ets_fetch_table, [:set, :private])\n\n  @spec put(:ets.tid(), term(), term()) :: :ok\n  def put(table, key, value) do\n    true = :ets.insert(table, {key, value})\n    :ok\n  end\n\n  @spec get(:ets.tid(), term()) :: {:ok, term()} | :error\n  def get(table, key) do\n    case :ets.lookup(table, key) do\n      [{^key, value}] -> {:ok, value}\n      [] -> :error\n    end\n  end\nend\n```", "rejected": "```elixir\ndefmodule EtsFetch do\n  @spec open() :: :ets.tid()\n  def open, do: :ets.new(:ets_fetch_table, [:set, :private])\n\n  @spec put(:ets.tid(), term(), term()) :: :ok\n  def put(table, key, value) do\n    true = :ets.insert(table, {key, value})\n    :ok\n  end\n\n  @spec get(:ets.tid(), term()) :: {:ok, term()} | :error\n  def get(table, key), do: {:ok, :ets.lookup_element(table, key, 2)}\nend\n```"}
+{"id": "round13.qwen25c3b.round11.qwen25c3b.beam.ref_timer", "family": "beam", "source": "qwen25c3b_micro_round13_dpo", "weakness": "process-timer-reference", "origin": "fresh-authored-round11-repacked", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "conversations": [{"from": "system", "value": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"from": "user", "value": "Write `RefTimer.schedule/3`.\n\nSchedule the supplied message to a pid after a non-negative millisecond delay\nwith `Process.send_after/3`, and return the timer reference. Require a pid,\ninteger delay, and any message.\n\nReply with a single ```elixir fence containing only the requested module."}], "chosen": "```elixir\ndefmodule RefTimer do\n  @spec schedule(pid(), non_neg_integer(), term()) :: reference()\n  def schedule(pid, delay, message) when is_pid(pid) and is_integer(delay) and delay >= 0 do\n    Process.send_after(pid, message, delay)\n  end\nend\n```", "rejected": "```elixir\ndefmodule RefTimer do\n  @spec schedule(pid(), non_neg_integer(), term()) :: reference()\n  def schedule(pid, delay, message) when is_pid(pid) and is_integer(delay) and delay >= 0 do\n    send(pid, message)\n  end\nend\n```"}
+{"id": "round13.qwen25c3b.round11.qwen25c3b.binaries.big_frame", "family": "binaries", "source": "qwen25c3b_micro_round13_dpo", "weakness": "exact-big-endian-frame", "origin": "fresh-authored-round11-repacked", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "conversations": [{"from": "system", "value": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"from": "user", "value": "Write `BigFrame.pack/2` and `BigFrame.unpack/1`.\n\nPack a one-byte tag, a 16-bit unsigned big-endian payload length, and the\npayload. Unpack only an exact frame: a short header, short payload, or\ntrailing bytes must return `:error`.\n\nReply with a single ```elixir fence containing only the requested module."}], "chosen": "```elixir\ndefmodule BigFrame do\n  @spec pack(byte(), binary()) :: binary()\n  def pack(tag, payload) when is_integer(tag) and is_binary(payload) do\n    <<tag, byte_size(payload)::unsigned-big-integer-size(16), payload::binary>>\n  end\n\n  @spec unpack(binary()) :: {:ok, byte(), binary()} | :error\n  def unpack(<<tag, size::unsigned-big-integer-size(16), payload::binary>>) do\n    if byte_size(payload) == size, do: {:ok, tag, payload}, else: :error\n  end\n\n  def unpack(_other), do: :error\nend\n```", "rejected": "```elixir\ndefmodule BigFrame do\n  @spec pack(byte(), binary()) :: binary()\n  def pack(tag, payload) when is_integer(tag) and is_binary(payload) do\n    <<tag, byte_size(payload)::unsigned-big-integer-size(16), payload::binary>>\n  end\n\n  @spec unpack(binary()) :: {:ok, byte(), binary()} | :error\n  def unpack(<<tag, size::unsigned-little-integer-size(16), payload::binary>>) do\n    if byte_size(payload) >= size, do: {:ok, tag, binary_part(payload, 0, size)}, else: :error\n  end\n\n  def unpack(_other), do: :error\nend\n```"}
+{"id": "round13.qwen25c3b.round11.qwen25c3b.binaries.nibble_pair", "family": "binaries", "source": "qwen25c3b_micro_round13_dpo", "weakness": "sub-byte-bit-syntax", "origin": "fresh-authored-round11-repacked", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "conversations": [{"from": "system", "value": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"from": "user", "value": "Write `NibblePair.encode/2` and `NibblePair.decode/1`.\n\nEncode two integers from 0 through 15 into one byte, with the first integer\nin the high four bits and the second in the low four bits. Decode exactly one\nbyte into `{high, low}` and return `:error` for every other binary size.\n\nReply with a single ```elixir fence containing only the requested module."}], "chosen": "```elixir\ndefmodule NibblePair do\n  @spec encode(non_neg_integer(), non_neg_integer()) :: binary()\n  def encode(high, low) when high in 0..15 and low in 0..15 do\n    <<high::4, low::4>>\n  end\n\n  @spec decode(binary()) :: {:ok, {non_neg_integer(), non_neg_integer()}} | :error\n  def decode(<<high::4, low::4>>), do: {:ok, {high, low}}\n  def decode(_other), do: :error\nend\n```", "rejected": "```elixir\ndefmodule NibblePair do\n  @spec encode(non_neg_integer(), non_neg_integer()) :: binary()\n  def encode(high, low) when high in 0..15 and low in 0..15, do: <<high, low>>\n\n  @spec decode(binary()) :: {:ok, {non_neg_integer(), non_neg_integer()}} | :error\n  def decode(<<high, low>>), do: {:ok, {high, low}}\n  def decode(_other), do: :error\nend\n```"}
+{"id": "round13.qwen25c3b.round11.qwen25c3b.collections.partition_order", "family": "collections", "source": "qwen25c3b_micro_round13_dpo", "weakness": "reduce-order-preservation", "origin": "fresh-authored-round11-repacked", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "conversations": [{"from": "system", "value": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"from": "user", "value": "Write `PartitionOrder.split/2`.\n\nPartition a list into `%{keep: list, skip: list}` according to a one-argument\npredicate. Preserve the original order in both lists and use an immutable\nreduce accumulator.\n\nReply with a single ```elixir fence containing only the requested module."}], "chosen": "```elixir\ndefmodule PartitionOrder do\n  @spec split([term()], (term() -> boolean())) :: %{keep: [term()], skip: [term()]}\n  def split(values, predicate) when is_list(values) and is_function(predicate, 1) do\n    {keep, skip} =\n      Enum.reduce(values, {[], []}, fn value, {keep, skip} ->\n        if predicate.(value) do\n          {[value | keep], skip}\n        else\n          {keep, [value | skip]}\n        end\n      end)\n\n    %{keep: Enum.reverse(keep), skip: Enum.reverse(skip)}\n  end\nend\n```", "rejected": "```elixir\ndefmodule PartitionOrder do\n  @spec split([term()], (term() -> boolean())) :: %{keep: [term()], skip: [term()]}\n  def split(values, predicate) when is_list(values) and is_function(predicate, 1) do\n    Enum.reduce(values, %{keep: [], skip: []}, fn value, result ->\n      key = if predicate.(value), do: :keep, else: :skip\n      Map.update!(result, key, &[value | &1])\n    end)\n  end\nend\n```"}
+{"id": "round13.qwen25c3b.round11.qwen25c3b.collections.reduce_summary", "family": "collections", "source": "qwen25c3b_micro_round13_dpo", "weakness": "reduce-nil-maximum", "origin": "fresh-authored-round11-repacked", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "conversations": [{"from": "system", "value": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"from": "user", "value": "Write `ReduceSummary.run/1`.\n\nFor a list of integers, return `{sum, maximum}` using one `Enum.reduce/3`.\nThe maximum is `nil` for an empty list, and negative values must remain\nnegative rather than being compared with a zero sentinel.\n\nReply with a single ```elixir fence containing only the requested module."}], "chosen": "```elixir\ndefmodule ReduceSummary do\n  @spec run([integer()]) :: {integer(), integer() | nil}\n  def run(values) when is_list(values) do\n    Enum.reduce(values, {0, nil}, fn value, {sum, maximum} ->\n      next_maximum =\n        if is_nil(maximum) or value > maximum do\n          value\n        else\n          maximum\n        end\n\n      {sum + value, next_maximum}\n    end)\n  end\nend\n```", "rejected": "```elixir\ndefmodule ReduceSummary do\n  @spec run([integer()]) :: {integer(), integer() | nil}\n  def run(values) when is_list(values) do\n    Enum.reduce(values, {0, 0}, fn value, {sum, maximum} ->\n      {sum + value, max(maximum, value)}\n    end)\n  end\nend\n```"}
+{"id": "round13.qwen25c3b.round11.qwen25c3b.core.guard_window", "family": "core", "source": "qwen25c3b_micro_round13_dpo", "weakness": "inclusive-guard-boundary", "origin": "fresh-authored-round11-repacked", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "conversations": [{"from": "system", "value": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"from": "user", "value": "Write `GuardWindow.inside?/3`.\n\nReturn `true` when an integer value is between the integer lower and upper\nbounds, inclusive. Return `false` for a value outside the interval. Express\nthe contract with a guard and handle an invalid interval as `false`.\n\nReply with a single ```elixir fence containing only the requested module."}], "chosen": "```elixir\ndefmodule GuardWindow do\n  @spec inside?(integer(), integer(), integer()) :: boolean()\n  def inside?(value, lower, upper)\n      when is_integer(value) and is_integer(lower) and is_integer(upper) and lower <= upper,\n      do: value >= lower and value <= upper\n\n  def inside?(_value, _lower, _upper), do: false\nend\n```", "rejected": "```elixir\ndefmodule GuardWindow do\n  @spec inside?(integer(), integer(), integer()) :: boolean()\n  def inside?(value, lower, upper) when is_integer(value) and is_integer(lower) and is_integer(upper),\n    do: value > lower and value < upper\n\n  def inside?(_value, _lower, _upper), do: false\nend\n```"}
+{"id": "round13.qwen25c3b.round11.qwen25c3b.core.head_or_fallback", "family": "core", "source": "qwen25c3b_micro_round13_dpo", "weakness": "pattern-match-empty-case", "origin": "fresh-authored-round11-repacked", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "conversations": [{"from": "system", "value": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"from": "user", "value": "Write `HeadFallback.first/2`.\n\nReturn the first element of a non-empty list, or the supplied fallback for an\nempty list. Use function clauses and keep the fallback term unchanged.\n\nReply with a single ```elixir fence containing only the requested module."}], "chosen": "```elixir\ndefmodule HeadFallback do\n  @spec first([term()], term()) :: term()\n  def first([head | _tail], _fallback), do: head\n  def first([], fallback), do: fallback\nend\n```", "rejected": "```elixir\ndefmodule HeadFallback do\n  @spec first([term()], term()) :: term()\n  def first(values, _fallback), do: Enum.at(values, 0, nil)\nend\n```"}
+{"id": "round13.qwen25c3b.round11.qwen25c3b.errors.rescue_cleanup", "family": "errors", "source": "qwen25c3b_micro_round13_dpo", "weakness": "rescue-and-after", "origin": "fresh-authored-round11-repacked", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "conversations": [{"from": "system", "value": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"from": "user", "value": "Write `RescueCleanup.run/2`.\n\nCall a zero-arity `work` function. Return `{:ok, value}` on success, convert a\n`RuntimeError` into `{:error, message}`, and always call the zero-arity\n`cleanup` function. Do not swallow other exception types.\n\nReply with a single ```elixir fence containing only the requested module."}], "chosen": "```elixir\ndefmodule RescueCleanup do\n  @spec run((() -> term()), (() -> term())) :: {:ok, term()} | {:error, String.t()}\n  def run(work, cleanup) when is_function(work, 0) and is_function(cleanup, 0) do\n    try do\n      {:ok, work.()}\n    rescue\n      error in RuntimeError -> {:error, Exception.message(error)}\n    after\n      cleanup.()\n    end\n  end\nend\n```", "rejected": "```elixir\ndefmodule RescueCleanup do\n  @spec run((() -> term()), (() -> term())) :: {:ok, term()} | {:error, String.t()}\n  def run(work, cleanup) when is_function(work, 0) and is_function(cleanup, 0) do\n    try do\n      result = {:ok, work.()}\n      cleanup.()\n      result\n    rescue\n      error in RuntimeError -> {:error, Exception.message(error)}\n    end\n  end\nend\n```"}
+{"id": "round13.qwen25c3b.round11.qwen25c3b.errors.strict_number", "family": "errors", "source": "qwen25c3b_micro_round13_dpo", "weakness": "tagged-strict-parse", "origin": "fresh-authored-round11-repacked", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "conversations": [{"from": "system", "value": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"from": "user", "value": "Write `StrictNumber.parse/1`.\n\nReturn `{:ok, integer}` only when `Integer.parse/1` consumes the complete\nstring. Return `{:error, :invalid}` for an empty string, partial number, or\nnon-number without raising. Use a tagged `with` expression.\n\nReply with a single ```elixir fence containing only the requested module."}], "chosen": "```elixir\ndefmodule StrictNumber do\n  @spec parse(String.t()) :: {:ok, integer()} | {:error, :invalid}\n  def parse(text) when is_binary(text) do\n    with {value, \"\"} <- Integer.parse(text) do\n      {:ok, value}\n    else\n      _ -> {:error, :invalid}\n    end\n  end\nend\n```", "rejected": "```elixir\ndefmodule StrictNumber do\n  @spec parse(String.t()) :: {:ok, integer()} | {:error, :invalid}\n  def parse(text) when is_binary(text), do: {:ok, String.to_integer(text)}\nend\n```"}
+{"id": "round13.qwen25c3b.round11.qwen25c3b.otp.mailbox", "family": "otp", "source": "qwen25c3b_micro_round13_dpo", "weakness": "genserver-call-state", "origin": "fresh-authored-round11-repacked", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "conversations": [{"from": "system", "value": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"from": "user", "value": "Write `Mailbox.start_link/1`, `Mailbox.push/2`, and `Mailbox.drain/1`.\n\nUse a GenServer whose state is a list. `push/2` must synchronously prepend a\nvalue and return `:ok`; `drain/1` must synchronously return values in insertion\norder and reset the state to an empty list. Both calls must pass an explicit\nmodule timeout.\n\nReply with a single ```elixir fence containing only the requested module."}], "chosen": "```elixir\ndefmodule Mailbox do\n  use GenServer\n\n  @timeout 1_000\n\n  @spec start_link(term()) :: GenServer.on_start()\n  def start_link(initial), do: GenServer.start_link(__MODULE__, [initial])\n\n  @spec push(pid(), term()) :: :ok\n  def push(pid, value), do: GenServer.call(pid, {:push, value}, @timeout)\n\n  @spec drain(pid()) :: [term()]\n  def drain(pid), do: GenServer.call(pid, :drain, @timeout)\n\n  @impl true\n  def init(values), do: {:ok, values}\n\n  @impl true\n  def handle_call({:push, value}, _from, state), do: {:reply, :ok, [value | state]}\n\n  @impl true\n  def handle_call(:drain, _from, state), do: {:reply, Enum.reverse(state), []}\nend\n```", "rejected": "```elixir\ndefmodule Mailbox do\n  use GenServer\n\n  @timeout 1_000\n\n  def start_link(initial), do: GenServer.start_link(__MODULE__, [initial])\n  def push(pid, value), do: GenServer.cast(pid, {:push, value})\n  def drain(pid), do: GenServer.call(pid, :drain, @timeout)\n\n  @impl true\n  def init(values), do: {:ok, values}\n\n  @impl true\n  def handle_cast({:push, value}, state), do: {:noreply, [value | state]}\n\n  @impl true\n  def handle_call(:drain, _from, state), do: {:reply, state, []}\nend\n```"}
+{"id": "round13.qwen25c3b.round11.qwen25c3b.otp.supervised_map", "family": "otp", "source": "qwen25c3b_micro_round13_dpo", "weakness": "supervised-task-await", "origin": "fresh-authored-round11-repacked", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "conversations": [{"from": "system", "value": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"from": "user", "value": "Write `SupervisedMap.run/3`.\n\nRun a one-argument function for each value using\n`Task.Supervisor.async_nolink/2`. Await every task with an explicit timeout of\n1_000 milliseconds and return results in input order. Require a supervisor pid\nand a one-argument function.\n\nReply with a single ```elixir fence containing only the requested module."}], "chosen": "```elixir\ndefmodule SupervisedMap do\n  @timeout 1_000\n\n  @spec run(pid(), [term()], (term() -> term())) :: [term()]\n  def run(supervisor, values, function)\n      when is_pid(supervisor) and is_list(values) and is_function(function, 1) do\n    values\n    |> Enum.map(fn value -> Task.Supervisor.async_nolink(supervisor, fn -> function.(value) end) end)\n    |> Enum.map(&Task.await(&1, @timeout))\n  end\nend\n```", "rejected": "```elixir\ndefmodule SupervisedMap do\n  @timeout 1_000\n\n  @spec run(pid(), [term()], (term() -> term())) :: [term()]\n  def run(supervisor, values, function)\n      when is_pid(supervisor) and is_list(values) and is_function(function, 1) do\n    values\n    |> Enum.reverse()\n    |> Enum.map(fn value -> Task.async(fn -> function.(value) end) end)\n    |> Enum.map(&Task.await(&1, @timeout))\n  end\nend\n```"}
+{"id": "round13.qwen25c3b.round11.qwen25c3b.stdlib.date_delta", "family": "stdlib", "source": "qwen25c3b_micro_round13_dpo", "weakness": "date-diff-direction", "origin": "fresh-authored-round11-repacked", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "conversations": [{"from": "system", "value": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"from": "user", "value": "Write `DateDelta.days/2`.\n\nReturn the signed number of calendar days from the first `Date` to the second\n`Date`, using the standard library. The result must be negative when the\nsecond date is earlier.\n\nReply with a single ```elixir fence containing only the requested module."}], "chosen": "```elixir\ndefmodule DateDelta do\n  @spec days(Date.t(), Date.t()) :: integer()\n  def days(first, second) do\n    Date.diff(second, first)\n  end\nend\n```", "rejected": "```elixir\ndefmodule DateDelta do\n  @spec days(Date.t(), Date.t()) :: non_neg_integer()\n  def days(first, second) do\n    abs(Date.diff(first, second))\n  end\nend\n```"}
+{"id": "round13.qwen25c3b.round11.qwen25c3b.stdlib.named_capture", "family": "stdlib", "source": "qwen25c3b_micro_round13_dpo", "weakness": "regex-named-capture", "origin": "fresh-authored-round11-repacked", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "conversations": [{"from": "system", "value": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"from": "user", "value": "Write `NamedCapture.user/1`.\n\nExtract a lowercase username after an `@` from a string with a named regular\nexpression capture. Return the captured username as a string, or `:error` if\nthere is no match.\n\nReply with a single ```elixir fence containing only the requested module."}], "chosen": "```elixir\ndefmodule NamedCapture do\n  @spec user(String.t()) :: String.t() | :error\n  def user(text) when is_binary(text) do\n    case Regex.named_captures(~r/@(?<user>[a-z][a-z0-9_]*)/, text) do\n      %{\"user\" => value} -> value\n      nil -> :error\n    end\n  end\nend\n```", "rejected": "```elixir\ndefmodule NamedCapture do\n  @spec user(String.t()) :: String.t() | :error\n  def user(text) when is_binary(text) do\n    case Regex.run(~r/@(?<user>[a-z][a-z0-9_]*)/, text) do\n      [value, _username] -> value\n      nil -> :error\n    end\n  end\nend\n```"}
+{"id": "round13.qwen25c3b.round11.qwen25c3b.stdlib.query_map", "family": "stdlib", "source": "qwen25c3b_micro_round13_dpo", "weakness": "uri-query-decoding", "origin": "fresh-authored-round11-repacked", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "conversations": [{"from": "system", "value": "You are a coding assistant. Write correct, idiomatic Elixir using the standard library and OTP when appropriate."}, {"from": "user", "value": "Write `QueryMap.decode/1`.\n\nDecode a URI query string into a map using the standard library. For example,\n`\"name=Ada&role=admin\"` becomes `%{\"name\" => \"Ada\", \"role\" => \"admin\"}`.\nAn empty query must return an empty map.\n\nReply with a single ```elixir fence containing only the requested module."}], "chosen": "```elixir\ndefmodule QueryMap do\n  @spec decode(String.t()) :: map()\n  def decode(query) when is_binary(query), do: URI.decode_query(query)\nend\n```", "rejected": "```elixir\ndefmodule QueryMap do\n  @spec decode(String.t()) :: map()\n  def decode(query) when is_binary(query), do: URI.parse(query)\nend\n```"}

data/onpolicy/qwen25c3b_micro_round2_dpo.jsonl ADDED Viewed

	@@ -0,0 +1,25 @@

+{"id": "round2.qwen25c3b.dpo.abstractions.facade.enum-state", "family": "abstractions", "source": "qwen25c3b_micro_round2_dpo", "weakness": "enum-state", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `Facade` with:\n\n`InnerMath` holds `double/1` and `triple/1` (integer guards). `Facade`\nexposes both via `defdelegate/2`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule InnerMath do\n  def double(n) when is_integer(n), do: n * 2\n  def triple(n) when is_integer(n), do: n * 3\nend\n\ndefmodule Facade do\n  defdelegate double(n), to: InnerMath\n  defdelegate triple(n), to: InnerMath, as: :triple\nend\n```", "rejected": "```elixir\ndefmodule Facade do\n  defdelegate double(n), to: InnerMath\n  defdelegate triple(n), to: InnerMath, as: :double\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.abstractions.overridable.v2.enum-state", "family": "abstractions", "source": "qwen25c3b_micro_round2_dpo", "weakness": "enum-state", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `StepRunner02` with:\n\nModule `StepRunner02` provides a `__using__/1` macro that injects a default\n`step/1` (`value + 1`) and marks it `defoverridable`. `StepDemo` does\n`use StepRunner02` and overrides `step/1` to return `super(value) * 10`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule StepRunner02 do\n  defmacro __using__(_) do\n    quote do\n      def step(value), do: value + 1\n\n      defoverridable step: 1\n    end\n  end\nend\n\ndefmodule StepDemo do\n  use StepRunner02\n\n  @doc \"Doubly-stepped: default result times ten.\"\n  def step(value), do: super(value) * 10\nend\n```", "rejected": "```elixir\ndefmodule StepDemo do\n  use StepRunner02\n\n  @doc \"Doubly-stepped: default result times ten.\"\n  def step(value), do: super(value * 10)\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.core.tuplerotate.v3.enum-state", "family": "core", "source": "qwen25c3b_micro_round2_dpo", "weakness": "enum-state", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `TupleSpin03` with:\n\n@spec left(tuple()) :: tuple()\n    def left(tuple)\n\n    @spec right(tuple()) :: tuple()\n    def right(tuple)\n\nRotate tuples of size >= 2: `left` moves the first element to the end,\n`right` moves the last element to the front.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule TupleSpin03 do\n  @spec left(tuple()) :: tuple()\n  def left(tuple) when tuple_size(tuple) >= 2 do\n    list = Tuple.to_list(tuple)\n    [first | rest] = list\n    List.to_tuple(rest ++ [first])\n  end\n\n  @spec right(tuple()) :: tuple()\n  def right(tuple) when tuple_size(tuple) >= 2 do\n    list = Tuple.to_list(tuple)\n    {last, front} = List.pop_at(list, -1)\n    List.to_tuple([last | front])\n  end\nend\n```", "rejected": "```elixir\ndefmodule TupleSpin03 do\n  @spec left(tuple()) :: tuple()\n  def left(tuple) when tuple_size(tuple) >= 2 do\n    list = Tuple.to_list(tuple)\n    [first | rest] = list\n    List.to_tuple([List.last(rest) | List.delete(rest, List.last(rest))] ) |> then(fn t -> t end)\n  end\n\n  @spec right(tuple()) :: tuple()\n  def right(tuple) when tuple_size(tuple) >= 2 do\n    list = Tuple.to_list(tuple)\n    {last, front} = List.pop_at(list, -1)\n    List.to_tuple([last | front])\n  end\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.core.poppath.v2.edge-empty", "family": "core", "source": "qwen25c3b_micro_round2_dpo", "weakness": "edge-empty", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `PopPath02` with:\n\n@spec pop(map(), [term()]) :: {term() | nil, map()}\n    def pop(map, path)\n\nRemove the value at a nested path and return `{value, updated_map}`. Missing\npaths and empty paths give `{nil, original_map}`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule PopPath02 do\n  @spec pop(map(), [term()]) :: {term() | nil, map()}\n  def pop(map, []), do: {nil, map}\n\n  def pop(map, path) when is_map(map) and is_list(path) do\n    case do_pop(map, path) do\n      {:ok, value, updated} -> {value, updated}\n      :missing -> {nil, map}\n    end\n  end\n\n  defp do_pop(map, [key]) do\n    case Map.fetch(map, key) do\n      {:ok, value} -> {:ok, value, Map.delete(map, key)}\n      :error -> :missing\n    end\n  end\n\n  defp do_pop(map, [key | rest]) do\n    case Map.fetch(map, key) do\n      {:ok, child} when is_map(child) ->\n        case do_pop(child, rest) do\n          {:ok, value, updated_child} -> {:ok, value, Map.put(map, key, updated_child)}\n          :missing -> :missing\n        end\n\n      _other -> :missing\n    end\n  end\nend\n```", "rejected": "```elixir\ndefmodule PopPath02 do\n  @spec pop(map(), [term()]) :: {term() | nil, map()}\n  def pop(map, path) when is_map(map) and is_list(path) do\n    case do_pop(map, path) do\n      {:ok, value, updated} -> {value, updated}\n      :missing -> {nil, map}\n    end\n  end\n\n  defp do_pop(map, [key]) do\n    case Map.fetch(map, key) do\n      {:ok, value} -> {:ok, value, Map.delete(map, key)}\n      :error -> :missing\n    end\n  end\n\n  defp do_pop(map, [key | rest]) do\n    case Map.fetch(map, key) do\n      {:ok, child} when is_map(child) ->\n        case do_pop(child, rest) do\n          {:ok, value, updated_child} -> {:ok, value, Map.put(map, key, updated_child)}\n          :missing -> :missing\n        end\n\n      _other -> :missing\n    end\n  end\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.collections.firstrerun.v3.edge-empty", "family": "collections", "source": "qwen25c3b_micro_round2_dpo", "weakness": "edge-empty", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `FirstRerun03` with:\n\n@spec first_repeat([term()]) :: {non_neg_integer(), non_neg_integer()} | :none\n    def first_repeat(items)\n\nIndices `{first, second}` of the earliest repeated value (by first occurrence).\n`:none` when every value is unique.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule FirstRerun03 do\n  @spec first_repeat([term()]) :: {non_neg_integer(), non_neg_integer()} | :none\n  def first_repeat(items) when is_list(items) do\n    items\n    |> Enum.with_index()\n    |> Enum.reduce_while(%{}, fn {item, idx}, seen ->\n      case seen do\n        %{^item => first_idx} -> {:halt, {first_idx, idx}}\n        _map -> {:cont, Map.put(seen, item, idx)}\n      end\n    end)\n    |> case do\n      %{} = _unfinished -> :none\n      pair -> pair\n    end\n  end\nend\n```", "rejected": "```elixir\ndefmodule FirstRerun03 do\n  @spec first_repeat([term()]) :: {non_neg_integer(), non_neg_integer()} | :none\n  def first_repeat(items) when is_list(items) do\n    items\n    |> Enum.with_index()\n    |> then(fn l -> if l == [], do: [{hd([]), 0}], else: l end)\n    |> Enum.reduce_while(%{}, fn {item, idx}, seen ->\n      case seen do\n        %{^item => first_idx} -> {:halt, {first_idx, idx}}\n        _map -> {:cont, Map.put(seen, item, idx)}\n      end\n    end)\n    |> case do\n      %{} = _unfinished -> :none\n      pair -> pair\n    end\n  end\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.stdlib.bizdays.v3.edge-empty", "family": "stdlib", "source": "qwen25c3b_micro_round2_dpo", "weakness": "edge-empty", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `BizDays03` with:\n\n@spec next_biz(Date.t()) :: Date.t()\n    def next_biz(date)\n\nThe next business day AFTER `date`: skip Saturdays and Sundays\n(`Date.day_of_week/1` returns 6 and 7).\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule BizDays03 do\n  @spec next_biz(Date.t()) :: Date.t()\n  def next_biz(date) when is_struct(date, Date) do\n    date\n    |> Date.add(1)\n    |> advance_if_weekend()\n  end\n\n  defp advance_if_weekend(date) do\n    case Date.day_of_week(date) do\n      day when day > 5 -> date |> Date.add(8 - day) |> advance_if_weekend()\n      _day -> date\n    end\n  end\nend\n```", "rejected": "```elixir\ndefmodule BizDays03 do\n  @spec next_biz(Date.t()) :: Date.t()\n  def next_biz(date) when is_struct(date, Date) do\nDate.add(date, 1)\n  end\n\n  defp advance_if_weekend(date) do\n    case Date.day_of_week(date) do\n      day when day > 5 -> date |> Date.add(8 - day) |> advance_if_weekend()\n      _day -> date\n    end\n  end\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.errors.catchtag.v3.err-swallow", "family": "errors", "source": "qwen25c3b_micro_round2_dpo", "weakness": "err-swallow", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `CatchKind03` with:\n\n@spec run((-> term())) :: {:ok, term()} | {:error, term()}\n    def run(fun)\n\nCall `fun`. Wrap normal returns as `{:ok, value}`, rescue `ArgumentError` as\n`{:error, {:argument, message}}`, and catch thrown terms as\n`{:error, {:thrown, value}}`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule CatchKind03 do\n  @spec run((-> term())) :: {:ok, term()} | {:error, term()}\n  def run(fun) when is_function(fun, 0) do\n    {:ok, fun.()}\n  rescue\n    e in ArgumentError -> {:error, {:argument, Exception.message(e)}}\n  catch\n    :throw, value -> {:error, {:thrown, value}}\n  end\nend\n```", "rejected": "```elixir\ndefmodule CatchKind03 do\n  @spec run((-> term())) :: {:ok, term()} | {:error, term()}\n  def run(fun) when is_function(fun, 0) do\n    {:ok, fun.()}\n  rescue\n    _kind, _value -> {:error, :unknown}\n  catch\n    :throw, value -> {:error, {:thrown, value}}\n  end\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.errors.mapresults.err-swallow", "family": "errors", "source": "qwen25c3b_micro_round2_dpo", "weakness": "err-swallow", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `MapResults` with:\n\n@spec run([{:ok, term()} | {:error, term()}]) :: {:ok, [term()]} | {:error, term()}\n    def run(items)\n\nCollect ok values in order; return the FIRST error otherwise.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule MapResults do\n  @spec run([{:ok, term()} | {:error, term()}]) ::\n          {:ok, [term()]} | {:error, term()}\n  def run(items) when is_list(items) do\n    Enum.reduce_while(items, {:ok, []}, fn\n      {:ok, value}, {:ok, acc} -> {:cont, {:ok, [value | acc]}}\n      {:error, reason}, _acc -> {:halt, {:error, reason}}\n      _other, acc -> {:cont, acc}\n    end)\n    |> case do\n      {:ok, acc} -> {:ok, Enum.reverse(acc)}\n      error -> error\n    end\n  end\nend\n```", "rejected": "```elixir\ndefmodule MapResults do\n  @spec run([{:ok, term()} | {:error, term()}]) ::\n          {:ok, [term()]} | {:error, term()}\n  def run(items) when is_list(items) do\n    Enum.reduce_while(items, {:ok, []}, fn\n      {:ok, value}, {:ok, acc} -> {:cont, {:ok, [value | acc]}}\n      {:error, _reason}, acc -> {:cont, acc}\n      _other, acc -> {:cont, acc}\n    end)\n    |> case do\n      {:ok, acc} -> {:ok, Enum.reverse(acc)}\n      error -> error\n    end\n  end\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.binaries.mpxframe.v2.err-swallow", "family": "binaries", "source": "qwen25c3b_micro_round2_dpo", "weakness": "err-swallow", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `MpxFrame02` with:\n\n@spec encode(binary()) :: binary()\n    def encode(payload)\n\n    @spec decode(binary()) :: {:ok, binary()} | :error\n    def decode(packet)\n\nLayout is magic `<<\"MPX1\">>`, version byte `1`, a one-byte payload\nlength, then the payload. Anything else is `:error`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule MpxFrame02 do\n  @spec encode(binary()) :: binary()\n  def encode(payload) when is_binary(payload) do\n    <<\"MPX1\", 1, byte_size(payload), payload::binary>>\n  end\n\n  @spec decode(binary()) :: {:ok, binary()} | :error\n  def decode(<<\"MPX1\", 1, len, rest::binary>>) do\n    if byte_size(rest) == len, do: {:ok, rest}, else: :error\n  end\n\n  def decode(_other), do: :error\nend\n```", "rejected": "```elixir\ndefmodule MpxFrame02 do\n  @spec encode(binary()) :: binary()\n  def encode(payload) when is_binary(payload) do\n    <<\"MPX1\", 1, byte_size(payload), payload::binary>>\n  end\n\n  @spec decode(binary()) :: {:ok, binary()} | :error\n  def decode(<<_magic::binary-size(4), _version, len, rest::binary>>) do\n    if byte_size(rest) == len, do: {:ok, rest}, else: :error\n  end\n\n  def decode(_other), do: :error\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.errors.safecleanup.v3.err-with-else", "family": "errors", "source": "qwen25c3b_micro_round2_dpo", "weakness": "err-with-else", "origin": "handmade", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `SafeCleanup03` with:\n\n@spec run((-> term()), (-> :ok)) :: {:ok, term()} | {:error, String.t()}\n    def run(fun, cleanup)\n\nCall `fun` inside `try`. Normal results become `{:ok, value}`, raised errors\nbecome `{:error, message}`. `cleanup` MUST run exactly once afterwards, on\nboth paths (`after`).\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule SafeCleanup03 do\n  @spec run((-> term()), (-> :ok)) :: {:ok, term()} | {:error, String.t()}\n  def run(fun, cleanup) when is_function(fun, 0) and is_function(cleanup, 0) do\n    try do\n      {:ok, fun.()}\n    rescue\n      e -> {:error, Exception.message(e)}\n    after\n      cleanup.()\n    end\n  end\nend\n```", "rejected": "```elixir\ndefmodule SafeCleanup03 do\n  @spec run((-> term()), (-> :ok)) :: {:ok, term()} | {:error, String.t()}\n  def run(fun, cleanup) when is_function(fun, 0) and is_function(cleanup, 0) do\n    try do\n      cleanup.()\n      {:ok, fun.()}\n    rescue\n      e -> {:error, Exception.message(e)}\n    end\n  end\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.errors.gradeof.err-with-else", "family": "errors", "source": "qwen25c3b_micro_round2_dpo", "weakness": "err-with-else", "origin": "handmade", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `GradeOf` with:\n\n@spec run(String.t()) :: {:ok, :low | :high} | {:error, :blank | :invalid}\n    def run(text)\n\nTrim `text`. Blank input is `{:error, :blank}`. Whole integers below 50 are\n`{:ok, :low}`, from 50 up `{:ok, :high}`. Anything else is\n`{:error, :invalid}`. Use `with` and an `else` that tells the error cases\napart.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule GradeOf do\n  @spec run(String.t()) :: {:ok, :low | :high} | {:error, :blank | :invalid}\n  def run(text) when is_binary(text) do\n    trimmed = String.trim(text)\n\n    with :ok <- check(trimmed),\n         {n, \"\"} <- Integer.parse(trimmed) do\n      {:ok, grade(n)}\n    else\n      :blank -> {:error, :blank}\n      :error -> {:error, :invalid}\n      _other -> {:error, :invalid}\n    end\n  end\n\n  defp check(\"\"), do: :blank\n  defp check(_t), do: :ok\n\n  defp grade(n) when n >= 50, do: :high\n  defp grade(_n), do: :low\nend\n```", "rejected": "```elixir\ndefmodule GradeOf do\n  @spec run(String.t()) :: {:ok, :low | :high} | {:error, :blank | :invalid}\n  def run(text) when is_binary(text) do\n    trimmed = String.trim(text)\n\n    with :ok <- check(trimmed),\n         {n, \"\"} <- Integer.parse(trimmed) do\n      {:ok, grade(n)}\n    else\n      _other -> {:error, :blank}\n    end\n  end\n\n  defp check(\"\"), do: :blank\n  defp check(_t), do: :ok\n\n  defp grade(n) when n >= 50, do: :high\n  defp grade(_n), do: :low\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.binaries.lenboxle.v3.bin-size-guard", "family": "binaries", "source": "qwen25c3b_micro_round2_dpo", "weakness": "bin-size-guard", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `LenBoxLE03` with:\n\n@spec encode(binary()) :: binary()\n    def encode(payload)\n\n    @spec decode(binary()) :: {:ok, binary()} | :error\n    def decode(packet)\n\nPrefix `payload` with its byte size as an unsigned-little 32-bit integer.\n`decode/1` succeeds only when the length matches the remaining bytes exactly.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule LenBoxLE03 do\n  @spec encode(binary()) :: binary()\n  def encode(payload) when is_binary(payload) do\n    <<byte_size(payload)::unsigned-little-integer-size(32), payload::binary>>\n  end\n\n  @spec decode(binary()) :: {:ok, binary()} | :error\n  def decode(<<len::unsigned-little-integer-size(32), rest::binary>>) do\n    if byte_size(rest) == len, do: {:ok, rest}, else: :error\n  end\n\n  def decode(_other), do: :error\nend\n```", "rejected": "```elixir\ndefmodule LenBoxLE03 do\n  @spec encode(binary()) :: binary()\n  def encode(payload) when is_binary(payload) do\n    <<byte_size(payload)::unsigned-little-integer-size(32), payload::binary>>\n  end\n\n  @spec decode(binary()) :: {:ok, binary()} | :error\n  def decode(<<len::unsigned-little-integer-size(32), rest::binary>>) do\n    if byte_size(rest) >= len, do: {:ok, binary_part(rest, 0, len)}, else: :error\n  end\n\n  def decode(_other), do: :error\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.binaries.lenbox.v3.bin-size-guard", "family": "binaries", "source": "qwen25c3b_micro_round2_dpo", "weakness": "bin-size-guard", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `LenBox03` with:\n\n@spec encode(binary()) :: binary()\n    def encode(payload)\n\n    @spec decode(binary()) :: {:ok, binary()} | :error\n    def decode(packet)\n\nPrefix `payload` with its byte size as an unsigned-big 16-bit integer.\n`decode/1` succeeds only when the length matches the remaining bytes exactly.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule LenBox03 do\n  @spec encode(binary()) :: binary()\n  def encode(payload) when is_binary(payload) do\n    <<byte_size(payload)::unsigned-big-integer-size(16), payload::binary>>\n  end\n\n  @spec decode(binary()) :: {:ok, binary()} | :error\n  def decode(<<len::unsigned-big-integer-size(16), rest::binary>>) do\n    if byte_size(rest) == len, do: {:ok, rest}, else: :error\n  end\n\n  def decode(_other), do: :error\nend\n```", "rejected": "```elixir\ndefmodule LenBox03 do\n  @spec encode(binary()) :: binary()\n  def encode(payload) when is_binary(payload) do\n    <<byte_size(payload)::unsigned-big-integer-size(16), payload::binary>>\n  end\n\n  @spec decode(binary()) :: {:ok, binary()} | :error\n  def decode(<<len::unsigned-big-integer-size(16), rest::binary>>) do\n    if byte_size(rest) >= len, do: {:ok, binary_part(rest, 0, len)}, else: :error\n  end\n\n  def decode(_other), do: :error\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.binaries.bitflags.v2.bin-size-guard", "family": "binaries", "source": "qwen25c3b_micro_round2_dpo", "weakness": "bin-size-guard", "origin": "handmade", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `BitFlags02` with:\n\n@spec pack([boolean()]) :: bitstring()\n    def pack(flags)\n\n    @spec unpack(bitstring()) :: [boolean()]\n    def unpack(bits)\n\nOne bit per flag, FIRST flag in the MOST significant position of the\nbitstring. `unpack/1` inverts it exactly.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule BitFlags02 do\n  @spec pack([boolean()]) :: bitstring()\n  def pack(flags) when is_list(flags) do\n    for flag <- flags, into: <<>>, do: <<if(flag, do: 1, else: 0)::size(1)>>\n  end\n\n  @spec unpack(bitstring()) :: [boolean()]\n  def unpack(bits) when is_bitstring(bits) do\n    for <<bit::size(1) <- bits>>, do: bit == 1\n  end\nend\n```", "rejected": "```elixir\ndefmodule BitFlags02 do\n  @spec pack([boolean()]) :: bitstring()\n  def pack(flags) when is_list(flags) do\n    for flag <- flags, into: <<>>, do: <<if(flag, do: 1, else: 0)::size(1)>>\n  end\n\n  @spec unpack(bitstring()) :: [boolean()]\n  def unpack(bits) when is_bitstring(bits) do\n    for <<byte::8 <- bits>>, byte != 0, do: true\n  end\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.otp.asyncuniqcount.fn-guard", "family": "otp", "source": "qwen25c3b_micro_round2_dpo", "weakness": "fn-guard", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `AsyncUniqCount` with:\n\n@spec run(list()) :: term()\n    def run(list)\n\nCompute the number of unique elements inside `Task.async`. Await with timeout `5_000` and return the\nresult. Do not use `spawn`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule AsyncUniqCount do\n  @spec run(list()) :: term()\n  def run(list) when is_list(list) do\n    task = Task.async(fn -> list |> Enum.uniq() |> length() end)\n    Task.await(task, 5_000)\n  end\nend\n```", "rejected": "```elixir\ndefmodule AsyncUniqCount do\n  @spec run(list()) :: term()\n  def run(list) when is_list(list) do\n    task = Task.async(fn list when is_list(list) -> list |> Enum.uniq() |> length() end)\n    Task.await(task, 5_000)\n  end\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.beam.appflag.persistent-term", "family": "beam", "source": "qwen25c3b_micro_round2_dpo", "weakness": "persistent-term", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `AppFlag` with:\n\n@spec put(term()) :: :ok\n    def put(value)\n\n    @spec get() :: {:ok, term()} | :unset\n    def get()\n\n    @spec erase() :: :ok\n    def erase()\n\nGlobal flag in `:persistent_term` under a module-specific key. Before any\n`put/1`, `get/0` is `:unset`; after `erase/0` it is `:unset` again.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule AppFlag do\n  @key {__MODULE__, :flag}\n\n  @spec put(term()) :: :ok\n  def put(value) do\n    :persistent_term.put(@key, value)\n    :ok\n  end\n\n  @spec get() :: {:ok, term()} | :unset\n  def get do\n    case :persistent_term.get(@key, :unset) do\n      :unset -> :unset\n      value -> {:ok, value}\n    end\n  end\n\n  @spec erase() :: :ok\n  def erase do\n    :persistent_term.erase(@key)\n    :ok\n  end\nend\n```", "rejected": "```elixir\ndefmodule AppFlag do\n  @key {__MODULE__, :flag}\n\n  @spec put(term()) :: :ok\n  def put(value) do\n    :persistent_term.put(@key, value)\n    :ok\n  end\n\n  @spec get() :: {:ok, term()} | :unset\n  def get do\n    case :persistent_term.get(@key) do\n      {:ok, value} -> {:ok, value}\n      :error -> :unset\n    end\n  end\n\n  @spec erase() :: :ok\n  def erase do\n    :persistent_term.erase(@key)\n    :ok\n  end\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.otp.stampstore.v2.otp-cast-call", "family": "otp", "source": "qwen25c3b_micro_round2_dpo", "weakness": "otp-cast-call", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `StampStore02` with:\n\n@spec start_link() :: {:ok, pid()}\n    def start_link()\n\n    @spec put(pid(), term(), term()) :: :ok\n    def put(pid, key, value)\n\n    @spec get(pid(), term()) :: {:ok, term()} | :error\n    def get(pid, key)\n\n    @spec keys(pid()) :: [term()]\n    def keys(pid)\n\nGenServer map that stamps each write with `System.monotonic_time/0` internally.\nCalls use timeout `5_000`. Unknown keys read as `:error`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule StampStore02 do\n  use GenServer\n\n  @timeout 5_000\n\n  @spec start_link() :: {:ok, pid()}\n  def start_link, do: GenServer.start_link(__MODULE__, %{})\n\n  @spec put(pid(), term(), term()) :: :ok\n  def put(pid, key, value), do: GenServer.call(pid, {:put, key, value}, @timeout)\n\n  @spec get(pid(), term()) :: {:ok, term()} | :error\n  def get(pid, key), do: GenServer.call(pid, {:get, key}, @timeout)\n\n  @spec keys(pid()) :: [term()]\n  def keys(pid), do: GenServer.call(pid, :keys, @timeout)\n\n  @impl true\n  def init(state), do: {:ok, state}\n\n  @impl true\n  def handle_call({:put, key, value}, _from, state) do\n    {:reply, :ok, Map.put(state, key, {System.monotonic_time(), value})}\n  end\n\n  def handle_call({:get, key}, _from, state) do\n    case Map.get(state, key) do\n      nil -> {:reply, :error, state}\n      {_ts, value} -> {:reply, {:ok, value}, state}\n    end\n  end\n\n  def handle_call(:keys, _from, state), do: {:reply, Map.keys(state), state}\nend\n```", "rejected": "```elixir\ndefmodule StampStore02 do\n  use GenServer\n\n  @timeout 5_000\n\n  @spec start_link() :: {:ok, pid()}\n  def start_link, do: GenServer.start_link(__MODULE__, %{})\n\n  @spec put(pid(), term(), term()) :: :ok\n  def put(pid, key, value), do: GenServer.cast(pid, {:put, key, value})\n\n  @spec get(pid(), term()) :: {:ok, term()} | :error\n  def get(pid, key), do: GenServer.call(pid, {:get, key}, @timeout)\n\n  @spec keys(pid()) :: [term()]\n  def keys(pid), do: GenServer.call(pid, :keys, @timeout)\n\n  @impl true\n  def init(state), do: {:ok, state}\n\n  @impl true\n  def handle_cast({:put, key, value}, state) do\n    {:noreply, Map.put(state, key, value)}\n  end\n\n  def handle_call({:get, key}, _from, state) do\n    case Map.get(state, key) do\n      nil -> {:reply, :error, state}\n      {_ts, value} -> {:reply, {:ok, value}, state}\n    end\n  end\n\n  def handle_call(:keys, _from, state), do: {:reply, Map.keys(state), state}\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.otp.rategate.otp-cast-call", "family": "otp", "source": "qwen25c3b_micro_round2_dpo", "weakness": "otp-cast-call", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `RateGate` with:\n\n@spec start_link() :: {:ok, pid()}\n    def start_link()\n\n    @spec pass?(pid()) :: boolean()\n    def pass?(pid)\n\nOne-shot gate: the first `pass?/1` is `true`, every later one is `false`.\nEvery `GenServer.call` must pass timeout `5_000`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule RateGate do\n  use GenServer\n\n  @timeout 5_000\n\n  @spec start_link() :: {:ok, pid()}\n  def start_link, do: GenServer.start_link(__MODULE__, :ready)\n\n  @spec pass?(pid()) :: boolean()\n  def pass?(pid), do: GenServer.call(pid, :pass, @timeout)\n\n  @impl true\n  def init(state), do: {:ok, state}\n\n  @impl true\n  def handle_call(:pass, _from, :ready), do: {:reply, true, :spent}\n  def handle_call(:pass, _from, :spent), do: {:reply, false, :spent}\nend\n```", "rejected": "```elixir\ndefmodule RateGate do\n  use GenServer\n\n  @timeout 5_000\n\n  @spec start_link() :: {:ok, pid()}\n  def start_link, do: GenServer.start_link(__MODULE__, :ready)\n\n  @spec pass?(pid()) :: boolean()\n  def pass?(pid) do\n    GenServer.cast(pid, :pass)\n    :ok\n  end\n\n  @impl true\n  def init(state), do: {:ok, state}\n\n  @impl true\n  def handle_cast(:pass, :ready), do: {:noreply, :spent}\n  def handle_cast(:pass, :spent), do: {:noreply, :spent}\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.otp.tapecell.otp-cast-call", "family": "otp", "source": "qwen25c3b_micro_round2_dpo", "weakness": "otp-cast-call", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `TapeCell` with:\n\n@spec start_link(term()) :: {:ok, pid()}\n    def start_link(initial)\n\n    @spec write(pid(), term()) :: term()\n    def write(pid, value)\n\nAgent cell. `write/2` stores `value` and returns the PREVIOUS value.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule TapeCell do\n  @spec start_link(term()) :: {:ok, pid()}\n  def start_link(initial), do: Agent.start_link(fn -> initial end)\n\n  @spec write(pid(), term()) :: term()\n  def write(pid, value), do: Agent.get_and_update(pid, fn old -> {old, value} end)\nend\n```", "rejected": "```elixir\ndefmodule TapeCell do\n  @spec start_link(term()) :: {:ok, pid()}\n  def start_link(initial), do: Agent.start_link(fn -> initial end)\n\n  @spec write(pid(), term()) :: term()\n  def write(pid, value) do\n    Agent.update(pid, fn _old -> value end)\n    value\n  end\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.otp.suprun.v3.otp-task-await", "family": "otp", "source": "qwen25c3b_micro_round2_dpo", "weakness": "otp-task-await", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `SupTaskRun03` with:\n\n@spec run((-> term())) :: term()\n    def run(fun)\n\nStart an unnamed `Task.Supervisor`, run the zero-arity function with\n`Task.Supervisor.async_nolink/2`, await it with timeout `5_000`, stop the\nsupervisor, and return the function result.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule SupTaskRun03 do\n  @spec run((-> term())) :: term()\n  def run(fun) do\n    {:ok, sup} = Task.Supervisor.start_link()\n    task = Task.Supervisor.async_nolink(sup, fun)\n    result = Task.await(task, 5_000)\n    Supervisor.stop(sup)\n    result\n  end\nend\n```", "rejected": "```elixir\ndefmodule SupTaskRun03 do\n  @spec run((-> term())) :: term()\n  def run(fun) do\n    {:ok, sup} = Task.Supervisor.start_link()\n    task = Task.Supervisor.async_nolink(sup, fun)\n    Supervisor.stop(sup)\n    Task.await(task, 5_000)\n  end\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.otp.stoplater.v3.otp-timeout", "family": "otp", "source": "qwen25c3b_micro_round2_dpo", "weakness": "otp-timeout", "origin": "handmade", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `StopLater03` with:\n\n@spec start_link() :: {:ok, pid()}\n    def start_link()\n\n    @spec ping(pid()) :: :ok\n    def ping(pid)\n\nGenServer that answers `ping/1` calls and STOPS normally when it receives\nthe `:stop` message via `handle_info/2`. Calls use timeout `5_000`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule StopLater03 do\n  use GenServer\n\n  @timeout 5_000\n\n  @spec start_link() :: {:ok, pid()}\n  def start_link, do: GenServer.start_link(__MODULE__, [])\n\n  @spec ping(pid()) :: :ok\n  def ping(pid), do: GenServer.call(pid, :ping, @timeout)\n\n  @impl true\n  def init(state), do: {:ok, state}\n\n  @impl true\n  def handle_call(:ping, _from, state), do: {:reply, :ok, state}\n\n  @impl true\n  def handle_info(:stop, state), do: {:stop, :normal, state}\nend\n```", "rejected": "```elixir\ndefmodule StopLater03 do\n  use GenServer\n\n  @spec start_link() :: {:ok, pid()}\n  def start_link, do: GenServer.start_link(__MODULE__, [])\n\n  @spec ping(pid()) :: :ok\n  def ping(pid), do: GenServer.call(pid, :ping)\n\n  @impl true\n  def init(state), do: {:ok, state}\n\n  @impl true\n  def handle_call(:ping, _from, state), do: {:reply, :ok, state}\n\n  @impl true\n  def handle_info(:stop, state), do: {:stop, :normal, state}\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.beam.linktrap.otp-supervision", "family": "beam", "source": "qwen25c3b_micro_round2_dpo", "weakness": "otp-supervision", "origin": "handmade", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `LinkTrap` with:\n\n@spec run((-> term())) :: {:ok, term()} | {:exit, term()}\n    def run(fun)\n\nTrap exits, spawn_link a process that computes `fun.()` and sends the result\nback to the caller as `{:result, value}`. Return `{:ok, value}` once the\nlinked process exits normally, or `{:exit, reason}` when it dies before\nproducing a result. Guard every receive with `after 2_000`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule LinkTrap do\n  @spec run((-> term())) :: {:ok, term()} | {:exit, term()}\n  def run(fun) do\n    previous = Process.flag(:trap_exit, true)\n\n    try do\n      parent = self()\n\n      pid =\n        spawn_link(fn ->\n          send(parent, {:result, fun.()})\n        end)\n\n      receive do\n        {:result, value} ->\n          receive do\n            {:EXIT, ^pid, _reason} -> {:ok, value}\n          after\n            2_000 -> {:ok, value}\n          end\n\n        {:EXIT, ^pid, reason} -> {:exit, reason}\n      after\n        2_000 ->\n          Process.unlink(pid)\n          Process.exit(pid, :kill)\n          {:exit, :timeout}\n      end\n    after\n      Process.flag(:trap_exit, previous)\n    end\n  end\nend\n```", "rejected": "```elixir\ndefmodule LinkTrap do\n  @spec run((-> term())) :: {:ok, term()} | {:exit, term()}\n  def run(fun) do\n    Process.flag(:trap_exit, true)\n    parent = self()\n\n    spawn(fn ->\n      send(parent, {:result, fun.()})\n    end)\n\n    receive do\n      {:result, value} -> {:ok, value}\n      {:EXIT, _pid, reason} -> {:exit, reason}\n    after\n      2_000 -> {:exit, :timeout}\n    end\n  end\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.beam.atomicvec.v3.otp-supervision", "family": "beam", "source": "qwen25c3b_micro_round2_dpo", "weakness": "otp-supervision", "origin": "handmade", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `AtomicVec03` with:\n\n@spec new(pos_integer()) :: :atomics.ref()\n    def new(size)\n\n    @spec bump(:atomics.ref(), pos_integer()) :: non_neg_integer()\n    def bump(ref, idx)\n\n    @spec read(:atomics.ref(), pos_integer()) :: non_neg_integer()\n    def read(ref, idx)\n\nAn unsigned `:atomics` array of `size` counters (1-based index). `bump/2`\nincrements and returns the NEW value; `read/2` never mutates.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule AtomicVec03 do\n  @spec new(pos_integer()) :: :atomics.ref()\n  def new(size) when size > 0, do: :atomics.new(size, signed: false)\n\n  @spec bump(:atomics.ref(), pos_integer()) :: non_neg_integer()\n  def bump(ref, idx), do: :atomics.add_get(ref, idx, 1)\n\n  @spec read(:atomics.ref(), pos_integer()) :: non_neg_integer()\n  def read(ref, idx), do: :atomics.get(ref, idx)\nend\n```", "rejected": "```elixir\ndefmodule AtomicVec03 do\n  @spec new(pos_integer()) :: :atomics.ref()\n  def new(size) when size > 0 do\n    {:ok, pid} = Agent.start_link(fn -> List.duplicate(0, size) end)\n    pid\n  end\n\n  @spec bump(:atomics.ref(), pos_integer()) :: non_neg_integer()\n  def bump(ref, idx) do\n    Agent.get_and_update(ref, fn counts ->\n      {Enum.at(counts, idx - 1) + 1, List.update_at(counts, idx - 1, &(&1 + 1))}\n    end)\n  end\n\n  @spec read(:atomics.ref(), pos_integer()) :: non_neg_integer()\n  def read(ref, idx), do: Agent.get(ref, &Enum.at(&1, idx - 1))\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.abstractions.areacalc.protocol-behaviour.1", "family": "abstractions", "source": "qwen25c3b_micro_round2_dpo", "weakness": "protocol-behaviour", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `AreaCalc` with:\n\nDefine protocol `AreaCalc` with `area/1`. Structs:\n\n- `Circle` with field `r` and `Circle.new/1`; area is `3 * r * r`\n- `Rect` with fields `w`, `h` and `Rect.new/2`; area is `w * h`\n\nImplement the protocol for both structs.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefprotocol AreaCalc do\n  def area(shape)\nend\n\ndefmodule Circle do\n  defstruct [:r]\n\n  def new(r), do: %__MODULE__{r: r}\nend\n\ndefimpl AreaCalc, for: Circle do\n  def area(%Circle{r: r}), do: 3 * r * r\nend\n\ndefmodule Rect do\n  defstruct [:w, :h]\n\n  def new(w, h), do: %__MODULE__{w: w, h: h}\nend\n\ndefimpl AreaCalc, for: Rect do\n  def area(%Rect{w: w, h: h}), do: w * h\nend\n```", "rejected": "```elixir\ndefmodule Rect do\n  def area(%__MODULE__{w: w, h: h}), do: w * h\n  defstruct [:w, :h]\n\n  def new(w, h), do: %__MODULE__{w: w, h: h}\nend\n```"}
+{"id": "round2.qwen25c3b.dpo.stdlib.uribuild.stdlib-misuse", "family": "stdlib", "source": "qwen25c3b_micro_round2_dpo", "weakness": "stdlib-misuse", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `UriBuild` with:\n\n@spec query(map()) :: String.t()\n    def query(params)\n\n    @spec parse(String.t()) :: map()\n    def parse(raw)\n\n`query/1` URL-encodes a map (keys sorted). `parse/1` decodes a query string\ninto a map.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule UriBuild do\n  @spec query(map()) :: String.t()\n  def query(params) when is_map(params) do\n    params |> Enum.sort() |> URI.encode_query()\n  end\n\n  @spec parse(String.t()) :: map()\n  def parse(raw) when is_binary(raw), do: URI.decode_query(raw)\nend\n```", "rejected": "```elixir\ndefmodule UriBuild do\n  @spec query(map()) :: String.t()\n  def query(params) when is_map(params) do\n    params |> Enum.sort() |> Enum.map_join(\"&\", fn {k, v} -> \"#{k}=#{v}\" end)\n  end\n\n  @spec parse(String.t()) :: map()\n  def parse(raw) when is_binary(raw), do: URI.decode_query(raw)\nend\n```"}

data/onpolicy/qwen25c3b_micro_round3_kto.jsonl ADDED Viewed

	@@ -0,0 +1,34 @@

+{"id": "round3.qwen25c3b.kto.otp.cast-callback.chosen", "family": "otp", "source": "qwen25c3b_micro_round3_kto", "weakness": "otp-cast-call", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpCastState` with:\n\nDefine a GenServer cast callback that handles `{:set, value}` as an\nasynchronous state update and returns `{:noreply, new_state}`.\nKeep the callback contract separate from the synchronous reply\ncontract of `handle_call/3`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpCastState do\n  use GenServer\n\n  @impl true\n  def init(state), do: {:ok, state}\n\n  @impl true\n  def handle_cast({:set, value}, _state), do: {:noreply, value}\nend\n```"}], "label": true}
+{"id": "round3.qwen25c3b.kto.otp.cast-callback.rejected", "family": "otp", "source": "qwen25c3b_micro_round3_kto", "weakness": "otp-cast-call", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpCastState` with:\n\nDefine a GenServer cast callback that handles `{:set, value}` as an\nasynchronous state update and returns `{:noreply, new_state}`.\nKeep the callback contract separate from the synchronous reply\ncontract of `handle_call/3`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpCastState do\n  use GenServer\n\n  @impl true\n  def handle_call({:set, value}, _from, _state), do: {:reply, :ok, value}\nend\n```"}], "label": false}
+{"id": "round3.qwen25c3b.kto.binary.exact-frame.chosen", "family": "binaries", "source": "qwen25c3b_micro_round3_kto", "weakness": "bin-size-guard", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoBinFrame` with:\n\nDefine `encode/1` and `decode/1` for an unsigned-big 16-bit\nlength-prefixed binary. Decode must return `{:ok, payload}` only\nwhen the remaining byte count exactly equals the prefix; short and\ntrailing packets return `:error`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoBinFrame do\n  @spec encode(binary()) :: binary()\n  def encode(payload) when is_binary(payload) and byte_size(payload) <= 65_535 do\n    <<byte_size(payload)::unsigned-big-integer-size(16), payload::binary>>\n  end\n\n  @spec decode(binary()) :: {:ok, binary()} | :error\n  def decode(<<length::unsigned-big-integer-size(16), rest::binary>>) do\n    if byte_size(rest) == length, do: {:ok, rest}, else: :error\n  end\n\n  def decode(_other), do: :error\nend\n```"}], "label": true}
+{"id": "round3.qwen25c3b.kto.binary.exact-frame.rejected", "family": "binaries", "source": "qwen25c3b_micro_round3_kto", "weakness": "bin-size-guard", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoBinFrame` with:\n\nDefine `encode/1` and `decode/1` for an unsigned-big 16-bit\nlength-prefixed binary. Decode must return `{:ok, payload}` only\nwhen the remaining byte count exactly equals the prefix; short and\ntrailing packets return `:error`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoBinFrame do\n  @spec encode(binary()) :: binary()\n  def encode(payload) when is_binary(payload) and byte_size(payload) <= 65_535 do\n    <<byte_size(payload)::unsigned-big-integer-size(16), payload::binary>>\n  end\n\n  @spec decode(binary()) :: {:ok, binary()} | :error\n  def decode(<<length::unsigned-big-integer-size(16), rest::binary>>) do\n    if byte_size(rest) >= length, do: {:ok, binary_part(rest, 0, length)}, else: :error\n  end\n\n  def decode(_other), do: :error\nend\n```"}], "label": false}
+{"id": "round3.qwen25c3b.kto.otp.task-supervised-await.chosen", "family": "otp", "source": "qwen25c3b_micro_round3_kto", "weakness": "otp-task-await", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpTaskRun` with:\n\nDefine `run/2` that accepts a `Task.Supervisor` pid and a zero-arity\nfunction. Start the work with `Task.Supervisor.async_nolink/2` and\nawait it with an explicit timeout of 1_000 milliseconds.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpTaskRun do\n  @timeout 1_000\n\n  @spec run(pid(), (() -> term())) :: term()\n  def run(supervisor, fun) when is_pid(supervisor) and is_function(fun, 0) do\n    task = Task.Supervisor.async_nolink(supervisor, fun)\n    Task.await(task, @timeout)\n  end\nend\n```"}], "label": true}
+{"id": "round3.qwen25c3b.kto.otp.task-supervised-await.rejected", "family": "otp", "source": "qwen25c3b_micro_round3_kto", "weakness": "otp-task-await", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpTaskRun` with:\n\nDefine `run/2` that accepts a `Task.Supervisor` pid and a zero-arity\nfunction. Start the work with `Task.Supervisor.async_nolink/2` and\nawait it with an explicit timeout of 1_000 milliseconds.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpTaskRun do\n  @spec run(pid(), (() -> term())) :: term()\n  def run(supervisor, fun) when is_pid(supervisor) and is_function(fun, 0) do\n    task = Task.Supervisor.async_nolink(supervisor, fun)\n    Task.await(task)\n  end\nend\n```"}], "label": false}
+{"id": "round3.qwen25c3b.kto.otp.child-spec.chosen", "family": "otp", "source": "qwen25c3b_micro_round3_kto", "weakness": "otp-supervision", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpWorker` with:\n\nDefine `start_link/1` and an explicit `child_spec/1`. The child\nspecification must use this module's start function, id from the\noptions, `restart: :transient`, `shutdown: 1_000`, and `type: :worker`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpWorker do\n  use GenServer\n\n  @spec start_link(keyword()) :: GenServer.on_start()\n  def start_link(options), do: GenServer.start_link(__MODULE__, options)\n\n  @spec child_spec(keyword()) :: Supervisor.child_spec()\n  def child_spec(options) do\n    %{\n      id: Keyword.fetch!(options, :id),\n      start: {__MODULE__, :start_link, [options]},\n      restart: :transient,\n      shutdown: 1_000,\n      type: :worker\n    }\n  end\n\n  @impl true\n  def init(options), do: {:ok, options}\nend\n```"}], "label": true}
+{"id": "round3.qwen25c3b.kto.otp.child-spec.rejected", "family": "otp", "source": "qwen25c3b_micro_round3_kto", "weakness": "otp-supervision", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpWorker` with:\n\nDefine `start_link/1` and an explicit `child_spec/1`. The child\nspecification must use this module's start function, id from the\noptions, `restart: :transient`, `shutdown: 1_000`, and `type: :worker`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpWorker do\n  use GenServer\n\n  @spec start_link(keyword()) :: GenServer.on_start()\n  def start_link(options), do: GenServer.start_link(__MODULE__, options)\n\n  @spec child_spec(keyword()) :: Supervisor.child_spec()\n  def child_spec(options) do\n    %{\n      id: Keyword.fetch!(options, :id),\n      start: {__MODULE__, :start_link, [options]},\n      restart: :permanent,\n      shutdown: 5_000,\n      type: :worker\n    }\n  end\n\n  @impl true\n  def init(options), do: {:ok, options}\nend\n```"}], "label": false}
+{"id": "round3.qwen25c3b.kto.core.function-clause-guard.chosen", "family": "core", "source": "qwen25c3b_micro_round3_kto", "weakness": "fn-guard", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoCoreClassify` with:\n\nDefine `classify/1` with function clauses and guards: non-negative\nintegers return `:non_negative`, negative integers return\n`:negative`, and all other terms return `:other`. Keep type and\nrange checks in function heads rather than simulating a procedural\ndecision tree inside an anonymous function.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoCoreClassify do\n  @spec classify(term()) :: :non_negative | :negative | :other\n  def classify(value) when is_integer(value) and value >= 0, do: :non_negative\n  def classify(value) when is_integer(value), do: :negative\n  def classify(_value), do: :other\nend\n```"}], "label": true}
+{"id": "round3.qwen25c3b.kto.core.function-clause-guard.rejected", "family": "core", "source": "qwen25c3b_micro_round3_kto", "weakness": "fn-guard", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoCoreClassify` with:\n\nDefine `classify/1` with function clauses and guards: non-negative\nintegers return `:non_negative`, negative integers return\n`:negative`, and all other terms return `:other`. Keep type and\nrange checks in function heads rather than simulating a procedural\ndecision tree inside an anonymous function.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoCoreClassify do\n  @spec classify(term()) :: :non_negative | :negative | :other\n  def classify(value) do\n    if is_integer(value) do\n      if value >= 0, do: :non_negative, else: :negative\n    else\n      :other\n    end\n  end\nend\n```"}], "label": false}
+{"id": "round3.qwen25c3b.kto.protocol.explicit-implementation.chosen", "family": "protocol", "source": "qwen25c3b_micro_round3_kto", "weakness": "protocol-behaviour", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoRender` with:\n\nDefine a `KtoRenderable` protocol with `render/1`, implement it\nfor integers, and expose `KtoRender.render/1` as the delegating\npublic function. Use the protocol/implementation boundary instead\nof a type-checking conditional in the public module.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefprotocol KtoRenderable do\n  @spec render(term()) :: String.t()\n  def render(value)\nend\n\ndefimpl KtoRenderable, for: Integer do\n  def render(value), do: Integer.to_string(value)\nend\n\ndefmodule KtoRender do\n  @spec render(term()) :: String.t()\n  def render(value), do: KtoRenderable.render(value)\nend\n```"}], "label": true}
+{"id": "round3.qwen25c3b.kto.protocol.explicit-implementation.rejected", "family": "protocol", "source": "qwen25c3b_micro_round3_kto", "weakness": "protocol-behaviour", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoRender` with:\n\nDefine a `KtoRenderable` protocol with `render/1`, implement it\nfor integers, and expose `KtoRender.render/1` as the delegating\npublic function. Use the protocol/implementation boundary instead\nof a type-checking conditional in the public module.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoRender do\n  @spec render(term()) :: String.t()\n  def render(value) when is_integer(value), do: Integer.to_string(value)\nend\n```"}], "label": false}
+{"id": "round3.qwen25c3b.kto.binary.explicit-bitwise.chosen", "family": "binaries", "source": "qwen25c3b_micro_round3_kto", "weakness": "bin-bitwise", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoBinFlags` with:\n\nDefine `toggle/2` that returns the bitwise XOR of two integers.\nCall the explicit `Bitwise.bxor/2` function rather than relying on\ndeprecated operators or arithmetic that happens to work for a\nnarrow sample.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoBinFlags do\n  @spec toggle(non_neg_integer(), non_neg_integer()) :: non_neg_integer()\n  def toggle(left, right) when is_integer(left) and is_integer(right) do\n    Bitwise.bxor(left, right)\n  end\nend\n```"}], "label": true}
+{"id": "round3.qwen25c3b.kto.binary.explicit-bitwise.rejected", "family": "binaries", "source": "qwen25c3b_micro_round3_kto", "weakness": "bin-bitwise", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoBinFlags` with:\n\nDefine `toggle/2` that returns the bitwise XOR of two integers.\nCall the explicit `Bitwise.bxor/2` function rather than relying on\ndeprecated operators or arithmetic that happens to work for a\nnarrow sample.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoBinFlags do\n  @spec toggle(non_neg_integer(), non_neg_integer()) :: non_neg_integer()\n  def toggle(left, right) when is_integer(left) and is_integer(right) do\n    Bitwise.band(left, right)\n  end\nend\n```"}], "label": false}
+{"id": "round3.qwen25c3b.kto.errors.tagged-with.chosen", "family": "errors", "source": "qwen25c3b_micro_round3_kto", "weakness": "err-with-else", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoErrorsSum` with:\n\nDefine `sum/2` for two strings containing integers. Return\n`{:ok, sum}` on success and `{:error, :invalid}` for malformed\ninput. Use tagged `with` branches and do not turn a parse failure\ninto a successful default.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoErrorsSum do\n  @spec sum(String.t(), String.t()) :: {:ok, integer()} | {:error, :invalid}\n  def sum(left, right) when is_binary(left) and is_binary(right) do\n    with {left_number, \"\"} <- Integer.parse(left),\n         {right_number, \"\"} <- Integer.parse(right) do\n      {:ok, left_number + right_number}\n    else\n      _ -> {:error, :invalid}\n    end\n  end\nend\n```"}], "label": true}
+{"id": "round3.qwen25c3b.kto.errors.tagged-with.rejected", "family": "errors", "source": "qwen25c3b_micro_round3_kto", "weakness": "err-with-else", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoErrorsSum` with:\n\nDefine `sum/2` for two strings containing integers. Return\n`{:ok, sum}` on success and `{:error, :invalid}` for malformed\ninput. Use tagged `with` branches and do not turn a parse failure\ninto a successful default.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoErrorsSum do\n  @spec sum(String.t(), String.t()) :: {:ok, integer()} | {:error, :invalid}\n  def sum(left, right) when is_binary(left) and is_binary(right) do\n    case Integer.parse(left) do\n      {left_number, _rest} -> {:ok, left_number + String.to_integer(right)}\n      :error -> {:ok, 0}\n    end\n  end\nend\n```"}], "label": false}
+{"id": "round3.qwen25c3b.kto.stdlib.string-length.chosen", "family": "stdlib", "source": "qwen25c3b_micro_round3_kto", "weakness": "stdlib-byte-vs-grapheme", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoStdlibText` with:\n\nDefine `characters/1` to count user-visible Unicode graphemes in a\nstring. Use the String API rather than counting UTF-8 bytes.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoStdlibText do\n  @spec characters(String.t()) :: non_neg_integer()\n  def characters(text) when is_binary(text), do: String.length(text)\nend\n```"}], "label": true}
+{"id": "round3.qwen25c3b.kto.stdlib.string-length.rejected", "family": "stdlib", "source": "qwen25c3b_micro_round3_kto", "weakness": "stdlib-byte-vs-grapheme", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoStdlibText` with:\n\nDefine `characters/1` to count user-visible Unicode graphemes in a\nstring. Use the String API rather than counting UTF-8 bytes.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoStdlibText do\n  @spec characters(String.t()) :: non_neg_integer()\n  def characters(text) when is_binary(text), do: byte_size(text)\nend\n```"}], "label": false}
+{"id": "round3.qwen25c3b.kto.protocol.behaviour-contract.chosen", "family": "protocol", "source": "qwen25c3b_micro_round3_kto", "weakness": "protocol-behaviour", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoUpperFormatter` with:\n\nDefine a `KtoFormatter` behaviour with a `format/1` callback and an\nimplementation module `KtoUpperFormatter` that declares the\nbehaviour and uses `@impl true`. Formatting should uppercase text.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFormatter do\n  @callback format(String.t()) :: String.t()\nend\n\ndefmodule KtoUpperFormatter do\n  @behaviour KtoFormatter\n\n  @impl true\n  def format(text) when is_binary(text), do: String.upcase(text)\nend\n```"}], "label": true}
+{"id": "round3.qwen25c3b.kto.protocol.behaviour-contract.rejected", "family": "protocol", "source": "qwen25c3b_micro_round3_kto", "weakness": "protocol-behaviour", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoUpperFormatter` with:\n\nDefine a `KtoFormatter` behaviour with a `format/1` callback and an\nimplementation module `KtoUpperFormatter` that declares the\nbehaviour and uses `@impl true`. Formatting should uppercase text.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoFormatter do\n  @callback format(String.t()) :: String.t()\nend\n\ndefmodule KtoUpperFormatter do\n  def format(text) when is_binary(text), do: String.upcase(text)\nend\n```"}], "label": false}
+{"id": "round3.qwen25c3b.kto.binary.safe-term.chosen", "family": "binaries", "source": "qwen25c3b_micro_round3_kto", "weakness": "stdlib-safe-deserialization", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoBinTerm` with:\n\nDefine `decode/1` for a binary term. Use the safe Erlang decoding\noption so the function does not create atoms or other resources\nfrom untrusted input. Valid encoded terms should be returned.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoBinTerm do\n  @spec decode(binary()) :: term()\n  def decode(binary) when is_binary(binary) do\n    :erlang.binary_to_term(binary, [:safe])\n  end\nend\n```"}], "label": true}
+{"id": "round3.qwen25c3b.kto.binary.safe-term.rejected", "family": "binaries", "source": "qwen25c3b_micro_round3_kto", "weakness": "stdlib-safe-deserialization", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoBinTerm` with:\n\nDefine `decode/1` for a binary term. Use the safe Erlang decoding\noption so the function does not create atoms or other resources\nfrom untrusted input. Valid encoded terms should be returned.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoBinTerm do\n  @spec decode(binary()) :: term()\n  def decode(binary) when is_binary(binary) do\n    :erlang.binary_to_term(binary)\n  end\nend\n```"}], "label": false}
+{"id": "round3.qwen25c3b.kto.stdlib.regex-nil.chosen", "family": "stdlib", "source": "qwen25c3b_micro_round3_kto", "weakness": "edge-nil-result", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoStdlibDigits` with:\n\nDefine `extract/1` to return `{:ok, digits}` for the first run of\ndecimal digits in a string, or `:error` when there is no match.\nHandle the `nil` result from `Regex.run/3` explicitly.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoStdlibDigits do\n  @spec extract(String.t()) :: {:ok, String.t()} | :error\n  def extract(text) when is_binary(text) do\n    case Regex.run(~r/(\\d+)/, text, capture: :all_but_first) do\n      [digits] -> {:ok, digits}\n      nil -> :error\n    end\n  end\nend\n```"}], "label": true}
+{"id": "round3.qwen25c3b.kto.stdlib.regex-nil.rejected", "family": "stdlib", "source": "qwen25c3b_micro_round3_kto", "weakness": "edge-nil-result", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoStdlibDigits` with:\n\nDefine `extract/1` to return `{:ok, digits}` for the first run of\ndecimal digits in a string, or `:error` when there is no match.\nHandle the `nil` result from `Regex.run/3` explicitly.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoStdlibDigits do\n  @spec extract(String.t()) :: {:ok, String.t()} | :error\n  def extract(text) when is_binary(text) do\n    [digits] = Regex.run(~r/(\\d+)/, text, capture: :all_but_first)\n    {:ok, digits}\n  end\nend\n```"}], "label": false}
+{"id": "round3.qwen25c3b.kto.binary.signed-integer.chosen", "family": "binaries", "source": "qwen25c3b_micro_round3_kto", "weakness": "bin-signed", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoBinSigned16` with:\n\nDefine `decode/1` for exactly two bytes containing a signed\nbig-endian 16-bit integer. Return `{:ok, integer}` for the exact\nbinary and `:error` for all other sizes.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoBinSigned16 do\n  @spec decode(binary()) :: {:ok, integer()} | :error\n  def decode(<<value::signed-big-integer-size(16)>>), do: {:ok, value}\n  def decode(_other), do: :error\nend\n```"}], "label": true}
+{"id": "round3.qwen25c3b.kto.binary.signed-integer.rejected", "family": "binaries", "source": "qwen25c3b_micro_round3_kto", "weakness": "bin-signed", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoBinSigned16` with:\n\nDefine `decode/1` for exactly two bytes containing a signed\nbig-endian 16-bit integer. Return `{:ok, integer}` for the exact\nbinary and `:error` for all other sizes.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoBinSigned16 do\n  @spec decode(binary()) :: {:ok, integer()} | :error\n  def decode(<<value::unsigned-big-integer-size(16)>>), do: {:ok, value}\n  def decode(_other), do: :error\nend\n```"}], "label": false}
+{"id": "round3.qwen25c3b.kto.binary.varint-empty-guard.chosen", "family": "binaries", "source": "qwen25c3b_micro_round3_kto", "weakness": "edge-empty", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoBinVarint` with:\n\nDefine `decode/1` for an unsigned little-endian base-128 varint.\nReturn `{:ok, {value, rest}}`, return `:error` for empty or\ntruncated input, and reject more than five bytes. Use recursive\npattern matching with an explicit empty-binary clause.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoBinVarint do\n  @spec decode(binary()) :: {:ok, {non_neg_integer(), binary()}} | :error\n  def decode(binary) when is_binary(binary), do: decode_bytes(binary, 0, 0)\n\n  defp decode_bytes(_rest, _value, 5), do: :error\n  defp decode_bytes(<<>>, _value, _count), do: :error\n\n  defp decode_bytes(<<byte, rest::binary>>, value, count) do\n    low_bits = Bitwise.band(byte, 0x7F)\n    next_value = value + Bitwise.bsl(low_bits, 7 * count)\n\n    if Bitwise.band(byte, 0x80) == 0 do\n      {:ok, {next_value, rest}}\n    else\n      decode_bytes(rest, next_value, count + 1)\n    end\n  end\nend\n```"}], "label": true}
+{"id": "round3.qwen25c3b.kto.binary.varint-empty-guard.rejected", "family": "binaries", "source": "qwen25c3b_micro_round3_kto", "weakness": "edge-empty", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoBinVarint` with:\n\nDefine `decode/1` for an unsigned little-endian base-128 varint.\nReturn `{:ok, {value, rest}}`, return `:error` for empty or\ntruncated input, and reject more than five bytes. Use recursive\npattern matching with an explicit empty-binary clause.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoBinVarint do\n  @spec decode(binary()) :: {:ok, {non_neg_integer(), binary()}} | :error\n  def decode(binary) when is_binary(binary), do: decode_bytes(binary, 0, 0)\n\n  defp decode_bytes(_rest, _value, 5), do: :error\n\n  defp decode_bytes(<<byte, rest::binary>>, value, count) do\n    low_bits = Bitwise.band(byte, 0x7F)\n    next_value = value + Bitwise.bsl(low_bits, 7 * count)\n\n    if Bitwise.band(byte, 0x80) == 0 do\n      {:ok, {next_value, rest}}\n    else\n      decode_bytes(rest, next_value, count + 1)\n    end\n  end\nend\n```"}], "label": false}
+{"id": "round3.qwen25c3b.kto.otp.immutable-state-update.chosen", "family": "otp", "source": "qwen25c3b_micro_round3_kto", "weakness": "enum-state", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpTotals` with:\n\nDefine a GenServer callback for `{:add, key, amount}`. Update the\nmap state immutably with `Map.update/4`, reply with the new value,\nand keep the updated map as the next state.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpTotals do\n  use GenServer\n\n  @impl true\n  def init(state), do: {:ok, state}\n\n  @impl true\n  def handle_call({:add, key, amount}, _from, state) when is_map(state) do\n    new_state = Map.update(state, key, amount, &(&1 + amount))\n    {:reply, Map.fetch!(new_state, key), new_state}\n  end\nend\n```"}], "label": true}
+{"id": "round3.qwen25c3b.kto.otp.immutable-state-update.rejected", "family": "otp", "source": "qwen25c3b_micro_round3_kto", "weakness": "enum-state", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpTotals` with:\n\nDefine a GenServer callback for `{:add, key, amount}`. Update the\nmap state immutably with `Map.update/4`, reply with the new value,\nand keep the updated map as the next state.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpTotals do\n  use GenServer\n\n  @impl true\n  def handle_call({:add, key, amount}, _from, state) when is_map(state) do\n    current = Map.get(state, key, 0)\n    {:reply, current + amount, state}\n  end\nend\n```"}], "label": false}
+{"id": "round3.qwen25c3b.kto.otp.call-explicit-timeout.chosen", "family": "otp", "source": "qwen25c3b_micro_round3_kto", "weakness": "otp-timeout", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpCounter` with:\n\nDefine a GenServer with `start_link/1` and `value/1`. Store the\ninitial value and read it through a synchronous `GenServer.call/3`\nwith an explicit module timeout. The callback must preserve state.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpCounter do\n  use GenServer\n\n  @timeout 1_000\n\n  @spec start_link(term()) :: GenServer.on_start()\n  def start_link(initial), do: GenServer.start_link(__MODULE__, initial)\n\n  @spec value(pid()) :: term()\n  def value(pid), do: GenServer.call(pid, :value, @timeout)\n\n  @impl true\n  def init(initial), do: {:ok, initial}\n\n  @impl true\n  def handle_call(:value, _from, state), do: {:reply, state, state}\nend\n```"}], "label": true}
+{"id": "round3.qwen25c3b.kto.otp.call-explicit-timeout.rejected", "family": "otp", "source": "qwen25c3b_micro_round3_kto", "weakness": "otp-timeout", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpCounter` with:\n\nDefine a GenServer with `start_link/1` and `value/1`. Store the\ninitial value and read it through a synchronous `GenServer.call/3`\nwith an explicit module timeout. The callback must preserve state.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpCounter do\n  use GenServer\n\n  @spec start_link(term()) :: GenServer.on_start()\n  def start_link(initial), do: GenServer.start_link(__MODULE__, initial)\n\n  @spec value(pid()) :: term()\n  def value(pid), do: GenServer.call(pid, :value)\n\n  @impl true\n  def init(initial), do: {:ok, initial}\n\n  @impl true\n  def handle_call(:value, _from, state), do: {:reply, state, state}\nend\n```"}], "label": false}
+{"id": "round3.qwen25c3b.kto.otp.handle-info.chosen", "family": "otp", "source": "qwen25c3b_micro_round3_kto", "weakness": "otp-handle-info", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpInfo` with:\n\nDefine a GenServer `handle_info/2` clause for `:refresh`. It should\nset `:refreshed` to `true` in a map state and return\n`{:noreply, new_state}`. Do not route an out-of-band message through\nthe cast or call callback.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpInfo do\n  use GenServer\n\n  @impl true\n  def init(state), do: {:ok, state}\n\n  @impl true\n  def handle_info(:refresh, state) when is_map(state) do\n    {:noreply, Map.put(state, :refreshed, true)}\n  end\nend\n```"}], "label": true}
+{"id": "round3.qwen25c3b.kto.otp.handle-info.rejected", "family": "otp", "source": "qwen25c3b_micro_round3_kto", "weakness": "otp-handle-info", "origin": null, "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `KtoOtpInfo` with:\n\nDefine a GenServer `handle_info/2` clause for `:refresh`. It should\nset `:refreshed` to `true` in a map state and return\n`{:noreply, new_state}`. Do not route an out-of-band message through\nthe cast or call callback.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule KtoOtpInfo do\n  use GenServer\n\n  @impl true\n  def handle_cast(:refresh, state) when is_map(state) do\n    {:noreply, Map.put(state, :refreshed, true)}\n  end\nend\n```"}], "label": false}

data/onpolicy/qwen25c3b_micro_round4_dpo.jsonl ADDED Viewed

	@@ -0,0 +1,11 @@

+{"id": "round4.qwen25c3b.dpo.stdlib.multisort.v2.enum-state.0", "family": "stdlib", "source": "qwen25c3b_micro_round4_dpo", "weakness": "enum-state", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `MultiSort02` with:\n\n@spec run([map()]) :: [map()]\n    def run(items)\n\nEach item is a map with `:first` and `:last`. Sort ascending by `:last`,\nties broken by `:first`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule MultiSort02 do\n  @spec run([map()]) :: [map()]\n  def run(items) when is_list(items) do\n    Enum.sort_by(items, &{&1.last, &1.first})\n  end\nend\n```", "rejected": "```elixir\ndefmodule MultiSort02 do\n  @spec run([map()]) :: [map()]\n  def run(items) when is_list(items) do\n    Enum.sort_by(items, & &1.last)\n  end\nend\n```"}
+{"id": "round4.qwen25c3b.dpo.collections.cartpair.v2.enum-state.0", "family": "collections", "source": "qwen25c3b_micro_round4_dpo", "weakness": "enum-state", "origin": "handmade", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `CartPair02` with:\n\n@spec run([term()], [term()], (term(), term() -> boolean())) :: [{term(), term()}]\n    def run(left, right, keep)\n\nCartesian product of `left` and `right`, keeping only pairs where\n`keep.(a, b)` is true, in row-major order.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule CartPair02 do\n  @spec run([term()], [term()], (term(), term() -> boolean())) :: [{term(), term()}]\n  def run(left, right, keep) when is_function(keep, 2) do\n    for a <- left, b <- right, keep.(a, b), do: {a, b}\n  end\nend\n```", "rejected": "```elixir\ndefmodule CartPair02 do\n  @spec run([term()], [term()], (term(), term() -> boolean())) :: [{term(), term()}]\n  def run(left, right, keep) when is_function(keep, 2) do\n    for a <- left, b <- right, do: {a, b}\n  end\nend\n```"}
+{"id": "round4.qwen25c3b.dpo.binaries.checksum8.v3.edge-empty", "family": "binaries", "source": "qwen25c3b_micro_round4_dpo", "weakness": "edge-empty", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `Checksum803` with:\n\n@spec frame(binary()) :: binary()\n    def frame(payload)\n\n    @spec verify(binary()) :: {:ok, binary()} | :error\n    def verify(frame)\n\n`frame/1` appends one checksum byte: the byte-sum of the payload mod 256.\n`verify/1` returns `{:ok, payload}` when the trailing byte matches, otherwise\n`:error`. An empty frame is `:error`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule Checksum803 do\n  @spec frame(binary()) :: binary()\n  def frame(payload) when is_binary(payload) do\n    <<payload::binary, sum(payload)>>\n  end\n\n  @spec verify(binary()) :: {:ok, binary()} | :error\n  def verify(<<payload::binary>>) when byte_size(payload) < 1, do: :error\n\n  def verify(frame) when is_binary(frame) do\n    body = binary_part(frame, 0, byte_size(frame) - 1)\n    <<checksum>> = binary_part(frame, byte_size(frame) - 1, 1)\n\n    if sum(body) == checksum, do: {:ok, body}, else: :error\n  end\n\n  defp sum(bin) do\n    Enum.reduce(:binary.bin_to_list(bin), 0, &+/2) |> rem(256)\n  end\nend\n```", "rejected": "```elixir\ndefmodule Checksum803 do\n  @spec frame(binary()) :: binary()\n  def frame(payload) when is_binary(payload) do\n    <<payload::binary, sum(payload)>>\n  end\n\n  @spec verify(binary()) :: {:ok, binary()} | :error\n  def verify(frame) when is_binary(frame) do\n    body = binary_part(frame, 0, byte_size(frame) - 1)\n    <<checksum>> = binary_part(frame, byte_size(frame) - 1, 1)\n\n    if sum(body) == checksum, do: {:ok, body}, else: :error\n  end\n\n  defp sum(bin) do\n    Enum.reduce(:binary.bin_to_list(bin), 0, &+/2) |> rem(256)\n  end\nend\n```"}
+{"id": "round4.qwen25c3b.dpo.otp.freqlog.edge-empty", "family": "otp", "source": "qwen25c3b_micro_round4_dpo", "weakness": "edge-empty", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `FreqLog` with:\n\n@spec start_link() :: {:ok, pid()}\n    def start_link()\n\n    @spec bump(pid(), term()) :: non_neg_integer()\n    def bump(pid, key)\n\n    @spec count(pid(), term()) :: non_neg_integer()\n    def count(pid, key)\n\nAgent frequency map. `bump/2` returns the new count; `count/2` is zero for\nunknown keys.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule FreqLog do\n  @spec start_link() :: {:ok, pid()}\n  def start_link, do: Agent.start_link(fn -> %{} end)\n\n  @spec bump(pid(), term()) :: non_neg_integer()\n  def bump(pid, key) do\n    Agent.get_and_update(pid, fn map ->\n      next = Map.update(map, key, 1, &(&1 + 1))\n      {Map.fetch!(next, key), next}\n    end)\n  end\n\n  @spec count(pid(), term()) :: non_neg_integer()\n  def count(pid, key), do: Agent.get(pid, &Map.get(&1, key, 0))\nend\n```", "rejected": "```elixir\ndefmodule FreqLog do\n  @spec start_link() :: {:ok, pid()}\n  def start_link, do: Agent.start_link(fn -> %{} end)\n\n  @spec bump(pid(), term()) :: non_neg_integer()\n  def bump(pid, key) do\n    Agent.get_and_update(pid, fn map ->\n      next = Map.update(map, key, 1, &(&1 + 1))\n      {Map.fetch!(next, key), next}\n    end)\n  end\n\n  @spec count(pid(), term()) :: non_neg_integer()\n  def count(pid, key), do: Agent.get(pid, &Map.fetch!(&1, key))\nend\n```"}
+{"id": "round4.qwen25c3b.dpo.errors.validatefields.v3.err-swallow", "family": "errors", "source": "qwen25c3b_micro_round4_dpo", "weakness": "err-swallow", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `ValidateFields03` with:\n\n@spec run(keyword()) :: :ok | {:error, [atom()]}\n    def run(fields)\n\nRequired keys are `[:name, :email]`. Return `:ok` when both are present,\notherwise `{:error, missing}` with the missing keys sorted alphabetically.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule ValidateFields03 do\n  @required [:name, :email]\n\n  @spec run(keyword()) :: :ok | {:error, [atom()]}\n  def run(fields) when is_list(fields) do\n    present = Keyword.keys(fields)\n    missing = Enum.reject(@required, &Enum.member?(present, &1))\n\n    case missing do\n      [] -> :ok\n      _missing -> {:error, Enum.sort(missing)}\n    end\n  end\nend\n```", "rejected": "```elixir\ndefmodule ValidateFields03 do\n  @required [:name, :email]\n\n  @spec run(keyword()) :: :ok | {:error, [atom()]}\n  def run(fields) when is_list(fields) do\n    present = Keyword.keys(fields)\n    missing = Enum.reject(@required, &Enum.member?(present, &1))\n\n    case missing do\n      [] -> :ok\n      _missing -> {:error, [hd(Enum.sort(missing))]}\n    end\n  end\nend\n```"}
+{"id": "round4.qwen25c3b.dpo.functional_style.transition_02.functional-style-process-state", "family": "functional", "source": "qwen25c3b_micro_round4_dpo", "weakness": "functional-style-process-state", "origin": "functional-style", "preference_kind": "functional-style", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `FnDpoStyleTransition02` with:\n\nDefine `step/2` for a state `%{total: integer, values: list}`. `{:add, value}` adds to the total and prepends the value; `:reset` returns an empty state.\n\nModel each event as a pure state transition with pattern clauses.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule FnDpoStyleTransition02 do\n  @spec step(%{total: integer(), values: [integer()]}, {:add, integer()} | :reset) :: map()\n  def step(state, {:add, value}) do\n    %{state | total: state.total + value, values: [value | state.values]}\n  end\n\n  def step(_state, :reset), do: %{total: 0, values: []}\nend\n```", "rejected": "```elixir\ndefmodule FnDpoStyleTransition02 do\n  @spec step(%{total: integer(), values: [integer()]}, {:add, integer()} | :reset) :: map()\n  def step(state, event) do\n    key = {__MODULE__, make_ref()}\n    Process.put(key, state)\n\n    case event do\n      {:add, value} ->\n        current = Process.get(key)\n        Process.put(key, %{current | total: current.total + value, values: [value | current.values]})\n\n      :reset ->\n        Process.put(key, %{total: 0, values: []})\n    end\n\n    result = Process.get(key)\n    Process.delete(key)\n    result\n  end\nend\n```"}
+{"id": "round4.qwen25c3b.dpo.functional_style.transition_03.functional-style-process-state", "family": "functional", "source": "qwen25c3b_micro_round4_dpo", "weakness": "functional-style-process-state", "origin": "functional-style", "preference_kind": "functional-style", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `FnDpoStyleTransition03` with:\n\nDefine `step/2` for a state `%{total: integer, values: list}`. `{:add, value}` adds to the total and prepends the value; `:reset` returns an empty state.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule FnDpoStyleTransition03 do\n  @spec step(%{total: integer(), values: [integer()]}, {:add, integer()} | :reset) :: map()\n  def step(state, {:add, value}) do\n    %{state | total: state.total + value, values: [value | state.values]}\n  end\n\n  def step(_state, :reset), do: %{total: 0, values: []}\nend\n```", "rejected": "```elixir\ndefmodule FnDpoStyleTransition03 do\n  @spec step(%{total: integer(), values: [integer()]}, {:add, integer()} | :reset) :: map()\n  def step(state, event) do\n    key = {__MODULE__, make_ref()}\n    Process.put(key, state)\n\n    case event do\n      {:add, value} ->\n        current = Process.get(key)\n        Process.put(key, %{current | total: current.total + value, values: [value | current.values]})\n\n      :reset ->\n        Process.put(key, %{total: 0, values: []})\n    end\n\n    result = Process.get(key)\n    Process.delete(key)\n    result\n  end\nend\n```"}
+{"id": "round4.qwen25c3b.dpo.functional_style.reduce_07.functional-style-agent-state", "family": "functional", "source": "qwen25c3b_micro_round4_dpo", "weakness": "functional-style-agent-state", "origin": "functional-style", "preference_kind": "functional-style", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `FnDpoStyleReduce07` with:\n\nDefine `run/1` to return a frequency map for all values in the list.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule FnDpoStyleReduce07 do\n  @spec run([term()]) :: map()\n  def run(values) when is_list(values) do\n    Enum.reduce(values, %{}, fn value, counts ->\n      Map.update(counts, value, 1, &(&1 + 1))\n    end)\n  end\nend\n```", "rejected": "```elixir\ndefmodule FnDpoStyleReduce07 do\n  @spec run([term()]) :: map()\n  def run(values) when is_list(values) do\n    {:ok, state} = Agent.start_link(fn -> %{} end)\n\n    Enum.each(values, fn value ->\n      Agent.update(state, &Map.update(&1, value, 1, fn count -> count + 1 end))\n    end)\n\n    counts = Agent.get(state, & &1)\n    Agent.stop(state)\n    counts\n  end\nend\n```"}
+{"id": "round4.qwen25c3b.dpo.functional_style.reduce_06.functional-style-agent-state", "family": "functional", "source": "qwen25c3b_micro_round4_dpo", "weakness": "functional-style-agent-state", "origin": "functional-style", "preference_kind": "functional-style", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `FnDpoStyleReduce06` with:\n\nDefine `run/1` to return a frequency map for all values in the list.\n\nThread one immutable map through `Enum.reduce/3`.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule FnDpoStyleReduce06 do\n  @spec run([term()]) :: map()\n  def run(values) when is_list(values) do\n    Enum.reduce(values, %{}, fn value, counts ->\n      Map.update(counts, value, 1, &(&1 + 1))\n    end)\n  end\nend\n```", "rejected": "```elixir\ndefmodule FnDpoStyleReduce06 do\n  @spec run([term()]) :: map()\n  def run(values) when is_list(values) do\n    {:ok, state} = Agent.start_link(fn -> %{} end)\n\n    Enum.each(values, fn value ->\n      Agent.update(state, &Map.update(&1, value, 1, fn count -> count + 1 end))\n    end)\n\n    counts = Agent.get(state, & &1)\n    Agent.stop(state)\n    counts\n  end\nend\n```"}
+{"id": "round4.qwen25c3b.dpo.functional_style.stable_unique_10.functional-style-append-accumulator", "family": "functional", "source": "qwen25c3b_micro_round4_dpo", "weakness": "functional-style-append-accumulator", "origin": "functional-style", "preference_kind": "functional-style", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `FnDpoStyleStableUnique10` with:\n\nDefine `run/1` to remove duplicate values while preserving their first occurrence.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule FnDpoStyleStableUnique10 do\n  @spec run([term()]) :: [term()]\n  def run(values) when is_list(values) do\n    {_seen, reversed} =\n      Enum.reduce(values, {MapSet.new(), []}, fn value, {seen, output} ->\n        if MapSet.member?(seen, value) do\n          {seen, output}\n        else\n          {MapSet.put(seen, value), [value | output]}\n        end\n      end)\n\n    Enum.reverse(reversed)\n  end\nend\n```", "rejected": "```elixir\ndefmodule FnDpoStyleStableUnique10 do\n  @spec run([term()]) :: [term()]\n  def run(values) when is_list(values) do\n    {_seen, output} =\n      Enum.reduce(values, {MapSet.new(), []}, fn value, {seen, output} ->\n        if MapSet.member?(seen, value) do\n          {seen, output}\n        else\n          {MapSet.put(seen, value), output ++ [value]}\n        end\n      end)\n\n    output\n  end\nend\n```"}
+{"id": "round4.qwen25c3b.dpo.functional_style.stable_unique_04.functional-style-append-accumulator", "family": "functional", "source": "qwen25c3b_micro_round4_dpo", "weakness": "functional-style-append-accumulator", "origin": "functional-style", "preference_kind": "functional-style", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-v1-dpo"], "conversations": [{"from": "system", "value": "You are a friendly coding assistant that helps with software engineering tasks."}, {"from": "human", "value": "Write a module `FnDpoStyleStableUnique04` with:\n\nDefine `run/1` to remove duplicate values while preserving their first occurrence.\n\nUse a `{seen, reversed}` reduction and reverse once.\n\nReply with a single ```elixir fence containing only the module."}], "chosen": "```elixir\ndefmodule FnDpoStyleStableUnique04 do\n  @spec run([term()]) :: [term()]\n  def run(values) when is_list(values) do\n    {_seen, reversed} =\n      Enum.reduce(values, {MapSet.new(), []}, fn value, {seen, output} ->\n        if MapSet.member?(seen, value) do\n          {seen, output}\n        else\n          {MapSet.put(seen, value), [value | output]}\n        end\n      end)\n\n    Enum.reverse(reversed)\n  end\nend\n```", "rejected": "```elixir\ndefmodule FnDpoStyleStableUnique04 do\n  @spec run([term()]) :: [term()]\n  def run(values) when is_list(values) do\n    {_seen, output} =\n      Enum.reduce(values, {MapSet.new(), []}, fn value, {seen, output} ->\n        if MapSet.member?(seen, value) do\n          {seen, output}\n        else\n          {MapSet.put(seen, value), output ++ [value]}\n        end\n      end)\n\n    output\n  end\nend\n```"}

data/onpolicy/qwen25c3b_micro_round6_kto.jsonl ADDED Viewed

	@@ -0,0 +1,22 @@

+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.stdlib.multisort.v2.enum-state.0.chosen", "family": "stdlib", "source": "qwen25c3b_micro_round6_kto", "weakness": "enum-state", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `MultiSort02` with:\n\n@spec run([map()]) :: [map()]\n    def run(items)\n\nEach item is a map with `:first` and `:last`. Sort ascending by `:last`,\nties broken by `:first`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule MultiSort02 do\n  @spec run([map()]) :: [map()]\n  def run(items) when is_list(items) do\n    Enum.sort_by(items, &{&1.last, &1.first})\n  end\nend\n```"}], "label": true}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.stdlib.multisort.v2.enum-state.0.rejected", "family": "stdlib", "source": "qwen25c3b_micro_round6_kto", "weakness": "enum-state", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `MultiSort02` with:\n\n@spec run([map()]) :: [map()]\n    def run(items)\n\nEach item is a map with `:first` and `:last`. Sort ascending by `:last`,\nties broken by `:first`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule MultiSort02 do\n  @spec run([map()]) :: [map()]\n  def run(items) when is_list(items) do\n    Enum.sort_by(items, & &1.last)\n  end\nend\n```"}], "label": false}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.collections.cartpair.v2.enum-state.0.chosen", "family": "collections", "source": "qwen25c3b_micro_round6_kto", "weakness": "enum-state", "origin": "handmade", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `CartPair02` with:\n\n@spec run([term()], [term()], (term(), term() -> boolean())) :: [{term(), term()}]\n    def run(left, right, keep)\n\nCartesian product of `left` and `right`, keeping only pairs where\n`keep.(a, b)` is true, in row-major order.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule CartPair02 do\n  @spec run([term()], [term()], (term(), term() -> boolean())) :: [{term(), term()}]\n  def run(left, right, keep) when is_function(keep, 2) do\n    for a <- left, b <- right, keep.(a, b), do: {a, b}\n  end\nend\n```"}], "label": true}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.collections.cartpair.v2.enum-state.0.rejected", "family": "collections", "source": "qwen25c3b_micro_round6_kto", "weakness": "enum-state", "origin": "handmade", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `CartPair02` with:\n\n@spec run([term()], [term()], (term(), term() -> boolean())) :: [{term(), term()}]\n    def run(left, right, keep)\n\nCartesian product of `left` and `right`, keeping only pairs where\n`keep.(a, b)` is true, in row-major order.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule CartPair02 do\n  @spec run([term()], [term()], (term(), term() -> boolean())) :: [{term(), term()}]\n  def run(left, right, keep) when is_function(keep, 2) do\n    for a <- left, b <- right, do: {a, b}\n  end\nend\n```"}], "label": false}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.binaries.checksum8.v3.edge-empty.chosen", "family": "binaries", "source": "qwen25c3b_micro_round6_kto", "weakness": "edge-empty", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `Checksum803` with:\n\n@spec frame(binary()) :: binary()\n    def frame(payload)\n\n    @spec verify(binary()) :: {:ok, binary()} | :error\n    def verify(frame)\n\n`frame/1` appends one checksum byte: the byte-sum of the payload mod 256.\n`verify/1` returns `{:ok, payload}` when the trailing byte matches, otherwise\n`:error`. An empty frame is `:error`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule Checksum803 do\n  @spec frame(binary()) :: binary()\n  def frame(payload) when is_binary(payload) do\n    <<payload::binary, sum(payload)>>\n  end\n\n  @spec verify(binary()) :: {:ok, binary()} | :error\n  def verify(<<payload::binary>>) when byte_size(payload) < 1, do: :error\n\n  def verify(frame) when is_binary(frame) do\n    body = binary_part(frame, 0, byte_size(frame) - 1)\n    <<checksum>> = binary_part(frame, byte_size(frame) - 1, 1)\n\n    if sum(body) == checksum, do: {:ok, body}, else: :error\n  end\n\n  defp sum(bin) do\n    Enum.reduce(:binary.bin_to_list(bin), 0, &+/2) |> rem(256)\n  end\nend\n```"}], "label": true}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.binaries.checksum8.v3.edge-empty.rejected", "family": "binaries", "source": "qwen25c3b_micro_round6_kto", "weakness": "edge-empty", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `Checksum803` with:\n\n@spec frame(binary()) :: binary()\n    def frame(payload)\n\n    @spec verify(binary()) :: {:ok, binary()} | :error\n    def verify(frame)\n\n`frame/1` appends one checksum byte: the byte-sum of the payload mod 256.\n`verify/1` returns `{:ok, payload}` when the trailing byte matches, otherwise\n`:error`. An empty frame is `:error`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule Checksum803 do\n  @spec frame(binary()) :: binary()\n  def frame(payload) when is_binary(payload) do\n    <<payload::binary, sum(payload)>>\n  end\n\n  @spec verify(binary()) :: {:ok, binary()} | :error\n  def verify(frame) when is_binary(frame) do\n    body = binary_part(frame, 0, byte_size(frame) - 1)\n    <<checksum>> = binary_part(frame, byte_size(frame) - 1, 1)\n\n    if sum(body) == checksum, do: {:ok, body}, else: :error\n  end\n\n  defp sum(bin) do\n    Enum.reduce(:binary.bin_to_list(bin), 0, &+/2) |> rem(256)\n  end\nend\n```"}], "label": false}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.otp.freqlog.edge-empty.chosen", "family": "otp", "source": "qwen25c3b_micro_round6_kto", "weakness": "edge-empty", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `FreqLog` with:\n\n@spec start_link() :: {:ok, pid()}\n    def start_link()\n\n    @spec bump(pid(), term()) :: non_neg_integer()\n    def bump(pid, key)\n\n    @spec count(pid(), term()) :: non_neg_integer()\n    def count(pid, key)\n\nAgent frequency map. `bump/2` returns the new count; `count/2` is zero for\nunknown keys.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule FreqLog do\n  @spec start_link() :: {:ok, pid()}\n  def start_link, do: Agent.start_link(fn -> %{} end)\n\n  @spec bump(pid(), term()) :: non_neg_integer()\n  def bump(pid, key) do\n    Agent.get_and_update(pid, fn map ->\n      next = Map.update(map, key, 1, &(&1 + 1))\n      {Map.fetch!(next, key), next}\n    end)\n  end\n\n  @spec count(pid(), term()) :: non_neg_integer()\n  def count(pid, key), do: Agent.get(pid, &Map.get(&1, key, 0))\nend\n```"}], "label": true}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.otp.freqlog.edge-empty.rejected", "family": "otp", "source": "qwen25c3b_micro_round6_kto", "weakness": "edge-empty", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `FreqLog` with:\n\n@spec start_link() :: {:ok, pid()}\n    def start_link()\n\n    @spec bump(pid(), term()) :: non_neg_integer()\n    def bump(pid, key)\n\n    @spec count(pid(), term()) :: non_neg_integer()\n    def count(pid, key)\n\nAgent frequency map. `bump/2` returns the new count; `count/2` is zero for\nunknown keys.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule FreqLog do\n  @spec start_link() :: {:ok, pid()}\n  def start_link, do: Agent.start_link(fn -> %{} end)\n\n  @spec bump(pid(), term()) :: non_neg_integer()\n  def bump(pid, key) do\n    Agent.get_and_update(pid, fn map ->\n      next = Map.update(map, key, 1, &(&1 + 1))\n      {Map.fetch!(next, key), next}\n    end)\n  end\n\n  @spec count(pid(), term()) :: non_neg_integer()\n  def count(pid, key), do: Agent.get(pid, &Map.fetch!(&1, key))\nend\n```"}], "label": false}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.errors.validatefields.v3.err-swallow.chosen", "family": "errors", "source": "qwen25c3b_micro_round6_kto", "weakness": "err-swallow", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `ValidateFields03` with:\n\n@spec run(keyword()) :: :ok | {:error, [atom()]}\n    def run(fields)\n\nRequired keys are `[:name, :email]`. Return `:ok` when both are present,\notherwise `{:error, missing}` with the missing keys sorted alphabetically.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule ValidateFields03 do\n  @required [:name, :email]\n\n  @spec run(keyword()) :: :ok | {:error, [atom()]}\n  def run(fields) when is_list(fields) do\n    present = Keyword.keys(fields)\n    missing = Enum.reject(@required, &Enum.member?(present, &1))\n\n    case missing do\n      [] -> :ok\n      _missing -> {:error, Enum.sort(missing)}\n    end\n  end\nend\n```"}], "label": true}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.errors.validatefields.v3.err-swallow.rejected", "family": "errors", "source": "qwen25c3b_micro_round6_kto", "weakness": "err-swallow", "origin": "designed", "preference_kind": "correctness", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `ValidateFields03` with:\n\n@spec run(keyword()) :: :ok | {:error, [atom()]}\n    def run(fields)\n\nRequired keys are `[:name, :email]`. Return `:ok` when both are present,\notherwise `{:error, missing}` with the missing keys sorted alphabetically.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule ValidateFields03 do\n  @required [:name, :email]\n\n  @spec run(keyword()) :: :ok | {:error, [atom()]}\n  def run(fields) when is_list(fields) do\n    present = Keyword.keys(fields)\n    missing = Enum.reject(@required, &Enum.member?(present, &1))\n\n    case missing do\n      [] -> :ok\n      _missing -> {:error, [hd(Enum.sort(missing))]}\n    end\n  end\nend\n```"}], "label": false}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.functional_style.transition_02.functional-style-process-state.chosen", "family": "functional", "source": "qwen25c3b_micro_round6_kto", "weakness": "functional-style-process-state", "origin": "functional-style", "preference_kind": "functional-style", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `FnDpoStyleTransition02` with:\n\nDefine `step/2` for a state `%{total: integer, values: list}`. `{:add, value}` adds to the total and prepends the value; `:reset` returns an empty state.\n\nModel each event as a pure state transition with pattern clauses.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule FnDpoStyleTransition02 do\n  @spec step(%{total: integer(), values: [integer()]}, {:add, integer()} | :reset) :: map()\n  def step(state, {:add, value}) do\n    %{state | total: state.total + value, values: [value | state.values]}\n  end\n\n  def step(_state, :reset), do: %{total: 0, values: []}\nend\n```"}], "label": true}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.functional_style.transition_02.functional-style-process-state.rejected", "family": "functional", "source": "qwen25c3b_micro_round6_kto", "weakness": "functional-style-process-state", "origin": "functional-style", "preference_kind": "functional-style", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `FnDpoStyleTransition02` with:\n\nDefine `step/2` for a state `%{total: integer, values: list}`. `{:add, value}` adds to the total and prepends the value; `:reset` returns an empty state.\n\nModel each event as a pure state transition with pattern clauses.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule FnDpoStyleTransition02 do\n  @spec step(%{total: integer(), values: [integer()]}, {:add, integer()} | :reset) :: map()\n  def step(state, event) do\n    key = {__MODULE__, make_ref()}\n    Process.put(key, state)\n\n    case event do\n      {:add, value} ->\n        current = Process.get(key)\n        Process.put(key, %{current | total: current.total + value, values: [value | current.values]})\n\n      :reset ->\n        Process.put(key, %{total: 0, values: []})\n    end\n\n    result = Process.get(key)\n    Process.delete(key)\n    result\n  end\nend\n```"}], "label": false}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.functional_style.transition_03.functional-style-process-state.chosen", "family": "functional", "source": "qwen25c3b_micro_round6_kto", "weakness": "functional-style-process-state", "origin": "functional-style", "preference_kind": "functional-style", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `FnDpoStyleTransition03` with:\n\nDefine `step/2` for a state `%{total: integer, values: list}`. `{:add, value}` adds to the total and prepends the value; `:reset` returns an empty state.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule FnDpoStyleTransition03 do\n  @spec step(%{total: integer(), values: [integer()]}, {:add, integer()} | :reset) :: map()\n  def step(state, {:add, value}) do\n    %{state | total: state.total + value, values: [value | state.values]}\n  end\n\n  def step(_state, :reset), do: %{total: 0, values: []}\nend\n```"}], "label": true}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.functional_style.transition_03.functional-style-process-state.rejected", "family": "functional", "source": "qwen25c3b_micro_round6_kto", "weakness": "functional-style-process-state", "origin": "functional-style", "preference_kind": "functional-style", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `FnDpoStyleTransition03` with:\n\nDefine `step/2` for a state `%{total: integer, values: list}`. `{:add, value}` adds to the total and prepends the value; `:reset` returns an empty state.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule FnDpoStyleTransition03 do\n  @spec step(%{total: integer(), values: [integer()]}, {:add, integer()} | :reset) :: map()\n  def step(state, event) do\n    key = {__MODULE__, make_ref()}\n    Process.put(key, state)\n\n    case event do\n      {:add, value} ->\n        current = Process.get(key)\n        Process.put(key, %{current | total: current.total + value, values: [value | current.values]})\n\n      :reset ->\n        Process.put(key, %{total: 0, values: []})\n    end\n\n    result = Process.get(key)\n    Process.delete(key)\n    result\n  end\nend\n```"}], "label": false}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.functional_style.reduce_07.functional-style-agent-state.chosen", "family": "functional", "source": "qwen25c3b_micro_round6_kto", "weakness": "functional-style-agent-state", "origin": "functional-style", "preference_kind": "functional-style", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `FnDpoStyleReduce07` with:\n\nDefine `run/1` to return a frequency map for all values in the list.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule FnDpoStyleReduce07 do\n  @spec run([term()]) :: map()\n  def run(values) when is_list(values) do\n    Enum.reduce(values, %{}, fn value, counts ->\n      Map.update(counts, value, 1, &(&1 + 1))\n    end)\n  end\nend\n```"}], "label": true}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.functional_style.reduce_07.functional-style-agent-state.rejected", "family": "functional", "source": "qwen25c3b_micro_round6_kto", "weakness": "functional-style-agent-state", "origin": "functional-style", "preference_kind": "functional-style", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `FnDpoStyleReduce07` with:\n\nDefine `run/1` to return a frequency map for all values in the list.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule FnDpoStyleReduce07 do\n  @spec run([term()]) :: map()\n  def run(values) when is_list(values) do\n    {:ok, state} = Agent.start_link(fn -> %{} end)\n\n    Enum.each(values, fn value ->\n      Agent.update(state, &Map.update(&1, value, 1, fn count -> count + 1 end))\n    end)\n\n    counts = Agent.get(state, & &1)\n    Agent.stop(state)\n    counts\n  end\nend\n```"}], "label": false}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.functional_style.reduce_06.functional-style-agent-state.chosen", "family": "functional", "source": "qwen25c3b_micro_round6_kto", "weakness": "functional-style-agent-state", "origin": "functional-style", "preference_kind": "functional-style", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `FnDpoStyleReduce06` with:\n\nDefine `run/1` to return a frequency map for all values in the list.\n\nThread one immutable map through `Enum.reduce/3`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule FnDpoStyleReduce06 do\n  @spec run([term()]) :: map()\n  def run(values) when is_list(values) do\n    Enum.reduce(values, %{}, fn value, counts ->\n      Map.update(counts, value, 1, &(&1 + 1))\n    end)\n  end\nend\n```"}], "label": true}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.functional_style.reduce_06.functional-style-agent-state.rejected", "family": "functional", "source": "qwen25c3b_micro_round6_kto", "weakness": "functional-style-agent-state", "origin": "functional-style", "preference_kind": "functional-style", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `FnDpoStyleReduce06` with:\n\nDefine `run/1` to return a frequency map for all values in the list.\n\nThread one immutable map through `Enum.reduce/3`.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule FnDpoStyleReduce06 do\n  @spec run([term()]) :: map()\n  def run(values) when is_list(values) do\n    {:ok, state} = Agent.start_link(fn -> %{} end)\n\n    Enum.each(values, fn value ->\n      Agent.update(state, &Map.update(&1, value, 1, fn count -> count + 1 end))\n    end)\n\n    counts = Agent.get(state, & &1)\n    Agent.stop(state)\n    counts\n  end\nend\n```"}], "label": false}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.functional_style.stable_unique_10.functional-style-append-accumulator.chosen", "family": "functional", "source": "qwen25c3b_micro_round6_kto", "weakness": "functional-style-append-accumulator", "origin": "functional-style", "preference_kind": "functional-style", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `FnDpoStyleStableUnique10` with:\n\nDefine `run/1` to remove duplicate values while preserving their first occurrence.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule FnDpoStyleStableUnique10 do\n  @spec run([term()]) :: [term()]\n  def run(values) when is_list(values) do\n    {_seen, reversed} =\n      Enum.reduce(values, {MapSet.new(), []}, fn value, {seen, output} ->\n        if MapSet.member?(seen, value) do\n          {seen, output}\n        else\n          {MapSet.put(seen, value), [value | output]}\n        end\n      end)\n\n    Enum.reverse(reversed)\n  end\nend\n```"}], "label": true}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.functional_style.stable_unique_10.functional-style-append-accumulator.rejected", "family": "functional", "source": "qwen25c3b_micro_round6_kto", "weakness": "functional-style-append-accumulator", "origin": "functional-style", "preference_kind": "functional-style", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `FnDpoStyleStableUnique10` with:\n\nDefine `run/1` to remove duplicate values while preserving their first occurrence.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule FnDpoStyleStableUnique10 do\n  @spec run([term()]) :: [term()]\n  def run(values) when is_list(values) do\n    {_seen, output} =\n      Enum.reduce(values, {MapSet.new(), []}, fn value, {seen, output} ->\n        if MapSet.member?(seen, value) do\n          {seen, output}\n        else\n          {MapSet.put(seen, value), output ++ [value]}\n        end\n      end)\n\n    output\n  end\nend\n```"}], "label": false}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.functional_style.stable_unique_04.functional-style-append-accumulator.chosen", "family": "functional", "source": "qwen25c3b_micro_round6_kto", "weakness": "functional-style-append-accumulator", "origin": "functional-style", "preference_kind": "functional-style", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `FnDpoStyleStableUnique04` with:\n\nDefine `run/1` to remove duplicate values while preserving their first occurrence.\n\nUse a `{seen, reversed}` reduction and reverse once.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule FnDpoStyleStableUnique04 do\n  @spec run([term()]) :: [term()]\n  def run(values) when is_list(values) do\n    {_seen, reversed} =\n      Enum.reduce(values, {MapSet.new(), []}, fn value, {seen, output} ->\n        if MapSet.member?(seen, value) do\n          {seen, output}\n        else\n          {MapSet.put(seen, value), [value | output]}\n        end\n      end)\n\n    Enum.reverse(reversed)\n  end\nend\n```"}], "label": true}
+{"id": "round6.qwen25c3b.round4.qwen25c3b.dpo.functional_style.stable_unique_04.functional-style-append-accumulator.rejected", "family": "functional", "source": "qwen25c3b_micro_round6_kto", "weakness": "functional-style-append-accumulator", "origin": "functional-style", "preference_kind": "functional-style", "models": ["qwen2.5-coder-3b-extra-layer-elixir-micro-round3-kto"], "prompt": [{"role": "system", "content": "You are a friendly coding assistant that helps with software engineering tasks."}, {"role": "user", "content": "Write a module `FnDpoStyleStableUnique04` with:\n\nDefine `run/1` to remove duplicate values while preserving their first occurrence.\n\nUse a `{seen, reversed}` reduction and reverse once.\n\nReply with a single ```elixir fence containing only the module."}], "completion": [{"role": "assistant", "content": "```elixir\ndefmodule FnDpoStyleStableUnique04 do\n  @spec run([term()]) :: [term()]\n  def run(values) when is_list(values) do\n    {_seen, output} =\n      Enum.reduce(values, {MapSet.new(), []}, fn value, {seen, output} ->\n        if MapSet.member?(seen, value) do\n          {seen, output}\n        else\n          {MapSet.put(seen, value), output ++ [value]}\n        end\n      end)\n\n    output\n  end\nend\n```"}], "label": false}

metadata/dataset_stats.json ADDED Viewed

	@@ -0,0 +1,606 @@

+{
+  "repo": "jmarceno/elixir-preference",
+  "total_rows": 909,
+  "files": [
+    {
+      "path": "data/dpo/dpo_failv0.jsonl",
+      "source": "publish/hf/_stage/elixir-preference/data/dpo/dpo_failv0.jsonl",
+      "rows": 654,
+      "sha256": "f27eb2c2ffcbea068ef03ad4c1c116e2b91cd5f5c60d01e107cd00e188ddc043",
+      "bytes": 1048704,
+      "characters": 460060,
+      "fields": [
+        "chosen",
+        "conversations",
+        "family",
+        "id",
+        "models",
+        "origin",
+        "preference_kind",
+        "rejected",
+        "source",
+        "weakness"
+      ],
+      "families": {
+        "abstractions": 41,
+        "beam": 66,
+        "binaries": 119,
+        "collections": 37,
+        "core": 41,
+        "errors": 47,
+        "functional": 120,
+        "otp": 134,
+        "stdlib": 49
+      },
+      "pack_overlap": {
+        "elixir_eval_v1.jsonl": {
+          "prompt_collisions": 0,
+          "module_collisions": 0
+        },
+        "elixir_eval_v2.jsonl": {
+          "prompt_collisions": 0,
+          "module_collisions": 0
+        }
+      },
+      "preference_kind": {
+        "correctness": 534,
+        "functional-style": 120
+      },
+      "origin": {
+        "designed": 411,
+        "functional-style": 120,
+        "handmade": 123
+      },
+      "weakness": {
+        "bin-bitwise": 6,
+        "bin-endian": 24,
+        "bin-signed": 21,
+        "bin-size-guard": 33,
+        "edge-empty": 42,
+        "enum-state": 99,
+        "err-swallow": 42,
+        "err-with-else": 15,
+        "ets-api": 6,
+        "fn-guard": 15,
+        "format-hygiene": 114,
+        "functional-style-agent-state": 40,
+        "functional-style-append-accumulator": 10,
+        "functional-style-manual-rebuild": 10,
+        "functional-style-multiple-passes": 10,
+        "functional-style-process-state": 40,
+        "functional-style-repeated-scan": 10,
+        "otp-cast-call": 15,
+        "otp-handle-info": 3,
+        "otp-supervision": 24,
+        "otp-task-await": 15,
+        "otp-timeout": 12,
+        "persistent-term": 9,
+        "protocol-behaviour": 21,
+        "stdlib-misuse": 18
+      }
+    },
+    {
+      "path": "data/kto/kto_v0.jsonl",
+      "source": "publish/hf/_stage/elixir-preference/data/kto/kto_v0.jsonl",
+      "rows": 76,
+      "sha256": "35737e168213360fb79cca7c1d577fba6b86a460919f4cfe898b642da7b7ee98",
+      "bytes": 75384,
+      "characters": 44173,
+      "fields": [
+        "completion",
+        "family",
+        "id",
+        "label",
+        "preference_kind",
+        "prompt",
+        "source",
+        "weakness"
+      ],
+      "families": {
+        "binaries": 10,
+        "core": 2,
+        "errors": 2,
+        "format": 2,
+        "functional": 40,
+        "otp": 12,
+        "protocol": 4,
+        "stdlib": 4
+      },
+      "pack_overlap": {
+        "elixir_eval_v1.jsonl": {
+          "prompt_collisions": 0,
+          "module_collisions": 0
+        },
+        "elixir_eval_v2.jsonl": {
+          "prompt_collisions": 0,
+          "module_collisions": 0
+        }
+      },
+      "preference_kind": {
+        "correctness": 36,
+        "functional-style": 40
+      },
+      "weakness": {
+        "bin-bitwise": 2,
+        "bin-signed": 2,
+        "bin-size-guard": 2,
+        "edge-absent-key": 2,
+        "edge-empty": 2,
+        "edge-nil-result": 2,
+        "enum-state": 2,
+        "err-with-else": 4,
+        "fn-guard": 2,
+        "format-hygiene": 2,
+        "functional-comprehension": 2,
+        "functional-early-halt": 2,
+        "functional-get-and-update": 2,
+        "functional-immutable-accumulator": 2,
+        "functional-iodata": 2,
+        "functional-lazy-stream": 2,
+        "functional-linear-recursion": 2,
+        "functional-nested-update": 2,
+        "functional-pattern-clauses": 2,
+        "functional-pipeline": 2,
+        "functional-pure-transition": 2,
+        "functional-reduce": 2,
+        "functional-set-operation": 2,
+        "functional-single-pass": 2,
+        "functional-state-threading": 2,
+        "functional-tagged-flow": 2,
+        "functional-unfold": 2,
+        "functional-zip-with": 2,
+        "otp-cast-call": 2,
+        "otp-handle-info": 2,
+        "otp-supervision": 2,
+        "otp-task-await": 2,
+        "otp-timeout": 2,
+        "protocol-behaviour": 4,
+        "stdlib-byte-vs-grapheme": 2,
+        "stdlib-safe-deserialization": 2
+      },
+      "label": {
+        "False": 38,
+        "True": 38
+      }
+    },
+    {
+      "path": "data/onpolicy/qwen25c3b_micro_dpo_v1.jsonl",
+      "source": "publish/hf/_stage/elixir-preference/data/onpolicy/qwen25c3b_micro_dpo_v1.jsonl",
+      "rows": 36,
+      "sha256": "07568a3a77ba0a9e9f2b1d434f373a10d7d953d0f2f13531037fe86a8221c83f",
+      "bytes": 57067,
+      "characters": 26322,
+      "fields": [
+        "chosen",
+        "conversations",
+        "family",
+        "id",
+        "models",
+        "origin",
+        "preference_kind",
+        "rejected",
+        "source",
+        "weakness"
+      ],
+      "families": {
+        "abstractions": 2,
+        "beam": 7,
+        "binaries": 9,
+        "collections": 3,
+        "core": 2,
+        "errors": 1,
+        "otp": 9,
+        "stdlib": 3
+      },
+      "pack_overlap": {
+        "elixir_eval_v1.jsonl": {
+          "prompt_collisions": 0,
+          "module_collisions": 0
+        },
+        "elixir_eval_v2.jsonl": {
+          "prompt_collisions": 0,
+          "module_collisions": 0
+        }
+      },
+      "preference_kind": {
+        "correctness": 36
+      },
+      "origin": {
+        "designed": 27,
+        "handmade": 9
+      },
+      "weakness": {
+        "bin-bitwise": 2,
+        "bin-endian": 2,
+        "bin-signed": 2,
+        "bin-size-guard": 2,
+        "edge-empty": 2,
+        "enum-state": 2,
+        "err-swallow": 2,
+        "err-with-else": 2,
+        "ets-api": 2,
+        "fn-guard": 2,
+        "format-hygiene": 2,
+        "otp-cast-call": 2,
+        "otp-supervision": 2,
+        "otp-task-await": 2,
+        "otp-timeout": 2,
+        "persistent-term": 2,
+        "protocol-behaviour": 2,
+        "stdlib-misuse": 2
+      }
+    },
+    {
+      "path": "data/onpolicy/qwen25c3b_micro_round2_dpo.jsonl",
+      "source": "publish/hf/_stage/elixir-preference/data/onpolicy/qwen25c3b_micro_round2_dpo.jsonl",
+      "rows": 25,
+      "sha256": "f119688017c19d217f5a009fac20f59b6a4da9905457b16d7190b02498a82cd8",
+      "bytes": 42058,
+      "characters": 19358,
+      "fields": [
+        "chosen",
+        "conversations",
+        "family",
+        "id",
+        "models",
+        "origin",
+        "preference_kind",
+        "rejected",
+        "source",
+        "weakness"
+      ],
+      "families": {
+        "abstractions": 3,
+        "beam": 3,
+        "binaries": 4,
+        "collections": 1,
+        "core": 2,
+        "errors": 4,
+        "otp": 6,
+        "stdlib": 2
+      },
+      "pack_overlap": {
+        "elixir_eval_v1.jsonl": {
+          "prompt_collisions": 0,
+          "module_collisions": 0
+        },
+        "elixir_eval_v2.jsonl": {
+          "prompt_collisions": 0,
+          "module_collisions": 0
+        }
+      },
+      "preference_kind": {
+        "correctness": 25
+      },
+      "origin": {
+        "designed": 19,
+        "handmade": 6
+      },
+      "weakness": {
+        "bin-size-guard": 3,
+        "edge-empty": 3,
+        "enum-state": 3,
+        "err-swallow": 3,
+        "err-with-else": 2,
+        "fn-guard": 1,
+        "otp-cast-call": 3,
+        "otp-supervision": 2,
+        "otp-task-await": 1,
+        "otp-timeout": 1,
+        "persistent-term": 1,
+        "protocol-behaviour": 1,
+        "stdlib-misuse": 1
+      }
+    },
+    {
+      "path": "data/onpolicy/qwen25c3b_micro_round4_dpo.jsonl",
+      "source": "publish/hf/_stage/elixir-preference/data/onpolicy/qwen25c3b_micro_round4_dpo.jsonl",
+      "rows": 11,
+      "sha256": "6f55c1192573313eb315e238e7f0e25f83f2581dd7aecc63833222c2aa6b6532",
+      "bytes": 17273,
+      "characters": 6953,
+      "fields": [
+        "chosen",
+        "conversations",
+        "family",
+        "id",
+        "models",
+        "origin",
+        "preference_kind",
+        "rejected",
+        "source",
+        "weakness"
+      ],
+      "families": {
+        "binaries": 1,
+        "collections": 1,
+        "errors": 1,
+        "functional": 6,
+        "otp": 1,
+        "stdlib": 1
+      },
+      "pack_overlap": {
+        "elixir_eval_v1.jsonl": {
+          "prompt_collisions": 0,
+          "module_collisions": 0
+        },
+        "elixir_eval_v2.jsonl": {
+          "prompt_collisions": 0,
+          "module_collisions": 0
+        }
+      },
+      "preference_kind": {
+        "correctness": 5,
+        "functional-style": 6
+      },
+      "origin": {
+        "designed": 4,
+        "functional-style": 6,
+        "handmade": 1
+      },
+      "weakness": {
+        "edge-empty": 2,
+        "enum-state": 2,
+        "err-swallow": 1,
+        "functional-style-agent-state": 2,
+        "functional-style-append-accumulator": 2,
+        "functional-style-process-state": 2
+      }
+    },
+    {
+      "path": "data/onpolicy/qwen25c3b_micro_round13_dpo.jsonl",
+      "source": "publish/hf/_stage/elixir-preference/data/onpolicy/qwen25c3b_micro_round13_dpo.jsonl",
+      "rows": 17,
+      "sha256": "36e22759596a2ea7dc39e5b8f92bf0a9cdbac628cd233535782e70c0630a8bd2",
+      "bytes": 25677,
+      "characters": 11000,
+      "fields": [
+        "chosen",
+        "conversations",
+        "family",
+        "id",
+        "models",
+        "origin",
+        "preference_kind",
+        "rejected",
+        "source",
+        "weakness"
+      ],
+      "families": {
+        "abstractions": 2,
+        "beam": 2,
+        "binaries": 2,
+        "collections": 2,
+        "core": 2,
+        "errors": 2,
+        "otp": 2,
+        "stdlib": 3
+      },
+      "pack_overlap": {
+        "elixir_eval_v1.jsonl": {
+          "prompt_collisions": 0,
+          "module_collisions": 0
+        },
+        "elixir_eval_v2.jsonl": {
+          "prompt_collisions": 0,
+          "module_collisions": 0
+        }
+      },
+      "preference_kind": {
+        "correctness": 17
+      },
+      "origin": {
+        "fresh-authored-round11-repacked": 17
+      },
+      "weakness": {
+        "behaviour-contract-arity": 1,
+        "date-diff-direction": 1,
+        "ets-tagged-lookup": 1,
+        "exact-big-endian-frame": 1,
+        "genserver-call-state": 1,
+        "inclusive-guard-boundary": 1,
+        "optional-callback-default": 1,
+        "pattern-match-empty-case": 1,
+        "process-timer-reference": 1,
+        "reduce-nil-maximum": 1,
+        "reduce-order-preservation": 1,
+        "regex-named-capture": 1,
+        "rescue-and-after": 1,
+        "sub-byte-bit-syntax": 1,
+        "supervised-task-await": 1,
+        "tagged-strict-parse": 1,
+        "uri-query-decoding": 1
+      }
+    },
+    {
+      "path": "data/onpolicy/qwen25c3b_micro_round3_kto.jsonl",
+      "source": "publish/hf/_stage/elixir-preference/data/onpolicy/qwen25c3b_micro_round3_kto.jsonl",
+      "rows": 34,
+      "sha256": "17642df15cc328fdf789f8491c73b4a3e0618920d967d1cc06c3cb6a8b59158c",
+      "bytes": 37855,
+      "characters": 20468,
+      "fields": [
+        "completion",
+        "family",
+        "id",
+        "label",
+        "models",
+        "origin",
+        "preference_kind",
+        "prompt",
+        "source",
+        "weakness"
+      ],
+      "families": {
+        "binaries": 10,
+        "core": 2,
+        "errors": 2,
+        "otp": 12,
+        "protocol": 4,
+        "stdlib": 4
+      },
+      "pack_overlap": {
+        "elixir_eval_v1.jsonl": {
+          "prompt_collisions": 0,
+          "module_collisions": 0
+        },
+        "elixir_eval_v2.jsonl": {
+          "prompt_collisions": 0,
+          "module_collisions": 0
+        }
+      },
+      "preference_kind": {
+        "correctness": 34
+      },
+      "origin": {
+        "None": 34
+      },
+      "weakness": {
+        "bin-bitwise": 2,
+        "bin-signed": 2,
+        "bin-size-guard": 2,
+        "edge-empty": 2,
+        "edge-nil-result": 2,
+        "enum-state": 2,
+        "err-with-else": 2,
+        "fn-guard": 2,
+        "otp-cast-call": 2,
+        "otp-handle-info": 2,
+        "otp-supervision": 2,
+        "otp-task-await": 2,
+        "otp-timeout": 2,
+        "protocol-behaviour": 4,
+        "stdlib-byte-vs-grapheme": 2,
+        "stdlib-safe-deserialization": 2
+      },
+      "label": {
+        "False": 17,
+        "True": 17
+      }
+    },
+    {
+      "path": "data/onpolicy/qwen25c3b_micro_round6_kto.jsonl",
+      "source": "publish/hf/_stage/elixir-preference/data/onpolicy/qwen25c3b_micro_round6_kto.jsonl",
+      "rows": 22,
+      "sha256": "dba0ce8fe08a964af7f9e56b90731229e5359bbca44be299879a9cb159e111b4",
+      "bytes": 27434,
+      "characters": 14549,
+      "fields": [
+        "completion",
+        "family",
+        "id",
+        "label",
+        "models",
+        "origin",
+        "preference_kind",
+        "prompt",
+        "source",
+        "weakness"
+      ],
+      "families": {
+        "binaries": 2,
+        "collections": 2,
+        "errors": 2,
+        "functional": 12,
+        "otp": 2,
+        "stdlib": 2
+      },
+      "pack_overlap": {
+        "elixir_eval_v1.jsonl": {
+          "prompt_collisions": 0,
+          "module_collisions": 0
+        },
+        "elixir_eval_v2.jsonl": {
+          "prompt_collisions": 0,
+          "module_collisions": 0
+        }
+      },
+      "preference_kind": {
+        "correctness": 10,
+        "functional-style": 12
+      },
+      "origin": {
+        "designed": 8,
+        "functional-style": 12,
+        "handmade": 2
+      },
+      "weakness": {
+        "edge-empty": 4,
+        "enum-state": 4,
+        "err-swallow": 2,
+        "functional-style-agent-state": 4,
+        "functional-style-append-accumulator": 4,
+        "functional-style-process-state": 4
+      },
+      "label": {
+        "False": 11,
+        "True": 11
+      }
+    },
+    {
+      "path": "data/onpolicy/qwen25c3b_micro_round11_kto.jsonl",
+      "source": "publish/hf/_stage/elixir-preference/data/onpolicy/qwen25c3b_micro_round11_kto.jsonl",
+      "rows": 34,
+      "sha256": "7c844c0e7107ba608bca9e2e92b5e010c3bdd8e15327f64437f437b1472f40d5",
+      "bytes": 39628,
+      "characters": 21397,
+      "fields": [
+        "completion",
+        "family",
+        "id",
+        "label",
+        "models",
+        "preference_kind",
+        "prompt",
+        "source",
+        "weakness"
+      ],
+      "families": {
+        "abstractions": 4,
+        "beam": 4,
+        "binaries": 4,
+        "collections": 4,
+        "core": 4,
+        "errors": 4,
+        "otp": 4,
+        "stdlib": 6
+      },
+      "pack_overlap": {
+        "elixir_eval_v1.jsonl": {
+          "prompt_collisions": 0,
+          "module_collisions": 0
+        },
+        "elixir_eval_v2.jsonl": {
+          "prompt_collisions": 0,
+          "module_collisions": 0
+        }
+      },
+      "preference_kind": {
+        "correctness": 34
+      },
+      "weakness": {
+        "behaviour-contract-arity": 2,
+        "date-diff-direction": 2,
+        "ets-tagged-lookup": 2,
+        "exact-big-endian-frame": 2,
+        "genserver-call-state": 2,
+        "inclusive-guard-boundary": 2,
+        "optional-callback-default": 2,
+        "pattern-match-empty-case": 2,
+        "process-timer-reference": 2,
+        "reduce-nil-maximum": 2,
+        "reduce-order-preservation": 2,
+        "regex-named-capture": 2,
+        "rescue-and-after": 2,
+        "sub-byte-bit-syntax": 2,
+        "supervised-task-await": 2,
+        "tagged-strict-parse": 2,
+        "uri-query-decoding": 2
+      },
+      "label": {
+        "False": 17,
+        "True": 17
+      }
+    }
+  ]
+}

metadata/manifests/qwen25c3b_micro_dpo_v1.manifest.json ADDED Viewed

	@@ -0,0 +1,33 @@

+{
+  "recipe": "qwen25c3b-micro-dpo-v1",
+  "base_checkpoint": "outputs/continue/qwen25c3b-sft2-final",
+  "frozen_pack": "eval/pack/elixir_eval_v1.jsonl",
+  "source": "sft/elixir_dpo_failv0.jsonl",
+  "source_sha256": "f27eb2c2ffcbea068ef03ad4c1c116e2b91cd5f5c60d01e107cd00e188ddc043",
+  "selection": "two unique normalized prompts per abstract weakness; no benchmark task rows",
+  "validation": {
+    "rows": 36,
+    "weaknesses": {
+      "otp-supervision": 2,
+      "edge-empty": 2,
+      "format-hygiene": 2,
+      "err-swallow": 2,
+      "enum-state": 2,
+      "persistent-term": 2,
+      "protocol-behaviour": 2,
+      "ets-api": 2,
+      "fn-guard": 2,
+      "bin-size-guard": 2,
+      "stdlib-misuse": 2,
+      "bin-signed": 2,
+      "otp-task-await": 2,
+      "otp-cast-call": 2,
+      "bin-endian": 2,
+      "err-with-else": 2,
+      "otp-timeout": 2,
+      "bin-bitwise": 2
+    },
+    "pack_prompt_collisions": 0,
+    "pack_module_collisions": 0
+  }
+}

metadata/manifests/qwen25c3b_micro_round11.manifest.json ADDED Viewed

	@@ -0,0 +1,625 @@

+{
+  "recipe": "qwen25c3b_micro_round11_kto",
+  "backend": "unsloth",
+  "base_checkpoint": "outputs/continue/qwen25c3b-micro-round3-kto/qwen25c3b-targeted-kto-final",
+  "phases": [
+    "kto"
+  ],
+  "no_cpt": true,
+  "selection": {
+    "source": "17 fresh authored generic construction contracts",
+    "benchmark_rows": "none; fresh prompts and module names authored independently",
+    "preference_signal": "semantic test failure only; formatting is identical Elixir fencing"
+  },
+  "frozen_pack": "eval/pack/elixir_eval_v1.jsonl",
+  "counts": {
+    "rows": 34,
+    "pairs": 17,
+    "labels": {
+      "true": 17,
+      "false": 17
+    },
+    "by_family": {
+      "core": 4,
+      "collections": 4,
+      "binaries": 4,
+      "errors": 4,
+      "otp": 4,
+      "beam": 4,
+      "abstractions": 4,
+      "stdlib": 6
+    },
+    "by_weakness": {
+      "pattern-match-empty-case": 2,
+      "inclusive-guard-boundary": 2,
+      "reduce-nil-maximum": 2,
+      "reduce-order-preservation": 2,
+      "exact-big-endian-frame": 2,
+      "sub-byte-bit-syntax": 2,
+      "tagged-strict-parse": 2,
+      "rescue-and-after": 2,
+      "genserver-call-state": 2,
+      "supervised-task-await": 2,
+      "ets-tagged-lookup": 2,
+      "process-timer-reference": 2,
+      "behaviour-contract-arity": 2,
+      "optional-callback-default": 2,
+      "uri-query-decoding": 2,
+      "regex-named-capture": 2,
+      "date-diff-direction": 2
+    }
+  },
+  "validation": {
+    "pairs": 17,
+    "rows": 34,
+    "pack_prompt_collisions": 0,
+    "pack_module_collisions": 0,
+    "scorer_checks": [
+      {
+        "id": "core.head_or_fallback",
+        "chosen": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 0,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": true,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        },
+        "rejected": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 1,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": false,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        }
+      },
+      {
+        "id": "core.guard_window",
+        "chosen": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 0,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": true,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        },
+        "rejected": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 1,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": false,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        }
+      },
+      {
+        "id": "collections.reduce_summary",
+        "chosen": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 0,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": true,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        },
+        "rejected": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 1,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": false,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        }
+      },
+      {
+        "id": "collections.partition_order",
+        "chosen": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 0,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": true,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        },
+        "rejected": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 1,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": false,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        }
+      },
+      {
+        "id": "binaries.big_frame",
+        "chosen": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 0,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": true,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        },
+        "rejected": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 1,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": false,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        }
+      },
+      {
+        "id": "binaries.nibble_pair",
+        "chosen": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 0,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": true,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        },
+        "rejected": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 1,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": false,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        }
+      },
+      {
+        "id": "errors.strict_number",
+        "chosen": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 0,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": true,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        },
+        "rejected": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 1,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": false,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        }
+      },
+      {
+        "id": "errors.rescue_cleanup",
+        "chosen": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 0,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": true,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        },
+        "rejected": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 1,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": false,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        }
+      },
+      {
+        "id": "otp.mailbox",
+        "chosen": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 0,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": true,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        },
+        "rejected": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 1,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": false,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        }
+      },
+      {
+        "id": "otp.supervised_map",
+        "chosen": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 0,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": true,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        },
+        "rejected": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 1,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": false,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        }
+      },
+      {
+        "id": "beam.ets_fetch",
+        "chosen": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 0,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": true,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        },
+        "rejected": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 1,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": false,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        }
+      },
+      {
+        "id": "beam.ref_timer",
+        "chosen": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 0,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": true,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        },
+        "rejected": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 1,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": false,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        }
+      },
+      {
+        "id": "abstractions.contract_call",
+        "chosen": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 0,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": true,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        },
+        "rejected": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 1,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": false,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        }
+      },
+      {
+        "id": "abstractions.optional_callback",
+        "chosen": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 0,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": true,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        },
+        "rejected": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 1,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": false,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        }
+      },
+      {
+        "id": "stdlib.query_map",
+        "chosen": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 0,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": true,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        },
+        "rejected": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 1,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": false,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        }
+      },
+      {
+        "id": "stdlib.named_capture",
+        "chosen": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 0,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": true,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        },
+        "rejected": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 1,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": false,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        }
+      },
+      {
+        "id": "stdlib.date_delta",
+        "chosen": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 0,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": true,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        },
+        "rejected": {
+          "compile_ok": true,
+          "error": "",
+          "failures": 1,
+          "format_ok": true,
+          "parse_ok": true,
+          "pass": false,
+          "static_failures": [],
+          "static_ok": true,
+          "timeout": false,
+          "total": 1,
+          "warning_count": 0,
+          "warning_free": true,
+          "output_format_ok": true
+        }
+      }
+    ]
+  },
+  "sha256": {
+    "pack": "945f41d2f09b3cd4e3a483837f0225d05737be0aa5554a2e0e8eb7cb011d1f05",
+    "output": "7c844c0e7107ba608bca9e2e92b5e010c3bdd8e15327f64437f437b1472f40d5"
+  }
+}

metadata/manifests/qwen25c3b_micro_round13.manifest.json ADDED Viewed

	@@ -0,0 +1,34 @@

+{
+  "recipe": "qwen25c3b_micro_round13_dpo",
+  "backend": "unsloth",
+  "base_checkpoint": "outputs/continue/qwen25c3b-micro-round3-kto/qwen25c3b-targeted-kto-final",
+  "phases": [
+    "dpo"
+  ],
+  "no_cpt": true,
+  "source": "kto/qwen25c3b_micro_round11_kto.jsonl",
+  "source_manifest": "kto/qwen25c3b_micro_round11.manifest.json",
+  "frozen_pack": "eval/pack/elixir_eval_v1.jsonl",
+  "selection": "same 17 fresh authored contracts as round 11; KTO sides repacked as DPO pairs",
+  "counts": {
+    "rows": 17,
+    "pairs": 17,
+    "pack_prompt_collisions": 0,
+    "pack_module_collisions": 0,
+    "by_family": {
+      "abstractions": 2,
+      "beam": 2,
+      "binaries": 2,
+      "collections": 2,
+      "core": 2,
+      "errors": 2,
+      "otp": 2,
+      "stdlib": 3
+    }
+  },
+  "sha256": {
+    "source": "7c844c0e7107ba608bca9e2e92b5e010c3bdd8e15327f64437f437b1472f40d5",
+    "output": "36e22759596a2ea7dc39e5b8f92bf0a9cdbac628cd233535782e70c0630a8bd2",
+    "pack": "945f41d2f09b3cd4e3a483837f0225d05737be0aa5554a2e0e8eb7cb011d1f05"
+  }
+}

metadata/manifests/qwen25c3b_micro_round2.manifest.json ADDED Viewed

	@@ -0,0 +1,898 @@

+{
+  "recipe": "qwen25c3b_micro_round2_sft_dpo",
+  "backend": "unsloth",
+  "base_checkpoint": "outputs/continue/qwen25c3b-micro-v1-dpo/qwen25c3b-targeted-dpo-final",
+  "phases": [
+    "sft",
+    "dpo"
+  ],
+  "no_cpt": true,
+  "selection": {
+    "sft": "six fresh normalized prompts per benchmark family from evalfmt_v0",
+    "dpo": "up to three fresh scorer-gated prompts per construction weakness; format-only pairs excluded",
+    "benchmark_rows": "never selected; prompt and module collisions rejected"
+  },
+  "sources": {
+    "sft": "sft/elixir_sft_evalfmt_v0.jsonl",
+    "dpo": "sft/elixir_dpo_failv0.jsonl",
+    "previous_dpo": "sft/qwen25c3b_micro_dpo_v1.jsonl",
+    "frozen_pack": "eval/pack/elixir_eval_v1.jsonl"
+  },
+  "counts": {
+    "sft": 48,
+    "dpo": 25,
+    "sft_by_family": {
+      "core": 6,
+      "collections": 6,
+      "errors": 6,
+      "binaries": 6,
+      "otp": 6,
+      "beam": 6,
+      "abstractions": 6,
+      "stdlib": 6
+    },
+    "dpo_by_weakness": {
+      "enum-state": 3,
+      "edge-empty": 3,
+      "err-swallow": 3,
+      "err-with-else": 2,
+      "bin-size-guard": 3,
+      "fn-guard": 1,
+      "persistent-term": 1,
+      "otp-cast-call": 3,
+      "otp-task-await": 1,
+      "otp-timeout": 1,
+      "otp-supervision": 2,
+      "protocol-behaviour": 1,
+      "stdlib-misuse": 1
+    }
+  },
+  "validation": {
+    "pack_prompt_collisions": 0,
+    "pack_module_collisions": 0,
+    "dpo": {
+      "rows": 25,
+      "scorer_checks": [
+        {
+          "id": "dpo.abstractions.facade.enum-state",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 2,
+            "warning_free": false,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.abstractions.overridable.v2.enum-state",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": false,
+            "error": "generated.ex: cannot compile module StepDemo (errors have been logged)",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 0,
+            "warning_count": 0,
+            "warning_free": false,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.core.tuplerotate.v3.enum-state",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 1,
+            "warning_free": false,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.core.poppath.v2.edge-empty",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.collections.firstrerun.v3.edge-empty",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 1,
+            "warning_free": false,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.stdlib.bizdays.v3.edge-empty",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 1,
+            "warning_free": false,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.errors.catchtag.v3.err-swallow",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": false,
+            "error": "generated.ex: cannot compile module CatchKind03 (errors have been logged)",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 0,
+            "warning_count": 0,
+            "warning_free": false,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.errors.mapresults.err-swallow",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.binaries.mpxframe.v2.err-swallow",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.errors.safecleanup.v3.err-with-else",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.errors.gradeof.err-with-else",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.binaries.lenboxle.v3.bin-size-guard",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.binaries.lenbox.v3.bin-size-guard",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.binaries.bitflags.v2.bin-size-guard",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.otp.asyncuniqcount.fn-guard",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 1,
+            "warning_free": false,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.beam.appflag.persistent-term",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.otp.stampstore.v2.otp-cast-call",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 1,
+            "warning_free": false,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.otp.rategate.otp-cast-call",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [
+              "missing call: GenServer.call/3"
+            ],
+            "static_ok": false,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 1,
+            "warning_free": false,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.otp.tapecell.otp-cast-call",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.otp.suprun.v3.otp-task-await",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.otp.stoplater.v3.otp-timeout",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [
+              "missing call: GenServer.call/3"
+            ],
+            "static_ok": false,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.beam.linktrap.otp-supervision",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.beam.atomicvec.v3.otp-supervision",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [
+              "missing call: :atomics.new/2"
+            ],
+            "static_ok": false,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.abstractions.areacalc.protocol-behaviour.1",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [
+              "missing source fragment: defprotocol AreaCalc",
+              "missing source fragment: defimpl AreaCalc"
+            ],
+            "static_ok": false,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.stdlib.uribuild.stdlib-misuse",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        }
+      ]
+    }
+  },
+  "sha256": {
+    "sft_source": "9b1a79cfda41e9ac59270c8b45693ae0cc641e961ed44e92a2e610090c2772df",
+    "dpo_source": "f27eb2c2ffcbea068ef03ad4c1c116e2b91cd5f5c60d01e107cd00e188ddc043",
+    "previous_dpo": "07568a3a77ba0a9e9f2b1d434f373a10d7d953d0f2f13531037fe86a8221c83f"
+  }
+}

metadata/manifests/qwen25c3b_micro_round3.manifest.json ADDED Viewed

	@@ -0,0 +1,51 @@

+{
+  "recipe": "qwen25c3b_micro_round3_kto",
+  "backend": "unsloth",
+  "base_checkpoint": "outputs/continue/qwen25c3b-micro-v1-dpo/qwen25c3b-targeted-dpo-final",
+  "phases": [
+    "kto"
+  ],
+  "no_cpt": true,
+  "selection": "all semantic correctness pairs from KTO v0; format-only pair excluded",
+  "source": "kto/elixir_kto_v0.jsonl",
+  "frozen_pack": "eval/pack/elixir_eval_v1.jsonl",
+  "validation": {
+    "rows": 34,
+    "pairs": 17,
+    "labels": {
+      "true": 17,
+      "false": 17
+    },
+    "families": {
+      "otp": 12,
+      "binaries": 10,
+      "core": 2,
+      "protocol": 4,
+      "errors": 2,
+      "stdlib": 4
+    },
+    "weaknesses": {
+      "otp-cast-call": 2,
+      "bin-size-guard": 2,
+      "otp-task-await": 2,
+      "otp-supervision": 2,
+      "fn-guard": 2,
+      "protocol-behaviour": 4,
+      "bin-bitwise": 2,
+      "err-with-else": 2,
+      "stdlib-byte-vs-grapheme": 2,
+      "stdlib-safe-deserialization": 2,
+      "edge-nil-result": 2,
+      "bin-signed": 2,
+      "edge-empty": 2,
+      "enum-state": 2,
+      "otp-timeout": 2,
+      "otp-handle-info": 2
+    },
+    "pack_prompt_collisions": 0,
+    "pack_module_collisions": 0
+  },
+  "sha256": {
+    "source": "35737e168213360fb79cca7c1d577fba6b86a460919f4cfe898b642da7b7ee98"
+  }
+}

metadata/manifests/qwen25c3b_micro_round4.manifest.json ADDED Viewed

	@@ -0,0 +1,436 @@

+{
+  "recipe": "qwen25c3b_micro_round4_dpo",
+  "backend": "unsloth",
+  "base_checkpoint": "outputs/continue/qwen25c3b-micro-v1-dpo/qwen25c3b-targeted-dpo-final",
+  "phases": [
+    "dpo"
+  ],
+  "no_cpt": true,
+  "selection": {
+    "semantic": "two fresh scorer-gated pairs for enum-state and edge-empty, one for err-swallow",
+    "functional": "two fresh scorer-gated pairs for three disjoint functional construction weaknesses",
+    "format": "chosen and rejected re-fenced so format is not the preference signal",
+    "benchmark_rows": "never selected; prompt and module collisions rejected"
+  },
+  "source": "sft/elixir_dpo_failv0.jsonl",
+  "previous_data": [
+    "sft/qwen25c3b_micro_dpo_v1.jsonl",
+    "sft/qwen25c3b_micro_round2_dpo.jsonl",
+    "kto/qwen25c3b_micro_round3_kto.jsonl"
+  ],
+  "frozen_pack": "eval/pack/elixir_eval_v1.jsonl",
+  "counts": {
+    "rows": 11,
+    "by_weakness": {
+      "enum-state": 2,
+      "edge-empty": 2,
+      "err-swallow": 1,
+      "functional-style-process-state": 2,
+      "functional-style-agent-state": 2,
+      "functional-style-append-accumulator": 2
+    },
+    "by_family": {
+      "stdlib": 1,
+      "collections": 1,
+      "binaries": 1,
+      "otp": 1,
+      "errors": 1,
+      "functional": 6
+    }
+  },
+  "validation": {
+    "pack_prompt_collisions": 0,
+    "pack_module_collisions": 0,
+    "dpo": {
+      "rows": 11,
+      "scorer_checks": [
+        {
+          "id": "dpo.stdlib.multisort.v2.enum-state.0",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.collections.cartpair.v2.enum-state.0",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.binaries.checksum8.v3.edge-empty",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.otp.freqlog.edge-empty",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.errors.validatefields.v3.err-swallow",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 1,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.functional_style.transition_02.functional-style-process-state",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [
+              "forbidden call: Process.put/2",
+              "missing source fragment: def step(state, {:add, value})",
+              "missing source fragment: def step(_state, :reset)"
+            ],
+            "static_ok": false,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.functional_style.transition_03.functional-style-process-state",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [
+              "forbidden call: Process.put/2",
+              "missing source fragment: def step(state, {:add, value})",
+              "missing source fragment: def step(_state, :reset)"
+            ],
+            "static_ok": false,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.functional_style.reduce_07.functional-style-agent-state",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [
+              "missing call: Enum.reduce/3",
+              "forbidden call: Agent.start_link/1"
+            ],
+            "static_ok": false,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.functional_style.reduce_06.functional-style-agent-state",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [
+              "missing call: Enum.reduce/3",
+              "forbidden call: Agent.start_link/1"
+            ],
+            "static_ok": false,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.functional_style.stable_unique_10.functional-style-append-accumulator",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [
+              "missing call: Enum.reverse/1",
+              "forbidden source fragment: ++"
+            ],
+            "static_ok": false,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        },
+        {
+          "id": "dpo.functional_style.stable_unique_04.functional-style-append-accumulator",
+          "chosen": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": true,
+            "static_failures": [],
+            "static_ok": true,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          },
+          "rejected": {
+            "compile_ok": true,
+            "error": "",
+            "failures": 0,
+            "format_ok": true,
+            "parse_ok": true,
+            "pass": false,
+            "static_failures": [
+              "missing call: Enum.reverse/1",
+              "forbidden source fragment: ++"
+            ],
+            "static_ok": false,
+            "timeout": false,
+            "total": 1,
+            "warning_count": 0,
+            "warning_free": true,
+            "output_format_ok": true
+          }
+        }
+      ]
+    }
+  },
+  "sha256": {
+    "source": "f27eb2c2ffcbea068ef03ad4c1c116e2b91cd5f5c60d01e107cd00e188ddc043"
+  }
+}

metadata/manifests/qwen25c3b_micro_round6.manifest.json ADDED Viewed

	@@ -0,0 +1,51 @@

+{
+  "recipe": "qwen25c3b_micro_round6_kto",
+  "backend": "unsloth",
+  "base_checkpoint": "outputs/continue/qwen25c3b-micro-round3-kto/qwen25c3b-targeted-kto-final",
+  "phases": [
+    "kto"
+  ],
+  "no_cpt": true,
+  "selection": {
+    "source": "the 11 fresh round4 DPO pairs, preserving both labels",
+    "quality": "chosen and rejected completions inherited the round4 scorer gate",
+    "benchmark_rows": "never selected; prompt and module collisions rejected"
+  },
+  "source": "sft/qwen25c3b_micro_round4_dpo.jsonl",
+  "source_manifest": "sft/qwen25c3b_micro_round4.manifest.json",
+  "frozen_pack": "eval/pack/elixir_eval_v1.jsonl",
+  "counts": {
+    "rows": 22,
+    "pairs": 11,
+    "labels": {
+      "true": 11,
+      "false": 11
+    },
+    "by_family": {
+      "stdlib": 2,
+      "collections": 2,
+      "binaries": 2,
+      "otp": 2,
+      "errors": 2,
+      "functional": 12
+    },
+    "by_weakness": {
+      "enum-state": 4,
+      "edge-empty": 4,
+      "err-swallow": 2,
+      "functional-style-process-state": 4,
+      "functional-style-agent-state": 4,
+      "functional-style-append-accumulator": 4
+    }
+  },
+  "validation": {
+    "pack_prompt_collisions": 0,
+    "pack_module_collisions": 0,
+    "chosen_rows": 11,
+    "rejected_rows": 11,
+    "source_sha256": "6f55c1192573313eb315e238e7f0e25f83f2581dd7aecc63833222c2aa6b6532"
+  },
+  "sha256": {
+    "output": "dba0ce8fe08a964af7f9e56b90731229e5359bbca44be299879a9cb159e111b4"
+  }
+}

metadata/provenance.json ADDED Viewed

	@@ -0,0 +1,14 @@

+{
+  "repo": "jmarceno/elixir-preference",
+  "source_repository": "model-training",
+  "source_commit": "708d0d52ee564a1a4e5656ce6afc67505e33938b",
+  "built_at_utc": "2026-10-26T11:50:21Z",
+  "license": "Apache-2.0",
+  "excluded_by_design": [
+    "all CPT corpora (elixir_cpt_v0, fp_cpt_v1, mini_elixir_cpt_v0, minicpm5 CPT batches)",
+    "elixir_sft_v0.jsonl (frozen ShareGPT dump kept as a negative example)",
+    "dataset originals under domains/elixir/sft/originals/",
+    "the frozen eval packs under domains/elixir/eval/pack/"
+  ],
+  "row_schema_note": "Files are copied byte-for-byte from the source paths listed in metadata/dataset_stats.json; no row was rewritten, reordered, or filtered."
+}

metadata/sha256sums.txt ADDED Viewed

	@@ -0,0 +1,9 @@

+f27eb2c2ffcbea068ef03ad4c1c116e2b91cd5f5c60d01e107cd00e188ddc043  data/dpo/dpo_failv0.jsonl
+35737e168213360fb79cca7c1d577fba6b86a460919f4cfe898b642da7b7ee98  data/kto/kto_v0.jsonl
+07568a3a77ba0a9e9f2b1d434f373a10d7d953d0f2f13531037fe86a8221c83f  data/onpolicy/qwen25c3b_micro_dpo_v1.jsonl
+f119688017c19d217f5a009fac20f59b6a4da9905457b16d7190b02498a82cd8  data/onpolicy/qwen25c3b_micro_round2_dpo.jsonl
+6f55c1192573313eb315e238e7f0e25f83f2581dd7aecc63833222c2aa6b6532  data/onpolicy/qwen25c3b_micro_round4_dpo.jsonl
+36e22759596a2ea7dc39e5b8f92bf0a9cdbac628cd233535782e70c0630a8bd2  data/onpolicy/qwen25c3b_micro_round13_dpo.jsonl
+17642df15cc328fdf789f8491c73b4a3e0618920d967d1cc06c3cb6a8b59158c  data/onpolicy/qwen25c3b_micro_round3_kto.jsonl
+dba0ce8fe08a964af7f9e56b90731229e5359bbca44be299879a9cb159e111b4  data/onpolicy/qwen25c3b_micro_round6_kto.jsonl
+7c844c0e7107ba608bca9e2e92b5e010c3bdd8e15327f64437f437b1472f40d5  data/onpolicy/qwen25c3b_micro_round11_kto.jsonl