Update original media workflow tasks

MANIFEST.json

@@ -1,196 +1,476 @@
 {
   "files": {
     "README.md": {
-      "bytes": 966,
-      "sha256": "bd0d465f995e6e88f99a624901bbf6577b31c7230a4ff959ca48516be0339af7"
+      "bytes": 1033,
+      "sha256": "4788fd92c347b0f30ec74e278f1c8d24e91eea0e1fd6106178bb29876e0bc4bd"
     },
     "SOURCE_LOCK.json": {
-      "bytes": 328,
-      "sha256": "df3acef0a949edac8c6ec87a15e4d7c5a87534a83d49186549699a59bdf22f98"
+      "bytes": 332,
+      "sha256": "a3f67ba6d525a1fdffbc87093b0a2b4ee12b7c482b95050dfd7b27b09d19143d"
     },
-    "components/skillsdesk/.dockerignore": {
+    "components/qemedia/.dockerignore": {
       "bytes": 29,
       "sha256": "60c9bdd905fcf45ac485c680d32e9773962cf061b6f041dcddd033911558a672"
     },
-    "components/skillsdesk/ADAPTER_NOTICE": {
-      "bytes": 167,
-      "sha256": "843b71a3a9f9de899cbb9d260d55c9bd082f3df2b7771a1c31100ce5767a0a53"
+    "components/qemedia/ADAPTER_NOTICE": {
+      "bytes": 301,
+      "sha256": "5991dc74fa45e42c24120d3ddf4fd39c92f908f44986c71cf658c5b12deda80b"
     },
-    "components/skillsdesk/Dockerfile": {
-      "bytes": 1010,
-      "sha256": "4f047d60bc07987131be2c9cf0662c6e6feef91125adda81eda04d4b88882f6b"
+    "components/qemedia/Dockerfile": {
+      "bytes": 978,
+      "sha256": "0edae3727291af6b7ed7b3d38bf94d4aaa2c42c01c4d748d676ef9045de1c8df"
     },
-    "components/skillsdesk/LICENSE": {
-      "bytes": 11358,
-      "sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30"
+    "components/qemedia/LICENSE": {
+      "bytes": 1074,
+      "sha256": "e0a8e97900a1184396b65bca8507d5c7b1a6df58537b61722dfe0f416990f0e2"
     },
-    "components/skillsdesk/NOTICE": {
-      "bytes": 676,
-      "sha256": "dca813e02ab76d4bc5afdcd2a2de3480d3fc0a7a710edea24c395adf23a99883"
+    "components/qemedia/README.md": {
+      "bytes": 293,
+      "sha256": "1f6d860d8285f6297e5381c08925a1ece2bf88eb5b0344b10740269e222a060d"
     },
-    "components/skillsdesk/README.md": {
-      "bytes": 303,
-      "sha256": "11775067d2cfb4c254084dd741f0b13a1a5058081c171712bdb9923d430a9cd4"
+    "components/qemedia/SOURCE_MANIFEST.json": {
+      "bytes": 11903,
+      "sha256": "f97c7ed6f032ebf9e6276f6156c447a2f128739858fc243143d72b86443292f3"
     },
-    "components/skillsdesk/SOURCE_MANIFEST.json": {
-      "bytes": 3982,
-      "sha256": "789ef47ecb391dfe876f65207ba8f477b064c1d9cded1becaf177ae7112a3d99"
+    "components/qemedia/THIRD_PARTY_NOTICES": {
+      "bytes": 4448,
+      "sha256": "755b9132babde91fb34bf29a7759c3cead1299484335fcafdb057fd207f210b8"
     },
-    "components/skillsdesk/UPSTREAM_DOCKERFILE": {
-      "bytes": 1899,
-      "sha256": "2c07033febd78777deeff04350ae6887c9bb170b152d38c26cf148efa1b75d1e"
+    "components/qemedia/UPSTREAM_DOCKERFILE": {
+      "bytes": 2415,
+      "sha256": "acb6b642cd8d1c4f66e8a82a2cc97c9d4643ca484422e225505c0ea2b739e146"
     },
-    "components/skillsdesk/UPSTREAM_TRAINING_TASKS.txt": {
-      "bytes": 666,
-      "sha256": "90e6e08d4269b5bb8308b5f2f05c61aa0cb9b71643b6abe6e47b34795828dd1e"
+    "components/qemedia/runtime/qemedia_compat/__init__.py": {
+      "bytes": 66,
+      "sha256": "bd90e5f33d8c325c978e826c5e7a73e4ad73ff535f367ddfed0dec3d52470ade"
     },
-    "components/skillsdesk/runtime/common/__init__.py": {
-      "bytes": 1,
-      "sha256": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b"
+    "components/qemedia/runtime/qemedia_compat/environment.py": {
+      "bytes": 7410,
+      "sha256": "0fbea553dc22fa2fd72a4590c2c008eeefaa4af5654a2e9936465c18c79c9149"
     },
-    "components/skillsdesk/runtime/common/contracts.py": {
-      "bytes": 1015,
-      "sha256": "b1e1429208e84aefc2422ee1d2400ad793c43cd5c0e8db213a3b669fe0947ce1"
+    "components/qemedia/runtime/qemedia_compat/server.py": {
+      "bytes": 543,
+      "sha256": "1d41688c822b842c70f32502d627c252fcd3526c7be74d6880f2f86d06df981a"
     },
-    "components/skillsdesk/runtime/common/models.py": {
+    "components/qemedia/upstream/qe_arena/__init__.py": {
+      "bytes": 72,
+      "sha256": "f1ce27b1c58f9547059e7f820aa65c1a8d8313144855ee8845b2eca91f7e0db3"
+    },
+    "components/qemedia/upstream/qe_arena/app.py": {
+      "bytes": 791,
+      "sha256": "2925e44219fdef6310ac1e2b60532e3ba1f1e768b33e65f14f1f5e8f86b33510"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/__init__.py": {
+      "bytes": 5497,
+      "sha256": "978aabadc5044616ff28ab7be69a2e9ff48f1fd82494a6897f4f2b8716283a08"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/aggregate_risk_factors.py": {
+      "bytes": 2512,
+      "sha256": "0485dfbc2676a1f666958935602cc2f347e5fcd95b6bfcd32e8af13cafe07e35"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/alternate_chat_roles.py": {
+      "bytes": 2402,
+      "sha256": "f999a088228120810c986f249964ba83d7a54a4853c9bebcbf61313b4362247e"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/amortization_schedule.py": {
+      "bytes": 2769,
+      "sha256": "4b4f6e1280956988736c2401747ed0c3d633eedfe38e7d24ec815773f5c21711"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/api_complexity_level.py": {
+      "bytes": 2122,
+      "sha256": "21517da739674bdc2b22efe9c2a2a7a85d47a7033aae3e24b2c1da8b4ac21684"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/artifact_retention_keep.py": {
+      "bytes": 2817,
+      "sha256": "71db4461633e0ad524e11c2384d75675331a515778ce4a8b675c6f738c94a02c"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/backoff_schedule.py": {
+      "bytes": 2091,
+      "sha256": "1f1937c25f4717a49a6e809ea81cc20da035f6aa843d4f47ce111b585e3ab4a2"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/badge_dimensions.py": {
+      "bytes": 2054,
+      "sha256": "2661b8a01fb4d7d1a31169592eaae370b3d4260d6b32187ce4427ffbcfa097ea"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/baseline_verdict.py": {
+      "bytes": 2121,
+      "sha256": "b1d44ea5c1b774f8572374e73468ca34483e3b382c982c28a368549da94656d5"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/booking_conflicts.py": {
+      "bytes": 2577,
+      "sha256": "01764d4994630e38a91a6599f90142a9b145084dbd5971c564727ac9855f97f8"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/boundary_violations.py": {
+      "bytes": 4373,
+      "sha256": "7f70d489eefbdae5794354fa457a39dc50eb0209929cb0f3a9f9493b41adc88a"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/brace_delta.py": {
+      "bytes": 1937,
+      "sha256": "04d411ac8a666d3916c13090c7658e5cc516028ced9b0db45a334062d96683c5"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/calibration_fit.py": {
+      "bytes": 2530,
+      "sha256": "6f0982869b0ef19ec7b95863008ea45b1a46dbd46108ee24b44338a383a37d23"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/chat_completion_result.py": {
+      "bytes": 4015,
+      "sha256": "42b4727623069a0e774e0d70be6cb9869d871b377ddb6421c60bfa78bd3be126"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/claim_steal_priority.py": {
+      "bytes": 2528,
+      "sha256": "f5c6486256438b89565cc1edcaf016d6e91f3c81067a77a30c9792cac7d0ef39"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/compare_versions.py": {
+      "bytes": 2384,
+      "sha256": "a77352fd67a18a9c24c3fe697c9310b079c998dc853c2f49eba1a2c877742a62"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/complexity_bucket.py": {
+      "bytes": 2333,
+      "sha256": "5e4e65b458e8cd2e9723206e43ea3a85d37df8b82c9f15e19f4da5ce26dd72ff"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/compound_interest.py": {
+      "bytes": 2693,
+      "sha256": "3979785d451cc4473ec2b057a404f0a8ea930bd11ce34bedea06f1b953ee9c08"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/convert_timecode.py": {
+      "bytes": 2696,
+      "sha256": "30ff0142461a624790a13766f9463c6fd6f21991442e5e37d46febd51f2ca7ad"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/coverage_gap_severity.py": {
+      "bytes": 2027,
+      "sha256": "af3e694760997b353678c7350b08e43ed26de256792221420006e5d4837712d5"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/crop_to_aspect.py": {
+      "bytes": 2252,
+      "sha256": "f85c6167be7fe0094e36b90d19fb4e382a2e804a34dc96fa09f379caf97d5904"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/debounce_switch.py": {
+      "bytes": 2416,
+      "sha256": "61e8975cc643b0bd4d10656d48a77a7314b5e13382794bdcbecf19f2a80b3186"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/decay_table.py": {
+      "bytes": 2553,
+      "sha256": "949197b79f96f244ccba1b44236510ec65d8c9aace59850cde4949697791024f"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/efficiency_reward.py": {
+      "bytes": 2167,
+      "sha256": "c5033c7d0a147c46e9cf1659187879b00e8f253725f1fcc00b6c4e5529c9685b"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/expense_violations.py": {
+      "bytes": 2567,
+      "sha256": "11d505901f9d2e00cc5b475d9cca75b4770db77345c1645b10e70620710a70b0"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/find_stop.py": {
+      "bytes": 2930,
+      "sha256": "284d4fcd6c5cb23efc4282659991d9a403b46c0d836641071ad7079d8d2c8d0d"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/flakiness_pattern.py": {
+      "bytes": 2283,
+      "sha256": "b3b94bcfe78f97b00187e7fe9783a8ae04b9a9b6af6d788f445f64bd52021aa0"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/flaky_hunter_reward.py": {
       "bytes": 1941,
-      "sha256": "6a1ac8e55af6168d3fdd6b17c700a15cf0546b6154773aa3c59c97d6bffa2ffd"
+      "sha256": "11c670fbe537cbeeaa101d9b9db49519f5ebd4cca82b7ccfd66d5d68e352e5ba"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/flaky_run_summary.py": {
+      "bytes": 2235,
+      "sha256": "f6ebbaffe1dd8aaccef7ad8ce48d8dfa60bacc8a44051880057c52b163e7748b"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/format_duration.py": {
+      "bytes": 1843,
+      "sha256": "7e0cf537d1bd38fdbc474bc259a52fbf23f095f35661586d771eca0561481eb0"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/gguf_loader.py": {
+      "bytes": 4031,
+      "sha256": "e232fbfe97a36cedf848caa11b9bf51828c5f4c6fe6ad3bf40133c6bc7deabd7"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/gguf_special_ids.py": {
+      "bytes": 4671,
+      "sha256": "b5fc54e4b3f6b45af2af289a746fe48d948e806b43910920e6ee31c81bbd805e"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/glob_match.py": {
+      "bytes": 2785,
+      "sha256": "52d8da6da1348af21303785a5dabfe36a42f7efeaed9b326b21898387a3e6536"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/income_tax.py": {
+      "bytes": 2997,
+      "sha256": "ce28e349ed362052dd0184dc4f1e215344831edc2f74ebe8438c470964fc70a3"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/integer_edge_values.py": {
+      "bytes": 2422,
+      "sha256": "edd468fbc9d11830559fbcc2bfb1d7afe35c71980432bb91c87d8c3571a704b7"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/ip_allowlist_match.py": {
+      "bytes": 3267,
+      "sha256": "94bc28736f587e3cc350fef83ba95fe70dc44db627bcb037f854332f6b52e7fd"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/is_collection_endpoint.py": {
+      "bytes": 2344,
+      "sha256": "87db0af0b61c0b95b0d8acf9235835db9631f9471d0e7dc29b0296abc76bccde"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/latency_percentiles.py": {
+      "bytes": 2250,
+      "sha256": "7d91f4eb06374851748cbd3e33ae5f3d2059a491572449d4fc700ecaaed1431c"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/login_rate_limit.py": {
+      "bytes": 2464,
+      "sha256": "814fc40372c1ece5068b04848f9c8a2a9069d504cf364df62c00a905d0ec777c"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/loudness_gain.py": {
+      "bytes": 2668,
+      "sha256": "ecc262d19d2b27970901017aa4a006ad2ce97861866ccddae2a9c876c4bbec37"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/mail_merge.py": {
+      "bytes": 2873,
+      "sha256": "2c3ec2cb2f5e050ff03d772675c372053fe3eb957f505a33d2d127916ee283bf"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/maintainability_index.py": {
+      "bytes": 1856,
+      "sha256": "48972588b8f75f1132aaf0eaa112a35875833b7dc661e3c41ff6972f3ce29dd5"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/maintenance_status.py": {
+      "bytes": 2875,
+      "sha256": "201bad40ff156e6a0caec2577011286262178000435aacaec83c603ba02aa4f8"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/merge_intervals.py": {
+      "bytes": 2602,
+      "sha256": "fd5b0f08e59fc763734cdb43d4cd893ce851403281a806902f5945ce71e7e7cd"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/mod_inverse.py": {
+      "bytes": 1845,
+      "sha256": "888558da6833e82d1b2dafadf39aa87609cf5c4bcc96345a4e37ac92cfd1d0de"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/mod_pow.py": {
+      "bytes": 1729,
+      "sha256": "58cdc61459945cdd9bf20ab09cfa422c85148d76fecfc70567ef81b1240c2f36"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/networkdays.py": {
+      "bytes": 2293,
+      "sha256": "1c72218af8a816d24fc7ba7d88901c83db49c056da34efea5f2ba491a77493d2"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/normalize_rational.py": {
+      "bytes": 2629,
+      "sha256": "62e849358e01be48618529568005a1b487b411bdc18a01b4c226b824f77320df"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/parse_cron_field.py": {
+      "bytes": 3288,
+      "sha256": "6275cc4556df344a4dfccbcdf5930e9561bcb27b93fcb247c9707a84c48f3231"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/parse_max_age.py": {
+      "bytes": 1593,
+      "sha256": "52df1c52ecfe9db206a6322350204d2bbbaeb2fe6bd192d8b98d56de8739bf50"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/parse_signature_header.py": {
+      "bytes": 2405,
+      "sha256": "cf81c249d3ff4092557d20bdcf210ce52cbe4c9e2e5e8634d279a46568d2f4df"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/password_violations.py": {
+      "bytes": 3045,
+      "sha256": "5d1a27cea4b7db6b2b2484015dfc73e61ddc04b3d021da8adfb1788ebf0dd54c"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/pattern_effectiveness.py": {
+      "bytes": 2379,
+      "sha256": "ccf4a9d4183523e3b82f95cf0f5f18efe86881ece0d7274f24f5236233aa4f13"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/pressure_check.py": {
+      "bytes": 3417,
+      "sha256": "c7b17812aa575ee19db876d526f0770ad6ee591e6aa2bc624e05527cc1ef7df2"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/quality_gain_reward.py": {
+      "bytes": 2028,
+      "sha256": "cca54e5fa4dfed47ac23f06111a357fb1a2f9fbd3b29a8d9873d268a91a754ec"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/quality_grade.py": {
+      "bytes": 2115,
+      "sha256": "aafb0bab705f85093cecdfa13bdce9a1f23bbf055b60f50783abc46f020b8fef"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/reconcile_invoices.py": {
+      "bytes": 3579,
+      "sha256": "169e88a7162bc1e2a798b76ee491191ca44fca3051d7eb392b56b7672139142e"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/round_sig_figs.py": {
+      "bytes": 2350,
+      "sha256": "361cbe3b3c5e2da8317b2cf703dc11405d4c10ad2d62551c65388028238f4fb5"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/safe_join.py": {
+      "bytes": 2508,
+      "sha256": "368365c0bd5b318b63d1614caba8bd4f752011f6beecf3ede4fbb42f137441d7"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/sample_variance.py": {
+      "bytes": 1906,
+      "sha256": "a26bc6ef76d5dfbc4b0abff3f0189f6bd181f6934bcb6dee3410ab752316223d"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/select_bitrate_rung.py": {
+      "bytes": 2366,
+      "sha256": "51ae093e2baeda053434e2e223827384124290ed5317bf160f0b3df366ef02eb"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/shift_cue.py": {
+      "bytes": 2795,
+      "sha256": "cce40f8f9266e58918b174e82d1b167523a4df1b78a53f07af06fe43d9c9100e"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/slew_limit.py": {
+      "bytes": 2885,
+      "sha256": "540a4e6c04b1e3cc78cf69e42897d6680840c513ffcc86eeba8f2aa735d30cf6"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/spec_readiness_score.py": {
+      "bytes": 4578,
+      "sha256": "02936fcc7e5931cad5a46b286d098ae2d34698449f2eaa190eaa44f9785543da"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/split_generic_params.py": {
+      "bytes": 2201,
+      "sha256": "9188e0c8045fa0d8e1a7a82153f6ccc791e075dd7a6f3b793abd117bb1064275"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/streamable_len.py": {
+      "bytes": 3235,
+      "sha256": "d3aac59af147f657bbe61bb45e368d78cee587be7a4fa58208410fd5a9e3d26c"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/string_length_boundaries.py": {
+      "bytes": 2253,
+      "sha256": "62a7ac1680df0375cae8ecb6cf08a3520375cb9c8dea94299a30551d0abe479e"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/threshold_compliance.py": {
+      "bytes": 4277,
+      "sha256": "13361068ea0f1ebaacadb264bfec120e990341cf66154f77a1a110777be1754e"
+    },
+    "components/qemedia/upstream/qe_arena/corpus/token_claims_check.py": {
+      "bytes": 3488,
+      "sha256": "081ef70cde049750026cc4f60794f46a74a86424c12d73ea5c278b19563b2e77"
     },
-    "components/skillsdesk/runtime/skillsdesk_compat/__init__.py": {
-      "bytes": 0,
-      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    "components/qemedia/upstream/qe_arena/corpus/token_jaccard.py": {
+      "bytes": 1948,
+      "sha256": "9d10c0da4d0375ea05c99d0e5d2dd57a4bedf1a4fa5a5f48d6cc9344177f19bb"
     },
-    "components/skillsdesk/runtime/skillsdesk_compat/environment.py": {
-      "bytes": 8142,
-      "sha256": "22a0011808344bdeeb635082afbacac2810bdf14e617ac72011e211dfa14c176"
+    "components/qemedia/upstream/qe_arena/corpus/trace_sampling_decision.py": {
+      "bytes": 2874,
+      "sha256": "6e20c250fb2d01cf06ed5b099d67089f43f7851e90224399f5865aee539d4f32"
     },
-    "components/skillsdesk/runtime/skillsdesk_compat/server.py": {
-      "bytes": 457,
-      "sha256": "634fd3bd58cb4ade2c5d959ae7fb09dfb24b102830170c00a140a3ff949e590c"
+    "components/qemedia/upstream/qe_arena/corpus/truncate_to_token_budget.py": {
+      "bytes": 2451,
+      "sha256": "5246d62082d3a37dd57e6d3510ea489a4de4c44a31e5bddb2d4d438817b0c43b"
     },
-    "components/skillsdesk/upstream/openenv.yaml": {
-      "bytes": 403,
-      "sha256": "88e8863954ec9a9d34d07cdde0d5d4688f1fc85a2c595f13c7b9d4d10be6218e"
+    "components/qemedia/upstream/qe_arena/corpus/uncovered_line_ranges.py": {
+      "bytes": 1864,
+      "sha256": "9feb8f950e2cff5904eddba37a15e16a8888a7cb8f5dc893e74808a36c6f1876"
     },
-    "components/skillsdesk/upstream/terminal_desk/__init__.py": {
-      "bytes": 0,
-      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    "components/qemedia/upstream/qe_arena/corpus/validate_csv_row.py": {
+      "bytes": 2764,
+      "sha256": "bc332a39e0143f24ee326b0f9343150a22f47fa420dc29ecf1cba816385a1d43"
     },
-    "components/skillsdesk/upstream/terminal_desk/core/__init__.py": {
-      "bytes": 0,
-      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    "components/qemedia/upstream/qe_arena/corpus/vuln_priority_bucket.py": {
+      "bytes": 1889,
+      "sha256": "3132a4152e1baf9061b0e70d3192e0617e8de735195eb560dcfee5011c14f6fc"
     },
-    "components/skillsdesk/upstream/terminal_desk/core/grading.py": {
-      "bytes": 10754,
-      "sha256": "d61652f92fc3691f55e71b76c9ef17ccabb4502ff7038f7626b69f52918907c9"
+    "components/qemedia/upstream/qe_arena/corpus/wilson_interval.py": {
+      "bytes": 1922,
+      "sha256": "28e98e2f9b24bb36171fa2f5c5c9d78be23e193615b265aad092bec771eb8021"
     },
-    "components/skillsdesk/upstream/terminal_desk/core/shell.py": {
-      "bytes": 4743,
-      "sha256": "e6af14ad4263f3067f47dc841f28fc6d24de64c8400df91facce1fdd71dced5d"
+    "components/qemedia/upstream/qe_arena/domains.py": {
+      "bytes": 1191,
+      "sha256": "13bb7b068896d5377b8f969c504dde01875df8eef8a0b341348e45bcea5f991b"
     },
-    "components/skillsdesk/upstream/terminal_desk/families/__init__.py": {
-      "bytes": 2614,
-      "sha256": "3d04bdea30395f1e8fa03d804a5728777633bf319f4e00575ef047f2011fa411"
+    "components/qemedia/upstream/qe_arena/edit_budget.py": {
+      "bytes": 28000,
+      "sha256": "4b27436ca7c4eed5e7dda34ccfac6c97eb413cf024274793d4d1cf47b50f9494"
     },
-    "components/skillsdesk/upstream/terminal_desk/families/base.py": {
-      "bytes": 1915,
-      "sha256": "a0ef4dec6a2932ead3331d0cea6e5bb3b91fa91075508560aa9cf08495b0ad6f"
+    "components/qemedia/upstream/qe_arena/environment.py": {
+      "bytes": 10774,
+      "sha256": "9675b6598456b5a8dbfe57eb6e6847998d86f2c93722caff3c8a3716d6ecc102"
     },
-    "components/skillsdesk/upstream/terminal_desk/families/compute.py": {
-      "bytes": 10755,
-      "sha256": "60c1e5c80f42479d79c86e222c3a101182955822b5b555b25cf0cff40d7bc7c3"
+    "components/qemedia/upstream/qe_arena/flaky.py": {
+      "bytes": 22246,
+      "sha256": "0db273642496825ec8f8924a164093df1191b29c92ac83b5497261373c20f768"
     },
-    "components/skillsdesk/upstream/terminal_desk/families/compute2.py": {
-      "bytes": 12743,
-      "sha256": "91cdb191a4af146bc8901e585f213d7377584ea6c493c60839a4aeddd7e63d33"
+    "components/qemedia/upstream/qe_arena/flaky_gen.py": {
+      "bytes": 13599,
+      "sha256": "46e2198bcbe9d415bf775f845a358c2eaa26d390a5aa62d3b806f07b5803fab1"
     },
-    "components/skillsdesk/upstream/terminal_desk/families/constraints.py": {
-      "bytes": 9807,
-      "sha256": "25494ac58d4fa7196b5e702dfc9cc55e9635dbaa1603de160a80d39fb09d3ea0"
+    "components/qemedia/upstream/qe_arena/flaky_templates.py": {
+      "bytes": 19057,
+      "sha256": "2272e0617a3a079d2e389bf50d62c4cc5da4ec005d2d68239bdfbf7e795fda92"
     },
-    "components/skillsdesk/upstream/terminal_desk/families/constraints2.py": {
-      "bytes": 14665,
-      "sha256": "411991bca80cbbdfb08eacc5192a07ba45442e41a3e600780b2efdac1b072cc4"
+    "components/qemedia/upstream/qe_arena/guest_harness.py": {
+      "bytes": 13974,
+      "sha256": "5b389cc8ab64218d3bdcc500f584ef0b78da4b68379bfb014e095d755ccdcdb1"
     },
-    "components/skillsdesk/upstream/terminal_desk/families/evidence.py": {
-      "bytes": 10896,
-      "sha256": "c2ff755246cc006d04f36acf9f8787efad0ca22a6e2c0c9b2dc14bb4d3fb7045"
+    "components/qemedia/upstream/qe_arena/keys/manifest_ed25519.pub": {
+      "bytes": 113,
+      "sha256": "ea2b370db92d82e1a0719ecf3416eeafdb7a14a524a94f6d6cd32a5f06b21106"
     },
-    "components/skillsdesk/upstream/terminal_desk/families/evidence2.py": {
-      "bytes": 14514,
-      "sha256": "d32eedf32ee8e385bd123501b33c2d15c75a7604cc9a029e97d8dabf6de97e60"
+    "components/qemedia/upstream/qe_arena/manifest.py": {
+      "bytes": 6932,
+      "sha256": "1911ef5d3696695364871da7be9744fd7c81d51fe81ae3c137341dd1b06c8494"
     },
-    "components/skillsdesk/upstream/terminal_desk/families/repair.py": {
-      "bytes": 17806,
-      "sha256": "a3392b6cf21d6cdb562862fb9f0999ec8a57a4116162e3b58d1c00f9fb19b781"
+    "components/qemedia/upstream/qe_arena/mutation.py": {
+      "bytes": 43554,
+      "sha256": "28a7abc5213c5a1504151d23148695e7f09e4441b39e941377cb7265ba6ff4de"
     },
-    "components/skillsdesk/upstream/terminal_desk/families/repair2.py": {
-      "bytes": 20016,
-      "sha256": "1d22338235ffb0e25786a45ddb0c28be00081f89df1bee94052d57f6ac01ace6"
+    "components/qemedia/upstream/qe_arena/runtime_pins.json": {
+      "bytes": 179,
+      "sha256": "97f080e2505ba4c6034fcc3f0322d9ecd8b9f9852ac19e424cc9273ccd0a9c77"
     },
-    "components/skillsdesk/upstream/terminal_desk/families/transform.py": {
-      "bytes": 6815,
-      "sha256": "d478ea588230f6394fdad03fef1d377399086015f7a33d1f892e78c268808df1"
+    "components/qemedia/upstream/qe_arena/sandbox.py": {
+      "bytes": 34230,
+      "sha256": "92faaac323c0b524c0181008c305134fc57d2e4c6af1ea6fbf919b48ec9ea03a"
     },
-    "components/skillsdesk/upstream/terminal_desk/families/transform2.py": {
-      "bytes": 13415,
-      "sha256": "2c176531664ffcbfb998283b1b6cc145ddac976c7b2137b5535a2a9e1b422af2"
+    "components/qemedia/upstream/qe_arena/shell.py": {
+      "bytes": 26494,
+      "sha256": "4e9aabefa6f23793a05804ec413aaa5d1c5125365156f22cdb50ff600808d34d"
     },
-    "components/skillsdesk/upstream/terminal_desk/families/util.py": {
-      "bytes": 3899,
-      "sha256": "0e3b71ebcd82ccce47ea3bcbcc98efafb23b297f9831b2e37afd399d44eb5832"
+    "components/qemedia/upstream/qe_arena/skills/__init__.py": {
+      "bytes": 6616,
+      "sha256": "c6b045c7b62b762ae4a56b13fcc61bf997ffd710494f9882e775f533dfe8c522"
     },
-    "components/skillsdesk/upstream/terminal_desk/models.py": {
-      "bytes": 1750,
-      "sha256": "f31264b0909878c6f2d4d18a270c7d92bc895052150c56e5ac3e6b38d4ceebb4"
+    "components/qemedia/upstream/qe_arena/skills/_common.py": {
+      "bytes": 1640,
+      "sha256": "ec722ad0aa0903fbca443dc8325f2569853b7191edfc525602d3cd0ddaf56037"
     },
-    "components/skillsdesk/upstream/terminal_desk/reserved/__init__.py": {
-      "bytes": 647,
-      "sha256": "012f259f4fd2aad8af71accaf7686f8e76235491d9ad200bfbec9f3641afa330"
+    "components/qemedia/upstream/qe_arena/skills/formal.py": {
+      "bytes": 24536,
+      "sha256": "da87595287e1d253512564769274e3063f262fce0d4d4ea0ef5b26d9285a72e0"
     },
-    "components/skillsdesk/upstream/terminal_desk/reserved/compute.py": {
-      "bytes": 12349,
-      "sha256": "e87cfd26e155b8c0a830cfd6809274c930ee45d31f2ac44398f35385b2dbe083"
+    "components/qemedia/upstream/qe_arena/skills/media.py": {
+      "bytes": 18987,
+      "sha256": "005eabea342ba948e6b68dcc341f3756a8ebdd5fb44830cb13bb482a16ef200c"
     },
-    "components/skillsdesk/upstream/terminal_desk/reserved/constraints.py": {
-      "bytes": 15358,
-      "sha256": "ca168704db89a1da64fd0262c44280e0461d2a58d4f9191a6c9747d19cb0bee0"
+    "components/qemedia/upstream/qe_arena/skills/science.py": {
+      "bytes": 23268,
+      "sha256": "f198046eb6e9d0610cd966f5e7a99d27e9da2e3f23e3687ecd42f4a5649aab98"
     },
-    "components/skillsdesk/upstream/terminal_desk/reserved/evidence.py": {
-      "bytes": 12524,
-      "sha256": "e3c5f779c29f730fd2844018150078640c17425bfe6ddb922103a661a86c5ee0"
+    "components/qemedia/upstream/qe_arena/skills/subtitles.py": {
+      "bytes": 8058,
+      "sha256": "872054f7309500113beab2c853bfeceebd146e60dc36d42f42f9e98e6c4a7b84"
     },
-    "components/skillsdesk/upstream/terminal_desk/reserved/repair.py": {
-      "bytes": 16541,
-      "sha256": "121c2be70cd21ca16c254153eebbce895f2bb86c37aedcaaaa237662917e18e5"
+    "components/qemedia/upstream/qe_arena/tasks.py": {
+      "bytes": 29386,
+      "sha256": "c540dc8eafd3ac648f768b17682ecb1f8f3bd3e14eed9a353c4021c427dc80bd"
     },
-    "components/skillsdesk/upstream/terminal_desk/reserved/transform.py": {
-      "bytes": 11909,
-      "sha256": "bd97f765a7e468bd2e4b4a6e1e959177df999a123d712c5c2b4f93e4359c99cf"
+    "components/qemedia/upstream/qe_arena/terminal_app.py": {
+      "bytes": 801,
+      "sha256": "d5a630210e1a8330ec3cc00a5b43d7d92b110a6d0eb8ec5e83d3bba13e85fcc0"
     },
-    "components/skillsdesk/upstream/terminal_desk/server/__init__.py": {
-      "bytes": 0,
-      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    "components/qemedia/upstream/qe_arena/terminal_env.py": {
+      "bytes": 11168,
+      "sha256": "6ea5cfcffc292e52ead2687728ad6d9c040dfaf32a5610386ac6514d4b1438b3"
     },
-    "components/skillsdesk/upstream/terminal_desk/server/app.py": {
-      "bytes": 802,
-      "sha256": "6bf7658ec8ad07dda230a01fd893091a9b87df18ebf6af25af6c35965ed01fd8"
+    "components/qemedia/upstream/qe_arena/wasi_fs.py": {
+      "bytes": 14300,
+      "sha256": "71f35970518b637bfa50fa79897d6f79d065e4531211af402f91a9dba4d31f38"
     },
-    "components/skillsdesk/upstream/terminal_desk/server/environment.py": {
-      "bytes": 6820,
-      "sha256": "82aa929676d76fe2f8d81a5122598986ac2950339dbfc4366de03a3604cd7319"
+    "components/qemedia/upstream/qe_arena/wasi_worker.py": {
+      "bytes": 17237,
+      "sha256": "6e81b271a5910977f38deba39ccde6465d70e23e9ed42cbec51f02a6e237c71e"
     },
     "schema.json": {
-      "bytes": 1911,
-      "sha256": "10993deaaa8553929fa0b3b6bf3c1ad100baaaf9ff10ae8ed139a8ec4279a3c4"
+      "bytes": 2557,
+      "sha256": "c486d87e05b69ab133dd04cba072d5a39de8fda53c9a2f6fd5995570384724b0"
     },
     "tasks.jsonl": {
-      "bytes": 17061,
-      "sha256": "2a3fe43c4b55a123f5a80f0c2d60c15f86d94470cd2a4fc86adbaec85c12054b"
+      "bytes": 2738,
+      "sha256": "7e16aa89ecd785fe76b4c3b1ef887845d33dbf293a849578a02efafb0da92c00"
     },
     "validate_dataset.py": {
-      "bytes": 8206,
-      "sha256": "db3704682eefb03f47a6c951865e9fb2113851f8bdf0266f6c4f517961f2973b"
+      "bytes": 11813,
+      "sha256": "3ab9912b176d4555f7d38828bd66854b60311dc42c2e25c665cb8296fffaf9db"
     }
   }
 }

README.md

@@ -1,7 +1,7 @@
 ---
 language:
 - en
-license: apache-2.0
+license: mit
 task_categories:
 - reinforcement-learning
 configs:
@@ -11,10 +11,10 @@ configs:
     path: tasks.jsonl
 ---
 
-Twenty original Skills Desk tasks covering evidence matching, computation, data transformation, code repair and constrained planning.
+Two original QE media task cells cover timecode arithmetic, catalogue normalization, crop dimensions and subtitle retiming.
 
-Each task ID identifies a fixed original instance. Use the tools shown at reset and `op=finish` to grade the artifact. Reward is one when all original checks pass, otherwise zero. Code repair tasks also run hidden-input checks.
+Reset with `task_id` set to `qe_skill-media-d2` or `qe_skill-media-d1`. An explicit seed reproduces the original instance; omitting it draws a fresh instance. Use the native `action_type` values `exec`, `write_file` and `evaluate`. Reward is one when all original checks on the output artifact pass, otherwise zero.
 
-Run one episode per fresh sandbox, with one active session. Each episode allows 32 actions, 8192 completion tokens and 16384 context tokens; later observations count toward completion tokens. Commands have the original 20-second limit.
+Run one active session per fresh sandbox. Episodes allow 32 actions, 4096 completion tokens and 8192 context tokens. Observations after reset count toward completion tokens. Commands have the original 30-second limit.
 
-Task IDs and pinned source references are in `tasks.jsonl`. Original licenses and attribution are in `components/skillsdesk/`. Run `python3 -B validate_dataset.py` to verify the file inventory.
+Pinned source and task metadata are in `tasks.jsonl` and `components/qemedia/`. Original modules and their import dependencies are included. Run `python3 -B validate_dataset.py` to verify the file inventory.

SHA256SUMS

@@ -1,48 +1,118 @@
-bd0d465f995e6e88f99a624901bbf6577b31c7230a4ff959ca48516be0339af7  README.md
-df3acef0a949edac8c6ec87a15e4d7c5a87534a83d49186549699a59bdf22f98  SOURCE_LOCK.json
-60c9bdd905fcf45ac485c680d32e9773962cf061b6f041dcddd033911558a672  components/skillsdesk/.dockerignore
-843b71a3a9f9de899cbb9d260d55c9bd082f3df2b7771a1c31100ce5767a0a53  components/skillsdesk/ADAPTER_NOTICE
-4f047d60bc07987131be2c9cf0662c6e6feef91125adda81eda04d4b88882f6b  components/skillsdesk/Dockerfile
-cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30  components/skillsdesk/LICENSE
-dca813e02ab76d4bc5afdcd2a2de3480d3fc0a7a710edea24c395adf23a99883  components/skillsdesk/NOTICE
-11775067d2cfb4c254084dd741f0b13a1a5058081c171712bdb9923d430a9cd4  components/skillsdesk/README.md
-789ef47ecb391dfe876f65207ba8f477b064c1d9cded1becaf177ae7112a3d99  components/skillsdesk/SOURCE_MANIFEST.json
-2c07033febd78777deeff04350ae6887c9bb170b152d38c26cf148efa1b75d1e  components/skillsdesk/UPSTREAM_DOCKERFILE
-90e6e08d4269b5bb8308b5f2f05c61aa0cb9b71643b6abe6e47b34795828dd1e  components/skillsdesk/UPSTREAM_TRAINING_TASKS.txt
-01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b  components/skillsdesk/runtime/common/__init__.py
-b1e1429208e84aefc2422ee1d2400ad793c43cd5c0e8db213a3b669fe0947ce1  components/skillsdesk/runtime/common/contracts.py
-6a1ac8e55af6168d3fdd6b17c700a15cf0546b6154773aa3c59c97d6bffa2ffd  components/skillsdesk/runtime/common/models.py
-e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  components/skillsdesk/runtime/skillsdesk_compat/__init__.py
-22a0011808344bdeeb635082afbacac2810bdf14e617ac72011e211dfa14c176  components/skillsdesk/runtime/skillsdesk_compat/environment.py
-634fd3bd58cb4ade2c5d959ae7fb09dfb24b102830170c00a140a3ff949e590c  components/skillsdesk/runtime/skillsdesk_compat/server.py
-88e8863954ec9a9d34d07cdde0d5d4688f1fc85a2c595f13c7b9d4d10be6218e  components/skillsdesk/upstream/openenv.yaml
-e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  components/skillsdesk/upstream/terminal_desk/__init__.py
-e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  components/skillsdesk/upstream/terminal_desk/core/__init__.py
-d61652f92fc3691f55e71b76c9ef17ccabb4502ff7038f7626b69f52918907c9  components/skillsdesk/upstream/terminal_desk/core/grading.py
-e6af14ad4263f3067f47dc841f28fc6d24de64c8400df91facce1fdd71dced5d  components/skillsdesk/upstream/terminal_desk/core/shell.py
-3d04bdea30395f1e8fa03d804a5728777633bf319f4e00575ef047f2011fa411  components/skillsdesk/upstream/terminal_desk/families/__init__.py
-a0ef4dec6a2932ead3331d0cea6e5bb3b91fa91075508560aa9cf08495b0ad6f  components/skillsdesk/upstream/terminal_desk/families/base.py
-60c1e5c80f42479d79c86e222c3a101182955822b5b555b25cf0cff40d7bc7c3  components/skillsdesk/upstream/terminal_desk/families/compute.py
-91cdb191a4af146bc8901e585f213d7377584ea6c493c60839a4aeddd7e63d33  components/skillsdesk/upstream/terminal_desk/families/compute2.py
-25494ac58d4fa7196b5e702dfc9cc55e9635dbaa1603de160a80d39fb09d3ea0  components/skillsdesk/upstream/terminal_desk/families/constraints.py
-411991bca80cbbdfb08eacc5192a07ba45442e41a3e600780b2efdac1b072cc4  components/skillsdesk/upstream/terminal_desk/families/constraints2.py
-c2ff755246cc006d04f36acf9f8787efad0ca22a6e2c0c9b2dc14bb4d3fb7045  components/skillsdesk/upstream/terminal_desk/families/evidence.py
-d32eedf32ee8e385bd123501b33c2d15c75a7604cc9a029e97d8dabf6de97e60  components/skillsdesk/upstream/terminal_desk/families/evidence2.py
-a3392b6cf21d6cdb562862fb9f0999ec8a57a4116162e3b58d1c00f9fb19b781  components/skillsdesk/upstream/terminal_desk/families/repair.py
-1d22338235ffb0e25786a45ddb0c28be00081f89df1bee94052d57f6ac01ace6  components/skillsdesk/upstream/terminal_desk/families/repair2.py
-d478ea588230f6394fdad03fef1d377399086015f7a33d1f892e78c268808df1  components/skillsdesk/upstream/terminal_desk/families/transform.py
-2c176531664ffcbfb998283b1b6cc145ddac976c7b2137b5535a2a9e1b422af2  components/skillsdesk/upstream/terminal_desk/families/transform2.py
-0e3b71ebcd82ccce47ea3bcbcc98efafb23b297f9831b2e37afd399d44eb5832  components/skillsdesk/upstream/terminal_desk/families/util.py
-f31264b0909878c6f2d4d18a270c7d92bc895052150c56e5ac3e6b38d4ceebb4  components/skillsdesk/upstream/terminal_desk/models.py
-012f259f4fd2aad8af71accaf7686f8e76235491d9ad200bfbec9f3641afa330  components/skillsdesk/upstream/terminal_desk/reserved/__init__.py
-e87cfd26e155b8c0a830cfd6809274c930ee45d31f2ac44398f35385b2dbe083  components/skillsdesk/upstream/terminal_desk/reserved/compute.py
-ca168704db89a1da64fd0262c44280e0461d2a58d4f9191a6c9747d19cb0bee0  components/skillsdesk/upstream/terminal_desk/reserved/constraints.py
-e3c5f779c29f730fd2844018150078640c17425bfe6ddb922103a661a86c5ee0  components/skillsdesk/upstream/terminal_desk/reserved/evidence.py
-121c2be70cd21ca16c254153eebbce895f2bb86c37aedcaaaa237662917e18e5  components/skillsdesk/upstream/terminal_desk/reserved/repair.py
-bd97f765a7e468bd2e4b4a6e1e959177df999a123d712c5c2b4f93e4359c99cf  components/skillsdesk/upstream/terminal_desk/reserved/transform.py
-e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  components/skillsdesk/upstream/terminal_desk/server/__init__.py
-6bf7658ec8ad07dda230a01fd893091a9b87df18ebf6af25af6c35965ed01fd8  components/skillsdesk/upstream/terminal_desk/server/app.py
-82aa929676d76fe2f8d81a5122598986ac2950339dbfc4366de03a3604cd7319  components/skillsdesk/upstream/terminal_desk/server/environment.py
-10993deaaa8553929fa0b3b6bf3c1ad100baaaf9ff10ae8ed139a8ec4279a3c4  schema.json
-2a3fe43c4b55a123f5a80f0c2d60c15f86d94470cd2a4fc86adbaec85c12054b  tasks.jsonl
-db3704682eefb03f47a6c951865e9fb2113851f8bdf0266f6c4f517961f2973b  validate_dataset.py
+4788fd92c347b0f30ec74e278f1c8d24e91eea0e1fd6106178bb29876e0bc4bd  README.md
+a3f67ba6d525a1fdffbc87093b0a2b4ee12b7c482b95050dfd7b27b09d19143d  SOURCE_LOCK.json
+60c9bdd905fcf45ac485c680d32e9773962cf061b6f041dcddd033911558a672  components/qemedia/.dockerignore
+5991dc74fa45e42c24120d3ddf4fd39c92f908f44986c71cf658c5b12deda80b  components/qemedia/ADAPTER_NOTICE
+0edae3727291af6b7ed7b3d38bf94d4aaa2c42c01c4d748d676ef9045de1c8df  components/qemedia/Dockerfile
+e0a8e97900a1184396b65bca8507d5c7b1a6df58537b61722dfe0f416990f0e2  components/qemedia/LICENSE
+1f6d860d8285f6297e5381c08925a1ece2bf88eb5b0344b10740269e222a060d  components/qemedia/README.md
+f97c7ed6f032ebf9e6276f6156c447a2f128739858fc243143d72b86443292f3  components/qemedia/SOURCE_MANIFEST.json
+755b9132babde91fb34bf29a7759c3cead1299484335fcafdb057fd207f210b8  components/qemedia/THIRD_PARTY_NOTICES
+acb6b642cd8d1c4f66e8a82a2cc97c9d4643ca484422e225505c0ea2b739e146  components/qemedia/UPSTREAM_DOCKERFILE
+bd90e5f33d8c325c978e826c5e7a73e4ad73ff535f367ddfed0dec3d52470ade  components/qemedia/runtime/qemedia_compat/__init__.py
+0fbea553dc22fa2fd72a4590c2c008eeefaa4af5654a2e9936465c18c79c9149  components/qemedia/runtime/qemedia_compat/environment.py
+1d41688c822b842c70f32502d627c252fcd3526c7be74d6880f2f86d06df981a  components/qemedia/runtime/qemedia_compat/server.py
+f1ce27b1c58f9547059e7f820aa65c1a8d8313144855ee8845b2eca91f7e0db3  components/qemedia/upstream/qe_arena/__init__.py
+2925e44219fdef6310ac1e2b60532e3ba1f1e768b33e65f14f1f5e8f86b33510  components/qemedia/upstream/qe_arena/app.py
+978aabadc5044616ff28ab7be69a2e9ff48f1fd82494a6897f4f2b8716283a08  components/qemedia/upstream/qe_arena/corpus/__init__.py
+0485dfbc2676a1f666958935602cc2f347e5fcd95b6bfcd32e8af13cafe07e35  components/qemedia/upstream/qe_arena/corpus/aggregate_risk_factors.py
+f999a088228120810c986f249964ba83d7a54a4853c9bebcbf61313b4362247e  components/qemedia/upstream/qe_arena/corpus/alternate_chat_roles.py
+4b4f6e1280956988736c2401747ed0c3d633eedfe38e7d24ec815773f5c21711  components/qemedia/upstream/qe_arena/corpus/amortization_schedule.py
+21517da739674bdc2b22efe9c2a2a7a85d47a7033aae3e24b2c1da8b4ac21684  components/qemedia/upstream/qe_arena/corpus/api_complexity_level.py
+71db4461633e0ad524e11c2384d75675331a515778ce4a8b675c6f738c94a02c  components/qemedia/upstream/qe_arena/corpus/artifact_retention_keep.py
+1f1937c25f4717a49a6e809ea81cc20da035f6aa843d4f47ce111b585e3ab4a2  components/qemedia/upstream/qe_arena/corpus/backoff_schedule.py
+2661b8a01fb4d7d1a31169592eaae370b3d4260d6b32187ce4427ffbcfa097ea  components/qemedia/upstream/qe_arena/corpus/badge_dimensions.py
+b1d44ea5c1b774f8572374e73468ca34483e3b382c982c28a368549da94656d5  components/qemedia/upstream/qe_arena/corpus/baseline_verdict.py
+01764d4994630e38a91a6599f90142a9b145084dbd5971c564727ac9855f97f8  components/qemedia/upstream/qe_arena/corpus/booking_conflicts.py
+7f70d489eefbdae5794354fa457a39dc50eb0209929cb0f3a9f9493b41adc88a  components/qemedia/upstream/qe_arena/corpus/boundary_violations.py
+04d411ac8a666d3916c13090c7658e5cc516028ced9b0db45a334062d96683c5  components/qemedia/upstream/qe_arena/corpus/brace_delta.py
+6f0982869b0ef19ec7b95863008ea45b1a46dbd46108ee24b44338a383a37d23  components/qemedia/upstream/qe_arena/corpus/calibration_fit.py
+42b4727623069a0e774e0d70be6cb9869d871b377ddb6421c60bfa78bd3be126  components/qemedia/upstream/qe_arena/corpus/chat_completion_result.py
+f5c6486256438b89565cc1edcaf016d6e91f3c81067a77a30c9792cac7d0ef39  components/qemedia/upstream/qe_arena/corpus/claim_steal_priority.py
+a77352fd67a18a9c24c3fe697c9310b079c998dc853c2f49eba1a2c877742a62  components/qemedia/upstream/qe_arena/corpus/compare_versions.py
+5e4e65b458e8cd2e9723206e43ea3a85d37df8b82c9f15e19f4da5ce26dd72ff  components/qemedia/upstream/qe_arena/corpus/complexity_bucket.py
+3979785d451cc4473ec2b057a404f0a8ea930bd11ce34bedea06f1b953ee9c08  components/qemedia/upstream/qe_arena/corpus/compound_interest.py
+30ff0142461a624790a13766f9463c6fd6f21991442e5e37d46febd51f2ca7ad  components/qemedia/upstream/qe_arena/corpus/convert_timecode.py
+af3e694760997b353678c7350b08e43ed26de256792221420006e5d4837712d5  components/qemedia/upstream/qe_arena/corpus/coverage_gap_severity.py
+f85c6167be7fe0094e36b90d19fb4e382a2e804a34dc96fa09f379caf97d5904  components/qemedia/upstream/qe_arena/corpus/crop_to_aspect.py
+61e8975cc643b0bd4d10656d48a77a7314b5e13382794bdcbecf19f2a80b3186  components/qemedia/upstream/qe_arena/corpus/debounce_switch.py
+949197b79f96f244ccba1b44236510ec65d8c9aace59850cde4949697791024f  components/qemedia/upstream/qe_arena/corpus/decay_table.py
+c5033c7d0a147c46e9cf1659187879b00e8f253725f1fcc00b6c4e5529c9685b  components/qemedia/upstream/qe_arena/corpus/efficiency_reward.py
+11d505901f9d2e00cc5b475d9cca75b4770db77345c1645b10e70620710a70b0  components/qemedia/upstream/qe_arena/corpus/expense_violations.py
+284d4fcd6c5cb23efc4282659991d9a403b46c0d836641071ad7079d8d2c8d0d  components/qemedia/upstream/qe_arena/corpus/find_stop.py
+b3b94bcfe78f97b00187e7fe9783a8ae04b9a9b6af6d788f445f64bd52021aa0  components/qemedia/upstream/qe_arena/corpus/flakiness_pattern.py
+11c670fbe537cbeeaa101d9b9db49519f5ebd4cca82b7ccfd66d5d68e352e5ba  components/qemedia/upstream/qe_arena/corpus/flaky_hunter_reward.py
+f6ebbaffe1dd8aaccef7ad8ce48d8dfa60bacc8a44051880057c52b163e7748b  components/qemedia/upstream/qe_arena/corpus/flaky_run_summary.py
+7e0cf537d1bd38fdbc474bc259a52fbf23f095f35661586d771eca0561481eb0  components/qemedia/upstream/qe_arena/corpus/format_duration.py
+e232fbfe97a36cedf848caa11b9bf51828c5f4c6fe6ad3bf40133c6bc7deabd7  components/qemedia/upstream/qe_arena/corpus/gguf_loader.py
+b5fc54e4b3f6b45af2af289a746fe48d948e806b43910920e6ee31c81bbd805e  components/qemedia/upstream/qe_arena/corpus/gguf_special_ids.py
+52d8da6da1348af21303785a5dabfe36a42f7efeaed9b326b21898387a3e6536  components/qemedia/upstream/qe_arena/corpus/glob_match.py
+ce28e349ed362052dd0184dc4f1e215344831edc2f74ebe8438c470964fc70a3  components/qemedia/upstream/qe_arena/corpus/income_tax.py
+edd468fbc9d11830559fbcc2bfb1d7afe35c71980432bb91c87d8c3571a704b7  components/qemedia/upstream/qe_arena/corpus/integer_edge_values.py
+94bc28736f587e3cc350fef83ba95fe70dc44db627bcb037f854332f6b52e7fd  components/qemedia/upstream/qe_arena/corpus/ip_allowlist_match.py
+87db0af0b61c0b95b0d8acf9235835db9631f9471d0e7dc29b0296abc76bccde  components/qemedia/upstream/qe_arena/corpus/is_collection_endpoint.py
+7d91f4eb06374851748cbd3e33ae5f3d2059a491572449d4fc700ecaaed1431c  components/qemedia/upstream/qe_arena/corpus/latency_percentiles.py
+814fc40372c1ece5068b04848f9c8a2a9069d504cf364df62c00a905d0ec777c  components/qemedia/upstream/qe_arena/corpus/login_rate_limit.py
+ecc262d19d2b27970901017aa4a006ad2ce97861866ccddae2a9c876c4bbec37  components/qemedia/upstream/qe_arena/corpus/loudness_gain.py
+2c3ec2cb2f5e050ff03d772675c372053fe3eb957f505a33d2d127916ee283bf  components/qemedia/upstream/qe_arena/corpus/mail_merge.py
+48972588b8f75f1132aaf0eaa112a35875833b7dc661e3c41ff6972f3ce29dd5  components/qemedia/upstream/qe_arena/corpus/maintainability_index.py
+201bad40ff156e6a0caec2577011286262178000435aacaec83c603ba02aa4f8  components/qemedia/upstream/qe_arena/corpus/maintenance_status.py
+fd5b0f08e59fc763734cdb43d4cd893ce851403281a806902f5945ce71e7e7cd  components/qemedia/upstream/qe_arena/corpus/merge_intervals.py
+888558da6833e82d1b2dafadf39aa87609cf5c4bcc96345a4e37ac92cfd1d0de  components/qemedia/upstream/qe_arena/corpus/mod_inverse.py
+58cdc61459945cdd9bf20ab09cfa422c85148d76fecfc70567ef81b1240c2f36  components/qemedia/upstream/qe_arena/corpus/mod_pow.py
+1c72218af8a816d24fc7ba7d88901c83db49c056da34efea5f2ba491a77493d2  components/qemedia/upstream/qe_arena/corpus/networkdays.py
+62e849358e01be48618529568005a1b487b411bdc18a01b4c226b824f77320df  components/qemedia/upstream/qe_arena/corpus/normalize_rational.py
+6275cc4556df344a4dfccbcdf5930e9561bcb27b93fcb247c9707a84c48f3231  components/qemedia/upstream/qe_arena/corpus/parse_cron_field.py
+52df1c52ecfe9db206a6322350204d2bbbaeb2fe6bd192d8b98d56de8739bf50  components/qemedia/upstream/qe_arena/corpus/parse_max_age.py
+cf81c249d3ff4092557d20bdcf210ce52cbe4c9e2e5e8634d279a46568d2f4df  components/qemedia/upstream/qe_arena/corpus/parse_signature_header.py
+5d1a27cea4b7db6b2b2484015dfc73e61ddc04b3d021da8adfb1788ebf0dd54c  components/qemedia/upstream/qe_arena/corpus/password_violations.py
+ccf4a9d4183523e3b82f95cf0f5f18efe86881ece0d7274f24f5236233aa4f13  components/qemedia/upstream/qe_arena/corpus/pattern_effectiveness.py
+c7b17812aa575ee19db876d526f0770ad6ee591e6aa2bc624e05527cc1ef7df2  components/qemedia/upstream/qe_arena/corpus/pressure_check.py
+cca54e5fa4dfed47ac23f06111a357fb1a2f9fbd3b29a8d9873d268a91a754ec  components/qemedia/upstream/qe_arena/corpus/quality_gain_reward.py
+aafb0bab705f85093cecdfa13bdce9a1f23bbf055b60f50783abc46f020b8fef  components/qemedia/upstream/qe_arena/corpus/quality_grade.py
+169e88a7162bc1e2a798b76ee491191ca44fca3051d7eb392b56b7672139142e  components/qemedia/upstream/qe_arena/corpus/reconcile_invoices.py
+361cbe3b3c5e2da8317b2cf703dc11405d4c10ad2d62551c65388028238f4fb5  components/qemedia/upstream/qe_arena/corpus/round_sig_figs.py
+368365c0bd5b318b63d1614caba8bd4f752011f6beecf3ede4fbb42f137441d7  components/qemedia/upstream/qe_arena/corpus/safe_join.py
+a26bc6ef76d5dfbc4b0abff3f0189f6bd181f6934bcb6dee3410ab752316223d  components/qemedia/upstream/qe_arena/corpus/sample_variance.py
+51ae093e2baeda053434e2e223827384124290ed5317bf160f0b3df366ef02eb  components/qemedia/upstream/qe_arena/corpus/select_bitrate_rung.py
+cce40f8f9266e58918b174e82d1b167523a4df1b78a53f07af06fe43d9c9100e  components/qemedia/upstream/qe_arena/corpus/shift_cue.py
+540a4e6c04b1e3cc78cf69e42897d6680840c513ffcc86eeba8f2aa735d30cf6  components/qemedia/upstream/qe_arena/corpus/slew_limit.py
+02936fcc7e5931cad5a46b286d098ae2d34698449f2eaa190eaa44f9785543da  components/qemedia/upstream/qe_arena/corpus/spec_readiness_score.py
+9188e0c8045fa0d8e1a7a82153f6ccc791e075dd7a6f3b793abd117bb1064275  components/qemedia/upstream/qe_arena/corpus/split_generic_params.py
+d3aac59af147f657bbe61bb45e368d78cee587be7a4fa58208410fd5a9e3d26c  components/qemedia/upstream/qe_arena/corpus/streamable_len.py
+62a7ac1680df0375cae8ecb6cf08a3520375cb9c8dea94299a30551d0abe479e  components/qemedia/upstream/qe_arena/corpus/string_length_boundaries.py
+13361068ea0f1ebaacadb264bfec120e990341cf66154f77a1a110777be1754e  components/qemedia/upstream/qe_arena/corpus/threshold_compliance.py
+081ef70cde049750026cc4f60794f46a74a86424c12d73ea5c278b19563b2e77  components/qemedia/upstream/qe_arena/corpus/token_claims_check.py
+9d10c0da4d0375ea05c99d0e5d2dd57a4bedf1a4fa5a5f48d6cc9344177f19bb  components/qemedia/upstream/qe_arena/corpus/token_jaccard.py
+6e20c250fb2d01cf06ed5b099d67089f43f7851e90224399f5865aee539d4f32  components/qemedia/upstream/qe_arena/corpus/trace_sampling_decision.py
+5246d62082d3a37dd57e6d3510ea489a4de4c44a31e5bddb2d4d438817b0c43b  components/qemedia/upstream/qe_arena/corpus/truncate_to_token_budget.py
+9feb8f950e2cff5904eddba37a15e16a8888a7cb8f5dc893e74808a36c6f1876  components/qemedia/upstream/qe_arena/corpus/uncovered_line_ranges.py
+bc332a39e0143f24ee326b0f9343150a22f47fa420dc29ecf1cba816385a1d43  components/qemedia/upstream/qe_arena/corpus/validate_csv_row.py
+3132a4152e1baf9061b0e70d3192e0617e8de735195eb560dcfee5011c14f6fc  components/qemedia/upstream/qe_arena/corpus/vuln_priority_bucket.py
+28e98e2f9b24bb36171fa2f5c5c9d78be23e193615b265aad092bec771eb8021  components/qemedia/upstream/qe_arena/corpus/wilson_interval.py
+13bb7b068896d5377b8f969c504dde01875df8eef8a0b341348e45bcea5f991b  components/qemedia/upstream/qe_arena/domains.py
+4b27436ca7c4eed5e7dda34ccfac6c97eb413cf024274793d4d1cf47b50f9494  components/qemedia/upstream/qe_arena/edit_budget.py
+9675b6598456b5a8dbfe57eb6e6847998d86f2c93722caff3c8a3716d6ecc102  components/qemedia/upstream/qe_arena/environment.py
+0db273642496825ec8f8924a164093df1191b29c92ac83b5497261373c20f768  components/qemedia/upstream/qe_arena/flaky.py
+46e2198bcbe9d415bf775f845a358c2eaa26d390a5aa62d3b806f07b5803fab1  components/qemedia/upstream/qe_arena/flaky_gen.py
+2272e0617a3a079d2e389bf50d62c4cc5da4ec005d2d68239bdfbf7e795fda92  components/qemedia/upstream/qe_arena/flaky_templates.py
+5b389cc8ab64218d3bdcc500f584ef0b78da4b68379bfb014e095d755ccdcdb1  components/qemedia/upstream/qe_arena/guest_harness.py
+ea2b370db92d82e1a0719ecf3416eeafdb7a14a524a94f6d6cd32a5f06b21106  components/qemedia/upstream/qe_arena/keys/manifest_ed25519.pub
+1911ef5d3696695364871da7be9744fd7c81d51fe81ae3c137341dd1b06c8494  components/qemedia/upstream/qe_arena/manifest.py
+28a7abc5213c5a1504151d23148695e7f09e4441b39e941377cb7265ba6ff4de  components/qemedia/upstream/qe_arena/mutation.py
+97f080e2505ba4c6034fcc3f0322d9ecd8b9f9852ac19e424cc9273ccd0a9c77  components/qemedia/upstream/qe_arena/runtime_pins.json
+92faaac323c0b524c0181008c305134fc57d2e4c6af1ea6fbf919b48ec9ea03a  components/qemedia/upstream/qe_arena/sandbox.py
+4e9aabefa6f23793a05804ec413aaa5d1c5125365156f22cdb50ff600808d34d  components/qemedia/upstream/qe_arena/shell.py
+c6b045c7b62b762ae4a56b13fcc61bf997ffd710494f9882e775f533dfe8c522  components/qemedia/upstream/qe_arena/skills/__init__.py
+ec722ad0aa0903fbca443dc8325f2569853b7191edfc525602d3cd0ddaf56037  components/qemedia/upstream/qe_arena/skills/_common.py
+da87595287e1d253512564769274e3063f262fce0d4d4ea0ef5b26d9285a72e0  components/qemedia/upstream/qe_arena/skills/formal.py
+005eabea342ba948e6b68dcc341f3756a8ebdd5fb44830cb13bb482a16ef200c  components/qemedia/upstream/qe_arena/skills/media.py
+f198046eb6e9d0610cd966f5e7a99d27e9da2e3f23e3687ecd42f4a5649aab98  components/qemedia/upstream/qe_arena/skills/science.py
+872054f7309500113beab2c853bfeceebd146e60dc36d42f42f9e98e6c4a7b84  components/qemedia/upstream/qe_arena/skills/subtitles.py
+c540dc8eafd3ac648f768b17682ecb1f8f3bd3e14eed9a353c4021c427dc80bd  components/qemedia/upstream/qe_arena/tasks.py
+d5a630210e1a8330ec3cc00a5b43d7d92b110a6d0eb8ec5e83d3bba13e85fcc0  components/qemedia/upstream/qe_arena/terminal_app.py
+6ea5cfcffc292e52ead2687728ad6d9c040dfaf32a5610386ac6514d4b1438b3  components/qemedia/upstream/qe_arena/terminal_env.py
+71f35970518b637bfa50fa79897d6f79d065e4531211af402f91a9dba4d31f38  components/qemedia/upstream/qe_arena/wasi_fs.py
+6e81b271a5910977f38deba39ccde6465d70e23e9ed42cbec51f02a6e237c71e  components/qemedia/upstream/qe_arena/wasi_worker.py
+c486d87e05b69ab133dd04cba072d5a39de8fda53c9a2f6fd5995570384724b0  schema.json
+7e16aa89ecd785fe76b4c3b1ef887845d33dbf293a849578a02efafb0da92c00  tasks.jsonl
+3ab9912b176d4555f7d38828bd66854b60311dc42c2e25c665cb8296fffaf9db  validate_dataset.py

SOURCE_LOCK.json

@@ -1,11 +1,11 @@
 {
   "components": {
-    "skillsdesk": {
-      "repository": "Syndicate604/skills-desk",
-      "revision": "a785ccdc9784ed863d0ffecec826d72176c0a785",
-      "license": "Apache-2.0",
+    "qemedia": {
+      "repository": "proffesor-for-testing/openenv-qe-arena",
+      "revision": "7490e2dc371b5060601ff4399a3d3688bff3ca80",
+      "license": "MIT",
       "source_file": "SOURCE_MANIFEST.json",
-      "record_sha256": "789ef47ecb391dfe876f65207ba8f477b064c1d9cded1becaf177ae7112a3d99"
+      "record_sha256": "f97c7ed6f032ebf9e6276f6156c447a2f128739858fc243143d72b86443292f3"
     }
   }
 }

components/qemedia/ADAPTER_NOTICE

@@ -0,0 +1,3 @@
+This distribution adds a two-task registry, source integrity checks and a single-session OpenEnv transport.
+Original QE generators, graders, task instructions and seed behavior are retained.
+The included qe_arena modules provide the original import dependencies; media tasks are the served selection.

components/qemedia/Dockerfile

@@ -0,0 +1,16 @@
+FROM ghcr.io/proffesor-for-testing/openenv-qe-arena-terminal@sha256:57dd0c2bfde0e503f1ff43400530cf99a6e2b8a5d9b1f42e0ae7471501f4b971
+USER root
+COPY upstream/qe_arena /opt/qemedia/qe_arena
+COPY runtime /opt/qemedia
+COPY SOURCE_MANIFEST.json /opt/qemedia/SOURCE_MANIFEST.json
+COPY LICENSE THIRD_PARTY_NOTICES ADAPTER_NOTICE /opt/qemedia/licenses/
+RUN rm -rf /app/qe_arena && chmod -R go-rwx /opt/qemedia /app /opt/qe-arena
+ENV PYTHONPATH=/opt/qemedia PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 OPENENV_MODE=production ENABLE_WEB_INTERFACE=false QE_ARENA_UNSANDBOXED_SHELL=0
+WORKDIR /opt/qemedia
+LABEL org.opencontainers.image.title="Media Workflows v11" \
+      org.opencontainers.image.description="Original QE media artifact tasks" \
+      org.opencontainers.image.source="https://huggingface.co/datasets/bochencs/openenv-multidomain" \
+      org.opencontainers.image.licenses="MIT"
+EXPOSE 8000
+ENTRYPOINT ["/usr/bin/tini", "--"]
+CMD ["python", "-m", "qemedia_compat.server"]

components/qemedia/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dragan Spiridonov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

components/qemedia/README.md

@@ -0,0 +1,4 @@
+Original QE media tasks by Dragan Spiridonov, with a two-task OpenEnv transport.
+
+Run `python -m qemedia_compat.server` as root. Commands run through the original isolated shell.
+Use one active session per sandbox. The selected original task IDs and source hashes are in SOURCE_MANIFEST.json.

components/qemedia/SOURCE_MANIFEST.json

@@ -0,0 +1,131 @@
+{
+  "repository": "proffesor-for-testing/openenv-qe-arena",
+  "revision": "7490e2dc371b5060601ff4399a3d3688bff3ca80",
+  "dataset": "Profa-QE/openenv-qe-arena-tasks",
+  "dataset_revision": "f5e0b952cffbb5d82e0c54c131e7b8a68abce69d",
+  "license": "MIT",
+  "base_image": "ghcr.io/proffesor-for-testing/openenv-qe-arena-terminal@sha256:57dd0c2bfde0e503f1ff43400530cf99a6e2b8a5d9b1f42e0ae7471501f4b971",
+  "sdk_revision": "86a180ede21e044f7929b9a7783ad83aa67d83a3",
+  "original_files": {
+    "qe_arena/__init__.py": "f1ce27b1c58f9547059e7f820aa65c1a8d8313144855ee8845b2eca91f7e0db3",
+    "qe_arena/app.py": "2925e44219fdef6310ac1e2b60532e3ba1f1e768b33e65f14f1f5e8f86b33510",
+    "qe_arena/corpus/__init__.py": "978aabadc5044616ff28ab7be69a2e9ff48f1fd82494a6897f4f2b8716283a08",
+    "qe_arena/corpus/aggregate_risk_factors.py": "0485dfbc2676a1f666958935602cc2f347e5fcd95b6bfcd32e8af13cafe07e35",
+    "qe_arena/corpus/alternate_chat_roles.py": "f999a088228120810c986f249964ba83d7a54a4853c9bebcbf61313b4362247e",
+    "qe_arena/corpus/amortization_schedule.py": "4b4f6e1280956988736c2401747ed0c3d633eedfe38e7d24ec815773f5c21711",
+    "qe_arena/corpus/api_complexity_level.py": "21517da739674bdc2b22efe9c2a2a7a85d47a7033aae3e24b2c1da8b4ac21684",
+    "qe_arena/corpus/artifact_retention_keep.py": "71db4461633e0ad524e11c2384d75675331a515778ce4a8b675c6f738c94a02c",
+    "qe_arena/corpus/backoff_schedule.py": "1f1937c25f4717a49a6e809ea81cc20da035f6aa843d4f47ce111b585e3ab4a2",
+    "qe_arena/corpus/badge_dimensions.py": "2661b8a01fb4d7d1a31169592eaae370b3d4260d6b32187ce4427ffbcfa097ea",
+    "qe_arena/corpus/baseline_verdict.py": "b1d44ea5c1b774f8572374e73468ca34483e3b382c982c28a368549da94656d5",
+    "qe_arena/corpus/booking_conflicts.py": "01764d4994630e38a91a6599f90142a9b145084dbd5971c564727ac9855f97f8",
+    "qe_arena/corpus/boundary_violations.py": "7f70d489eefbdae5794354fa457a39dc50eb0209929cb0f3a9f9493b41adc88a",
+    "qe_arena/corpus/brace_delta.py": "04d411ac8a666d3916c13090c7658e5cc516028ced9b0db45a334062d96683c5",
+    "qe_arena/corpus/calibration_fit.py": "6f0982869b0ef19ec7b95863008ea45b1a46dbd46108ee24b44338a383a37d23",
+    "qe_arena/corpus/chat_completion_result.py": "42b4727623069a0e774e0d70be6cb9869d871b377ddb6421c60bfa78bd3be126",
+    "qe_arena/corpus/claim_steal_priority.py": "f5c6486256438b89565cc1edcaf016d6e91f3c81067a77a30c9792cac7d0ef39",
+    "qe_arena/corpus/compare_versions.py": "a77352fd67a18a9c24c3fe697c9310b079c998dc853c2f49eba1a2c877742a62",
+    "qe_arena/corpus/complexity_bucket.py": "5e4e65b458e8cd2e9723206e43ea3a85d37df8b82c9f15e19f4da5ce26dd72ff",
+    "qe_arena/corpus/compound_interest.py": "3979785d451cc4473ec2b057a404f0a8ea930bd11ce34bedea06f1b953ee9c08",
+    "qe_arena/corpus/convert_timecode.py": "30ff0142461a624790a13766f9463c6fd6f21991442e5e37d46febd51f2ca7ad",
+    "qe_arena/corpus/coverage_gap_severity.py": "af3e694760997b353678c7350b08e43ed26de256792221420006e5d4837712d5",
+    "qe_arena/corpus/crop_to_aspect.py": "f85c6167be7fe0094e36b90d19fb4e382a2e804a34dc96fa09f379caf97d5904",
+    "qe_arena/corpus/debounce_switch.py": "61e8975cc643b0bd4d10656d48a77a7314b5e13382794bdcbecf19f2a80b3186",
+    "qe_arena/corpus/decay_table.py": "949197b79f96f244ccba1b44236510ec65d8c9aace59850cde4949697791024f",
+    "qe_arena/corpus/efficiency_reward.py": "c5033c7d0a147c46e9cf1659187879b00e8f253725f1fcc00b6c4e5529c9685b",
+    "qe_arena/corpus/expense_violations.py": "11d505901f9d2e00cc5b475d9cca75b4770db77345c1645b10e70620710a70b0",
+    "qe_arena/corpus/find_stop.py": "284d4fcd6c5cb23efc4282659991d9a403b46c0d836641071ad7079d8d2c8d0d",
+    "qe_arena/corpus/flakiness_pattern.py": "b3b94bcfe78f97b00187e7fe9783a8ae04b9a9b6af6d788f445f64bd52021aa0",
+    "qe_arena/corpus/flaky_hunter_reward.py": "11c670fbe537cbeeaa101d9b9db49519f5ebd4cca82b7ccfd66d5d68e352e5ba",
+    "qe_arena/corpus/flaky_run_summary.py": "f6ebbaffe1dd8aaccef7ad8ce48d8dfa60bacc8a44051880057c52b163e7748b",
+    "qe_arena/corpus/format_duration.py": "7e0cf537d1bd38fdbc474bc259a52fbf23f095f35661586d771eca0561481eb0",
+    "qe_arena/corpus/gguf_loader.py": "e232fbfe97a36cedf848caa11b9bf51828c5f4c6fe6ad3bf40133c6bc7deabd7",
+    "qe_arena/corpus/gguf_special_ids.py": "b5fc54e4b3f6b45af2af289a746fe48d948e806b43910920e6ee31c81bbd805e",
+    "qe_arena/corpus/glob_match.py": "52d8da6da1348af21303785a5dabfe36a42f7efeaed9b326b21898387a3e6536",
+    "qe_arena/corpus/income_tax.py": "ce28e349ed362052dd0184dc4f1e215344831edc2f74ebe8438c470964fc70a3",
+    "qe_arena/corpus/integer_edge_values.py": "edd468fbc9d11830559fbcc2bfb1d7afe35c71980432bb91c87d8c3571a704b7",
+    "qe_arena/corpus/ip_allowlist_match.py": "94bc28736f587e3cc350fef83ba95fe70dc44db627bcb037f854332f6b52e7fd",
+    "qe_arena/corpus/is_collection_endpoint.py": "87db0af0b61c0b95b0d8acf9235835db9631f9471d0e7dc29b0296abc76bccde",
+    "qe_arena/corpus/latency_percentiles.py": "7d91f4eb06374851748cbd3e33ae5f3d2059a491572449d4fc700ecaaed1431c",
+    "qe_arena/corpus/login_rate_limit.py": "814fc40372c1ece5068b04848f9c8a2a9069d504cf364df62c00a905d0ec777c",
+    "qe_arena/corpus/loudness_gain.py": "ecc262d19d2b27970901017aa4a006ad2ce97861866ccddae2a9c876c4bbec37",
+    "qe_arena/corpus/mail_merge.py": "2c3ec2cb2f5e050ff03d772675c372053fe3eb957f505a33d2d127916ee283bf",
+    "qe_arena/corpus/maintainability_index.py": "48972588b8f75f1132aaf0eaa112a35875833b7dc661e3c41ff6972f3ce29dd5",
+    "qe_arena/corpus/maintenance_status.py": "201bad40ff156e6a0caec2577011286262178000435aacaec83c603ba02aa4f8",
+    "qe_arena/corpus/merge_intervals.py": "fd5b0f08e59fc763734cdb43d4cd893ce851403281a806902f5945ce71e7e7cd",
+    "qe_arena/corpus/mod_inverse.py": "888558da6833e82d1b2dafadf39aa87609cf5c4bcc96345a4e37ac92cfd1d0de",
+    "qe_arena/corpus/mod_pow.py": "58cdc61459945cdd9bf20ab09cfa422c85148d76fecfc70567ef81b1240c2f36",
+    "qe_arena/corpus/networkdays.py": "1c72218af8a816d24fc7ba7d88901c83db49c056da34efea5f2ba491a77493d2",
+    "qe_arena/corpus/normalize_rational.py": "62e849358e01be48618529568005a1b487b411bdc18a01b4c226b824f77320df",
+    "qe_arena/corpus/parse_cron_field.py": "6275cc4556df344a4dfccbcdf5930e9561bcb27b93fcb247c9707a84c48f3231",
+    "qe_arena/corpus/parse_max_age.py": "52df1c52ecfe9db206a6322350204d2bbbaeb2fe6bd192d8b98d56de8739bf50",
+    "qe_arena/corpus/parse_signature_header.py": "cf81c249d3ff4092557d20bdcf210ce52cbe4c9e2e5e8634d279a46568d2f4df",
+    "qe_arena/corpus/password_violations.py": "5d1a27cea4b7db6b2b2484015dfc73e61ddc04b3d021da8adfb1788ebf0dd54c",
+    "qe_arena/corpus/pattern_effectiveness.py": "ccf4a9d4183523e3b82f95cf0f5f18efe86881ece0d7274f24f5236233aa4f13",
+    "qe_arena/corpus/pressure_check.py": "c7b17812aa575ee19db876d526f0770ad6ee591e6aa2bc624e05527cc1ef7df2",
+    "qe_arena/corpus/quality_gain_reward.py": "cca54e5fa4dfed47ac23f06111a357fb1a2f9fbd3b29a8d9873d268a91a754ec",
+    "qe_arena/corpus/quality_grade.py": "aafb0bab705f85093cecdfa13bdce9a1f23bbf055b60f50783abc46f020b8fef",
+    "qe_arena/corpus/reconcile_invoices.py": "169e88a7162bc1e2a798b76ee491191ca44fca3051d7eb392b56b7672139142e",
+    "qe_arena/corpus/round_sig_figs.py": "361cbe3b3c5e2da8317b2cf703dc11405d4c10ad2d62551c65388028238f4fb5",
+    "qe_arena/corpus/safe_join.py": "368365c0bd5b318b63d1614caba8bd4f752011f6beecf3ede4fbb42f137441d7",
+    "qe_arena/corpus/sample_variance.py": "a26bc6ef76d5dfbc4b0abff3f0189f6bd181f6934bcb6dee3410ab752316223d",
+    "qe_arena/corpus/select_bitrate_rung.py": "51ae093e2baeda053434e2e223827384124290ed5317bf160f0b3df366ef02eb",
+    "qe_arena/corpus/shift_cue.py": "cce40f8f9266e58918b174e82d1b167523a4df1b78a53f07af06fe43d9c9100e",
+    "qe_arena/corpus/slew_limit.py": "540a4e6c04b1e3cc78cf69e42897d6680840c513ffcc86eeba8f2aa735d30cf6",
+    "qe_arena/corpus/spec_readiness_score.py": "02936fcc7e5931cad5a46b286d098ae2d34698449f2eaa190eaa44f9785543da",
+    "qe_arena/corpus/split_generic_params.py": "9188e0c8045fa0d8e1a7a82153f6ccc791e075dd7a6f3b793abd117bb1064275",
+    "qe_arena/corpus/streamable_len.py": "d3aac59af147f657bbe61bb45e368d78cee587be7a4fa58208410fd5a9e3d26c",
+    "qe_arena/corpus/string_length_boundaries.py": "62a7ac1680df0375cae8ecb6cf08a3520375cb9c8dea94299a30551d0abe479e",
+    "qe_arena/corpus/threshold_compliance.py": "13361068ea0f1ebaacadb264bfec120e990341cf66154f77a1a110777be1754e",
+    "qe_arena/corpus/token_claims_check.py": "081ef70cde049750026cc4f60794f46a74a86424c12d73ea5c278b19563b2e77",
+    "qe_arena/corpus/token_jaccard.py": "9d10c0da4d0375ea05c99d0e5d2dd57a4bedf1a4fa5a5f48d6cc9344177f19bb",
+    "qe_arena/corpus/trace_sampling_decision.py": "6e20c250fb2d01cf06ed5b099d67089f43f7851e90224399f5865aee539d4f32",
+    "qe_arena/corpus/truncate_to_token_budget.py": "5246d62082d3a37dd57e6d3510ea489a4de4c44a31e5bddb2d4d438817b0c43b",
+    "qe_arena/corpus/uncovered_line_ranges.py": "9feb8f950e2cff5904eddba37a15e16a8888a7cb8f5dc893e74808a36c6f1876",
+    "qe_arena/corpus/validate_csv_row.py": "bc332a39e0143f24ee326b0f9343150a22f47fa420dc29ecf1cba816385a1d43",
+    "qe_arena/corpus/vuln_priority_bucket.py": "3132a4152e1baf9061b0e70d3192e0617e8de735195eb560dcfee5011c14f6fc",
+    "qe_arena/corpus/wilson_interval.py": "28e98e2f9b24bb36171fa2f5c5c9d78be23e193615b265aad092bec771eb8021",
+    "qe_arena/domains.py": "13bb7b068896d5377b8f969c504dde01875df8eef8a0b341348e45bcea5f991b",
+    "qe_arena/edit_budget.py": "4b27436ca7c4eed5e7dda34ccfac6c97eb413cf024274793d4d1cf47b50f9494",
+    "qe_arena/environment.py": "9675b6598456b5a8dbfe57eb6e6847998d86f2c93722caff3c8a3716d6ecc102",
+    "qe_arena/flaky.py": "0db273642496825ec8f8924a164093df1191b29c92ac83b5497261373c20f768",
+    "qe_arena/flaky_gen.py": "46e2198bcbe9d415bf775f845a358c2eaa26d390a5aa62d3b806f07b5803fab1",
+    "qe_arena/flaky_templates.py": "2272e0617a3a079d2e389bf50d62c4cc5da4ec005d2d68239bdfbf7e795fda92",
+    "qe_arena/guest_harness.py": "5b389cc8ab64218d3bdcc500f584ef0b78da4b68379bfb014e095d755ccdcdb1",
+    "qe_arena/keys/manifest_ed25519.pub": "ea2b370db92d82e1a0719ecf3416eeafdb7a14a524a94f6d6cd32a5f06b21106",
+    "qe_arena/manifest.py": "1911ef5d3696695364871da7be9744fd7c81d51fe81ae3c137341dd1b06c8494",
+    "qe_arena/mutation.py": "28a7abc5213c5a1504151d23148695e7f09e4441b39e941377cb7265ba6ff4de",
+    "qe_arena/runtime_pins.json": "97f080e2505ba4c6034fcc3f0322d9ecd8b9f9852ac19e424cc9273ccd0a9c77",
+    "qe_arena/sandbox.py": "92faaac323c0b524c0181008c305134fc57d2e4c6af1ea6fbf919b48ec9ea03a",
+    "qe_arena/shell.py": "4e9aabefa6f23793a05804ec413aaa5d1c5125365156f22cdb50ff600808d34d",
+    "qe_arena/skills/__init__.py": "c6b045c7b62b762ae4a56b13fcc61bf997ffd710494f9882e775f533dfe8c522",
+    "qe_arena/skills/_common.py": "ec722ad0aa0903fbca443dc8325f2569853b7191edfc525602d3cd0ddaf56037",
+    "qe_arena/skills/formal.py": "da87595287e1d253512564769274e3063f262fce0d4d4ea0ef5b26d9285a72e0",
+    "qe_arena/skills/media.py": "005eabea342ba948e6b68dcc341f3756a8ebdd5fb44830cb13bb482a16ef200c",
+    "qe_arena/skills/science.py": "f198046eb6e9d0610cd966f5e7a99d27e9da2e3f23e3687ecd42f4a5649aab98",
+    "qe_arena/skills/subtitles.py": "872054f7309500113beab2c853bfeceebd146e60dc36d42f42f9e98e6c4a7b84",
+    "qe_arena/tasks.py": "c540dc8eafd3ac648f768b17682ecb1f8f3bd3e14eed9a353c4021c427dc80bd",
+    "qe_arena/terminal_app.py": "d5a630210e1a8330ec3cc00a5b43d7d92b110a6d0eb8ec5e83d3bba13e85fcc0",
+    "qe_arena/terminal_env.py": "6ea5cfcffc292e52ead2687728ad6d9c040dfaf32a5610386ac6514d4b1438b3",
+    "qe_arena/wasi_fs.py": "71f35970518b637bfa50fa79897d6f79d065e4531211af402f91a9dba4d31f38",
+    "qe_arena/wasi_worker.py": "6e81b271a5910977f38deba39ccde6465d70e23e9ed42cbec51f02a6e237c71e"
+  },
+  "selected_tasks": [
+    "qe_skill-media-d2",
+    "qe_skill-media-d1"
+  ],
+  "native_pools": {
+    "qe_skill-media-d2": [
+      "subtitles",
+      "timecode",
+      "catalogue",
+      "assets"
+    ],
+    "qe_skill-media-d1": [
+      "timecode",
+      "catalogue",
+      "assets"
+    ]
+  },
+  "instance_policy": "Native seeded generation; omitted seed draws original randomness."
+}

components/qemedia/THIRD_PARTY_NOTICES

@@ -0,0 +1,63 @@
+Third-party notices
+===================
+
+The real-bug corpus entries listed below are Python ports of code from RuVector,
+https://github.com/ruvnet/RuVector, used under the MIT License. The fixed code comes from
+merged PR #1125 (32033a8bc0d4d92e0ea644fce98eef4bb5c6bfef). Each recorded fault reproduces
+pre-fix behaviour from its parent commit (3e1d1886c50f2db817664648b95fab18e3e4c34b).
+
+Entries and origins:
+
+- qe_arena/corpus/chat_completion_result.py
+  fixed code: ruvnet/RuVector@32033a8bc0d4d92e0ea644fce98eef4bb5c6bfef:crates/ruvllm-cli/src/commands/serve.rs
+  fault chat_completion_result/always-stop: ruvnet/RuVector@3e1d1886c50f2db817664648b95fab18e3e4c34b:crates/ruvllm-cli/src/commands/serve.rs
+  fault chat_completion_result/whitespace-token-count: ruvnet/RuVector@3e1d1886c50f2db817664648b95fab18e3e4c34b:crates/ruvllm-cli/src/commands/serve.rs
+
+- qe_arena/corpus/find_stop.py
+  fixed code: ruvnet/RuVector@32033a8bc0d4d92e0ea644fce98eef4bb5c6bfef:crates/ruvllm/src/backends/gguf_arch/mod.rs
+  fault find_stop/first-listed: ruvnet/RuVector@3e1d1886c50f2db817664648b95fab18e3e4c34b:crates/ruvllm/src/backends/candle_backend.rs
+  fault find_stop/empty-matches: ruvnet/RuVector@3e1d1886c50f2db817664648b95fab18e3e4c34b:crates/ruvllm/src/backends/candle_backend.rs
+
+- qe_arena/corpus/gguf_loader.py
+  fixed code: ruvnet/RuVector@32033a8bc0d4d92e0ea644fce98eef4bb5c6bfef:crates/ruvllm/src/backends/gguf_arch/mod.rs
+  fault gguf_loader/no-split-check: ruvnet/RuVector@3e1d1886c50f2db817664648b95fab18e3e4c34b:crates/ruvllm/src/backends/candle_backend.rs
+  fault gguf_loader/qwen-rejected: ruvnet/RuVector@3e1d1886c50f2db817664648b95fab18e3e4c34b:crates/ruvllm/src/backends/candle_backend.rs
+  fault gguf_loader/substring-match: ruvnet/RuVector@3e1d1886c50f2db817664648b95fab18e3e4c34b:crates/ruvllm/src/backends/candle_backend.rs
+
+- qe_arena/corpus/gguf_special_ids.py
+  fixed code: ruvnet/RuVector@32033a8bc0d4d92e0ea644fce98eef4bb5c6bfef:crates/ruvllm/src/backends/gguf_arch/mod.rs
+  fixed code: ruvnet/RuVector@32033a8bc0d4d92e0ea644fce98eef4bb5c6bfef:crates/ruvllm/src/backends/candle_backend.rs
+  fault gguf_special_ids/eos-from-vocab-guess: ruvnet/RuVector@3e1d1886c50f2db817664648b95fab18e3e4c34b:crates/ruvllm/src/backends/candle_backend.rs (pre-fix behaviour (EOS guessed from the vocabulary) expressed through the fixed function's interface)
+  fault gguf_special_ids/stop-is-only-eos: ruvnet/RuVector@3e1d1886c50f2db817664648b95fab18e3e4c34b:crates/ruvllm/src/backends/candle_backend.rs (pre-fix behaviour (stop on the single EOS id) expressed through the fixed function's interface)
+
+- qe_arena/corpus/streamable_len.py
+  fixed code: ruvnet/RuVector@32033a8bc0d4d92e0ea644fce98eef4bb5c6bfef:crates/ruvllm/src/backends/gguf_arch/mod.rs
+  fault streamable_len/no-holdback: ruvnet/RuVector@3e1d1886c50f2db817664648b95fab18e3e4c34b:crates/ruvllm/src/backends/candle_backend.rs (reconstructed from the pre-fix streaming behaviour; the pre-fix code had no streamable_len)
+  fault streamable_len/streams-pending-bytes: ruvnet/RuVector@3e1d1886c50f2db817664648b95fab18e3e4c34b:crates/ruvllm/src/backends/candle_backend.rs (reconstructed from the pre-fix streaming behaviour; the pre-fix code had no streamable_len)
+
+Other corpus entries adapt MIT-licensed code by the same authors as this repository; their
+origins are recorded per entry in META["origin"].
+
+RuVector licence:
+
+MIT License
+
+Copyright (c) 2025 rUv
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

components/qemedia/UPSTREAM_DOCKERFILE

@@ -0,0 +1,33 @@
+# The terminal-interface image (qe_arena.terminal_app): the same tasks and WASM graders as Dockerfile, behind
+# tbench2_env-shaped actions (exec / write_file / evaluate) with a real bash per episode.
+#
+# Unlike Dockerfile, the server runs as root: that is what lets qe_arena/shell.py run every episode's commands
+# as its own unprivileged uid (20000-20063). The sources and the WASI runtime are 0700 root, so an episode's
+# shell can read neither the corpus (the reference implementations) nor the graders. On a host that drops
+# CAP_SETUID the shell reports "disabled" at start-up and exec is refused; write_file and evaluate still work.
+FROM python:3.12-slim@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1 AS wasi-runtime
+WORKDIR /build
+COPY requirements-wasmtime.lock /build/requirements-wasmtime.lock
+RUN pip install --no-cache-dir --require-hashes -r /build/requirements-wasmtime.lock
+COPY scripts/build_wasi_runtime.py qe_arena/runtime_pins.json /build/
+RUN python /build/build_wasi_runtime.py --out /opt/qe-arena/wasi --pins /build/runtime_pins.json
+
+FROM python:3.12-slim@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1
+LABEL org.opencontainers.image.source="https://github.com/proffesor-for-testing/openenv-qe-arena"
+LABEL org.opencontainers.image.description="OpenEnv Arena training environment: QE tasks behind a terminal interface"
+LABEL org.opencontainers.image.licenses="MIT"
+WORKDIR /app
+RUN apt-get update && apt-get install -y --no-install-recommends git ca-certificates tini && rm -rf /var/lib/apt/lists/*
+COPY requirements.lock requirements-wasmtime.lock /app/
+RUN pip install --no-cache-dir --require-hashes -r /app/requirements-wasmtime.lock \
+    && pip install --no-cache-dir -r /app/requirements.lock
+COPY --from=wasi-runtime /opt/qe-arena/wasi /opt/qe-arena/wasi
+COPY qe_arena /app/qe_arena
+COPY openenv.terminal.yaml /app/openenv.yaml
+COPY THIRD_PARTY_NOTICES /app/THIRD_PARTY_NOTICES
+# The sources and runtime are root-only; the image's own world-writable dirs are locked (shell.SHARED_DIRS).
+RUN chmod 0700 /app /opt/qe-arena && chmod 0711 /var/tmp /run/lock
+ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 ENABLE_WEB_INTERFACE=false QE_ARENA_WASI_ROOT=/opt/qe-arena/wasi
+EXPOSE 8000
+ENTRYPOINT ["/usr/bin/tini", "--"]
+CMD ["python", "-m", "uvicorn", "qe_arena.terminal_app:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "1"]

components/qemedia/runtime/qemedia_compat/__init__.py

@@ -0,0 +1 @@
+"""OpenEnv transport for the selected original QE media tasks."""

components/qemedia/runtime/qemedia_compat/environment.py

@@ -0,0 +1,170 @@
+"""Select original QE media tasks and manage a single active episode."""
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+from threading import RLock
+import weakref
+
+from openenv.core.env_server.interfaces import Environment
+from openenv.core.env_server.types import EnvironmentMetadata
+
+ROOT = Path(__file__).resolve().parents[1]
+SOURCE_REVISION = '7490e2dc371b5060601ff4399a3d3688bff3ca80'
+TASK_IDS = ('qe_skill-media-d2', 'qe_skill-media-d1')
+MANIFEST = json.loads((ROOT / 'SOURCE_MANIFEST.json').read_text())
+if MANIFEST['revision'] != SOURCE_REVISION or tuple(MANIFEST['selected_tasks']) != TASK_IDS:
+    raise RuntimeError('Unexpected original source or selected tasks')
+
+
+def verify_original_source():
+    expected = MANIFEST['original_files']
+    if any(p.is_symlink() for p in (ROOT / 'qe_arena').rglob('*')):
+        raise RuntimeError('Symlink in original source tree')
+    actual = {p.relative_to(ROOT).as_posix() for p in (ROOT / 'qe_arena').rglob('*') if p.is_file()}
+    if actual != set(expected):
+        raise RuntimeError('Original source inventory mismatch')
+    for relative, digest in expected.items():
+        path = ROOT / relative
+        if (path.is_symlink() or not path.is_file()
+                or not path.resolve().is_relative_to(ROOT)
+                or hashlib.sha256(path.read_bytes()).hexdigest() != digest):
+            raise RuntimeError('Original source hash mismatch: ' + relative)
+
+
+verify_original_source()
+from qe_arena import shell, skills  # noqa: E402
+from qe_arena.terminal_env import TerminalAction, TerminalEnvironment, TerminalObservation  # noqa: E402
+
+
+def verify_runtime():
+    if os.geteuid() != 0 or os.environ.get('QE_ARENA_UNSANDBOXED_SHELL') == '1':
+        raise RuntimeError('The service requires root and the native isolated shell')
+    import sys
+    for name, module in tuple(sys.modules.items()):
+        if name == 'qe_arena' or name.startswith('qe_arena.'):
+            filename = getattr(module, '__file__', None)
+            if filename is None or not Path(filename).resolve().is_relative_to(ROOT / 'qe_arena'):
+                raise RuntimeError('Original module resolved outside the source tree: ' + name)
+    if shell.mode() != 'uid':
+        raise RuntimeError('Native isolated exec is unavailable')
+    if (shell.EXEC_TIMEOUT_S != 30 or shell.MAX_OUTPUT_BYTES != 8192
+            or shell.MAX_WRITE_BYTES != 65536 or shell.MAX_READ_BYTES != 65536):
+        raise RuntimeError('Native shell limits changed')
+    if skills.SERVED['qe_skill-media-d2'] != ('subtitles', 'timecode', 'catalogue', 'assets'):
+        raise RuntimeError('Native media d2 pool changed')
+    if skills.SERVED['qe_skill-media-d1'] != ('timecode', 'catalogue', 'assets'):
+        raise RuntimeError('Native media d1 pool changed')
+
+
+_SESSION_LOCK = RLock()
+_OWNER = None
+
+
+class CompatEnvironment(Environment):
+    SUPPORTS_CONCURRENT_SESSIONS = False
+
+    def __init__(self):
+        super().__init__()
+        self._original = TerminalEnvironment()
+        self._task_id = None
+        self._terminal = None
+
+    def reset(self, seed=None, episode_id=None, *, task_id=None, index=None, split='train', **kwargs):
+        global _OWNER
+        # Validate before touching an existing episode, including the seed-zero case.
+        if kwargs:
+            raise ValueError('Unsupported reset arguments: ' + ', '.join(sorted(kwargs)))
+        if split != 'train':
+            raise ValueError('Unknown split')
+        if index is not None:
+            if type(index) is not int or not 0 <= index < len(TASK_IDS):
+                raise ValueError('Invalid task index')
+            if task_id is not None and task_id != TASK_IDS[index]:
+                raise ValueError('Task selection mismatch')
+            task_id = TASK_IDS[index]
+        if type(task_id) is not str or task_id not in TASK_IDS:
+            raise ValueError('Reset requires a selected task_id or index')
+        if seed is not None and (type(seed) is not int or not 0 <= seed < 2**64):
+            raise ValueError('Seed must be an unsigned 64-bit integer')
+        with _SESSION_LOCK:
+            verify_runtime()
+            owner = _OWNER() if _OWNER is not None else None
+            if owner is not None and owner is not self:
+                raise RuntimeError('Another episode is active in this sandbox')
+            was_active = owner is self
+            _OWNER = weakref.ref(self)
+            try:
+                opening = self._original.reset(task_id=task_id, seed=seed, episode_id=episode_id)
+            except BaseException:
+                if not was_active:
+                    self._original.close()
+                    _OWNER = None
+                    self._task_id = None
+                raise
+            self._task_id = task_id
+            self._terminal = None
+            return opening
+
+    def step(self, action, timeout_s=None, **kwargs):
+        global _OWNER
+        with _SESSION_LOCK:
+            if self._task_id is None:
+                raise RuntimeError('Reset before stepping')
+            if self._terminal is not None:
+                return self._terminal.model_copy(deep=True)
+            native = action if isinstance(action, TerminalAction) else TerminalAction.model_validate(action)
+            observed = self._original.step(native, timeout_s=timeout_s, **kwargs)
+            if observed.done:
+                reward = observed.reward
+                if (isinstance(reward, bool) or not isinstance(reward, (int, float))
+                        or not math.isfinite(reward) or reward not in (0, 1)):
+                    raise RuntimeError('Original terminal reward is not binary')
+                self._terminal = observed.model_copy(deep=True)
+                if _OWNER is not None and _OWNER() is self:
+                    _OWNER = None
+            return observed
+
+    @property
+    def state(self):
+        return self._original.state
+
+    def close(self):
+        global _OWNER
+        with _SESSION_LOCK:
+            # This closes only this instance's workspace, including metadata-only instances.
+            self._original.close()
+            if _OWNER is not None and _OWNER() is self:
+                _OWNER = None
+            self._task_id = None
+            self._terminal = None
+
+    def get_metadata(self):
+        return EnvironmentMetadata(name='qemedia', version='1.0.0',
+                                   description='Original QE media artifact tasks')
+
+    def list_splits(self):
+        return ['train']
+
+    def list_tasks(self, split):
+        if split != 'train':
+            raise ValueError('Unknown split')
+        return [{'id': task_id, 'index': i} for i, task_id in enumerate(TASK_IDS)]
+
+    def num_tasks(self, split):
+        return len(self.list_tasks(split))
+
+    def get_task(self, split, index):
+        if type(index) is not int or not 0 <= index < len(TASK_IDS):
+            raise ValueError('Invalid task index')
+        return self.list_tasks(split)[index]
+
+    def get_task_range(self, split, start=None, stop=None):
+        tasks = self.list_tasks(split)
+        for bound in (start, stop):
+            if bound is not None and (type(bound) is not int or not 0 <= bound <= len(tasks)):
+                raise ValueError('Invalid task range')
+        if start is not None and stop is not None and start > stop:
+            raise ValueError('Invalid task range')
+        return tasks[start:stop]

components/qemedia/runtime/qemedia_compat/server.py

@@ -0,0 +1,16 @@
+"""Serve the original terminal action and observation models."""
+from openenv.core.env_server.http_server import create_app
+from .environment import CompatEnvironment, TerminalAction, TerminalObservation, verify_runtime
+
+verify_runtime()
+app = create_app(CompatEnvironment, TerminalAction, TerminalObservation,
+                 env_name='qemedia', max_concurrent_envs=1, mode='production')
+
+
+def main():
+    import uvicorn
+    uvicorn.run(app, host='0.0.0.0', port=8000, workers=1, log_level='warning')
+
+
+if __name__ == '__main__':
+    main()

components/qemedia/upstream/qe_arena/__init__.py

@@ -0,0 +1 @@
+"""OpenEnv Arena training environment for quality-engineering tasks."""

components/qemedia/upstream/qe_arena/app.py

@@ -0,0 +1,21 @@
+import logging
+import threading
+
+from openenv.core.env_server.http_server import create_app
+
+from . import sandbox
+from .environment import QEAction, QEEnvironment, QEObservation
+
+app = create_app(QEEnvironment, QEAction, QEObservation, env_name="qe_arena", max_concurrent_envs=8)
+
+
+def _warm_sandbox() -> None:
+    # Each sandbox worker compiles python.wasm (~5 s each at --cpus=2, measured in the image). Do it
+    # now, off the request path, so /health answers at once and the first episode does not wait.
+    try:
+        sandbox.warm()
+    except Exception:  # noqa: BLE001 - logged here; the next run_calls raises the same error
+        logging.getLogger(__name__).exception("sandbox warm-up failed")
+
+
+threading.Thread(target=_warm_sandbox, name="sandbox-warm", daemon=True).start()

components/qemedia/upstream/qe_arena/corpus/__init__.py

@@ -0,0 +1,154 @@
+"""Corpus of small, pure QE functions used by the bug-fix and mutant-kill task families.
+
+Each module in this package follows the corpus contract in docs/DESIGN.md: a one-line module
+docstring, a ``META`` dict, the entry function plus any helpers, and ``gen_inputs(rng, n)``.
+
+An entry whose META has ``real_faults`` is a real-bug entry: the function is the fixed upstream code
+and each real fault records the pre-fix logic as an exact text replacement in ``function_source``.
+Real-bug entries are served only by the qe_bugfix real tier (``REAL_NAMES``); the injected tiers and
+qe_mutant_kill draw from ``INJECTED_NAMES``.
+
+``META["domain"]`` names the arena domain the code belongs to (``qe_arena.domains.DOMAINS``). A task
+cell draws only entries of its own domain (``domain_names``).
+"""
+from __future__ import annotations
+
+import ast
+import importlib
+import pkgutil
+import random
+from dataclasses import dataclass
+from pathlib import Path
+
+from ..domains import DOMAINS, SOFTWARE
+
+_PACKAGE_DIR = Path(__file__).resolve().parent
+
+
+@dataclass(frozen=True)
+class RealFault:
+    """A defect that existed upstream before a fix, as an exact replacement in ``function_source``."""
+
+    id: str
+    kind: str
+    summary: str
+    origin: str
+    find: str
+    replace: str
+    note: str = ""  # how the fault relates to the pre-fix code when it is not a literal copy of it
+
+
+@dataclass(frozen=True)
+class CorpusEntry:
+    name: str
+    entry: str
+    origin: str
+    tags: tuple[str, ...]
+    source: str
+    function_source: str
+    summary: str
+    domain: str = SOFTWARE
+    real_faults: tuple[RealFault, ...] = ()
+
+
+def _is_kept(node: ast.stmt) -> bool:
+    if isinstance(node, (ast.Import, ast.ImportFrom)):
+        return True
+    return isinstance(node, ast.FunctionDef) and node.name != "gen_inputs"
+
+
+def _start_line(node: ast.stmt) -> int:
+    decorators = getattr(node, "decorator_list", [])
+    return min([node.lineno] + [d.lineno for d in decorators])
+
+
+def extract_function_source(text: str) -> str:
+    """Return the imports plus every function except ``gen_inputs``, verbatim from ``text``.
+
+    Consecutive kept top-level statements form one run, copied with their original
+    formatting and comments. Runs are joined with two blank lines.
+    """
+    lines = text.splitlines()
+    runs: list[list[ast.stmt]] = []
+    previous_kept = False
+    for node in ast.parse(text).body:
+        kept = _is_kept(node)
+        if kept and previous_kept:
+            runs[-1].append(node)
+        elif kept:
+            runs.append([node])
+        previous_kept = kept
+    chunks = [
+        "\n".join(lines[_start_line(run[0]) - 1 : run[-1].end_lineno])
+        for run in runs
+    ]
+    return "\n\n\n".join(chunks) + "\n"
+
+
+def _summary(text: str) -> str:
+    docstring = ast.get_docstring(ast.parse(text)) or ""
+    first_line = docstring.strip().splitlines()[0] if docstring.strip() else ""
+    for marker in (" Adapted from ", " Ported from ", " Original."):
+        if marker in first_line:
+            first_line = first_line.split(marker, 1)[0]
+    return first_line.strip()
+
+
+def _load_entries() -> dict[str, CorpusEntry]:
+    entries: dict[str, CorpusEntry] = {}
+    names = sorted(
+        info.name
+        for info in pkgutil.iter_modules([str(_PACKAGE_DIR)])
+        if not info.name.startswith("_")
+    )
+    for name in names:
+        module = importlib.import_module(f"{__name__}.{name}")
+        text = (_PACKAGE_DIR / f"{name}.py").read_text(encoding="utf-8")
+        meta = module.META
+        if meta.get("domain") not in DOMAINS:
+            raise ValueError(f"corpus entry {name}: META domain must be one of {DOMAINS}, got {meta.get('domain')!r}")
+        entries[name] = CorpusEntry(
+            name=name,
+            entry=meta["entry"],
+            origin=meta["origin"],
+            tags=tuple(meta["tags"]),
+            source=text,
+            function_source=extract_function_source(text),
+            summary=_summary(text),
+            domain=meta["domain"],
+            real_faults=tuple(RealFault(**fault) for fault in meta.get("real_faults", ())),
+        )
+    return entries
+
+
+ENTRIES: dict[str, CorpusEntry] = _load_entries()
+REAL_NAMES: tuple[str, ...] = tuple(name for name, e in ENTRIES.items() if e.real_faults)
+INJECTED_NAMES: tuple[str, ...] = tuple(name for name, e in ENTRIES.items() if not e.real_faults)
+
+
+def domain_names(domain: str, names: tuple[str, ...] = INJECTED_NAMES) -> tuple[str, ...]:
+    """The entries of ``names`` that belong to ``domain``, in their original (sorted) order."""
+    if domain not in DOMAINS:
+        raise ValueError(f"unknown domain: {domain!r}")
+    return tuple(name for name in names if ENTRIES[name].domain == domain)
+
+
+def _module(name: str):
+    if name not in ENTRIES:
+        raise KeyError(f"unknown corpus entry: {name}")
+    return importlib.import_module(f"{__name__}.{name}")
+
+
+def call_reference(name: str, args: list):
+    """Call the original entry function directly. For tests only; the verifier runs it in a sandbox."""
+    module = _module(name)
+    return getattr(module, ENTRIES[name].entry)(*args)
+
+
+def gen_inputs(name: str, seed: int, n: int) -> list[list]:
+    """Deterministic argument lists for ``name``: boundary cases first, then seeded random ones."""
+    return _module(name).gen_inputs(random.Random(seed), n)
+
+
+__all__ = ["CorpusEntry", "ENTRIES", "INJECTED_NAMES", "REAL_NAMES", "RealFault", "call_reference",
+           "domain_names", "extract_function_source", "gen_inputs"]

components/qemedia/upstream/qe_arena/corpus/aggregate_risk_factors.py

@@ -0,0 +1,53 @@
+"""Rank defect-risk factors by their average contribution across files. Ported from TypeScript; adapted from proffesor-for-testing/agentic-qe@214a5bc881fe4ad6324e243c9d9c2c24baae5295:src/mcp/tools/defect-intelligence/predict.ts (MIT)."""
+
+META = {
+    "entry": "aggregate_risk_factors",
+    "origin": "proffesor-for-testing/agentic-qe@214a5bc881fe4ad6324e243c9d9c2c24baae5295:src/mcp/tools/defect-intelligence/predict.ts",
+    "tags": ["defect-prediction", "grouping", "sorting"],
+    "domain": "software-engineering",
+}
+
+
+def aggregate_risk_factors(predictions):
+    """Aggregate per-file risk factors into the top five factors overall.
+
+    predictions is a list (one item per file) of lists of [factor_name, contribution]
+    pairs, where contribution is an int. Every occurrence counts, even if a factor
+    repeats within one file. For each factor name: count = number of occurrences and
+    impact = round(sum of contributions / count, 2). Returns [name, impact, count]
+    rows sorted by impact descending; ties keep the order in which the factor names
+    first appeared. At most the first 5 rows are returned.
+    """
+    totals = {}
+    for factors in predictions:
+        for name, contribution in factors:
+            impact, count = totals.get(name, [0, 0])
+            totals[name] = [impact + contribution, count + 1]
+    ranked = []
+    for name, (impact, count) in totals.items():
+        ranked.append([name, round(impact / count, 2), count])
+    ranked.sort(key=lambda row: row[1], reverse=True)
+    return ranked[:5]
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        [[]],
+        [[[]]],
+        [[[["churn", 30]]]],
+        [[[["churn", 30]], [["churn", 10]]]],
+        [[[["churn", 30], ["churn", 0]]]],
+        [[[["a", 10], ["b", 20]], [["b", 0], ["c", 5]]]],
+        [[[["a", 7], ["b", 7], ["c", 7]]]],
+        [[[["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5], ["f", 6]]]],
+        [[[["a", 6], ["b", 5], ["c", 4], ["d", 3], ["e", 2], ["f", 1]]]],
+        [[[["a", 1], ["b", 1], ["c", 1], ["d", 1], ["e", 1], ["f", 1]]]],
+        [[[["x", 10]], [["x", 11]], [["x", 11]]]],
+        [[[["size", -5], ["age", 3]]]],
+    ]
+    names = ["churn", "size", "age", "authors", "bugs", "deps", "lint"]
+    while len(cases) < n:
+        cases.append([[[[rng.choice(names), rng.randint(0, 50)] for _ in range(rng.randint(0, 3))]
+                       for _ in range(rng.randint(1, 4))]])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/alternate_chat_roles.py

@@ -0,0 +1,53 @@
+"""Normalize a chat transcript into strict user/assistant alternation. Adapted from proffesor-for-testing/sentinel-api-testing@704f47fbc4d2d75ed9261f9a602d76aea930d01b:sentinel_backend/llm_providers/providers/anthropic_provider.py (MIT)."""
+
+META = {
+    "entry": "alternate_chat_roles",
+    "origin": "proffesor-for-testing/sentinel-api-testing@704f47fbc4d2d75ed9261f9a602d76aea930d01b:sentinel_backend/llm_providers/providers/anthropic_provider.py",
+    "tags": ["llm", "normalization", "lists"],
+    "domain": "software-engineering",
+}
+
+
+def alternate_chat_roles(messages):
+    """Return a new transcript whose roles strictly alternate and start and end with "user".
+
+    messages is a list of {"role": "user" or "assistant", "content": str}; the input is
+    not modified. Consecutive messages with the same role are merged into one message,
+    joining the contents with "\n\n". After merging: if the first message is not from
+    "user", {"role": "user", "content": "Continue."} is inserted at the front; then if
+    the last message is not from "user", {"role": "user", "content": "Please respond."}
+    is appended. An empty list returns [].
+    """
+    result = []
+    for msg in messages:
+        if result and result[-1]["role"] == msg["role"]:
+            result[-1]["content"] += "\n\n" + msg["content"]
+        else:
+            result.append({"role": msg["role"], "content": msg["content"]})
+    if result and result[0]["role"] != "user":
+        result.insert(0, {"role": "user", "content": "Continue."})
+    if result and result[-1]["role"] != "user":
+        result.append({"role": "user", "content": "Please respond."})
+    return result
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    def _m(role, content):
+        return {"role": role, "content": content}
+
+    u, a = "user", "assistant"
+    cases = [
+        [[]],
+        [[_m(u, "hi")]],
+        [[_m(a, "hi")]],
+        [[_m(u, "q"), _m(a, "r")]],
+        [[_m(u, "a"), _m(u, "b")]],
+        [[_m(a, "a"), _m(a, "b"), _m(u, "c")]],
+        [[_m(u, "a"), _m(a, "b"), _m(a, "c"), _m(u, "d")]],
+        [[_m(a, "x"), _m(u, "y"), _m(u, "z"), _m(a, "w")]],
+        [[_m(u, ""), _m(u, ""), _m(u, "")]],
+    ]
+    while len(cases) < n:
+        cases.append([[_m(rng.choice([u, a]), rng.choice("abcdefg")) for _ in range(rng.randint(1, 6))]])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/amortization_schedule.py

@@ -0,0 +1,71 @@
+"""Summarise a level-payment loan in integer cents. Original."""
+
+import math
+from fractions import Fraction
+
+META = {
+    "entry": "amortization_schedule",
+    "origin": "Original.",
+    "tags": ["loan", "amortization", "money"],
+    "domain": "finance-economics",
+}
+
+
+def amortization_schedule(principal_cents, annual_rate_bp, months):
+    """Summarise a fixed-rate level-payment loan in integer cents.
+
+    r = annual_rate_bp / 120000 per month, exact. payment = ceil(principal_cents / months) if the
+    rate is 0, else ceil(principal_cents * r / (1 - (1 + r) ** -months)). From balance =
+    principal_cents, each month's interest is balance * r rounded half up to a cent. The loan closes
+    in the first month where balance + interest <= payment, or in month `months`, by paying
+    balance + interest; otherwise balance becomes balance + interest - payment.
+    Returns [payment, final_payment, total_interest, months_paid].
+    Raises ValueError if principal_cents < 1, months < 1 or annual_rate_bp is outside 0..5000.
+    """
+    if principal_cents < 1 or months < 1 or not 0 <= annual_rate_bp <= 5000:
+        raise ValueError
+    if annual_rate_bp == 0:
+        payment = math.ceil(Fraction(principal_cents, months))
+    else:
+        rate = Fraction(annual_rate_bp, 120000)
+        payment = math.ceil(principal_cents * rate / (1 - (1 + rate) ** -months))
+    balance, total_interest = principal_cents, 0
+    for month in range(1, months + 1):
+        interest = (balance * annual_rate_bp + 60000) // 120000
+        total_interest += interest
+        if balance + interest <= payment or month == months:
+            return [payment, balance + interest, total_interest, month]
+        balance += interest - payment
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        [100, 0, 3],
+        [10, 0, 7],
+        [9, 0, 7],
+        [7, 1200, 2],
+        [1000, 3000, 3],
+        [705, 2132, 7],
+        [1229, 2598, 5],
+        [1774, 608, 6],
+        [59999, 1, 1],
+        [100000, 0, 12],
+        [100000, 600, 12],
+        [100000, 600, 1],
+        [1, 600, 1],
+        [1, 1, 1],
+        [25000000, 450, 360],
+        [2000000, 5000, 24],
+        [2000000, 4999, 24],
+        [500000, 1200, 6],
+        [0, 600, 12],
+        [100000, 600, 0],
+        [100000, -1, 12],
+        [100000, 5001, 12],
+    ]
+    while len(cases) < n:
+        months = rng.choice([1, 2, 3, 6, 12, 24, 36, 48, 60, rng.randint(1, 120), rng.choice([180, 240, 360])])
+        rate = rng.choice([0, rng.randint(1, 3000), rng.randint(1, 3000), rng.randint(1, 5000)])
+        cases.append([rng.randint(1, 50) * rng.choice([1, 100, 1000, 10000]) + rng.randint(0, 99), rate, months])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/api_complexity_level.py

@@ -0,0 +1,57 @@
+"""Bucket an API's performance-test planning complexity. Adapted from proffesor-for-testing/sentinel-api-testing@704f47fbc4d2d75ed9261f9a602d76aea930d01b:sentinel_backend/orchestration_service/agents/performance_planner_agent.py (MIT)."""
+
+META = {
+    "entry": "api_complexity_level",
+    "origin": "proffesor-for-testing/sentinel-api-testing@704f47fbc4d2d75ed9261f9a602d76aea930d01b:sentinel_backend/orchestration_service/agents/performance_planner_agent.py",
+    "tags": ["performance", "planning", "thresholds"],
+    "domain": "software-engineering",
+}
+
+
+def api_complexity_level(total_endpoints, critical_paths, data_intensive_ops):
+    """Return "low", "medium" or "high" for the planning complexity of an API.
+
+    score = total_endpoints + 2 * critical_paths + 3 * data_intensive_ops.
+    score < 10 is "low", 10 <= score < 25 is "medium", score >= 25 is "high".
+    Raises ValueError if any count is negative, or if critical_paths or
+    data_intensive_ops is greater than total_endpoints.
+    """
+    if min(total_endpoints, critical_paths, data_intensive_ops) < 0:
+        raise ValueError("counts must be non-negative")
+    if critical_paths > total_endpoints or data_intensive_ops > total_endpoints:
+        raise ValueError("subset counts cannot exceed total_endpoints")
+    score = total_endpoints + critical_paths * 2 + data_intensive_ops * 3
+    if score < 10:
+        return "low"
+    if score < 25:
+        return "medium"
+    return "high"
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        [0, 0, 0],
+        [9, 0, 0],
+        [10, 0, 0],
+        [7, 1, 0],
+        [6, 0, 1],
+        [8, 1, 0],
+        [24, 0, 0],
+        [25, 0, 0],
+        [18, 2, 1],
+        [17, 2, 1],
+        [12, 3, 2],
+        [3, 3, 3],
+        [4, 3, 3],
+        [-1, 0, 0],
+        [5, -1, 0],
+        [5, 0, -2],
+        [2, 3, 0],
+        [2, 0, 3],
+        [3, 3, 0],
+    ]
+    while len(cases) < n:
+        total = rng.randint(0, 20)
+        cases.append([total, rng.randint(0, total), rng.randint(0, total)])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/artifact_retention_keep.py

@@ -0,0 +1,62 @@
+"""Decide whether a stored test artifact survives the retention policy. Adapted from proffesor-for-testing/lionagi-qe-fleet@ce1d58750a240a16c3c53abcb8a7c73864e98c99:src/lionagi_qe/storage/utils/retention.py (MIT)."""
+
+META = {
+    "entry": "artifact_retention_keep",
+    "origin": "proffesor-for-testing/lionagi-qe-fleet@ce1d58750a240a16c3c53abcb8a7c73864e98c99:src/lionagi_qe/storage/utils/retention.py",
+    "tags": ["storage", "time-window", "policy"],
+    "domain": "software-engineering",
+}
+
+
+def artifact_retention_keep(rank, keep_latest_n, created_day, retention_days, expires_day,
+                            default_ttl_days, today):
+    """Return True if an artifact should be kept. Days are integer day numbers.
+
+    rank is the artifact's 0-based position among the newest artifacts (0 = newest),
+    or None if unranked. Rules in order:
+    1. rank is not None and rank < keep_latest_n -> True (always kept).
+    2. retention_days is not None and today > created_day + retention_days -> False.
+    3. expires_day is not None and today > expires_day -> False.
+    4. retention_days and expires_day are both None and
+       today > created_day + default_ttl_days -> False.
+    5. Otherwise True. An artifact is still kept on its last day (today equal to the limit).
+    """
+    if rank is not None and rank < keep_latest_n:
+        return True
+    if retention_days is not None and today > created_day + retention_days:
+        return False
+    if expires_day is not None and today > expires_day:
+        return False
+    if retention_days is None and expires_day is None:
+        if today > created_day + default_ttl_days:
+            return False
+    return True
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        [0, 1, 0, None, None, 30, 100],
+        [1, 1, 0, None, None, 30, 100],
+        [None, 5, 0, None, None, 30, 100],
+        [None, 5, 0, None, None, 30, 30],
+        [None, 5, 0, None, None, 30, 31],
+        [None, 0, 10, 7, None, 30, 17],
+        [None, 0, 10, 7, None, 30, 18],
+        [None, 0, 10, 7, None, 3, 16],
+        [None, 0, 10, None, 20, 3, 20],
+        [None, 0, 10, None, 20, 3, 21],
+        [None, 0, 10, None, 20, 300, 21],
+        [None, 0, 10, 30, 20, 300, 21],
+        [None, 0, 10, 5, 40, 30, 16],
+        [2, 3, 0, 1, 1, 1, 50],
+        [3, 3, 0, 1, 1, 1, 50],
+        [0, 0, 0, None, None, 0, 1],
+    ]
+    while len(cases) < n:
+        created = rng.randint(0, 50)
+        cases.append([rng.choice([None, rng.randint(0, 5)]), rng.randint(0, 4), created,
+                      rng.choice([None, rng.randint(0, 30)]),
+                      rng.choice([None, created + rng.randint(0, 40)]),
+                      rng.randint(1, 40), created + rng.randint(0, 60)])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/backoff_schedule.py

@@ -0,0 +1,53 @@
+"""List capped exponential retry delays with their jitter allowance. Ported from TypeScript; adapted from proffesor-for-testing/agentic-qe@214a5bc881fe4ad6324e243c9d9c2c24baae5295:src/shared/retry-engine.ts (MIT)."""
+
+META = {
+    "entry": "backoff_schedule",
+    "origin": "proffesor-for-testing/agentic-qe@214a5bc881fe4ad6324e243c9d9c2c24baae5295:src/shared/retry-engine.ts",
+    "tags": ["retry", "backoff", "arithmetic"],
+    "domain": "software-engineering",
+}
+
+
+def backoff_schedule(attempts, base_ms, max_ms, jitter_pct):
+    """Return the maximum delay (ms) before each retry attempt 0..attempts-1.
+
+    For attempt k: exponential = min(base_ms * 2**k, max_ms) and the delay is
+    exponential + exponential * jitter_pct // 100 (the largest value the random jitter
+    can add, using integer division). Returns a list of `attempts` ints ([] for 0).
+    Raises ValueError if attempts < 0, base_ms < 1, max_ms < base_ms, or jitter_pct
+    is outside 0..100.
+    """
+    if attempts < 0 or base_ms < 1 or max_ms < base_ms:
+        raise ValueError("invalid backoff parameters")
+    if jitter_pct < 0 or jitter_pct > 100:
+        raise ValueError("jitter_pct must be within 0..100")
+    delays = []
+    for attempt in range(attempts):
+        exponential = min(base_ms * 2 ** attempt, max_ms)
+        delays.append(exponential + exponential * jitter_pct // 100)
+    return delays
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        [0, 100, 1000, 0],
+        [1, 100, 1000, 0],
+        [4, 100, 1000, 0],
+        [5, 100, 1000, 0],
+        [6, 100, 1600, 25],
+        [5, 1000, 32000, 25],
+        [3, 7, 7, 50],
+        [4, 3, 20, 33],
+        [3, 10, 100, 100],
+        [2, 10, 100, 101],
+        [2, 10, 100, -1],
+        [-1, 10, 100, 0],
+        [2, 0, 100, 0],
+        [2, 50, 49, 0],
+        [10, 1, 1000, 10],
+    ]
+    while len(cases) < n:
+        base = rng.randint(1, 500)
+        cases.append([rng.randint(0, 10), base, base * rng.randint(1, 40), rng.randint(0, 100)])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/badge_dimensions.py

@@ -0,0 +1,52 @@
+"""Compute SVG badge geometry from label and message lengths. Adapted from proffesor-for-testing/lionagi-qe-fleet@ce1d58750a240a16c3c53abcb8a7c73864e98c99:src/lionagi_qe/badges/generator.py (MIT)."""
+
+META = {
+    "entry": "badge_dimensions",
+    "origin": "proffesor-for-testing/lionagi-qe-fleet@ce1d58750a240a16c3c53abcb8a7c73864e98c99:src/lionagi_qe/badges/generator.py",
+    "tags": ["reporting", "arithmetic"],
+    "domain": "software-engineering",
+}
+
+
+def badge_dimensions(label, message):
+    """Return the integer layout of a two-part status badge (shields.io style).
+
+    With char_width = 6 pixels:
+      label_width   = len(label) * 6 + 10
+      message_width = len(message) * 6 + 10
+      width         = label_width + message_width
+      label_x       = label_width * 10 // 2
+      message_x     = label_width * 10 + message_width * 10 // 2
+      label_text_length   = len(label) * 6 * 10
+      message_text_length = len(message) * 6 * 10
+    Returns a dict with exactly those seven keys.
+    """
+    char_width = 6
+    label_width = len(label) * char_width + 10
+    message_width = len(message) * char_width + 10
+    return {
+        "width": label_width + message_width,
+        "label_width": label_width,
+        "message_width": message_width,
+        "label_x": (label_width * 10) // 2,
+        "message_x": (label_width * 10) + (message_width * 10) // 2,
+        "label_text_length": len(label) * char_width * 10,
+        "message_text_length": len(message) * char_width * 10,
+    }
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        ["", ""],
+        ["a", ""],
+        ["", "a"],
+        ["coverage", "87%"],
+        ["build", "passing"],
+        ["tests", "1203 passed"],
+        ["quality gate", "failed"],
+    ]
+    words = ["coverage", "tests", "build", "flaky", "mutation", "92%", "ok", "failed", "A+", "v3.1.0"]
+    while len(cases) < n:
+        cases.append([rng.choice(words)[: rng.randint(0, 8)], rng.choice(words)])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/baseline_verdict.py

@@ -0,0 +1,60 @@
+"""Compare a test success rate against its baseline. Adapted from proffesor-for-testing/sentinel-api-testing@704f47fbc4d2d75ed9261f9a602d76aea930d01b:sentinel_backend/orchestration_service/services/pattern_analytics.py (MIT)."""
+
+META = {
+    "entry": "baseline_verdict",
+    "origin": "proffesor-for-testing/sentinel-api-testing@704f47fbc4d2d75ed9261f9a602d76aea930d01b:sentinel_backend/orchestration_service/services/pattern_analytics.py",
+    "tags": ["analytics", "thresholds", "regression"],
+    "domain": "software-engineering",
+}
+
+
+def baseline_verdict(current_success, baseline_success):
+    """Classify the change of a test success rate (integer percent) versus a baseline.
+
+    baseline_success None -> "no baseline", without checking current_success at all.
+    Otherwise with d = current - baseline:
+      d > 10        -> "significantly improved"
+      0 < d <= 10   -> "improved"
+      -5 <= d <= 0  -> "maintained"
+      d < -5        -> "degraded"
+    When baseline_success is not None, raises ValueError if either rate is outside 0..100.
+    """
+    if baseline_success is None:
+        return "no baseline"
+    for rate in (current_success, baseline_success):
+        if rate < 0 or rate > 100:
+            raise ValueError("rates are percentages")
+    if current_success > baseline_success + 10:
+        return "significantly improved"
+    if current_success > baseline_success:
+        return "improved"
+    if current_success >= baseline_success - 5:
+        return "maintained"
+    return "degraded"
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        [50, None],
+        [0, 0],
+        [61, 50],
+        [60, 50],
+        [59, 50],
+        [51, 50],
+        [50, 50],
+        [46, 50],
+        [45, 50],
+        [44, 50],
+        [100, 89],
+        [100, 90],
+        [0, 6],
+        [0, 5],
+        [101, 50],
+        [50, -1],
+        [-1, None],
+    ]
+    while len(cases) < n:
+        base = rng.randint(0, 100)
+        cases.append([max(0, min(100, base + rng.randint(-15, 15))), base])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/booking_conflicts.py

@@ -0,0 +1,60 @@
+"""Find meeting-room bookings that clash once a cleaning turnover gap is required. Original."""
+
+META = {
+    "entry": "booking_conflicts",
+    "origin": "Original.",
+    "tags": ["scheduling", "intervals", "calendar"],
+    "domain": "office-white-collar",
+}
+
+
+def booking_conflicts(bookings, turnover):
+    """Return clashing meeting-room bookings as a list of [i, j, shortfall], i < j, sorted.
+
+    bookings are [room, start, end] with integer minutes 0 <= start < end <= 1440; a room
+    needs turnover (int >= 0) free minutes between meetings. i and j clash when the room is
+    the same and start_i < end_j + turnover and start_j < end_i + turnover; shortfall is
+    min(end_i, end_j) + turnover - max(start_i, start_j). Raises ValueError for a negative
+    turnover or a booking time outside 0 <= start < end <= 1440.
+    """
+    if turnover < 0:
+        raise ValueError("turnover must be >= 0")
+    for room, start, end in bookings:
+        if not 0 <= start < end <= 1440:
+            raise ValueError("bad booking time")
+    clashes = []
+    for i in range(len(bookings)):
+        room_i, start_i, end_i = bookings[i]
+        for j in range(i + 1, len(bookings)):
+            room_j, start_j, end_j = bookings[j]
+            if room_i == room_j and start_i < end_j + turnover and start_j < end_i + turnover:
+                clashes.append([i, j, min(end_i, end_j) + turnover - max(start_i, start_j)])
+    return clashes
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        [[], 0],
+        [[["Oak", 540, 600], ["Oak", 600, 660]], 0],
+        [[["Oak", 540, 600], ["Oak", 600, 660]], 10],
+        [[["Oak", 540, 600], ["Oak", 610, 660]], 10],
+        [[["Oak", 540, 600], ["Oak", 609, 660]], 10],
+        [[["Oak", 540, 600], ["Elm", 570, 630]], 0],
+        [[["Oak", 0, 30], ["Oak", 1380, 1440], ["Oak", 20, 40]], 0],
+        [[["Oak", 600, 660], ["Oak", 540, 600], ["Oak", 630, 700]], 5],
+        [[["Oak", 600, 660], ["Oak", 540, 600]], 0],
+        [[["Oak", 540, 600]], -1],
+        [[["Oak", 600, 600]], 0],
+        [[["Oak", -1, 30]], 0],
+        [[["Oak", 1400, 1441]], 0],
+        [[["Elm", 480, 540], ["Oak", 700, 650]], 0],
+    ]
+    rooms = ["A", "B", "C"]
+    while len(cases) < n:
+        bookings = []
+        for _ in range(rng.choice([2, 2, 3, 4])):
+            start = 5 * rng.randint(96, 216)
+            bookings.append([rng.choice(rooms), start, start + 5 * rng.randint(3, 24)])
+        cases.append([bookings, rng.choice([0, 0, 5, 10, 15])])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/boundary_violations.py

@@ -0,0 +1,83 @@
+"""Build request values that each violate one schema boundary. Adapted from proffesor-for-testing/sentinel-api-testing@704f47fbc4d2d75ed9261f9a602d76aea930d01b:sentinel_backend/orchestration_service/agents/functional_negative_agent.py (MIT)."""
+
+META = {
+    "entry": "boundary_violations",
+    "origin": "proffesor-for-testing/sentinel-api-testing@704f47fbc4d2d75ed9261f9a602d76aea930d01b:sentinel_backend/orchestration_service/agents/functional_negative_agent.py",
+    "tags": ["api", "negative-testing", "boundary-values"],
+    "domain": "software-engineering",
+}
+
+
+def boundary_violations(properties):
+    """Return up to three property values that each break one JSON-schema boundary.
+
+    properties maps a name to a schema dict and is visited in insertion order.
+    - "integer" or "number": maximum + 1 if "maximum" is set, else minimum - 1 if
+      "minimum" is set.
+    - "string" (also the default when "type" is missing): "x" * (maxLength + 1) if
+      "maxLength" is set, else "x" * (minLength - 1) if minLength is set and > 0.
+    - "array": ["item"] * (maxItems + 1) if "maxItems" is set, else
+      ["item"] * (minItems - 1) if minItems is set and > 0.
+    Other types, and properties with no usable boundary, are skipped. Stops as soon
+    as three modifications exist. Returns a dict of property name -> violating value.
+    """
+    modifications = {}
+    for name, schema in properties.items():
+        kind = schema.get("type", "string")
+        if kind in ("integer", "number"):
+            if "maximum" in schema:
+                modifications[name] = schema["maximum"] + 1
+            elif "minimum" in schema:
+                modifications[name] = schema["minimum"] - 1
+        elif kind == "string":
+            if "maxLength" in schema:
+                modifications[name] = "x" * (schema["maxLength"] + 1)
+            elif "minLength" in schema and schema["minLength"] > 0:
+                modifications[name] = "x" * (schema["minLength"] - 1)
+        elif kind == "array":
+            if "maxItems" in schema:
+                modifications[name] = ["item"] * (schema["maxItems"] + 1)
+            elif "minItems" in schema and schema["minItems"] > 0:
+                modifications[name] = ["item"] * (schema["minItems"] - 1)
+        if len(modifications) >= 3:
+            break
+    return modifications
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    def _schema(rng):
+        kind = rng.choice(["integer", "number", "string", "array", "boolean", None])
+        schema = {} if kind is None else {"type": kind}
+        names = {"integer": ("minimum", "maximum"), "number": ("minimum", "maximum"),
+                 "string": ("minLength", "maxLength"), "array": ("minItems", "maxItems")}
+        low_key, high_key = names.get(kind or "string", ("minLength", "maxLength"))
+        if rng.random() < 0.6:
+            schema[low_key] = rng.randint(0, 4)
+        if rng.random() < 0.5:
+            schema[high_key] = rng.randint(1, 6)
+        return schema
+
+    cases = [
+        [{}],
+        [{"a": {"type": "integer", "maximum": 10}}],
+        [{"a": {"type": "number", "minimum": 0}}],
+        [{"a": {"type": "integer", "minimum": 2, "maximum": 5}}],
+        [{"a": {"type": "integer"}}],
+        [{"s": {"maxLength": 3}}],
+        [{"s": {"type": "string", "minLength": 0}}],
+        [{"s": {"type": "string", "minLength": 1}}],
+        [{"s": {"type": "string", "minLength": 3, "maxLength": 4}}],
+        [{"s": {"type": "string", "minLength": 4}}],
+        [{"l": {"type": "array", "maxItems": 1}}],
+        [{"l": {"type": "array", "minItems": 1}}],
+        [{"l": {"type": "array", "minItems": 3}}],
+        [{"l": {"type": "array", "minItems": 0}}],
+        [{"b": {"type": "boolean", "maximum": 1}}],
+        [{"a": {"type": "integer", "maximum": 1}, "b": {"maxLength": 0}, "c": {"type": "array", "maxItems": 0}}],
+        [{"a": {"type": "integer", "maximum": 1}, "b": {"maxLength": 0}, "c": {"type": "array", "maxItems": 0}, "d": {"type": "number", "minimum": 1}}],
+        [{"a": {"type": "integer"}, "b": {"maxLength": 1}, "c": {"type": "boolean"}, "d": {"type": "number", "minimum": -3}, "e": {"type": "array", "minItems": 2}}],
+    ]
+    while len(cases) < n:
+        cases.append([{f"p{i}": _schema(rng) for i in range(rng.randint(1, 5))}])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/brace_delta.py

@@ -0,0 +1,59 @@
+"""Count the net curly-brace depth change of a source line, ignoring strings. Ported from TypeScript; adapted from proffesor-for-testing/agentic-qe@214a5bc881fe4ad6324e243c9d9c2c24baae5295:src/shared/parsers/multi-language-parser.ts (MIT)."""
+
+META = {
+    "entry": "brace_delta",
+    "origin": "proffesor-for-testing/agentic-qe@214a5bc881fe4ad6324e243c9d9c2c24baae5295:src/shared/parsers/multi-language-parser.ts",
+    "tags": ["parsing", "strings"],
+    "domain": "software-engineering",
+}
+
+
+def brace_delta(line):
+    """Return (number of "{") - (number of "}") in line, ignoring braces inside strings.
+
+    A string starts at ", ' or ` and ends at the next occurrence of the same quote
+    character that is not immediately preceded by a backslash. Braces inside a string
+    are not counted. An unterminated string runs to the end of the line.
+    """
+    delta = 0
+    in_string = False
+    quote = ""
+    for i in range(len(line)):
+        ch = line[i]
+        if in_string:
+            if ch == quote and line[i - 1] != "\\":
+                in_string = False
+            continue
+        if ch == '"' or ch == "'" or ch == "`":
+            in_string = True
+            quote = ch
+        elif ch == "{":
+            delta += 1
+        elif ch == "}":
+            delta -= 1
+    return delta
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        [""],
+        ["{"],
+        ["}"],
+        ["{}"],
+        ["if (x) {"],
+        ["} else {"],
+        ["'{'"],
+        ['"}" + {'],
+        ["`${a}` {"],
+        ['"a\\"{" }'],
+        ["'it\\'s {' {"],
+        ['"{" \'}\' {'],
+        ["'{"],
+        ['"x" {{ "y" }'],
+        ["{'\"'}"],
+    ]
+    alphabet = ['{', '}', '{', '}', '"', "'", '`', '\\', 'a', ' ']
+    while len(cases) < n:
+        cases.append(["".join(rng.choice(alphabet) for _ in range(rng.randint(1, 16)))])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/calibration_fit.py

@@ -0,0 +1,52 @@
+"""Least-squares gain and offset calibration in exact arithmetic. Original."""
+
+from fractions import Fraction
+
+META = {
+    "entry": "calibration_fit",
+    "origin": "Original.",
+    "tags": ["calibration", "regression", "exact-arithmetic"],
+    "domain": "natural-science",
+}
+
+
+def calibration_fit(pairs, tolerance):
+    """Fit reference = gain * raw + offset to [raw, reference] integer pairs by ordinary least squares.
+
+    With n pairs and sums Sx = sum(raw), Sy = sum(reference), Sxx = sum(raw * raw) and
+    Sxy = sum(raw * reference): gain = (n * Sxy - Sx * Sy) / (n * Sxx - Sx * Sx) and
+    offset = (Sy - gain * Sx) / n, both exact. A pair's residual is
+    gain * raw + offset - reference; the fit is accepted when every residual's absolute value is
+    <= tolerance. Returns [[gain_num, gain_den], [offset_num, offset_den], accepted], the
+    fractions in lowest terms with a positive denominator and accepted a bool.
+    Raises ValueError if fewer than two distinct raw readings are given (including no pairs).
+    """
+    n = len(pairs)
+    sx = sum(raw for raw, _ in pairs)
+    sy = sum(ref for _, ref in pairs)
+    sxx = sum(raw * raw for raw, _ in pairs)
+    sxy = sum(raw * ref for raw, ref in pairs)
+    denominator = n * sxx - sx * sx
+    if denominator == 0:
+        raise ValueError("need at least two distinct raw readings")
+    gain = Fraction(n * sxy - sx * sy, denominator)
+    offset = (sy - gain * sx) / n
+    worst = max(abs(gain * raw + offset - ref) for raw, ref in pairs)
+    return [[gain.numerator, gain.denominator], [offset.numerator, offset.denominator], worst <= tolerance]
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        [[], 0], [[[5, 10]], 0], [[[5, 10], [5, 12]], 1], [[[0, 1], [10, 21]], 0],
+        [[[0, 3], [1, 5], [2, 7]], 0], [[[0, 0], [1, 1], [2, 3]], 0], [[[0, 0], [1, 1], [2, 3]], 1],
+        [[[1, 2], [2, 3], [3, 5], [4, 4]], 1], [[[-2, 7], [2, -1]], 0], [[[3, 4], [7, 4]], 0],
+        [[[100, 251], [200, 498], [300, 752]], 2], [[[100, 251], [200, 498], [300, 752]], 1],
+        [[[1, 10], [3, 2]], 5], [[[0, 5], [4, 9], [8, 11], [12, 18]], 1],
+    ]
+    while len(cases) < n:
+        gain, offset = rng.randint(-3, 5), rng.randint(-20, 20)
+        raws = [rng.randint(-10, 40) for _ in range(rng.randint(2, 4 if rng.random() < 0.6 else 7))]
+        pairs = [[x, gain * x + offset + rng.randint(-2, 2)] for x in raws]
+        cases.append([pairs, rng.randint(0, 3)])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/chat_completion_result.py

@@ -0,0 +1,71 @@
+"""Build the finish_reason and token usage of an OpenAI-style chat completion. Ported from Rust; adapted from ruvnet/RuVector@32033a8bc0d4d92e0ea644fce98eef4bb5c6bfef:crates/ruvllm-cli/src/commands/serve.rs (MIT)."""
+
+PRE_FIX = "ruvnet/RuVector@3e1d1886c50f2db817664648b95fab18e3e4c34b:crates/ruvllm-cli/src/commands/serve.rs"
+META = {
+    "entry": "chat_completion_result",
+    "origin": "ruvnet/RuVector@32033a8bc0d4d92e0ea644fce98eef4bb5c6bfef:crates/ruvllm-cli/src/commands/serve.rs",
+    "tags": ["llm", "api", "accounting"],
+    "domain": "software-engineering",
+    "real_faults": [
+        {"id": "chat_completion_result/always-stop", "kind": "constant-field", "origin": PRE_FIX,
+         "summary": "finish_reason is always stop, even when max_tokens cut the reply or generation failed",
+         "find": "    if cause == \"length\":\n        finish_reason = \"length\"\n"
+                 "    elif cause in (\"stop\", \"end_of_sequence\", \"cancelled\"):\n        finish_reason = \"stop\"\n"
+                 "    else:\n        raise ValueError(\"generation ended with an error\")\n",
+         "replace": "    finish_reason = \"stop\"\n"},
+        {"id": "chat_completion_result/whitespace-token-count", "kind": "placeholder-approximation",
+         "origin": PRE_FIX, "summary": "usage counts whitespace-separated words, not tokens",
+         "find": "    used = [prompt_tokens, completion_tokens]\n",
+         "replace": "    used = [len(prompt.split()), len(completion.split())]\n"},
+    ],
+}
+
+
+def chat_completion_result(cause, prompt, completion, prompt_tokens, completion_tokens):
+    """Return {"finish_reason": ..., "usage": {...}} for a finished chat completion.
+
+    cause says how generation ended. "length" (max_tokens reached) gives finish_reason
+    "length"; "stop" (a stop sequence), "end_of_sequence" (an end-of-turn token) and
+    "cancelled" give "stop"; "error" or any other cause raises ValueError. usage is
+    {"prompt_tokens": p, "completion_tokens": c, "total_tokens": p + c} where p and c
+    are the tokenizer's counts prompt_tokens and completion_tokens; the prompt and
+    completion texts do not affect usage. Raises ValueError if a count is negative.
+    """
+    if prompt_tokens < 0 or completion_tokens < 0:
+        raise ValueError("token counts must be non-negative")
+    if cause == "length":
+        finish_reason = "length"
+    elif cause in ("stop", "end_of_sequence", "cancelled"):
+        finish_reason = "stop"
+    else:
+        raise ValueError("generation ended with an error")
+    used = [prompt_tokens, completion_tokens]
+    usage = {"prompt_tokens": used[0], "completion_tokens": used[1], "total_tokens": used[0] + used[1]}
+    return {"finish_reason": finish_reason, "usage": usage}
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        ["stop", "", "", 0, 0],
+        ["length", "Hi", "Hello there", 1, 2],
+        ["end_of_sequence", "Capital of France?", "Paris", 5, 1],
+        ["cancelled", "a b", "c", 2, 1],
+        ["error", "a", "b", 1, 1],
+        ["timeout", "a", "b", 1, 1],
+        ["stop", "one two three", "four five", 3, 2],
+        ["length", "x", "y", -1, 0],
+        ["stop", "x", "y", 0, -1],
+        ["STOP", "x", "y", 1, 1],
+        ["stop", "Hello, world!", "Bonjour", 4, 3],
+        ["end_of_sequence", "a b c d", "", 9, 0],
+    ]
+    words = ["the", "cat", "sat", "Paris", "is", "x=1;", "ok", "no"]
+    causes = ["stop", "stop", "end_of_sequence", "end_of_sequence", "length", "cancelled", "error"]
+    while len(cases) < n:
+        prompt = " ".join(rng.choice(words) for _ in range(rng.randint(0, 5)))
+        completion = " ".join(rng.choice(words) for _ in range(rng.randint(0, 5)))
+        p = len(prompt.split()) + (rng.randint(0, 3) if rng.random() < 0.6 else 0)
+        c = len(completion.split()) + (rng.randint(0, 3) if rng.random() < 0.6 else 0)
+        cases.append([rng.choice(causes), prompt, completion, p, c])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/claim_steal_priority.py

@@ -0,0 +1,60 @@
+"""Score how urgently a stalled work claim should be stolen. Ported from TypeScript; adapted from proffesor-for-testing/agentic-qe@214a5bc881fe4ad6324e243c9d9c2c24baae5295:src/coordination/claims/work-stealing.ts (MIT)."""
+
+META = {
+    "entry": "claim_steal_priority",
+    "origin": "proffesor-for-testing/agentic-qe@214a5bc881fe4ad6324e243c9d9c2c24baae5295:src/coordination/claims/work-stealing.ts",
+    "tags": ["scheduling", "scoring"],
+    "domain": "software-engineering",
+}
+
+
+def claim_steal_priority(priority, stale_ms, time_to_deadline_ms, steal_count):
+    """Return the integer steal priority of a work claim (higher = steal sooner).
+
+    score = base + staleness + deadline - 10 * steal_count, where
+    - base is 100 for "p0", 75 for "p1", 50 for "p2", 25 for "p3";
+    - staleness = min(stale_ms // 60000, 50) (whole minutes since the last update);
+    - deadline is 0 when time_to_deadline_ms is None, otherwise 50 if it is < 3600000
+      (under an hour, including overdue negatives), 25 if < 86400000, else 0.
+    Raises ValueError for an unknown priority or a negative stale_ms or steal_count.
+    """
+    base = {"p0": 100, "p1": 75, "p2": 50, "p3": 25}
+    if priority not in base:
+        raise ValueError("unknown priority")
+    if stale_ms < 0 or steal_count < 0:
+        raise ValueError("stale_ms and steal_count must be non-negative")
+    score = base[priority] + min(stale_ms // 60000, 50)
+    if time_to_deadline_ms is not None:
+        if time_to_deadline_ms < 3600000:
+            score += 50
+        elif time_to_deadline_ms < 86400000:
+            score += 25
+    score -= steal_count * 10
+    return score
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        ["p0", 0, None, 0],
+        ["p1", 59999, None, 0],
+        ["p2", 60000, None, 0],
+        ["p3", 3000000, None, 0],
+        ["p3", 3060000, None, 0],
+        ["p3", 2999999, None, 0],
+        ["p1", 0, 3599999, 0],
+        ["p1", 0, 3600000, 0],
+        ["p1", 0, 86399999, 0],
+        ["p1", 0, 86400000, 0],
+        ["p0", 0, -5000, 0],
+        ["p2", 120000, 7200000, 2],
+        ["p0", 0, None, 13],
+        ["p4", 0, None, 0],
+        ["P0", 0, None, 0],
+        ["p1", -1, None, 0],
+        ["p1", 0, None, -1],
+    ]
+    while len(cases) < n:
+        cases.append([rng.choice(["p0", "p1", "p2", "p3"]), rng.randint(0, 4000000),
+                      rng.choice([None, rng.randint(-100000, 100000000)]), rng.randint(0, 4)])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/compare_versions.py

@@ -0,0 +1,67 @@
+"""Compare two dotted version strings. Ported from TypeScript; adapted from proffesor-for-testing/agentic-qe@214a5bc881fe4ad6324e243c9d9c2c24baae5295:src/mcp/tools/security-compliance/scan.ts (MIT)."""
+
+META = {
+    "entry": "compare_versions",
+    "origin": "proffesor-for-testing/agentic-qe@214a5bc881fe4ad6324e243c9d9c2c24baae5295:src/mcp/tools/security-compliance/scan.ts",
+    "tags": ["versions", "parsing"],
+    "domain": "software-engineering",
+}
+
+
+def parse_version(text):
+    """Return the first three numeric components of a version string, padded with 0."""
+    if text.startswith("v"):
+        text = text[1:]
+    parts = text.split(".")[:3]
+    for part in parts:
+        if not part.isdigit():
+            raise ValueError("bad version component: " + part)
+    numbers = [int(part) for part in parts]
+    return numbers + [0] * (3 - len(numbers))
+
+
+def compare_versions(a, b):
+    """Compare versions like "1.2.3": return -1 if a < b, 0 if equal, 1 if a > b.
+
+    One leading "v" is ignored. Only the first three dot-separated components are
+    read (later ones are ignored without validation); missing components count as 0,
+    so "1.2" equals "1.2.0". Components compare numerically ("1.10" > "1.9").
+    Raises ValueError if one of the first three components is empty or not all digits.
+    """
+    pa, pb = parse_version(a), parse_version(b)
+    for i in range(3):
+        if pa[i] < pb[i]:
+            return -1
+        if pa[i] > pb[i]:
+            return 1
+    return 0
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        ["1.0.0", "1.0.0"],
+        ["1.2", "1.2.0"],
+        ["1", "1.0.1"],
+        ["1.10.0", "1.9.9"],
+        ["1.9.9", "1.10.0"],
+        ["2.0.0", "1.99.99"],
+        ["0.0.1", "0.0.2"],
+        ["0.1.0", "0.0.9"],
+        ["v1.2.3", "1.2.3"],
+        ["vv1.0", "1.0"],
+        ["1.2.3.9", "1.2.3.1"],
+        ["1.2.3", "1.2.4.x"],
+        ["1..3", "1.0.3"],
+        ["1.2.beta", "1.2.0"],
+        ["", "0"],
+        ["3.0.1", "3.0.0"],
+        ["10.0.0", "9.0.0"],
+    ]
+    while len(cases) < n:
+        def version():
+            return ".".join(str(rng.randint(0, 12)) for _ in range(rng.randint(1, 4)))
+        a = version()
+        b = a if rng.random() < 0.2 else version()
+        cases.append([rng.choice(["", "v"]) + a, b])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/complexity_bucket.py

@@ -0,0 +1,68 @@
+"""Bucket a QE task's complexity from code-size signals. Adapted from proffesor-for-testing/lionagi-qe-fleet@ce1d58750a240a16c3c53abcb8a7c73864e98c99:src/lionagi_qe/learning/state_encoder.py (MIT)."""
+
+META = {
+    "entry": "complexity_bucket",
+    "origin": "proffesor-for-testing/lionagi-qe-fleet@ce1d58750a240a16c3c53abcb8a7c73864e98c99:src/lionagi_qe/learning/state_encoder.py",
+    "tags": ["scoring", "thresholds"],
+    "domain": "software-engineering",
+}
+
+
+def complexity_bucket(lines_of_code, cyclomatic, num_dependencies, num_tests):
+    """Return "simple", "moderate" or "complex" for a task context.
+
+    Points: lines_of_code > 500 adds 2, else > 100 adds 1; cyclomatic > 20 adds 2,
+    else > 10 adds 1; num_dependencies > 10 adds 1; num_tests > 100 adds 1.
+    A total of 4 or more is "complex", 2 or 3 is "moderate", 0 or 1 is "simple".
+    Raises ValueError if any argument is negative.
+    """
+    if min(lines_of_code, cyclomatic, num_dependencies, num_tests) < 0:
+        raise ValueError("signals must be non-negative")
+    score = 0
+    if lines_of_code > 500:
+        score += 2
+    elif lines_of_code > 100:
+        score += 1
+    if cyclomatic > 20:
+        score += 2
+    elif cyclomatic > 10:
+        score += 1
+    if num_dependencies > 10:
+        score += 1
+    if num_tests > 100:
+        score += 1
+    if score >= 4:
+        return "complex"
+    if score >= 2:
+        return "moderate"
+    return "simple"
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        [0, 0, 0, 0],
+        [100, 10, 10, 100],
+        [101, 0, 0, 0],
+        [101, 11, 0, 0],
+        [500, 20, 0, 0],
+        [501, 0, 0, 0],
+        [501, 11, 0, 0],
+        [0, 21, 0, 0],
+        [0, 21, 11, 101],
+        [0, 0, 11, 0],
+        [0, 0, 11, 101],
+        [0, 11, 0, 101],
+        [501, 21, 0, 0],
+        [101, 11, 11, 0],
+        [101, 11, 11, 101],
+        [101, 0, 0, 100],
+        [101, 0, 10, 0],
+        [-1, 0, 0, 0],
+        [0, 0, 0, -5],
+    ]
+    while len(cases) < n:
+        cases.append([rng.choice([rng.randint(0, 700), rng.choice([100, 101, 500, 501])]),
+                      rng.choice([rng.randint(0, 30), rng.choice([10, 11, 20, 21])]),
+                      rng.randint(5, 15), rng.randint(80, 120)])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/compound_interest.py

@@ -0,0 +1,70 @@
+"""Grow a deposit by compound interest with banker's rounding of each period. Original."""
+
+META = {
+    "entry": "compound_interest",
+    "origin": "Original.",
+    "tags": ["interest", "rounding", "money"],
+    "domain": "finance-economics",
+}
+
+
+def compound_interest(principal_cents, annual_rate_bp, periods_per_year, years):
+    """Compound a deposit in integer cents, rounding each period's interest half to even.
+
+    There are periods_per_year * years periods. Each period's interest is
+    balance * annual_rate_bp / (10000 * periods_per_year) rounded to a whole cent, an exact half
+    cent going to the even neighbour (banker's rounding), and is added to the balance.
+    Returns [final_balance, total_interest, ties]; ties counts periods whose exact interest ended
+    in exactly half a cent.
+    Raises ValueError if periods_per_year is not 1, 2, 4 or 12, or if principal_cents < 0,
+    annual_rate_bp < 0, or years is outside 0..50.
+    """
+    if periods_per_year not in (1, 2, 4, 12):
+        raise ValueError("invalid frequency")
+    if principal_cents < 0 or annual_rate_bp < 0 or years < 0 or years > 50:
+        raise ValueError("invalid terms")
+    denominator = 10000 * periods_per_year
+    balance, ties = principal_cents, 0
+    for _ in range(periods_per_year * years):
+        whole, rest = divmod(balance * annual_rate_bp, denominator)
+        if 2 * rest == denominator:
+            ties += 1
+            whole += whole % 2
+        elif 2 * rest > denominator:
+            whole += 1
+        balance += whole
+    return [balance, balance - principal_cents, ties]
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        [50, 10000, 1, 1],
+        [150, 10000, 1, 1],
+        [250, 10000, 1, 1],
+        [149, 10000, 1, 1],
+        [151, 10000, 1, 1],
+        [1050, 1200, 12, 1],
+        [1150, 1200, 12, 1],
+        [100000, 500, 1, 0],
+        [100000, 500, 1, 1],
+        [100000, 500, 2, 1],
+        [100000, 500, 4, 2],
+        [100000, 500, 12, 50],
+        [0, 500, 12, 10],
+        [100000, 0, 12, 10],
+        [100000, 500, 3, 1],
+        [100000, 500, 365, 1],
+        [-1, 500, 12, 1],
+        [100000, -1, 12, 1],
+        [100000, 500, 12, -1],
+        [100000, 500, 12, 51],
+        [350, 2000, 4, 3],
+        [12345, 375, 2, 7],
+    ]
+    while len(cases) < n:
+        periods = rng.choice([1, 2, 4, 12])
+        rate = rng.choice([600, 1200, 2400, 10000, 400 * periods, rng.randint(1, 2500)])
+        principal = rng.randint(0, 2000) * 100 + rng.choice([50, 50, rng.randint(0, 99)])
+        cases.append([principal, rate, periods, rng.randint(0, 12)])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/convert_timecode.py

@@ -0,0 +1,63 @@
+"""Convert a non-drop-frame SMPTE timecode between integer frame rates. Original."""
+
+import re
+
+META = {
+    "entry": "convert_timecode",
+    "origin": "Original.",
+    "tags": ["timecode", "smpte", "frame-rate"],
+    "domain": "media-content-production",
+}
+
+
+def convert_timecode(timecode, src_fps, dst_fps):
+    """Convert a non-drop-frame "HH:MM:SS:FF" timecode; return [dst frames, dst timecode].
+
+    Rates must be 24, 25, 30, 48, 50 or 60. Fields are two digits: HH 00-23, MM and SS
+    00-59, FF 00 to src_fps - 1. frames = ((HH * 60 + MM) * 60 + SS) * src_fps + FF becomes
+    frames * dst_fps // src_fps (rounded down) at dst_fps, written back as "HH:MM:SS:FF".
+    Raises ValueError for another rate, a malformed timecode or a field out of range.
+    """
+    for fps in (src_fps, dst_fps):
+        if fps not in (24, 25, 30, 48, 50, 60):
+            raise ValueError("unsupported frame rate")
+    match = re.fullmatch(r"(\d\d):(\d\d):(\d\d):(\d\d)", timecode)
+    if not match:
+        raise ValueError("timecode must be HH:MM:SS:FF")
+    hours, minutes, seconds, frame = (int(part) for part in match.groups())
+    if hours > 23 or minutes > 59 or seconds > 59 or frame >= src_fps:
+        raise ValueError("field out of range")
+    count = ((hours * 60 + minutes) * 60 + seconds) * src_fps + frame
+    frames = count * dst_fps // src_fps
+    whole, frame = divmod(frames, dst_fps)
+    return [frames, "%02d:%02d:%02d:%02d" % (whole // 3600, whole // 60 % 60, whole % 60, frame)]
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        ["00:00:00:00", 24, 25],
+        ["01:00:00:00", 25, 30],
+        ["00:00:01:23", 24, 48],
+        ["00:00:01:24", 24, 48],
+        ["00:00:01:29", 30, 25],
+        ["00:00:01:12", 25, 24],
+        ["23:59:59:59", 60, 50],
+        ["24:00:00:00", 25, 25],
+        ["00:60:00:00", 25, 25],
+        ["00:00:60:00", 25, 25],
+        ["00:59:59:24", 25, 60],
+        ["10:10:10:10", 23, 25],
+        ["10:10:10:10", 25, 29],
+        ["1:00:00:00", 25, 25],
+        ["01:00:00;00", 30, 30],
+        ["12:34:56:07", 30, 24],
+    ]
+    rates = [24, 25, 30, 48, 50, 60]
+    while len(cases) < n:
+        src, dst = rng.choice(rates), rng.choice(rates + [29] if rng.random() < 0.1 else rates)
+        hours = rng.choice([0, 0, 0, 1, rng.randint(0, 23)])  # most clips are under an hour
+        last_frame = src - 1 if rng.random() < 0.9 else src  # sometimes one frame too many
+        parts = [hours, rng.choice([0, rng.randint(0, 59)]), rng.randint(0, 59), rng.randint(0, last_frame)]
+        cases.append([":".join("%02d" % p for p in parts), src, dst])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/coverage_gap_severity.py

@@ -0,0 +1,59 @@
+"""Rate the severity of an uncovered code range. Ported from TypeScript; adapted from proffesor-for-testing/agentic-qe@214a5bc881fe4ad6324e243c9d9c2c24baae5295:src/domains/coverage-analysis/services/coverage-parser.ts (MIT)."""
+
+META = {
+    "entry": "coverage_gap_severity",
+    "origin": "proffesor-for-testing/agentic-qe@214a5bc881fe4ad6324e243c9d9c2c24baae5295:src/domains/coverage-analysis/services/coverage-parser.ts",
+    "tags": ["coverage", "thresholds"],
+    "domain": "software-engineering",
+}
+
+
+def coverage_gap_severity(range_size, total_lines):
+    """Return "critical", "high", "medium" or "low" for an uncovered range.
+
+    percentage = range_size * 100 / total_lines (exact, not rounded).
+    - percentage > 20 or range_size > 50 -> "critical"
+    - percentage > 10 or range_size > 20 -> "high"
+    - percentage > 5 or range_size > 10  -> "medium"
+    - otherwise "low".
+    Raises ValueError if total_lines < 1, range_size < 0 or range_size > total_lines.
+    """
+    if total_lines < 1 or range_size < 0 or range_size > total_lines:
+        raise ValueError("invalid range")
+    percentage = range_size * 100 / total_lines
+    if percentage > 20 or range_size > 50:
+        return "critical"
+    if percentage > 10 or range_size > 20:
+        return "high"
+    if percentage > 5 or range_size > 10:
+        return "medium"
+    return "low"
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        [0, 1],
+        [1, 5],
+        [1, 4],
+        [10, 100],
+        [11, 100],
+        [20, 200],
+        [21, 200],
+        [5, 100],
+        [6, 100],
+        [50, 1000],
+        [51, 1000],
+        [20, 1000],
+        [21, 1000],
+        [10, 1000],
+        [11, 1000],
+        [21, 100],
+        [5, 0],
+        [-1, 10],
+        [11, 10],
+    ]
+    while len(cases) < n:
+        total = rng.choice([rng.randint(1, 100), rng.randint(100, 2000)])
+        cases.append([rng.randint(0, min(total, 80)), total])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/crop_to_aspect.py

@@ -0,0 +1,56 @@
+"""Center-crop an image to a target aspect ratio and report which dimension was cut. Original."""
+
+META = {
+    "entry": "crop_to_aspect",
+    "origin": "Original.",
+    "tags": ["aspect-ratio", "image", "crop"],
+    "domain": "media-content-production",
+}
+
+
+def crop_to_aspect(src_w, src_h, aspect_w, aspect_h):
+    """Center-crop a src_w x src_h image to the aspect_w:aspect_h shape; return [x, y, w, h, cut].
+
+    Let wide = src_w * aspect_h and tall = aspect_w * src_h; divisions round down. If
+    wide > tall the width is cut: w = src_h * aspect_w // aspect_h, h = src_h, cut "width".
+    If wide < tall the height is cut: w = src_w, h = src_w * aspect_h // aspect_w, cut
+    "height". Otherwise the whole image is kept, cut "none". The box is centered:
+    x = (src_w - w) // 2, y = (src_h - h) // 2. Raises ValueError if any argument is below 1.
+    """
+    if min(src_w, src_h, aspect_w, aspect_h) < 1:
+        raise ValueError("sizes must be >= 1")
+    wide, tall = src_w * aspect_h, aspect_w * src_h
+    if wide > tall:
+        w, h, cut = src_h * aspect_w // aspect_h, src_h, "width"
+    elif wide < tall:
+        w, h, cut = src_w, src_w * aspect_h // aspect_w, "height"
+    else:
+        w, h, cut = src_w, src_h, "none"
+    return [(src_w - w) // 2, (src_h - h) // 2, w, h, cut]
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        [1920, 1080, 16, 9],
+        [1920, 1080, 4, 3],
+        [1920, 1080, 9, 16],
+        [4000, 3000, 16, 9],
+        [1080, 1920, 1, 1],
+        [1080, 1080, 1, 1],
+        [2560, 1080, 64, 27],
+        [1, 1, 1, 1],
+        [1, 3, 2, 1],
+        [3, 1, 1, 2],
+        [1001, 600, 5, 3],
+        [1000, 601, 5, 3],
+        [0, 1080, 16, 9],
+        [1920, 1080, 16, 0],
+    ]
+    aspects = [[16, 9], [4, 3], [1, 1], [9, 16], [21, 9], [2, 1], [3, 2], [4, 5]]
+    sizes = [1, 2, 3, 5, 7, 16, 100, 333, 720, 1080, 1280, 1920, 2160, 3840]
+    while len(cases) < n:
+        dims = [rng.choice(sizes) if rng.random() < 0.3 else rng.randint(1, 4000) for _ in range(2)]
+        aspect = rng.choice(aspects) if rng.random() < 0.7 else [rng.randint(1, 30), rng.randint(1, 30)]
+        cases.append(dims + aspect)
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/debounce_switch.py

@@ -0,0 +1,63 @@
+"""Debounce an analogue sensor into an on/off signal with hysteresis. Original."""
+
+META = {
+    "entry": "debounce_switch",
+    "origin": "Original.",
+    "tags": ["sensor", "debounce", "hysteresis"],
+    "domain": "industrial-physical-systems",
+}
+
+
+def debounce_switch(samples, low, high, hold):
+    """Turn sensor samples into a debounced on/off state with hysteresis.
+
+    The state starts off. While off, it turns on once `hold` consecutive samples are >= high; while
+    on, it turns off once `hold` consecutive samples are <= low. A sample that does not continue
+    the run resets the count to zero, and the count restarts at zero after every change.
+    Returns [final_state, changes]; changes lists [index, state] for every change, index being the
+    position of the sample that completed the run.
+    Raises ValueError if low >= high or hold < 1.
+    """
+    if low >= high or hold < 1:
+        raise ValueError("invalid debounce settings")
+    state, run, changes = False, 0, []
+    for index, sample in enumerate(samples):
+        crossing = sample <= low if state else sample >= high
+        run = run + 1 if crossing else 0
+        if run >= hold:
+            state, run = not state, 0
+            changes.append([index, state])
+    return [state, changes]
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        [[], 10, 20, 1],
+        [[20], 10, 20, 1],
+        [[19], 10, 20, 1],
+        [[21, 9], 10, 20, 1],
+        [[21, 10], 10, 20, 1],
+        [[21, 11], 10, 20, 1],
+        [[25, 25], 10, 20, 2],
+        [[25, 15, 25], 10, 20, 2],
+        [[25, 25, 25, 5, 5], 10, 20, 2],
+        [[25, 25, 5, 25, 5, 5], 10, 20, 2],
+        [[25, 25, 25, 25], 10, 20, 3],
+        [[30, 0, 30, 0], 10, 20, 1],
+        [[15, 15, 15], 10, 20, 1],
+        [[5, 5, 5], 10, 20, 1],
+        [[25], 20, 20, 1],
+        [[25], 21, 20, 1],
+        [[25], 10, 20, 0],
+        [[0, 100, 100, 100, 0, 0, 0, 0], 40, 60, 3],
+        [[1], -5, 0, 0],
+        [[1], 0, 5, 0],
+    ]
+    while len(cases) < n:
+        low = rng.randint(0, 50)
+        high = low + rng.randint(1, 30)
+        samples = [rng.choice([rng.randint(low - 10, low), rng.randint(high, high + 10), rng.randint(low, high)])
+                   for _ in range(rng.randint(1, 12))]
+        cases.append([samples, low, high, rng.choice([1, 1, 2, 2, 3])])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/decay_table.py

@@ -0,0 +1,54 @@
+"""Tabulate a decaying activity in integer counts and find its half-life step. Original."""
+
+META = {
+    "entry": "decay_table",
+    "origin": "Original.",
+    "tags": ["simulation", "decay", "integer-arithmetic"],
+    "domain": "natural-science",
+}
+
+
+def decay_table(activity, keep_num, keep_den, threshold, max_steps):
+    """Tabulate a first-order decay (radioactive source or drug dose), one level per time step.
+
+    Each step multiplies the previous activity by keep_num / keep_den, the fraction retained per
+    step, and rounds down to an integer count. Steps continue while the current activity is
+    >= threshold and fewer than max_steps steps have been taken, so the first activity below
+    threshold is the last one listed and at most max_steps steps are listed.
+    Returns [levels, h]: levels[k] is the activity after k steps (levels[0] is the initial
+    activity), and h is the first step k >= 1 with 2 * levels[k] <= levels[0], or None if no
+    listed step reaches it.
+    Raises ValueError if activity < 0, threshold < 1, max_steps < 0, or unless
+    0 <= keep_num < keep_den.
+    """
+    if activity < 0 or threshold < 1 or max_steps < 0:
+        raise ValueError("bad table parameters")
+    if not 0 <= keep_num < keep_den:
+        raise ValueError("the retained fraction must be in [0, 1)")
+    levels = [activity]
+    half_life_step = None
+    current, step = activity, 0
+    while current >= threshold and step < max_steps:
+        step += 1
+        current = current * keep_num // keep_den
+        levels.append(current)
+        if half_life_step is None and 2 * current <= activity:
+            half_life_step = step
+    return [levels, half_life_step]
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        [1000, 1, 2, 100, 20], [1000, 9, 10, 1, 0], [1000, 9, 10, 1, 1], [1000, 9, 10, 500, 30],
+        [0, 1, 2, 1, 5], [-1, 1, 2, 1, 5], [100, 1, 2, 0, 5], [100, 1, 2, 1, -1],
+        [100, 0, 3, 1, 5], [100, 3, 3, 1, 5], [100, -1, 3, 1, 5], [100, 4, 3, 1, 5],
+        [64, 1, 2, 1, 10], [64, 1, 2, 64, 10], [64, 1, 2, 65, 10], [7, 2, 3, 2, 10],
+        [10, 1, 2, 5, 10], [11, 1, 2, 6, 10], [1, 1, 2, 1, 3], [500, 7, 8, 100, 4],
+    ]
+    while len(cases) < n:
+        den = rng.randint(2, 12)
+        steps = rng.randint(0, 5) if rng.random() < 0.6 else rng.randint(6, 25)
+        cases.append([rng.randint(0, rng.choice([200, 5000])), rng.randint(0, den - 1), den,
+                      rng.randint(1, 120), steps])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/efficiency_reward.py

@@ -0,0 +1,54 @@
+"""Reward an agent for finishing faster and cheaper than estimated. Adapted from proffesor-for-testing/lionagi-qe-fleet@ce1d58750a240a16c3c53abcb8a7c73864e98c99:src/lionagi_qe/learning/reward_calculator.py (MIT)."""
+
+META = {
+    "entry": "efficiency_reward",
+    "origin": "proffesor-for-testing/lionagi-qe-fleet@ce1d58750a240a16c3c53abcb8a7c73864e98c99:src/lionagi_qe/learning/reward_calculator.py",
+    "tags": ["reward", "clamping"],
+    "domain": "software-engineering",
+}
+
+
+def efficiency_reward(actual_seconds, expected_seconds, actual_cost, estimated_cost):
+    """Return [time_reward, cost_reward], each rounded to 2 decimals.
+
+    time_reward: 0.0 if actual_seconds <= 0; otherwise
+      (expected_seconds / actual_seconds - 1) * 50 clamped to [-50, 50].
+    cost_reward: 0.0 if actual_cost <= 0; otherwise
+      (estimated_cost / actual_cost - 1) * 50 clamped to [-25, 50].
+    The clamps are inclusive: values outside are replaced by the nearest bound.
+    Rounding is Python's round(x, 2): an exact half goes to the even digit, so
+    actual_seconds 16 with expected_seconds 3 gives -40.625 -> -40.62.
+    """
+    if actual_seconds <= 0:
+        time_reward = 0.0
+    else:
+        time_reward = (expected_seconds / actual_seconds - 1.0) * 50.0
+        time_reward = max(-50.0, min(time_reward, 50.0))
+    if actual_cost <= 0:
+        cost_reward = 0.0
+    else:
+        cost_reward = (estimated_cost / actual_cost - 1.0) * 50.0
+        cost_reward = max(-25.0, min(cost_reward, 50.0))
+    return [round(time_reward, 2), round(cost_reward, 2)]
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        [0, 10, 0, 10],
+        [-5, 10, -1, 10],
+        [10, 10, 10, 10],
+        [5, 10, 5, 10],
+        [4, 10, 4, 10],
+        [20, 10, 20, 10],
+        [30, 10, 30, 10],
+        [11, 10, 11, 10],
+        [8, 10, 8, 10],
+        [100, 1, 100, 1],
+        [1, 100, 1, 100],
+        [40, 30, 3, 2],
+        [7, 9, 15, 12],
+    ]
+    while len(cases) < n:
+        cases.append([rng.randint(0, 40), rng.randint(1, 40), rng.randint(0, 40), rng.randint(1, 40)])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/expense_violations.py

@@ -0,0 +1,62 @@
+"""Check expense claim lines against a travel-and-expense policy. Original."""
+
+META = {
+    "entry": "expense_violations",
+    "origin": "Original.",
+    "tags": ["expenses", "policy", "compliance"],
+    "domain": "office-white-collar",
+}
+
+
+def expense_violations(items):
+    """Return one day's expense-policy violations as [index, code] pairs.
+
+    items are [category, cents, receipt] lines, checked in order; a line adds its codes
+    in this order: "OVER_CAP" if cents exceed the cap (meal 7500, hotel 25000, taxi 6000,
+    other 10000); "NO_RECEIPT" if cents >= 2500 and receipt is false; "DAILY_MEALS" for a
+    meal after which the day's meal total so far exceeds 10000. Raises ValueError at the
+    first line with an unknown category or cents <= 0.
+    """
+    caps = {"meal": 7500, "hotel": 25000, "taxi": 6000, "other": 10000}
+    meals, found = 0, []
+    for index, (category, cents, receipt) in enumerate(items):
+        if category not in caps:
+            raise ValueError("unknown category")
+        if cents <= 0:
+            raise ValueError("cents must be positive")
+        if cents > caps[category]:
+            found.append([index, "OVER_CAP"])
+        if cents >= 2500 and not receipt:
+            found.append([index, "NO_RECEIPT"])
+        if category == "meal":
+            meals += cents
+            if meals > 10000:
+                found.append([index, "DAILY_MEALS"])
+    return found
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        [[]],
+        [[["meal", 7500, True]]],
+        [[["meal", 7501, True]]],
+        [[["hotel", 25000, True], ["hotel", 25001, True]]],
+        [[["taxi", 6000, True], ["taxi", 6001, True]]],
+        [[["other", 10000, True], ["other", 10001, True]]],
+        [[["taxi", 2499, False], ["taxi", 2500, False]]],
+        [[["meal", 1, False], ["meal", 9999, True]]],
+        [[["meal", 4000, True], ["meal", 6001, True]]],
+        [[["meal", 3000, False], ["hotel", 30000, False]]],
+        [[["taxi", 1200, True], ["meal", 0, True]]],
+        [[["taxi", 1200, True], ["bar", 900, True]]],
+        [[["meal", -5, True]]],
+    ]
+    categories = ["meal", "meal", "hotel", "taxi", "other"]
+    while len(cases) < n:
+        claim = []
+        for _ in range(rng.choice([1, 2, 2, 3])):
+            cents = rng.choice([rng.randint(1, 4000), rng.randint(2000, 12000), rng.randint(5000, 32000)])
+            claim.append([rng.choice(categories), cents, rng.random() < 0.7])
+        cases.append([claim])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/find_stop.py

@@ -0,0 +1,66 @@
+"""Find where generated text is cut at the earliest stop sequence. Ported from Rust; adapted from ruvnet/RuVector@32033a8bc0d4d92e0ea644fce98eef4bb5c6bfef:crates/ruvllm/src/backends/gguf_arch/mod.rs (MIT)."""
+
+PRE_FIX = "ruvnet/RuVector@3e1d1886c50f2db817664648b95fab18e3e4c34b:crates/ruvllm/src/backends/candle_backend.rs"
+META = {
+    "entry": "find_stop",
+    "origin": "ruvnet/RuVector@32033a8bc0d4d92e0ea644fce98eef4bb5c6bfef:crates/ruvllm/src/backends/gguf_arch/mod.rs",
+    "tags": ["llm", "strings", "streaming"],
+    "domain": "software-engineering",
+    "real_faults": [
+        {"id": "find_stop/first-listed", "kind": "first-match-vs-best", "origin": PRE_FIX,
+         "summary": "cuts at the first stop sequence in list order that occurs, not at the earliest offset",
+         "find": "        if pos != -1 and (earliest is None or pos < earliest):\n            earliest = pos\n",
+         "replace": "        if pos != -1:\n            return pos\n"},
+        {"id": "find_stop/empty-matches", "kind": "missing-guard", "origin": PRE_FIX,
+         "summary": "an empty stop sequence matches at offset 0, so the whole output is cut",
+         "find": "        if not stop:\n            continue\n", "replace": ""},
+    ],
+}
+
+
+def find_stop(text, stop_sequences):
+    """Return the offset in text where the earliest stop sequence starts, or None.
+
+    Every non-empty string in stop_sequences is searched for in text. The result is the
+    smallest index at which any of them occurs (0 means the whole text is cut away).
+    The order of stop_sequences does not matter. Empty stop sequences never match.
+    Returns None when no non-empty stop sequence occurs, including for an empty list.
+    """
+    earliest = None
+    for stop in stop_sequences:
+        if not stop:
+            continue
+        pos = text.find(stop)
+        if pos != -1 and (earliest is None or pos < earliest):
+            earliest = pos
+    return earliest
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        ["", []],
+        ["hello", []],
+        ["hello", ["lo", "l"]],
+        ["hello", ["", "lo", "l"]],
+        ["hey", ["", "lo", "l"]],
+        ["abc", [""]],
+        ["", ["a"]],
+        ["abcabc", ["c", "b"]],
+        ["abcabc", ["b", "c"]],
+        ["a\nUser: hi", ["User:", "\n"]],
+        ["done</s>more", ["</s>", "<im_end>"]],
+        ["x<im_end>y</s>", ["</s>", "<im_end>"]],
+        ["aaaa", ["aa", "a"]],
+    ]
+    alphabet = "abcab\n "
+    while len(cases) < n:
+        text = "".join(rng.choice(alphabet) for _ in range(rng.randint(0, 16)))
+        stops = []
+        for _ in range(rng.randint(0, 3)):
+            if rng.random() < 0.12:
+                stops.append("")
+            else:
+                stops.append("".join(rng.choice("abc\n") for _ in range(rng.randint(1, 3))))
+        cases.append([text, stops])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/flakiness_pattern.py

@@ -0,0 +1,68 @@
+"""Classify the flakiness pattern of repeated test runs. Adapted from proffesor-for-testing/lionagi-qe-fleet@ce1d58750a240a16c3c53abcb8a7c73864e98c99:src/lionagi_qe/agents/flaky_test_hunter.py (MIT)."""
+
+META = {
+    "entry": "flakiness_pattern",
+    "origin": "proffesor-for-testing/lionagi-qe-fleet@ce1d58750a240a16c3c53abcb8a7c73864e98c99:src/lionagi_qe/agents/flaky_test_hunter.py",
+    "tags": ["flaky-tests", "sequences"],
+    "domain": "software-engineering",
+}
+
+
+def flakiness_pattern(results):
+    """Classify a sequence of test outcomes (True = passed) from repeated runs.
+
+    Let n = len(results) and let the longest consecutive run of passes and of failures
+    be max_pass and max_fail.
+    - Empty list -> "UNKNOWN".
+    - max_pass == n -> "STABLE_PASS"; max_fail == n -> "STABLE_FAIL".
+    - max_pass or max_fail strictly greater than 70% of n (x * 10 > n * 7)
+      -> "INTERMITTENT".
+    - Otherwise -> "RANDOM".
+    """
+    if not results:
+        return "UNKNOWN"
+    passes = fails = max_pass = max_fail = 0
+    for passed in results:
+        if passed:
+            passes += 1
+            fails = 0
+            max_pass = max(max_pass, passes)
+        else:
+            fails += 1
+            passes = 0
+            max_fail = max(max_fail, fails)
+    total = len(results)
+    if max_pass == total:
+        return "STABLE_PASS"
+    if max_fail == total:
+        return "STABLE_FAIL"
+    if max_pass * 10 > total * 7 or max_fail * 10 > total * 7:
+        return "INTERMITTENT"
+    return "RANDOM"
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    T, F = True, False
+    cases = [
+        [[]],
+        [[T]],
+        [[F]],
+        [[T, T, T]],
+        [[F, F, F, F]],
+        [[T, F]],
+        [[T, T, T, F]],
+        [[F, T, T, T]],
+        [[T, T, T, T, T, T, T, F, F, F]],
+        [[T, T, T, T, T, T, T, T, F, F]],
+        [[F, F, F, F, F, F, F, F, T, T]],
+        [[F, F, F, F, F, F, F, T, T, T]],
+        [[T, F, T, F, T, F]],
+        [[T, T, F, F, T, T]],
+        [[F, T, F, F, F, F]],
+        [[T, F, F, F, F, F, F, F, F]],
+    ]
+    while len(cases) < n:
+        bias = rng.random()
+        cases.append([[rng.random() < bias for _ in range(rng.randint(1, 12))]])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/flaky_hunter_reward.py

@@ -0,0 +1,53 @@
+"""Reward a flaky-test hunter with an F1 score minus miss penalties. Adapted from proffesor-for-testing/lionagi-qe-fleet@ce1d58750a240a16c3c53abcb8a7c73864e98c99:src/lionagi_qe/learning/reward_calculator.py (MIT)."""
+
+META = {
+    "entry": "flaky_hunter_reward",
+    "origin": "proffesor-for-testing/lionagi-qe-fleet@ce1d58750a240a16c3c53abcb8a7c73864e98c99:src/lionagi_qe/learning/reward_calculator.py",
+    "tags": ["flaky-tests", "metrics", "reward"],
+    "domain": "software-engineering",
+}
+
+
+def flaky_hunter_reward(true_positives, false_positives, false_negatives):
+    """Reward for a flaky-test detector, rounded to 2 decimals.
+
+    precision = tp / (tp + fp), or 0.0 when tp + fp == 0.
+    recall    = tp / (tp + fn), or 0.0 when tp + fn == 0.
+    f1 = 2 * precision * recall / (precision + recall), or 0.0 when both are 0.
+    reward = f1 * 100 - 20 * false_negatives - 5 * false_positives (may be negative).
+    Raises ValueError if any count is negative.
+    """
+    tp, fp, fn = true_positives, false_positives, false_negatives
+    if min(tp, fp, fn) < 0:
+        raise ValueError("counts must be non-negative")
+    precision = tp / (tp + fp) if tp + fp > 0 else 0.0
+    recall = tp / (tp + fn) if tp + fn > 0 else 0.0
+    if precision + recall > 0:
+        f1 = 2 * precision * recall / (precision + recall)
+    else:
+        f1 = 0.0
+    reward = f1 * 100.0
+    reward -= fn * 20.0
+    reward -= fp * 5.0
+    return round(reward, 2)
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        [0, 0, 0],
+        [1, 0, 0],
+        [0, 1, 0],
+        [0, 0, 1],
+        [3, 1, 0],
+        [3, 0, 1],
+        [2, 2, 2],
+        [5, 1, 2],
+        [1, 4, 0],
+        [10, 0, 3],
+        [-1, 0, 0],
+        [0, 0, -2],
+    ]
+    while len(cases) < n:
+        cases.append([rng.randint(0, 10), rng.randint(0, 4), rng.randint(0, 4)])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/flaky_run_summary.py

@@ -0,0 +1,58 @@
+"""Summarize repeated runs of one test into a flakiness verdict. Adapted from proffesor-for-testing/lionagi-qe-fleet@ce1d58750a240a16c3c53abcb8a7c73864e98c99:src/lionagi_qe/agents/flaky_test_hunter.py (MIT)."""
+
+META = {
+    "entry": "flaky_run_summary",
+    "origin": "proffesor-for-testing/lionagi-qe-fleet@ce1d58750a240a16c3c53abcb8a7c73864e98c99:src/lionagi_qe/agents/flaky_test_hunter.py",
+    "tags": ["flaky-tests", "statistics"],
+    "domain": "software-engineering",
+}
+
+
+def flaky_run_summary(results, iterations):
+    """Summarize `iterations` runs of one test; results lists the outcomes seen (True = passed).
+
+    Runs missing from results (when len(results) < iterations) count as failures.
+    Returns {"passed", "failed", "is_flaky", "flakiness_pct", "pass_rate_pct"} where
+    passed = number of True values, failed = iterations - passed,
+    is_flaky = 0 < passed < iterations,
+    flakiness_pct = min(passed, failed) * 200 // iterations (integer division, 0..100),
+    pass_rate_pct = round(passed * 100 / iterations, 1).
+    Raises ValueError if iterations < 1 or len(results) > iterations.
+    """
+    if iterations < 1:
+        raise ValueError("iterations must be positive")
+    if len(results) > iterations:
+        raise ValueError("more results than iterations")
+    passed = sum(1 for r in results if r)
+    failed = iterations - passed
+    return {
+        "passed": passed,
+        "failed": failed,
+        "is_flaky": 0 < passed < iterations,
+        "flakiness_pct": min(passed, failed) * 200 // iterations,
+        "pass_rate_pct": round(passed * 100 / iterations, 1),
+    }
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    T, F = True, False
+    cases = [
+        [[], 1],
+        [[T], 1],
+        [[F], 1],
+        [[T, F], 2],
+        [[T, T], 2],
+        [[T], 2],
+        [[T, T, F], 3],
+        [[T, F, F], 3],
+        [[T, T, T, F, F, F, T], 7],
+        [[T, T, T], 7],
+        [[], 0],
+        [[T, T], 1],
+        [[T, F, T, T, T, T, T, T, T, T, T, T], 12],
+    ]
+    while len(cases) < n:
+        k = rng.randint(1, 12)
+        cases.append([[rng.random() < 0.6 for _ in range(rng.randint(0, k))], k])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/format_duration.py

@@ -0,0 +1,42 @@
+"""Format a duration in milliseconds for CLI output. Ported from TypeScript; adapted from proffesor-for-testing/agentic-qe@214a5bc881fe4ad6324e243c9d9c2c24baae5295:src/cli/handlers/interfaces.ts (MIT)."""
+
+META = {
+    "entry": "format_duration",
+    "origin": "proffesor-for-testing/agentic-qe@214a5bc881fe4ad6324e243c9d9c2c24baae5295:src/cli/handlers/interfaces.ts",
+    "tags": ["formatting", "durations", "thresholds"],
+    "domain": "software-engineering",
+}
+
+
+def one_decimal(ms, unit):
+    """ms / unit rounded half up to one decimal place, as text (exact integer arithmetic)."""
+    tenths = (ms * 10 + unit // 2) // unit
+    return str(tenths // 10) + "." + str(tenths % 10)
+
+
+def format_duration(ms):
+    """Render a non-negative integer millisecond duration as a short string.
+
+    ms < 1000 -> "<ms>ms"; ms < 60000 -> seconds + "s"; ms < 3600000 -> minutes + "m";
+    otherwise hours + "h". Seconds, minutes and hours have exactly one decimal, rounded
+    half up from the exact value: 1500 -> "1.5s", 1450 -> "1.5s", 14350 -> "14.4s",
+    59999 -> "60.0s", 90000 -> "1.5m". Raises ValueError if ms is negative.
+    """
+    if ms < 0:
+        raise ValueError("duration must be non-negative")
+    if ms < 1000:
+        return str(ms) + "ms"
+    if ms < 60000:
+        return one_decimal(ms, 1000) + "s"
+    if ms < 3600000:
+        return one_decimal(ms, 60000) + "m"
+    return one_decimal(ms, 3600000) + "h"
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [[0], [999], [1000], [1500], [59999], [60000], [90000], [3599999],
+             [3600000], [5400000], [86400000], [-1], [12345], [654321]]
+    while len(cases) < n:
+        cases.append([rng.choice([rng.randint(0, 2000), rng.randint(0, 120000), rng.randint(0, 20000000)])])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/gguf_loader.py

@@ -0,0 +1,79 @@
+"""Choose the weight loader for a GGUF model file from its metadata. Ported from Rust; adapted from ruvnet/RuVector@32033a8bc0d4d92e0ea644fce98eef4bb5c6bfef:crates/ruvllm/src/backends/gguf_arch/mod.rs (MIT)."""
+
+PRE_FIX = "ruvnet/RuVector@3e1d1886c50f2db817664648b95fab18e3e4c34b:crates/ruvllm/src/backends/candle_backend.rs"
+META = {
+    "entry": "gguf_loader",
+    "origin": "ruvnet/RuVector@32033a8bc0d4d92e0ea644fce98eef4bb5c6bfef:crates/ruvllm/src/backends/gguf_arch/mod.rs",
+    "tags": ["llm", "dispatch", "validation"],
+    "domain": "software-engineering",
+    "real_faults": [
+        {"id": "gguf_loader/no-split-check", "kind": "missing-guard", "origin": PRE_FIX,
+         "summary": "a split (multi-part) GGUF is not rejected",
+         "find": "    if isinstance(parts, int) and parts > 1:\n        raise ValueError(\"split GGUF files are not supported\")\n",
+         "replace": ""},
+        {"id": "gguf_loader/qwen-rejected", "kind": "allowlist-too-narrow", "origin": PRE_FIX,
+         "summary": "only llama-family layouts load; qwen2 and qwen3 are rejected",
+         "find": "    if name == \"qwen2\":\n        return \"qwen2\"\n    if name == \"qwen3\":\n        return \"qwen3\"\n",
+         "replace": ""},
+        {"id": "gguf_loader/substring-match", "kind": "allowlist-too-wide", "origin": PRE_FIX,
+         "summary": "any architecture containing llama or mistral loads as llama",
+         "find": "    if name in (\"\", \"llama\", \"mistral\"):\n",
+         "replace": "    if name in (\"\", \"llama\", \"mistral\") or \"llama\" in name or \"mistral\" in name:\n"},
+    ],
+}
+
+
+def gguf_loader(metadata):
+    """Return the weight loader ("llama", "qwen2" or "qwen3") for a GGUF file's metadata.
+
+    If metadata["split.count"] is an int greater than 1, the model is split into several
+    files, which is not supported: raise ValueError. The architecture is
+    metadata["general.architecture"]; a missing key or a non-string value counts as "".
+    It is matched case-insensitively and exactly: "", "llama" and "mistral" use the
+    "llama" loader, "qwen2" uses "qwen2" and "qwen3" uses "qwen3". Every other
+    architecture (for example "qwen35", "qwen3moe", "llama4", "codellama") raises
+    ValueError naming it.
+    """
+    parts = metadata.get("split.count")
+    if isinstance(parts, int) and parts > 1:
+        raise ValueError("split GGUF files are not supported")
+    arch = metadata.get("general.architecture", "")
+    name = arch.lower() if isinstance(arch, str) else ""
+    if name in ("", "llama", "mistral"):
+        return "llama"
+    if name == "qwen2":
+        return "qwen2"
+    if name == "qwen3":
+        return "qwen3"
+    raise ValueError("GGUF architecture " + repr(arch) + " is not supported")
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    arches = ["", "llama", "LLaMA", "mistral", "Mistral", "qwen2", "Qwen2", "qwen3", "QWEN3", "qwen35",
+              "qwen3moe", "qwen3next", "llama4", "codellama", "mistral-nemo", "phi3", "gemma2"]
+    cases = [
+        [{}],
+        [{"general.architecture": "LLaMA"}],
+        [{"general.architecture": "qwen2"}],
+        [{"general.architecture": "qwen3"}],
+        [{"general.architecture": "qwen35"}],
+        [{"general.architecture": "llama4"}],
+        [{"general.architecture": "qwen2", "split.count": 3}],
+        [{"split.count": 1}],
+        [{"split.count": 2}],
+        [{"general.architecture": 7}],
+        [{"general.architecture": "phi3", "split.count": 0}],
+        [{"general.architecture": "mistral", "split.count": 2}],
+        [{"general.architecture": "Qwen2"}],
+        [{"general.architecture": "codellama"}],
+        [{"general.architecture": "Mistral-Nemo"}],
+    ]
+    while len(cases) < n:
+        md = {}
+        if rng.random() < 0.9:
+            md["general.architecture"] = rng.choice(arches)
+        if rng.random() < 0.35:
+            md["split.count"] = rng.choice([0, 1, 1, 2, 3, 5])
+        cases.append([md])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/gguf_special_ids.py

@@ -0,0 +1,85 @@
+"""Resolve a GGUF model's end-of-sequence id and the ids that stop generation. Ported from Rust; adapted from ruvnet/RuVector@32033a8bc0d4d92e0ea644fce98eef4bb5c6bfef:crates/ruvllm/src/backends/gguf_arch/mod.rs; ruvnet/RuVector@32033a8bc0d4d92e0ea644fce98eef4bb5c6bfef:crates/ruvllm/src/backends/candle_backend.rs (MIT)."""
+
+PRE_FIX = "ruvnet/RuVector@3e1d1886c50f2db817664648b95fab18e3e4c34b:crates/ruvllm/src/backends/candle_backend.rs"
+META = {
+    "entry": "gguf_special_ids",
+    "origin": "ruvnet/RuVector@32033a8bc0d4d92e0ea644fce98eef4bb5c6bfef:crates/ruvllm/src/backends/gguf_arch/mod.rs; ruvnet/RuVector@32033a8bc0d4d92e0ea644fce98eef4bb5c6bfef:crates/ruvllm/src/backends/candle_backend.rs",
+    "tags": ["llm", "tokenizer", "lookup"],
+    "domain": "software-engineering",
+    "real_faults": [
+        {"id": "gguf_special_ids/eos-from-vocab-guess", "kind": "wrong-sibling-constant", "origin": PRE_FIX,
+         "summary": "the declared EOS id is ignored: a Qwen instruct model gets its end-of-text token, not end-of-turn",
+         "note": "pre-fix behaviour (EOS guessed from the vocabulary) expressed through the fixed function's interface",
+         "find": "    eos = declared(\"eos\")\n    if eos is None:\n        eos = guess\n",
+         "replace": "    eos = guess\n"},
+        {"id": "gguf_special_ids/stop-is-only-eos", "kind": "missing-logic", "origin": PRE_FIX,
+         "summary": "generation stops only at the EOS id, never at end-of-turn tokens",
+         "note": "pre-fix behaviour (stop on the single EOS id) expressed through the fixed function's interface",
+         "find": "    stop = [vocab[t] for t in STOPS if t in vocab]\n    for name in (\"eos\", \"eot\", \"eom\"):\n"
+                 "        value = declared(name)\n        if value is not None and value not in stop:\n"
+                 "            stop.append(value)\n",
+         "replace": "    stop = [] if eos is None else [eos]\n"},
+    ],
+}
+
+
+def gguf_special_ids(metadata, vocab):
+    """Return {"eos": id or None, "stop": [ids]} for a GGUF model.
+
+    vocab maps token text to id. A declared id metadata["tokenizer.ggml.<x>_token_id"]
+    (x is eos, eot or eom) counts only if it is an int (not a bool) with 0 <= id < len(vocab).
+    eos is the declared eos id; without one, the id of the first of "</s>",
+    "<end_of_text>", "<endoftext>", "<eot_id>" present in vocab; else None.
+    stop lists the vocab ids of "<im_end>", "<endoftext>", "<eot_id>",
+    "<end_of_text>", "</s>" (in that order, when present), then the declared eos,
+    eot and eom ids, skipping any id already in the list.
+    """
+    def declared(x):
+        value = metadata.get("tokenizer.ggml." + x + "_token_id")
+        ok = isinstance(value, int) and not isinstance(value, bool) and 0 <= value < len(vocab)
+        return value if ok else None
+
+    candidates = ["</s>", "<end_of_text>", "<endoftext>", "<eot_id>"]
+    guess = next((vocab[t] for t in candidates if t in vocab), None)
+    STOPS = ["<im_end>", "<endoftext>", "<eot_id>", "<end_of_text>", "</s>"]
+    eos = declared("eos")
+    if eos is None:
+        eos = guess
+    stop = [vocab[t] for t in STOPS if t in vocab]
+    for name in ("eos", "eot", "eom"):
+        value = declared(name)
+        if value is not None and value not in stop:
+            stop.append(value)
+    return {"eos": eos, "stop": stop}
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    qwen = {"a": 0, "b": 1, "<endoftext>": 2, "<im_start>": 3, "<im_end>": 4}
+    llama = {"<s>": 0, "</s>": 1, "a": 2, "b": 3}
+    llama3 = {"<begin_of_text>": 0, "<end_of_text>": 1, "<eot_id>": 2, "a": 3, "b": 4, "c": 5}
+    key = "tokenizer.ggml.{}_token_id".format
+    cases = [
+        [{}, {}],
+        [{}, qwen],
+        [{key("eos"): 4}, qwen],
+        [{key("eos"): 2}, qwen],
+        [{key("eos"): 5, key("eot"): 6, key("eom"): 99}, {"a": 0, "b": 1, "c": 2, "d": 3, "<my_eos>": 4,
+                                                      "e": 5, "f": 6, "g": 7}],
+        [{key("eos"): 1}, llama],
+        [{key("eos"): 4}, llama],
+        [{key("eos"): -1}, llama],
+        [{key("eos"): True}, llama],
+        [{key("eos"): "1"}, llama3],
+        [{key("eot"): 2, key("eom"): 2}, llama3],
+        [{key("eos"): 5}, llama3],
+    ]
+    vocabs = [qwen, llama, llama3, {"x": 0, "y": 1, "z": 2}]
+    while len(cases) < n:
+        vocab = rng.choice(vocabs)
+        md = {}
+        for x in ("eos", "eot", "eom"):
+            if rng.random() < 0.5:
+                md[key(x)] = rng.choice([rng.randint(-1, len(vocab) + 1), rng.randrange(len(vocab))])
+        cases.append([md, vocab])
+    return cases[:n]

components/qemedia/upstream/qe_arena/corpus/glob_match.py

@@ -0,0 +1,82 @@
+"""Match a file path against a glob with *, ** and ? wildcards. Ported from TypeScript; adapted from proffesor-for-testing/agentic-qe@214a5bc881fe4ad6324e243c9d9c2c24baae5295:src/shared/io/file-reader.ts (MIT)."""
+
+import re
+
+META = {
+    "entry": "glob_match",
+    "origin": "proffesor-for-testing/agentic-qe@214a5bc881fe4ad6324e243c9d9c2c24baae5295:src/shared/io/file-reader.ts",
+    "tags": ["glob", "parsing", "paths"],
+    "domain": "software-engineering",
+}
+
+
+def glob_to_regex(pattern):
+    """Translate a glob into a regular expression body (without anchors)."""
+    regex = ""
+    i = 0
+    while i < len(pattern):
+        char = pattern[i]
+        if pattern[i:i + 2] == "**":
+            if pattern[i + 2:i + 3] == "/":
+                regex += "(?:.*/)?"
+                i += 3
+            else:
+                regex += ".*"
+                i += 2
+        elif char == "*":
+            regex += "[^/]*"
+            i += 1
+        elif char == "?":
+            regex += "[^/]"
+            i += 1
+        elif char in ".+^${}()|[]\\":
+            regex += "\\" + char
+            i += 1
+        else:
+            regex += char
+            i += 1
+    return regex
+
+
+def glob_match(pattern, path):
+    """Return True if the whole path matches the glob pattern.
+
+    "**/" anywhere in the pattern matches zero or more whole directories (nothing, or
+    any text ending in "/"), so "a/**/b" matches "a/b"; "**" elsewhere matches anything,
+    including "/"; "*" matches any run of characters except "/"; "?" matches exactly
+    one character except "/". Every other character matches itself literally.
+    """
+    return re.fullmatch(glob_to_regex(pattern), path, re.DOTALL) is not None
+
+
+def gen_inputs(rng, n):
+    """Return exactly n argument lists: boundary cases first, then rng-driven cases."""
+    cases = [
+        ["*.py", "a.py"],
+        ["*.py", "src/a.py"],
+        ["**/*.py", "a.py"],
+        ["**/*.py", "src/pkg/a.py"],
+        ["src/**", "src/a/b.ts"],
+        ["src/**", "src"],
+        ["src/**/test_*.py", "src/test_a.py"],
+        ["src/**/test_*.py", "src/x/y/test_a.py"],
+        ["a?c", "abc"],
+        ["a?c", "a/c"],
+        ["a?c", "ac"],
+        ["a.b", "axb"],
+        ["a.b", "a.b"],
+        ["(x)+[y]", "(x)+[y]"],
+        ["*", ""],
+        ["**", "a/b/c"],
+        ["*/*", "a/b"],
+        ["*/*", "a/b/c"],
+        ["$x^", "$x^"],
+        ["a**b", "a/x/b"],
+    ]
+    parts = ["src", "tests", "*", "**", "a", "b.py", "?", "c.ts", "*.py"]
+    names = ["src", "tests", "a", "bb", "b.py", "c.ts", "x.py"]
+    while len(cases) < n:
+        pattern = "/".join(rng.choice(parts) for _ in range(rng.randint(1, 3)))
+        path = "/".join(rng.choice(names) for _ in range(rng.randint(1, 3)))
+        cases.append([pattern, path])
+    return cases[:n]