{ "format": "rulemetric-public-study-v1", "revision": 1, "publishedStudyDate": "2026-10-10", "title": "What did one adversarial TDD skill add?", "experimentId": "5e05402d-63c0-442c-92c8-dfcbb9e8d50d", "sourceReceiptSha256": "d28648c0e4c075e943d028d2790598e7f4b1d1a72f37cfe5fa8ff19cdbdf1c88", "productCommit": "261fbda1349c11d293def8180bb497d5ed2f0c21", "studySourceCommitAtExecution": "ed8aad10d6a199968e5de6ba2a42c691ab4f97b1", "modelProvenance": "Requested/pinned codex:gpt-6.1-sol, not provider-attested; codex-cli 0.161.0", "frozen": { "planHash": "84e9d6d19ced789df2a5143ca3ff202b0dac483293427de5de883a32af77ead6", "manifestHash": "2c786c345d7294a44c5a9db9c885f805d191dc296914052a688bd1be35b477eb", "skillHash": "da80b2fd13f451fda6467a88825b909dabdc42bd4d1fd2d508a1b42797f7b2e6", "profile": { "kind": "codex-native-delegating-v1", "maxDescendants": 3, "maxConcurrentDescendants": 3, "maxDepth": 1, "sharedContext": "" }, "model": "codex:gpt-6.1-sol", "harnessVersion": "codex-cli 0.161.0", "repetitions": 2, "timeoutSeconds": 300 }, "primary": { "plannedAttempts": 32, "observedAttempts": 32, "independentFamilies": 8, "unknownCompletions": 0, "arms": { "baseline": { "completionKnown": 16, "completionPassed": 16, "qualityKnown": 16, "qualityPassed": 16, "tokens": 3405421, "measuredTokenSubtotal": 3405421, "unknownTokenAttempts": 0, "durationMs": 1935462 }, "treatment": { "completionKnown": 16, "completionPassed": 16, "qualityKnown": 16, "qualityPassed": 16, "tokens": 8390170, "measuredTokenSubtotal": 8390170, "unknownTokenAttempts": 0, "durationMs": 3103609 } }, "families": [ { "taskId": "record-normalization", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:record-normalization", "baselineCompletionRate": 1, "treatmentCompletionRate": 1, "completionDelta": 0, "tokenRatio": 6.494147407496108, "timeRatio": 2.650444186944766 }, { "taskId": "path-scope", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:path-scope", "baselineCompletionRate": 1, "treatmentCompletionRate": 1, "completionDelta": 0, "tokenRatio": 1.2382794295833721, "timeRatio": 1.1861917795772807 }, { "taskId": "interval-subtraction", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:interval-subtraction", "baselineCompletionRate": 1, "treatmentCompletionRate": 1, "completionDelta": 0, "tokenRatio": 1.3051427006067404, "timeRatio": 1.3593680694568189 }, { "taskId": "reservation-replay", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:reservation-replay", "baselineCompletionRate": 1, "treatmentCompletionRate": 1, "completionDelta": 0, "tokenRatio": 1.9485630208521776, "timeRatio": 1.243560754861719 }, { "taskId": "job-lifecycle", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:job-lifecycle", "baselineCompletionRate": 1, "treatmentCompletionRate": 1, "completionDelta": 0, "tokenRatio": 6.573147328867081, "timeRatio": 1.9103443297480691 }, { "taskId": "response-ledger", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:response-ledger", "baselineCompletionRate": 1, "treatmentCompletionRate": 1, "completionDelta": 0, "tokenRatio": 6.219987876419636, "timeRatio": 1.7440272421965464 }, { "taskId": "atomic-edits", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:atomic-edits", "baselineCompletionRate": 1, "treatmentCompletionRate": 1, "completionDelta": 0, "tokenRatio": 6.787148202601855, "timeRatio": 2.7399264244497212 }, { "taskId": "dependency-waves", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:dependency-waves", "baselineCompletionRate": 1, "treatmentCompletionRate": 1, "completionDelta": 0, "tokenRatio": 1.599914279418911, "timeRatio": 1.2521677402883677 } ], "skillWinFamilies": 0, "reproducibleSkillWinFamilies": 0, "reproducibleHarmFamilies": 0, "medianTokenRatio": 4.084275448635907, "medianTimeRatio": 1.5516976558266826, "zeroObservedWinsUpper95": 0.31234397806636793, "equivalenceDemonstrated": false, "recommendation": "inconclusive", "unverifiedCleanupAttempts": 0, "exclusions": [ { "taskId": "reservation-replay", "arm": "treatment", "repetition": 2, "exclusion": "Exact successful native skill read is unverified" } ], "descendants": { "baseline": 12, "treatment": 48 }, "treatmentReadCount": 15, "costUsd": null, "promptBoundaryCompliance": "unknown", "experimentId": "5e05402d-63c0-442c-92c8-dfcbb9e8d50d", "protocolHash": "5205d096c13bd520a652fdb877f966205e4162dc20dd810b16c509f32678bffd", "scope": "Eight independently authored supplied-function proxies; exploratory selected tasks, not a representative repository or triggering sample" }, "observations": [ { "taskId": "record-normalization", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:record-normalization", "arm": "treatment", "repetition": 1, "completion": true, "quality": true, "tokens": 412029, "durationMs": 132865, "descendants": 3, "observedDescendants": 3, "denials": 0, "skillRead": true, "actorDurationMs": 132441, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "92d3798eb37b95fc0185c7732b3d45ad2c2766c843a0efed6ab5722a9140cbec" }, { "taskId": "record-normalization", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:record-normalization", "arm": "baseline", "repetition": 1, "completion": true, "quality": true, "tokens": 60062, "durationMs": 51481, "descendants": 0, "observedDescendants": 0, "denials": 0, "skillRead": false, "actorDurationMs": 51077, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "40463225fcf8d73db644680b4383a4ea84ec2e99700f02659885a5162623856b" }, { "taskId": "record-normalization", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:record-normalization", "arm": "baseline", "repetition": 2, "completion": true, "quality": true, "tokens": 73554, "durationMs": 54668, "descendants": 0, "observedDescendants": 0, "denials": 0, "skillRead": false, "actorDurationMs": 54249, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "c5b7de37e8568dc7af4cbf65d9c4305f22b373f1f280c6e0163bc63db80c718e" }, { "taskId": "record-normalization", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:record-normalization", "arm": "treatment", "repetition": 2, "completion": true, "quality": true, "tokens": 455693, "durationMs": 148477, "descendants": 3, "observedDescendants": 3, "denials": 0, "skillRead": true, "actorDurationMs": 148054, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "ddf393f485a50426c9e99ed8a9f3383ece6ccf8012d94b517656842c9c7a590f" }, { "taskId": "interval-subtraction", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:interval-subtraction", "arm": "treatment", "repetition": 1, "completion": true, "quality": true, "tokens": 404891, "durationMs": 149379, "descendants": 3, "observedDescendants": 3, "denials": 0, "skillRead": true, "actorDurationMs": 148940, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "9553db7c97f95d4d056eb668964efccfca3f1a029429a14760addc99c5db2079" }, { "taskId": "interval-subtraction", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:interval-subtraction", "arm": "baseline", "repetition": 1, "completion": true, "quality": true, "tokens": 549595, "durationMs": 191769, "descendants": 3, "observedDescendants": 3, "denials": 0, "skillRead": false, "actorDurationMs": 191337, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "c21448857f9c30f8565a7698b144048ff92faaeca7e2b7cd66d437dfdbdd306f" }, { "taskId": "interval-subtraction", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:interval-subtraction", "arm": "baseline", "repetition": 2, "completion": true, "quality": true, "tokens": 63682, "durationMs": 67500, "descendants": 0, "observedDescendants": 0, "denials": 0, "skillRead": false, "actorDurationMs": 67057, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "fa92a5fb6d5098bdc0613206e4452acbf1eed9f64ff5c79439d71c5c0447aeef" }, { "taskId": "interval-subtraction", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:interval-subtraction", "arm": "treatment", "repetition": 2, "completion": true, "quality": true, "tokens": 395523, "durationMs": 203063, "descendants": 3, "observedDescendants": 3, "denials": 0, "skillRead": true, "actorDurationMs": 202618, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "5f6b8fc767a2f9b129f83fbfb36ce441aa80f13fe9361e5c44c5e6df41196570" }, { "taskId": "dependency-waves", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:dependency-waves", "arm": "baseline", "repetition": 1, "completion": true, "quality": true, "tokens": 599862, "durationMs": 247069, "descendants": 3, "observedDescendants": 3, "denials": 0, "skillRead": false, "actorDurationMs": 246488, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "85002f90e917167a35ad1b7d89b4d2f93efd03ea27099c816f2e8cbbbe59eb61" }, { "taskId": "dependency-waves", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:dependency-waves", "arm": "treatment", "repetition": 1, "completion": true, "quality": true, "tokens": 541455, "durationMs": 183233, "descendants": 3, "observedDescendants": 3, "denials": 0, "skillRead": true, "actorDurationMs": 182802, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "fd29e59f7b45aa1353e4f4d2a12132dc94e276dd1c65ee7c024820a6d26ec360" }, { "taskId": "dependency-waves", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:dependency-waves", "arm": "treatment", "repetition": 2, "completion": true, "quality": true, "tokens": 518677, "durationMs": 218947, "descendants": 3, "observedDescendants": 3, "denials": 0, "skillRead": true, "actorDurationMs": 218522, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "2f726c9faa0dd5de05ae0768f90e6dad35f0bc1012402566857194c58a05952e" }, { "taskId": "dependency-waves", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:dependency-waves", "arm": "baseline", "repetition": 2, "completion": true, "quality": true, "tokens": 62756, "durationMs": 74118, "descendants": 0, "observedDescendants": 0, "denials": 0, "skillRead": false, "actorDurationMs": 73673, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "0e4ab6a96f9eda3c1f3952b5a71d2aed7148471b522db827f10d15b7fc415acf" }, { "taskId": "path-scope", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:path-scope", "arm": "baseline", "repetition": 1, "completion": true, "quality": true, "tokens": 755177, "durationMs": 213549, "descendants": 3, "observedDescendants": 3, "denials": 0, "skillRead": false, "actorDurationMs": 213123, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "28ffb7498aca0922977f43bc80314f8ac2999c499fe93f798432cfeecf75b9fe" }, { "taskId": "path-scope", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:path-scope", "arm": "treatment", "repetition": 1, "completion": true, "quality": true, "tokens": 549890, "durationMs": 196497, "descendants": 3, "observedDescendants": 3, "denials": 0, "skillRead": true, "actorDurationMs": 196078, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "a4e20d1a85b47fab1f0cb7708efc8b2fe2506fa08d1a1de8612f811d70f3f2dd" }, { "taskId": "path-scope", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:path-scope", "arm": "treatment", "repetition": 2, "completion": true, "quality": true, "tokens": 459808, "durationMs": 116832, "descendants": 3, "observedDescendants": 3, "denials": 0, "skillRead": true, "actorDurationMs": 116421, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "aebdf36c2761fae4780d9b201499192ce24154ec055207e5a46e28d1676e6991" }, { "taskId": "path-scope", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:path-scope", "arm": "baseline", "repetition": 2, "completion": true, "quality": true, "tokens": 60227, "durationMs": 50598, "descendants": 0, "observedDescendants": 0, "denials": 0, "skillRead": false, "actorDurationMs": 50194, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "f73de7e420a8320044e2cefcf205d09217ee1c03434e1dc744fe691f4baa2ffc" }, { "taskId": "atomic-edits", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:atomic-edits", "arm": "treatment", "repetition": 1, "completion": true, "quality": true, "tokens": 527153, "durationMs": 242394, "descendants": 3, "observedDescendants": 3, "denials": 0, "skillRead": true, "actorDurationMs": 241983, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "24b79050b0ffbc01be7374834a1d98f53ddbd3b040f6bed56c7d3f189bb5b468" }, { "taskId": "atomic-edits", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:atomic-edits", "arm": "baseline", "repetition": 1, "completion": true, "quality": true, "tokens": 78464, "durationMs": 88094, "descendants": 0, "observedDescendants": 0, "denials": 0, "skillRead": false, "actorDurationMs": 87666, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "e2a9332b5a3a4ec6506494db6e7462f581932f62b1b7c43b0003274c2231b35f" }, { "taskId": "atomic-edits", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:atomic-edits", "arm": "baseline", "repetition": 2, "completion": true, "quality": true, "tokens": 65049, "durationMs": 74460, "descendants": 0, "observedDescendants": 0, "denials": 0, "skillRead": false, "actorDurationMs": 74048, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "27100198df010686f961ee25b0bc7dc9f3377613ebe4ae046d88acbec147c641" }, { "taskId": "atomic-edits", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:atomic-edits", "arm": "treatment", "repetition": 2, "completion": true, "quality": true, "tokens": 446891, "durationMs": 202992, "descendants": 3, "observedDescendants": 3, "denials": 0, "skillRead": true, "actorDurationMs": 202578, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "323969d3067c542c06a69b2f9992fb6a0713057efdb86f6cb3564a196f51ba0e" }, { "taskId": "reservation-replay", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:reservation-replay", "arm": "baseline", "repetition": 1, "completion": true, "quality": true, "tokens": 65104, "durationMs": 76324, "descendants": 0, "observedDescendants": 0, "denials": 0, "skillRead": false, "actorDurationMs": 75928, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "79c0fc1f1190e219c1d994cd1fc9f5acf2d6bc6022e512af3f5dcb0d4615afaf" }, { "taskId": "reservation-replay", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:reservation-replay", "arm": "treatment", "repetition": 1, "completion": true, "quality": true, "tokens": 569183, "durationMs": 162327, "descendants": 3, "observedDescendants": 3, "denials": 0, "skillRead": true, "actorDurationMs": 161914, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "fffff4a08b555ce937e4dd73ffaa5170952b3b0300cefaedc35904800c21e6d6" }, { "taskId": "reservation-replay", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:reservation-replay", "arm": "treatment", "repetition": 2, "completion": true, "quality": true, "tokens": 723369, "durationMs": 239705, "descendants": 3, "observedDescendants": 3, "denials": 0, "skillRead": false, "actorDurationMs": 239299, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": false, "exclusion": "Exact successful native skill read is unverified", "promptBoundaryCompliance": "unknown", "sourceHash": "529d38a69238b91e4a4e649174caedf2408f0b627d524323be89a91ed229e412" }, { "taskId": "reservation-replay", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:reservation-replay", "arm": "baseline", "repetition": 2, "completion": true, "quality": true, "tokens": 598232, "durationMs": 246967, "descendants": 3, "observedDescendants": 3, "denials": 0, "skillRead": false, "actorDurationMs": 246531, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "f040e56d5f711ad87f6405d4d27cecacc07f0c61a939ee242f2023d3b197d928" }, { "taskId": "response-ledger", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:response-ledger", "arm": "baseline", "repetition": 1, "completion": true, "quality": true, "tokens": 107904, "durationMs": 146335, "descendants": 0, "observedDescendants": 0, "denials": 0, "skillRead": false, "actorDurationMs": 145931, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "8240c276ab123f97540a2ecf5f21ccd19831914c329d297b4c38c453747603f8" }, { "taskId": "response-ledger", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:response-ledger", "arm": "treatment", "repetition": 1, "completion": true, "quality": true, "tokens": 503965, "durationMs": 202420, "descendants": 3, "observedDescendants": 3, "denials": 0, "skillRead": true, "actorDurationMs": 202000, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "30ef6145f0859a2dfdaf580d8011e6b312404ad2b68fc6c353f21cd603de2972" }, { "taskId": "response-ledger", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:response-ledger", "arm": "treatment", "repetition": 2, "completion": true, "quality": true, "tokens": 737613, "durationMs": 281054, "descendants": 3, "observedDescendants": 3, "denials": 0, "skillRead": true, "actorDurationMs": 280638, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "1239e2248ea0765ff607c878796ed83a23c0e49f2237f5d2558d05b28c925e7d" }, { "taskId": "response-ledger", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:response-ledger", "arm": "baseline", "repetition": 2, "completion": true, "quality": true, "tokens": 91707, "durationMs": 130882, "descendants": 0, "observedDescendants": 0, "denials": 0, "skillRead": false, "actorDurationMs": 130473, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "5bd297e661baeaa526e02d22a2b6258dd94bc3e285873553cdd9ae42d9ff7c6e" }, { "taskId": "job-lifecycle", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:job-lifecycle", "arm": "treatment", "repetition": 1, "completion": true, "quality": true, "tokens": 557887, "durationMs": 209532, "descendants": 3, "observedDescendants": 3, "denials": 0, "skillRead": true, "actorDurationMs": 209116, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "fe8d971ecd55e3b827380d6d10d8bf5d898cafe238a8dd0d468265583750e7a1" }, { "taskId": "job-lifecycle", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:job-lifecycle", "arm": "baseline", "repetition": 1, "completion": true, "quality": true, "tokens": 82764, "durationMs": 98835, "descendants": 0, "observedDescendants": 0, "denials": 0, "skillRead": false, "actorDurationMs": 98432, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "c0860f26fdf4d3945e979f82c831b81eca3ad850fcdecfefe279eec826f4b025" }, { "taskId": "job-lifecycle", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:job-lifecycle", "arm": "baseline", "repetition": 2, "completion": true, "quality": true, "tokens": 91282, "durationMs": 122813, "descendants": 0, "observedDescendants": 0, "denials": 0, "skillRead": false, "actorDurationMs": 122394, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "1d0dcb92c87a322b6a689d7862e15a2dbccc2e4b89a7e571288f0cec9fab28ab" }, { "taskId": "job-lifecycle", "family": "suite:f901f894-e6fa-4c35-9b70-156b8007d2b9:task:job-lifecycle", "arm": "treatment", "repetition": 2, "completion": true, "quality": true, "tokens": 586143, "durationMs": 213892, "descendants": 3, "observedDescendants": 3, "denials": 0, "skillRead": true, "actorDurationMs": 213482, "withinDeadline": true, "cleanupVerified": true, "outputPassFraction": 1, "mutationFailures": 0, "safeguards": true, "eligible": true, "exclusion": null, "promptBoundaryCompliance": "unknown", "sourceHash": "f0450d7d115fa64026b5ae18b8726aa91e531bf151a6454f3acc8891843e770c" } ], "totals": { "tokenRatio": 2.4637687968682873, "elapsedRatio": 1.6035494367753023, "actorSeconds": { "baseline": 1928.601, "treatment": 3096.886 }, "denials": 0, "cleanupVerified": true, "secondaryAdditionalModelCalls": 0 }, "secondary": { "format": "rulemetric-secondary-robustness-results-v1", "primaryComparisonChanged": false, "additionalModelCalls": 0, "casesHash": "3717af2552f31db1f59cfd1d374bbac767391c1becadd6a0b087b597cf2249e6", "scope": "Secondary tests of retained submitted code, including incomplete original attempts; not a rerun or a replacement primary completion verdict", "arms": { "baseline": { "planned": 16, "observed": 16, "known": 16, "passed": 16, "unknown": 0, "missing": 0 }, "treatment": { "planned": 16, "observed": 16, "known": 16, "passed": 16, "unknown": 0, "missing": 0 } }, "rows": [ { "taskId": "record-normalization", "arm": "treatment", "repetition": 1, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "92d3798eb37b95fc0185c7732b3d45ad2c2766c843a0efed6ab5722a9140cbec", "error": null, "verificationReceiptHash": "a6f99f11853dfb2d85a4f07cba99bd72534ceada0a73583fe6729d5082f24c1b" }, { "taskId": "record-normalization", "arm": "baseline", "repetition": 1, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "40463225fcf8d73db644680b4383a4ea84ec2e99700f02659885a5162623856b", "error": null, "verificationReceiptHash": "dfc2b7d5328c700eedf36e54249c75e39e976fb3961d21f2fab489d9c623f00e" }, { "taskId": "record-normalization", "arm": "baseline", "repetition": 2, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "c5b7de37e8568dc7af4cbf65d9c4305f22b373f1f280c6e0163bc63db80c718e", "error": null, "verificationReceiptHash": "159395505c1fabbb78614594f9907416a2d95156619f3d3268a631c0384b1a12" }, { "taskId": "record-normalization", "arm": "treatment", "repetition": 2, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "ddf393f485a50426c9e99ed8a9f3383ece6ccf8012d94b517656842c9c7a590f", "error": null, "verificationReceiptHash": "2fd41094aaba0a8fb39b256eb549571cdddf58fd178586bf74533792d7784a9e" }, { "taskId": "interval-subtraction", "arm": "treatment", "repetition": 1, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "9553db7c97f95d4d056eb668964efccfca3f1a029429a14760addc99c5db2079", "error": null, "verificationReceiptHash": "dc770bbffb960099d176e891aef75ed54679b0b0696ed5b799c95be2037569b9" }, { "taskId": "interval-subtraction", "arm": "baseline", "repetition": 1, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "c21448857f9c30f8565a7698b144048ff92faaeca7e2b7cd66d437dfdbdd306f", "error": null, "verificationReceiptHash": "6be2ac41d8e7de4356cd2a88e63345c34caa9b20a32eb348c7932c42b406a223" }, { "taskId": "interval-subtraction", "arm": "baseline", "repetition": 2, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "fa92a5fb6d5098bdc0613206e4452acbf1eed9f64ff5c79439d71c5c0447aeef", "error": null, "verificationReceiptHash": "7b6cda922ba80f74824a211ab56eec6c16bee31f8a0625d93b63c94c2dcdbdae" }, { "taskId": "interval-subtraction", "arm": "treatment", "repetition": 2, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "5f6b8fc767a2f9b129f83fbfb36ce441aa80f13fe9361e5c44c5e6df41196570", "error": null, "verificationReceiptHash": "a45ff755c049668350c7c4465ab10b5e9c79655678f8403b282dd672aa6db835" }, { "taskId": "dependency-waves", "arm": "baseline", "repetition": 1, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "85002f90e917167a35ad1b7d89b4d2f93efd03ea27099c816f2e8cbbbe59eb61", "error": null, "verificationReceiptHash": "8266276b75be79481f9678c4667cb6b9f06be21177870eff7cd955885aba1a7c" }, { "taskId": "dependency-waves", "arm": "treatment", "repetition": 1, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "fd29e59f7b45aa1353e4f4d2a12132dc94e276dd1c65ee7c024820a6d26ec360", "error": null, "verificationReceiptHash": "20b059fe25caf5fb8cccaf6297efae26461e5dacf4e53ae450736bcdea3403b4" }, { "taskId": "dependency-waves", "arm": "treatment", "repetition": 2, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "2f726c9faa0dd5de05ae0768f90e6dad35f0bc1012402566857194c58a05952e", "error": null, "verificationReceiptHash": "60ee6b39da40bf618e1fe0141f858a63fc4a2663cc1929998c400702b0c84c9b" }, { "taskId": "dependency-waves", "arm": "baseline", "repetition": 2, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "0e4ab6a96f9eda3c1f3952b5a71d2aed7148471b522db827f10d15b7fc415acf", "error": null, "verificationReceiptHash": "a35b81908f23881850cc8d56273d365b60ca98793a47f6a24727b630f6cd1e7e" }, { "taskId": "path-scope", "arm": "baseline", "repetition": 1, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "28ffb7498aca0922977f43bc80314f8ac2999c499fe93f798432cfeecf75b9fe", "error": null, "verificationReceiptHash": "48b22502f47ba2db43f701aa4b9784b25b01d6aa0a6cb0a08d754a9afff4ba37" }, { "taskId": "path-scope", "arm": "treatment", "repetition": 1, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "a4e20d1a85b47fab1f0cb7708efc8b2fe2506fa08d1a1de8612f811d70f3f2dd", "error": null, "verificationReceiptHash": "e03f82c71cb67dda28f4909ac94754507e1471aea84bc9d0680e31eaef73806c" }, { "taskId": "path-scope", "arm": "treatment", "repetition": 2, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "aebdf36c2761fae4780d9b201499192ce24154ec055207e5a46e28d1676e6991", "error": null, "verificationReceiptHash": "f946423b84d4ff1874139bd97f8eefdb3748d1de46e0cc8d85c6ef8e12be996d" }, { "taskId": "path-scope", "arm": "baseline", "repetition": 2, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "f73de7e420a8320044e2cefcf205d09217ee1c03434e1dc744fe691f4baa2ffc", "error": null, "verificationReceiptHash": "f8db43424da9745c0ed959298c15b701bbe4b75f48403fccff1ea1362c8ae428" }, { "taskId": "atomic-edits", "arm": "treatment", "repetition": 1, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "24b79050b0ffbc01be7374834a1d98f53ddbd3b040f6bed56c7d3f189bb5b468", "error": null, "verificationReceiptHash": "09787a343185c02579ba281dbc1a29a6537e344d2c1e3366e8701551cd31919e" }, { "taskId": "atomic-edits", "arm": "baseline", "repetition": 1, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "e2a9332b5a3a4ec6506494db6e7462f581932f62b1b7c43b0003274c2231b35f", "error": null, "verificationReceiptHash": "80f028618eb0976ca35effd795e61486516f523376a7c37916ea11c0cee53602" }, { "taskId": "atomic-edits", "arm": "baseline", "repetition": 2, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "27100198df010686f961ee25b0bc7dc9f3377613ebe4ae046d88acbec147c641", "error": null, "verificationReceiptHash": "2e620d682e6082682bb1c1e37872135667f90a5fac35ee2c6030bca3f5738f06" }, { "taskId": "atomic-edits", "arm": "treatment", "repetition": 2, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "323969d3067c542c06a69b2f9992fb6a0713057efdb86f6cb3564a196f51ba0e", "error": null, "verificationReceiptHash": "98a57aeacb01096f0f54c4acee2b43a9e0ca93b54c950b167b20f406d83e051d" }, { "taskId": "reservation-replay", "arm": "baseline", "repetition": 1, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "79c0fc1f1190e219c1d994cd1fc9f5acf2d6bc6022e512af3f5dcb0d4615afaf", "error": null, "verificationReceiptHash": "9ef06da83a913d4ae7b8c8e57a5c2ff5556a559b4c61d4f5f2c9884ba2f8a111" }, { "taskId": "reservation-replay", "arm": "treatment", "repetition": 1, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "fffff4a08b555ce937e4dd73ffaa5170952b3b0300cefaedc35904800c21e6d6", "error": null, "verificationReceiptHash": "31490ec0f71c9c405431d86c7062ab04ec0e5eb4413db5f404b2afda399bdc74" }, { "taskId": "reservation-replay", "arm": "treatment", "repetition": 2, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "529d38a69238b91e4a4e649174caedf2408f0b627d524323be89a91ed229e412", "error": null, "verificationReceiptHash": "6f58e0fb8f84037118cf99456cd9a568c18396de29e52ab1290835c9bc7928ec" }, { "taskId": "reservation-replay", "arm": "baseline", "repetition": 2, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "f040e56d5f711ad87f6405d4d27cecacc07f0c61a939ee242f2023d3b197d928", "error": null, "verificationReceiptHash": "a4c53f0024bd1226a9811d64dfbe8b7541a805a9c22e67a6e7fd37fcdc025231" }, { "taskId": "response-ledger", "arm": "baseline", "repetition": 1, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "8240c276ab123f97540a2ecf5f21ccd19831914c329d297b4c38c453747603f8", "error": null, "verificationReceiptHash": "41fa7cc5128dc9081eabf5c36cddb76c0be2fb987129dcf8912d858f9ccef51f" }, { "taskId": "response-ledger", "arm": "treatment", "repetition": 1, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "30ef6145f0859a2dfdaf580d8011e6b312404ad2b68fc6c353f21cd603de2972", "error": null, "verificationReceiptHash": "54f6dfe8af71ce7f734ccea49b0c0aa0cb9885e597d8f3a5c4a72abd9509460f" }, { "taskId": "response-ledger", "arm": "treatment", "repetition": 2, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "1239e2248ea0765ff607c878796ed83a23c0e49f2237f5d2558d05b28c925e7d", "error": null, "verificationReceiptHash": "5edc7dbab3fa9a47a2c9e8821ed058f03bebe2590b2271e117d61c03628fec6f" }, { "taskId": "response-ledger", "arm": "baseline", "repetition": 2, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "5bd297e661baeaa526e02d22a2b6258dd94bc3e285873553cdd9ae42d9ff7c6e", "error": null, "verificationReceiptHash": "b43fa6fa20f41af14436920f5b85c7c42eec7a898b7f1c0cdf6ae4f2d911d511" }, { "taskId": "job-lifecycle", "arm": "treatment", "repetition": 1, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "fe8d971ecd55e3b827380d6d10d8bf5d898cafe238a8dd0d468265583750e7a1", "error": null, "verificationReceiptHash": "6e937653f0ef3b024af993ebb0c679dff1df91b6d1b38f28eebf2596e25724e8" }, { "taskId": "job-lifecycle", "arm": "baseline", "repetition": 1, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "c0860f26fdf4d3945e979f82c831b81eca3ad850fcdecfefe279eec826f4b025", "error": null, "verificationReceiptHash": "13ba6b67c7204b9f88d07be8259804af86901884364e3d1fdc3ef1f532c42439" }, { "taskId": "job-lifecycle", "arm": "baseline", "repetition": 2, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "1d0dcb92c87a322b6a689d7862e15a2dbccc2e4b89a7e571288f0cec9fab28ab", "error": null, "verificationReceiptHash": "16ff8ed6a8a3f573c275d2e02d3bb4c499a50b0d5b3f7c51e4a74fa04141ec06" }, { "taskId": "job-lifecycle", "arm": "treatment", "repetition": 2, "passed": true, "secondaryCases": 34, "casePassed": 34, "failedCases": [], "inputMutationFailures": 0, "sourceHash": "f0450d7d115fa64026b5ae18b8726aa91e531bf151a6454f3acc8891843e770c", "error": null, "verificationReceiptHash": "994b1221a2607603708392d1af0548b15da52c69d941f9413a3d7f2088451244" } ] }, "recommendation": { "practical": "Keep opt-in rather than require default use for supplied-function work; do not delete globally from this evidence", "formal": "inconclusive", "automaticSkillChange": false, "reason": "No quality gain on primary or secondary checks; materially higher effort. Formal frozen full-read gate missed one compound read.", "exposureDiagnostic": { "taskId": "reservation-replay", "arm": "treatment", "repetition": 2, "compoundCommand": true, "matchedOutputContainedExactFullSkillBody": true, "commandExitCode": 0, "frozenSuccessfulReadFlag": false, "primaryReceiptChanged": false, "callRecordHash": "cde9e15bd80fae615334913ec2179024999fa45776665c9472e4d0585ce0d544", "matchedOutputRecordHash": "3d252af6f55b108c20b33abb68ccacb5116b4c44ff4f1336e079a3334b1423aa", "diagnosticPerformedAfterPrimaryInspection": true, "skillUnchanged": true } }, "limitations": [ "Eight selected synthetic function families, not random repository-wide tasks or ordinary-session trigger tests.", "Two repeats/cases/children do not increase the independent sample beyond eight.", "Both arms hit a quality ceiling; zero observed wins cannot establish a 10-point equivalence margin.", "Strict mechanical reads15/16; diagnostic compound-read evidence is reported separately.", "Encrypted child prompts leave information-barrier adherence unknown.", "Unpriced tokens do not establish dollar cost." ], "sources": [ { "taskId": "record-normalization", "arm": "treatment", "repetition": 1, "sourceHash": "92d3798eb37b95fc0185c7732b3d45ad2c2766c843a0efed6ab5722a9140cbec", "submittedSource": "exports.solve = (rows) => {\n if (!Array.isArray(rows)) {\n return { ok: false, error: \"invalid-input\" };\n }\n\n const result = [];\n const selectedIds = new Set();\n\n for (const row of rows) {\n if (row === null || typeof row !== \"object\" || Array.isArray(row) ||\n row.active !== true || typeof row.id !== \"string\") {\n continue;\n }\n\n const id = row.id.trim();\n if (id.length === 0 || selectedIds.has(id)) {\n continue;\n }\n selectedIds.add(id);\n\n const tags = [];\n const selectedTags = new Set();\n if (Array.isArray(row.tags)) {\n for (const value of row.tags) {\n if (typeof value !== \"string\") {\n continue;\n }\n const tag = value.trim().toLowerCase();\n if (tag.length > 0 && !selectedTags.has(tag)) {\n selectedTags.add(tag);\n tags.push(tag);\n }\n }\n }\n\n result.push({ id, tags });\n }\n\n return { ok: true, result };\n};\n" }, { "taskId": "record-normalization", "arm": "baseline", "repetition": 1, "sourceHash": "40463225fcf8d73db644680b4383a4ea84ec2e99700f02659885a5162623856b", "submittedSource": "exports.solve = function solve(rows) {\n if (!Array.isArray(rows)) {\n return { ok: false, error: \"invalid-input\" };\n }\n\n const result = [];\n const seenIds = new Set();\n\n for (const row of rows) {\n if (\n row === null ||\n typeof row !== \"object\" ||\n Array.isArray(row) ||\n row.active !== true ||\n typeof row.id !== \"string\"\n ) {\n continue;\n }\n\n const id = row.id.trim();\n if (id.length === 0 || seenIds.has(id)) {\n continue;\n }\n seenIds.add(id);\n\n const tags = [];\n const seenTags = new Set();\n if (Array.isArray(row.tags)) {\n for (const tag of row.tags) {\n if (typeof tag !== \"string\") {\n continue;\n }\n const normalized = tag.trim().toLowerCase();\n if (normalized.length > 0 && !seenTags.has(normalized)) {\n seenTags.add(normalized);\n tags.push(normalized);\n }\n }\n }\n\n result.push({ id, tags });\n }\n\n return { ok: true, result };\n};\n" }, { "taskId": "record-normalization", "arm": "baseline", "repetition": 2, "sourceHash": "c5b7de37e8568dc7af4cbf65d9c4305f22b373f1f280c6e0163bc63db80c718e", "submittedSource": "exports.solve = function solve(rows) {\n if (!Array.isArray(rows)) {\n return { ok: false, error: \"invalid-input\" };\n }\n\n const result = [];\n const seenIds = new Set();\n\n for (const row of rows) {\n if (row === null || typeof row !== \"object\" || Array.isArray(row)) {\n continue;\n }\n if (row.active !== true || typeof row.id !== \"string\") {\n continue;\n }\n\n const id = row.id.trim();\n if (id.length === 0 || seenIds.has(id)) {\n continue;\n }\n seenIds.add(id);\n\n const tags = [];\n const seenTags = new Set();\n if (Array.isArray(row.tags)) {\n for (const value of row.tags) {\n if (typeof value !== \"string\") {\n continue;\n }\n const tag = value.trim().toLowerCase();\n if (tag.length === 0 || seenTags.has(tag)) {\n continue;\n }\n seenTags.add(tag);\n tags.push(tag);\n }\n }\n\n result.push({ id, tags });\n }\n\n return { ok: true, result };\n};\n" }, { "taskId": "record-normalization", "arm": "treatment", "repetition": 2, "sourceHash": "ddf393f485a50426c9e99ed8a9f3383ece6ccf8012d94b517656842c9c7a590f", "submittedSource": "exports.solve = (rows) => {\n if (!Array.isArray(rows)) {\n return { ok: false, error: 'invalid-input' };\n }\n\n const result = [];\n const seenIds = new Set();\n\n for (const row of rows) {\n if (row === null || typeof row !== 'object' || Array.isArray(row)) {\n continue;\n }\n if (row.active !== true || typeof row.id !== 'string') {\n continue;\n }\n\n const id = row.id.trim();\n if (id === '' || seenIds.has(id)) {\n continue;\n }\n seenIds.add(id);\n\n const tags = [];\n const seenTags = new Set();\n if (Array.isArray(row.tags)) {\n for (const tag of row.tags) {\n if (typeof tag !== 'string') {\n continue;\n }\n const normalized = tag.trim().toLowerCase();\n if (normalized !== '' && !seenTags.has(normalized)) {\n seenTags.add(normalized);\n tags.push(normalized);\n }\n }\n }\n\n result.push({ id, tags });\n }\n\n return { ok: true, result };\n};\n" }, { "taskId": "interval-subtraction", "arm": "treatment", "repetition": 1, "sourceHash": "9553db7c97f95d4d056eb668964efccfca3f1a029429a14760addc99c5db2079", "submittedSource": "function normalize(intervals) {\n const sorted = intervals.map(([start, end]) => [start, end]);\n sorted.sort((left, right) => {\n if (left[0] !== right[0]) return left[0] < right[0] ? -1 : 1;\n if (left[1] === right[1]) return 0;\n return left[1] < right[1] ? -1 : 1;\n });\n\n const merged = [];\n for (const interval of sorted) {\n const previous = merged[merged.length - 1];\n if (previous && interval[0] <= previous[1]) {\n if (interval[1] > previous[1]) previous[1] = interval[1];\n } else {\n merged.push(interval);\n }\n }\n return merged;\n}\n\nfunction validIntervals(intervals) {\n if (!Array.isArray(intervals)) return false;\n for (let index = 0; index < intervals.length; index += 1) {\n if (!Object.prototype.hasOwnProperty.call(intervals, index)) return false;\n const interval = intervals[index];\n if (!Array.isArray(interval) || interval.length !== 2 ||\n !Object.prototype.hasOwnProperty.call(interval, 0) ||\n !Object.prototype.hasOwnProperty.call(interval, 1) ||\n !Number.isSafeInteger(interval[0]) ||\n !Number.isSafeInteger(interval[1]) || interval[0] >= interval[1]) {\n return false;\n }\n }\n return true;\n}\n\nexports.solve = function solve(allowed, blocked) {\n if (!validIntervals(allowed) || !validIntervals(blocked)) {\n return { ok: false, error: 'invalid-input' };\n }\n\n const allowedUnion = normalize(allowed);\n const blockedUnion = normalize(blocked);\n const result = [];\n let blockedIndex = 0;\n\n for (const [start, end] of allowedUnion) {\n let cursor = start;\n while (blockedIndex < blockedUnion.length &&\n blockedUnion[blockedIndex][1] <= cursor) {\n blockedIndex += 1;\n }\n\n while (blockedIndex < blockedUnion.length &&\n blockedUnion[blockedIndex][0] < end) {\n const [blockedStart, blockedEnd] = blockedUnion[blockedIndex];\n if (blockedStart > cursor) result.push([cursor, blockedStart]);\n if (blockedEnd > cursor) cursor = blockedEnd;\n if (cursor >= end) break;\n blockedIndex += 1;\n }\n\n if (cursor < end) result.push([cursor, end]);\n }\n\n return { ok: true, result };\n};\n" }, { "taskId": "interval-subtraction", "arm": "baseline", "repetition": 1, "sourceHash": "c21448857f9c30f8565a7698b144048ff92faaeca7e2b7cd66d437dfdbdd306f", "submittedSource": "exports.solve = function solve(allowed, blocked) {\n function isValid(collection) {\n if (!Array.isArray(collection)) return false;\n for (let i = 0; i < collection.length; i += 1) {\n const interval = collection[i];\n if (!Array.isArray(interval) || interval.length !== 2 ||\n !Number.isSafeInteger(interval[0]) ||\n !Number.isSafeInteger(interval[1]) ||\n interval[0] >= interval[1]) return false;\n }\n return true;\n }\n\n if (!isValid(allowed) || !isValid(blocked)) {\n return { ok: false, error: 'invalid-input' };\n }\n\n function normalize(collection) {\n const sorted = collection.map(interval => [interval[0], interval[1]]);\n sorted.sort((a, b) => {\n if (a[0] !== b[0]) return a[0] < b[0] ? -1 : 1;\n if (a[1] !== b[1]) return a[1] < b[1] ? -1 : 1;\n return 0;\n });\n const merged = [];\n for (const interval of sorted) {\n const previous = merged[merged.length - 1];\n if (previous && interval[0] <= previous[1]) {\n if (interval[1] > previous[1]) previous[1] = interval[1];\n } else {\n merged.push(interval);\n }\n }\n return merged;\n }\n\n const allowedUnion = normalize(allowed);\n const blockedUnion = normalize(blocked);\n const result = [];\n let blockIndex = 0;\n\n for (const [start, end] of allowedUnion) {\n let cursor = start;\n while (blockIndex < blockedUnion.length &&\n blockedUnion[blockIndex][1] <= cursor) {\n blockIndex += 1;\n }\n while (blockIndex < blockedUnion.length && cursor < end) {\n const [blockStart, blockEnd] = blockedUnion[blockIndex];\n if (blockStart >= end) break;\n if (blockStart > cursor) result.push([cursor, blockStart]);\n if (blockEnd >= end) {\n cursor = end;\n break;\n }\n cursor = blockEnd;\n blockIndex += 1;\n }\n if (cursor < end) result.push([cursor, end]);\n }\n\n return { ok: true, result };\n};\n" }, { "taskId": "interval-subtraction", "arm": "baseline", "repetition": 2, "sourceHash": "fa92a5fb6d5098bdc0613206e4452acbf1eed9f64ff5c79439d71c5c0447aeef", "submittedSource": "exports.solve = function solve(allowed, blocked) {\n const valid = (intervals) => {\n if (!Array.isArray(intervals)) return false;\n for (let i = 0; i < intervals.length; i++) {\n if (!Object.prototype.hasOwnProperty.call(intervals, i)) return false;\n const interval = intervals[i];\n if (!Array.isArray(interval) || interval.length !== 2 ||\n !Number.isSafeInteger(interval[0]) ||\n !Number.isSafeInteger(interval[1]) || interval[0] >= interval[1]) {\n return false;\n }\n }\n return true;\n };\n\n if (!valid(allowed) || !valid(blocked)) {\n return { ok: false, error: 'invalid-input' };\n }\n\n const normalize = (intervals) => {\n const sorted = intervals.map(([start, end]) => [start, end]);\n sorted.sort((a, b) => a[0] - b[0] || a[1] - b[1]);\n const merged = [];\n for (const interval of sorted) {\n const last = merged[merged.length - 1];\n if (last && interval[0] <= last[1]) {\n last[1] = Math.max(last[1], interval[1]);\n } else {\n merged.push(interval);\n }\n }\n return merged;\n };\n\n const allowedUnion = normalize(allowed);\n const blockedUnion = normalize(blocked);\n const result = [];\n let blockedIndex = 0;\n\n for (const [start, end] of allowedUnion) {\n let cursor = start;\n while (blockedIndex < blockedUnion.length &&\n blockedUnion[blockedIndex][1] <= cursor) {\n blockedIndex++;\n }\n while (blockedIndex < blockedUnion.length &&\n blockedUnion[blockedIndex][0] < end) {\n const [blockStart, blockEnd] = blockedUnion[blockedIndex];\n if (blockStart > cursor) result.push([cursor, blockStart]);\n cursor = Math.max(cursor, blockEnd);\n // Keep a spanning blocker for the next allowed interval.\n if (cursor >= end) break;\n blockedIndex++;\n }\n if (cursor < end) result.push([cursor, end]);\n }\n\n return { ok: true, result };\n};\n" }, { "taskId": "interval-subtraction", "arm": "treatment", "repetition": 2, "sourceHash": "5f6b8fc767a2f9b129f83fbfb36ce441aa80f13fe9361e5c44c5e6df41196570", "submittedSource": "function validIntervals(intervals) {\n if (!Array.isArray(intervals)) return false;\n for (const interval of intervals) {\n if (!Array.isArray(interval) || interval.length !== 2 ||\n !Number.isSafeInteger(interval[0]) ||\n !Number.isSafeInteger(interval[1]) ||\n interval[0] >= interval[1]) {\n return false;\n }\n }\n return true;\n}\n\nfunction normalize(intervals) {\n const sorted = intervals.map(interval => [interval[0], interval[1]]);\n sorted.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);\n const merged = [];\n for (const interval of sorted) {\n const previous = merged[merged.length - 1];\n if (previous && interval[0] <= previous[1]) {\n previous[1] = Math.max(previous[1], interval[1]);\n } else {\n merged.push(interval);\n }\n }\n return merged;\n}\n\nexports.solve = function solve(allowed, blocked) {\n if (!validIntervals(allowed) || !validIntervals(blocked)) {\n return {ok: false, error: 'invalid-input'};\n }\n\n const allowedUnion = normalize(allowed);\n const blockedUnion = normalize(blocked);\n const result = [];\n let blockedIndex = 0;\n\n for (const [start, end] of allowedUnion) {\n let cursor = start;\n while (blockedIndex < blockedUnion.length &&\n blockedUnion[blockedIndex][1] <= cursor) {\n blockedIndex++;\n }\n\n while (blockedIndex < blockedUnion.length &&\n blockedUnion[blockedIndex][0] < end) {\n const [blockStart, blockEnd] = blockedUnion[blockedIndex];\n if (blockStart > cursor) result.push([cursor, blockStart]);\n cursor = Math.max(cursor, blockEnd);\n if (cursor >= end) break;\n blockedIndex++;\n }\n\n if (cursor < end) result.push([cursor, end]);\n }\n\n return {ok: true, result};\n};\n" }, { "taskId": "dependency-waves", "arm": "baseline", "repetition": 1, "sourceHash": "85002f90e917167a35ad1b7d89b4d2f93efd03ea27099c816f2e8cbbbe59eb61", "submittedSource": "exports.solve = function solve(nodes, concurrency) {\n const fail = (error) => ({ ok: false, error });\n const isNonemptyString = (value) =>\n typeof value === \"string\" && value.length > 0;\n\n if (!Array.isArray(nodes) ||\n !Number.isSafeInteger(concurrency) || concurrency < 1 || concurrency > 3) {\n return fail(\"invalid-input\");\n }\n\n // Validate every node before checking any graph-level error.\n for (const node of nodes) {\n if (node === null || typeof node !== \"object\" || Array.isArray(node) ||\n !isNonemptyString(node.id) || !Array.isArray(node.deps) ||\n !Number.isSafeInteger(node.priority)) {\n return fail(\"invalid-input\");\n }\n for (const dependency of node.deps) {\n if (!isNonemptyString(dependency)) return fail(\"invalid-input\");\n }\n }\n\n const pending = new Map();\n for (const node of nodes) {\n if (pending.has(node.id)) return fail(\"duplicate-id\");\n pending.set(node.id, {\n id: node.id,\n deps: new Set(node.deps),\n priority: node.priority,\n });\n }\n\n for (const node of pending.values()) {\n for (const dependency of node.deps) {\n if (!pending.has(dependency)) return fail(\"unknown-dependency\");\n }\n }\n\n const finished = new Set();\n const waves = [];\n while (pending.size > 0) {\n const eligible = [];\n for (const node of pending.values()) {\n let ready = true;\n for (const dependency of node.deps) {\n if (!finished.has(dependency)) {\n ready = false;\n break;\n }\n }\n if (ready) eligible.push(node);\n }\n\n if (eligible.length === 0) return fail(\"cycle\");\n eligible.sort((a, b) => {\n if (a.priority !== b.priority) return a.priority > b.priority ? -1 : 1;\n return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;\n });\n\n const wave = eligible.slice(0, concurrency).map((node) => node.id);\n waves.push(wave);\n for (const id of wave) {\n pending.delete(id);\n finished.add(id);\n }\n }\n\n return { ok: true, result: waves };\n};\n" }, { "taskId": "dependency-waves", "arm": "treatment", "repetition": 1, "sourceHash": "fd29e59f7b45aa1353e4f4d2a12132dc94e276dd1c65ee7c024820a6d26ec360", "submittedSource": "exports.solve = function solve(nodes, concurrency) {\n const invalid = () => ({ ok: false, error: 'invalid-input' });\n const isNonemptyString = (value) => typeof value === 'string' && value.length > 0;\n\n if (!Array.isArray(nodes) || !Number.isSafeInteger(concurrency) || concurrency < 1 || concurrency > 3) {\n return invalid();\n }\n\n // Finish structural validation before checking any graph relationships.\n for (const node of nodes) {\n if (node === null || typeof node !== 'object' || Array.isArray(node) ||\n !isNonemptyString(node.id) || !Array.isArray(node.deps) ||\n !Number.isSafeInteger(node.priority)) {\n return invalid();\n }\n for (const dependency of node.deps) {\n if (!isNonemptyString(dependency)) return invalid();\n }\n }\n\n const pending = new Map();\n for (const node of nodes) {\n if (pending.has(node.id)) return { ok: false, error: 'duplicate-id' };\n pending.set(node.id, { id: node.id, deps: new Set(node.deps), priority: node.priority });\n }\n\n for (const node of pending.values()) {\n for (const dependency of node.deps) {\n if (!pending.has(dependency)) return { ok: false, error: 'unknown-dependency' };\n }\n }\n\n const finished = new Set();\n const waves = [];\n while (pending.size > 0) {\n const eligible = [];\n for (const node of pending.values()) {\n let ready = true;\n for (const dependency of node.deps) {\n if (!finished.has(dependency)) {\n ready = false;\n break;\n }\n }\n if (ready) eligible.push(node);\n }\n if (eligible.length === 0) return { ok: false, error: 'cycle' };\n\n eligible.sort((left, right) => {\n if (left.priority !== right.priority) return left.priority > right.priority ? -1 : 1;\n return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;\n });\n const wave = eligible.slice(0, concurrency).map((node) => node.id);\n waves.push(wave);\n for (const id of wave) {\n pending.delete(id);\n finished.add(id);\n }\n }\n\n return { ok: true, result: waves };\n};\n" }, { "taskId": "dependency-waves", "arm": "treatment", "repetition": 2, "sourceHash": "2f726c9faa0dd5de05ae0768f90e6dad35f0bc1012402566857194c58a05952e", "submittedSource": "exports.solve = function solve(nodes, concurrency) {\n if (!Array.isArray(nodes) || !Number.isSafeInteger(concurrency) ||\n concurrency < 1 || concurrency > 3) {\n return { ok: false, error: 'invalid-input' };\n }\n\n // Finish structural validation before checking any graph-level errors.\n const records = [];\n for (const node of nodes) {\n if (node === null || typeof node !== 'object' || Array.isArray(node) ||\n typeof node.id !== 'string' || node.id.length === 0 ||\n !Array.isArray(node.deps) || !Number.isSafeInteger(node.priority)) {\n return { ok: false, error: 'invalid-input' };\n }\n for (const dependency of node.deps) {\n if (typeof dependency !== 'string' || dependency.length === 0) {\n return { ok: false, error: 'invalid-input' };\n }\n }\n records.push({ id: node.id, deps: new Set(node.deps), priority: node.priority });\n }\n\n const byId = new Map();\n for (const record of records) {\n if (byId.has(record.id)) {\n return { ok: false, error: 'duplicate-id' };\n }\n byId.set(record.id, record);\n }\n for (const record of records) {\n for (const dependency of record.deps) {\n if (!byId.has(dependency)) {\n return { ok: false, error: 'unknown-dependency' };\n }\n }\n }\n\n const remaining = new Map();\n const dependents = new Map();\n for (const record of records) {\n remaining.set(record.id, record.deps.size);\n dependents.set(record.id, []);\n }\n for (const record of records) {\n for (const dependency of record.deps) {\n dependents.get(dependency).push(record);\n }\n }\n\n const ready = records.filter(record => record.deps.size === 0);\n const result = [];\n let completed = 0;\n while (completed < records.length) {\n if (ready.length === 0) {\n return { ok: false, error: 'cycle' };\n }\n ready.sort((a, b) => {\n if (a.priority !== b.priority) {\n return a.priority > b.priority ? -1 : 1;\n }\n return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;\n });\n const wave = ready.splice(0, concurrency);\n result.push(wave.map(record => record.id));\n completed += wave.length;\n\n // Only release dependents after the entire wave has been selected.\n for (const record of wave) {\n for (const dependent of dependents.get(record.id)) {\n const count = remaining.get(dependent.id) - 1;\n remaining.set(dependent.id, count);\n if (count === 0) ready.push(dependent);\n }\n }\n }\n return { ok: true, result };\n};\n" }, { "taskId": "dependency-waves", "arm": "baseline", "repetition": 2, "sourceHash": "0e4ab6a96f9eda3c1f3952b5a71d2aed7148471b522db827f10d15b7fc415acf", "submittedSource": "exports.solve = function solve(nodes, concurrency) {\n const fail = (error) => ({ ok: false, error });\n if (!Array.isArray(nodes) || !Number.isSafeInteger(concurrency) ||\n concurrency < 1 || concurrency > 3) {\n return fail('invalid-input');\n }\n\n // Validate every node before checking any graph-level errors.\n const tasks = [];\n for (const node of nodes) {\n if (node === null || typeof node !== 'object' || Array.isArray(node) ||\n typeof node.id !== 'string' || node.id.length === 0 ||\n !Array.isArray(node.deps) || !Number.isSafeInteger(node.priority)) {\n return fail('invalid-input');\n }\n const deps = new Set();\n for (const dep of node.deps) {\n if (typeof dep !== 'string' || dep.length === 0) {\n return fail('invalid-input');\n }\n deps.add(dep);\n }\n tasks.push({ id: node.id, priority: node.priority, deps,\n remaining: deps.size, dependents: [] });\n }\n\n const byId = new Map();\n for (const task of tasks) {\n if (byId.has(task.id)) return fail('duplicate-id');\n byId.set(task.id, task);\n }\n for (const task of tasks) {\n for (const dep of task.deps) {\n if (!byId.has(dep)) return fail('unknown-dependency');\n byId.get(dep).dependents.push(task);\n }\n }\n\n const eligible = tasks.filter((task) => task.remaining === 0);\n const waves = [];\n let completed = 0;\n while (eligible.length > 0) {\n eligible.sort((a, b) => {\n if (a.priority !== b.priority) return a.priority > b.priority ? -1 : 1;\n return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;\n });\n const wave = eligible.splice(0, concurrency);\n waves.push(wave.map((task) => task.id));\n completed += wave.length;\n\n // Only release dependents after selecting the entire wave.\n for (const task of wave) {\n for (const dependent of task.dependents) {\n dependent.remaining -= 1;\n if (dependent.remaining === 0) eligible.push(dependent);\n }\n }\n }\n if (completed !== tasks.length) return fail('cycle');\n return { ok: true, result: waves };\n};\n" }, { "taskId": "path-scope", "arm": "baseline", "repetition": 1, "sourceHash": "28ffb7498aca0922977f43bc80314f8ac2999c499fe93f798432cfeecf75b9fe", "submittedSource": "function canonicalize(path) {\n if (typeof path !== 'string' || !path.startsWith('/') ||\n /[\\\\\\x00-\\x1f\\x7f]/.test(path)) {\n return null;\n }\n\n const segments = path.split('/');\n const normalized = [];\n for (const segment of segments) {\n if (segment === '..') return null;\n if (segment !== '' && segment !== '.') normalized.push(segment);\n }\n return '/' + normalized.join('/');\n}\n\nexports.solve = function solve(paths, roots) {\n if (!Array.isArray(paths) || !Array.isArray(roots)) {\n return { ok: false, error: 'invalid-input' };\n }\n\n const canonicalRoots = [];\n for (let index = 0; index < roots.length; index++) {\n const root = canonicalize(roots[index]);\n if (root === null) return { ok: false, error: 'invalid-input' };\n canonicalRoots.push(root);\n }\n\n const result = [];\n for (let index = 0; index < paths.length; index++) {\n const canonical = canonicalize(paths[index]);\n let allowed = false;\n if (canonical !== null) {\n for (const root of canonicalRoots) {\n if (root === '/' || canonical === root || canonical.startsWith(root + '/')) {\n allowed = true;\n break;\n }\n }\n }\n result.push({ index, canonical, allowed });\n }\n return { ok: true, result };\n};\n" }, { "taskId": "path-scope", "arm": "treatment", "repetition": 1, "sourceHash": "a4e20d1a85b47fab1f0cb7708efc8b2fe2506fa08d1a1de8612f811d70f3f2dd", "submittedSource": "function canonicalize(path) {\n if (typeof path !== 'string' || !path.startsWith('/') ||\n /[\\\\\\x00-\\x1f\\x7f]/.test(path)) {\n return null;\n }\n\n const segments = path.split('/');\n const normalized = [];\n for (const segment of segments) {\n if (segment === '..') return null;\n if (segment !== '' && segment !== '.') normalized.push(segment);\n }\n return '/' + normalized.join('/');\n}\n\nexports.solve = function solve(paths, roots) {\n if (!Array.isArray(paths) || !Array.isArray(roots)) {\n return { ok: false, error: 'invalid-input' };\n }\n\n const normalizedRoots = [];\n for (let index = 0; index < roots.length; index += 1) {\n const root = canonicalize(roots[index]);\n if (root === null) return { ok: false, error: 'invalid-input' };\n normalizedRoots.push(root);\n }\n\n const result = [];\n for (let index = 0; index < paths.length; index += 1) {\n const canonical = canonicalize(paths[index]);\n const allowed = canonical !== null && normalizedRoots.some(root =>\n root === '/' || canonical === root || canonical.startsWith(root + '/')\n );\n result.push({ index, canonical, allowed });\n }\n return { ok: true, result };\n};\n" }, { "taskId": "path-scope", "arm": "treatment", "repetition": 2, "sourceHash": "aebdf36c2761fae4780d9b201499192ce24154ec055207e5a46e28d1676e6991", "submittedSource": "function normalizePath(path) {\n if (typeof path !== \"string\" || !path.startsWith(\"/\") ||\n /[\\\\\\u0000-\\u001F\\u007F]/.test(path)) {\n return null;\n }\n\n const segments = path.split(\"/\");\n if (segments.includes(\"..\")) return null;\n\n return \"/\" + segments.filter(segment => segment !== \"\" && segment !== \".\").join(\"/\");\n}\n\nexports.solve = function solve(paths, roots) {\n if (!Array.isArray(paths) || !Array.isArray(roots)) {\n return { ok: false, error: \"invalid-input\" };\n }\n\n const normalizedRoots = [];\n for (let index = 0; index < roots.length; index += 1) {\n const root = normalizePath(roots[index]);\n if (root === null) return { ok: false, error: \"invalid-input\" };\n normalizedRoots.push(root);\n }\n\n const result = [];\n for (let index = 0; index < paths.length; index += 1) {\n const canonical = normalizePath(paths[index]);\n const allowed = canonical !== null && normalizedRoots.some(root =>\n root === \"/\" || canonical === root || canonical.startsWith(root + \"/\")\n );\n result.push({ index, canonical, allowed });\n }\n return { ok: true, result };\n};\n" }, { "taskId": "path-scope", "arm": "baseline", "repetition": 2, "sourceHash": "f73de7e420a8320044e2cefcf205d09217ee1c03434e1dc744fe691f4baa2ffc", "submittedSource": "function canonicalize(path) {\n if (typeof path !== 'string' || !path.startsWith('/') ||\n /[\\\\\\x00-\\x1f\\x7f]/.test(path)) {\n return null;\n }\n\n const segments = path.split('/');\n const normalized = [];\n for (const segment of segments) {\n if (segment === '..') return null;\n if (segment !== '' && segment !== '.') normalized.push(segment);\n }\n return '/' + normalized.join('/');\n}\n\nexports.solve = function solve(paths, roots) {\n if (!Array.isArray(paths) || !Array.isArray(roots)) {\n return {ok: false, error: 'invalid-input'};\n }\n\n const normalizedRoots = [];\n for (let index = 0; index < roots.length; index++) {\n const root = canonicalize(roots[index]);\n if (root === null) return {ok: false, error: 'invalid-input'};\n normalizedRoots.push(root);\n }\n\n const result = [];\n for (let index = 0; index < paths.length; index++) {\n const canonical = canonicalize(paths[index]);\n const allowed = canonical !== null && normalizedRoots.some(root =>\n root === '/' || canonical === root || canonical.startsWith(root + '/')\n );\n result.push({index, canonical, allowed});\n }\n return {ok: true, result};\n};\n" }, { "taskId": "atomic-edits", "arm": "treatment", "repetition": 1, "sourceHash": "24b79050b0ffbc01be7374834a1d98f53ddbd3b040f6bed56c7d3f189bb5b468", "submittedSource": "'use strict';\n\nexports.solve = function solve(source, edits) {\n if (typeof source !== 'string' || !Array.isArray(edits)) {\n return { ok: false, error: 'invalid-input' };\n }\n\n function splitsSurrogatePair(offset) {\n if (offset === 0 || offset === source.length) return false;\n const left = source.charCodeAt(offset - 1);\n const right = source.charCodeAt(offset);\n return left >= 0xd800 && left <= 0xdbff && right >= 0xdc00 && right <= 0xdfff;\n }\n\n const validated = [];\n for (let index = 0; index < edits.length; index += 1) {\n const edit = edits[index];\n if (edit === null || typeof edit !== 'object' || Array.isArray(edit)) {\n return { ok: false, error: 'invalid-input' };\n }\n const { start, end, text, expected } = edit;\n if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) ||\n start < 0 || start > end || end > source.length ||\n typeof text !== 'string' || typeof expected !== 'string' ||\n splitsSurrogatePair(start) || splitsSurrogatePair(end)) {\n return { ok: false, error: 'invalid-input' };\n }\n validated.push({ start, end, text, expected, index });\n }\n\n for (const edit of validated) {\n if (source.slice(edit.start, edit.end) !== edit.expected) {\n return { ok: false, error: 'stale-edit' };\n }\n }\n\n // At a shared offset, insertions precede the replacement beginning there.\n validated.sort((a, b) => a.start - b.start ||\n Number(a.start !== a.end) - Number(b.start !== b.end) || a.index - b.index);\n\n let previousReplacement = null;\n for (const edit of validated) {\n if (previousReplacement !== null && edit.start < previousReplacement.end) {\n return { ok: false, error: 'overlap' };\n }\n if (edit.start !== edit.end) previousReplacement = edit;\n }\n\n const pieces = [];\n let cursor = 0;\n for (const edit of validated) {\n pieces.push(source.slice(cursor, edit.start), edit.text);\n cursor = edit.end;\n }\n pieces.push(source.slice(cursor));\n return { ok: true, result: pieces.join('') };\n};\n" }, { "taskId": "atomic-edits", "arm": "baseline", "repetition": 1, "sourceHash": "e2a9332b5a3a4ec6506494db6e7462f581932f62b1b7c43b0003274c2231b35f", "submittedSource": "exports.solve = function solve(source, edits) {\n if (typeof source !== 'string' || !Array.isArray(edits)) {\n return {ok: false, error: 'invalid-input'};\n }\n\n function splitsSurrogatePair(offset) {\n if (offset === 0 || offset === source.length) return false;\n const before = source.charCodeAt(offset - 1);\n const after = source.charCodeAt(offset);\n return before >= 0xD800 && before <= 0xDBFF &&\n after >= 0xDC00 && after <= 0xDFFF;\n }\n\n const validated = [];\n for (let index = 0; index < edits.length; index++) {\n const edit = edits[index];\n if (edit === null || typeof edit !== 'object' || Array.isArray(edit)) {\n return {ok: false, error: 'invalid-input'};\n }\n const {start, end, text, expected} = edit;\n if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) ||\n start < 0 || start > end || end > source.length ||\n typeof text !== 'string' || typeof expected !== 'string' ||\n splitsSurrogatePair(start) || splitsSurrogatePair(end)) {\n return {ok: false, error: 'invalid-input'};\n }\n validated.push({start, end, text, expected, index});\n }\n\n for (const edit of validated) {\n if (edit.expected !== source.slice(edit.start, edit.end)) {\n return {ok: false, error: 'stale-edit'};\n }\n }\n\n // Insertions sort before a replacement at the same start, in input order.\n validated.sort((a, b) => a.start - b.start || a.end - b.end || a.index - b.index);\n let replacementEnd = 0;\n for (const edit of validated) {\n if (edit.start < replacementEnd) {\n return {ok: false, error: 'overlap'};\n }\n if (edit.start !== edit.end) replacementEnd = edit.end;\n }\n\n const pieces = [];\n let cursor = 0;\n for (const edit of validated) {\n pieces.push(source.slice(cursor, edit.start), edit.text);\n cursor = edit.end;\n }\n pieces.push(source.slice(cursor));\n return {ok: true, result: pieces.join('')};\n};\n" }, { "taskId": "atomic-edits", "arm": "baseline", "repetition": 2, "sourceHash": "27100198df010686f961ee25b0bc7dc9f3377613ebe4ae046d88acbec147c641", "submittedSource": "exports.solve = function solve(source, edits) {\n if (typeof source !== \"string\" || !Array.isArray(edits)) {\n return { ok: false, error: \"invalid-input\" };\n }\n\n // Offsets are UTF-16 code units, but may not divide a surrogate pair.\n function splitsPair(offset) {\n if (offset === 0 || offset === source.length) return false;\n const before = source.charCodeAt(offset - 1);\n const after = source.charCodeAt(offset);\n return before >= 0xd800 && before <= 0xdbff &&\n after >= 0xdc00 && after <= 0xdfff;\n }\n\n const ordered = [];\n for (let index = 0; index < edits.length; index += 1) {\n const edit = edits[index];\n if (edit === null || typeof edit !== \"object\" || Array.isArray(edit)) {\n return { ok: false, error: \"invalid-input\" };\n }\n const { start, end, text, expected } = edit;\n if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) ||\n start < 0 || start > end || end > source.length ||\n typeof text !== \"string\" || typeof expected !== \"string\" ||\n splitsPair(start) || splitsPair(end)) {\n return { ok: false, error: \"invalid-input\" };\n }\n ordered.push({ start, end, text, expected, index });\n }\n\n for (const edit of ordered) {\n if (edit.expected !== source.slice(edit.start, edit.end)) {\n return { ok: false, error: \"stale-edit\" };\n }\n }\n\n // Insertions precede replacements at the same start. The input index\n // breaks ties so multiple insertions at one offset preserve their order.\n ordered.sort((a, b) => a.start - b.start || a.end - b.end || a.index - b.index);\n let replacementEnd = -1;\n for (const edit of ordered) {\n if (edit.start < replacementEnd) {\n return { ok: false, error: \"overlap\" };\n }\n if (edit.start < edit.end) replacementEnd = edit.end;\n }\n\n // Application starts only after every validation phase has succeeded.\n const pieces = [];\n let cursor = 0;\n for (const edit of ordered) {\n pieces.push(source.slice(cursor, edit.start), edit.text);\n cursor = edit.end;\n }\n pieces.push(source.slice(cursor));\n return { ok: true, result: pieces.join(\"\") };\n};\n" }, { "taskId": "atomic-edits", "arm": "treatment", "repetition": 2, "sourceHash": "323969d3067c542c06a69b2f9992fb6a0713057efdb86f6cb3564a196f51ba0e", "submittedSource": "exports.solve = function solve(source, edits) {\n const invalid = () => ({ ok: false, error: 'invalid-input' });\n if (typeof source !== 'string' || !Array.isArray(edits)) return invalid();\n\n // Offsets are UTF-16 units, but an edit must keep each surrogate pair whole.\n const splitsPair = (offset) => {\n if (offset === 0 || offset === source.length) return false;\n const before = source.charCodeAt(offset - 1);\n const after = source.charCodeAt(offset);\n return before >= 0xd800 && before <= 0xdbff &&\n after >= 0xdc00 && after <= 0xdfff;\n };\n\n const validated = [];\n for (let index = 0; index < edits.length; index += 1) {\n const edit = edits[index];\n if (edit === null || typeof edit !== 'object' || Array.isArray(edit)) {\n return invalid();\n }\n const { start, end, text, expected } = edit;\n if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) ||\n start < 0 || start > end || end > source.length ||\n typeof text !== 'string' || typeof expected !== 'string' ||\n splitsPair(start) || splitsPair(end)) {\n return invalid();\n }\n validated.push({ start, end, text, expected, index });\n }\n\n // Every edit is validated before checking expectations or conflicts.\n for (const edit of validated) {\n if (source.slice(edit.start, edit.end) !== edit.expected) {\n return { ok: false, error: 'stale-edit' };\n }\n }\n\n validated.sort((left, right) => {\n if (left.start !== right.start) return left.start - right.start;\n const leftInsertion = left.start === left.end;\n const rightInsertion = right.start === right.end;\n if (leftInsertion !== rightInsertion) return leftInsertion ? -1 : 1;\n return left.index - right.index;\n });\n\n let replacementEnd = 0;\n for (const edit of validated) {\n if (edit.start < replacementEnd) return { ok: false, error: 'overlap' };\n if (edit.start !== edit.end) replacementEnd = edit.end;\n }\n\n const pieces = [];\n let cursor = 0;\n for (const edit of validated) {\n pieces.push(source.slice(cursor, edit.start), edit.text);\n cursor = edit.end;\n }\n pieces.push(source.slice(cursor));\n return { ok: true, result: pieces.join('') };\n};\n" }, { "taskId": "reservation-replay", "arm": "baseline", "repetition": 1, "sourceHash": "79c0fc1f1190e219c1d994cd1fc9f5acf2d6bc6022e512af3f5dcb0d4615afaf", "submittedSource": "const isObject = value =>\n value !== null && typeof value === 'object' && !Array.isArray(value);\nconst isNonemptyString = value => typeof value === 'string' && value.length > 0;\n\nexports.solve = function solve(initial, requests, limit) {\n if (!Array.isArray(initial) || !Array.isArray(requests) ||\n !Number.isSafeInteger(limit) || limit < 0 || limit > 9) {\n return {ok: false, error: 'invalid-input'};\n }\n\n const records = [];\n const ledger = new Map();\n let admittedCount = 0;\n\n for (const record of initial) {\n if (!isObject(record) || !isNonemptyString(record.id) ||\n !isNonemptyString(record.fingerprint) ||\n (record.status !== 'admitted' && record.status !== 'denied') ||\n ledger.has(record.id)) {\n return {ok: false, error: 'invalid-input'};\n }\n const retained = {\n id: record.id,\n fingerprint: record.fingerprint,\n status: record.status\n };\n records.push(retained);\n ledger.set(retained.id, retained);\n if (retained.status === 'admitted') admittedCount++;\n }\n\n if (admittedCount > limit) return {ok: false, error: 'invalid-input'};\n\n const events = [];\n for (let index = 0; index < requests.length; index++) {\n const request = requests[index];\n if (!isObject(request) || !isNonemptyString(request.id) ||\n !isNonemptyString(request.fingerprint)) {\n events.push({index, id: null, status: 'invalid', decision: null});\n continue;\n }\n\n const {id, fingerprint} = request;\n const retained = ledger.get(id);\n if (retained) {\n const recovered = retained.fingerprint === fingerprint;\n events.push({\n index,\n id,\n status: recovered ? 'recovered' : 'conflict',\n decision: recovered ? retained.status : null\n });\n continue;\n }\n\n const decision = admittedCount < limit ? 'admitted' : 'denied';\n const record = {id, fingerprint, status: decision};\n records.push(record);\n ledger.set(id, record);\n if (decision === 'admitted') admittedCount++;\n events.push({index, id, status: 'created', decision});\n }\n\n return {ok: true, result: {records, admittedCount, events}};\n};\n" }, { "taskId": "reservation-replay", "arm": "treatment", "repetition": 1, "sourceHash": "fffff4a08b555ce937e4dd73ffaa5170952b3b0300cefaedc35904800c21e6d6", "submittedSource": "exports.solve = function solve(initial, requests, limit) {\n const isObject = value => value !== null && typeof value === 'object' && !Array.isArray(value);\n const isNonemptyString = value => typeof value === 'string' && value.length > 0;\n const hasOwn = (object, key) => Object.prototype.hasOwnProperty.call(object, key);\n const invalidInput = () => ({ ok: false, error: 'invalid-input' });\n\n if (!Array.isArray(initial) || !Array.isArray(requests) ||\n !Number.isSafeInteger(limit) || limit < 0 || limit > 9) {\n return invalidInput();\n }\n\n const records = [];\n const ledger = new Map();\n let admittedCount = 0;\n\n for (let index = 0; index < initial.length; index += 1) {\n if (!hasOwn(initial, index)) return invalidInput();\n const entry = initial[index];\n if (!isObject(entry) || !isNonemptyString(entry.id) ||\n !isNonemptyString(entry.fingerprint) ||\n (entry.status !== 'admitted' && entry.status !== 'denied') ||\n ledger.has(entry.id)) {\n return invalidInput();\n }\n const record = { id: entry.id, fingerprint: entry.fingerprint, status: entry.status };\n records.push(record);\n ledger.set(record.id, record);\n if (record.status === 'admitted') admittedCount += 1;\n if (admittedCount > limit) return invalidInput();\n }\n\n const events = [];\n for (let index = 0; index < requests.length; index += 1) {\n const request = hasOwn(requests, index) ? requests[index] : undefined;\n if (!isObject(request) || !isNonemptyString(request.id) ||\n !isNonemptyString(request.fingerprint)) {\n events.push({ index, id: null, status: 'invalid', decision: null });\n continue;\n }\n\n const { id, fingerprint } = request;\n const retained = ledger.get(id);\n if (retained !== undefined) {\n const identical = retained.fingerprint === fingerprint;\n events.push({ index, id, status: identical ? 'recovered' : 'conflict',\n decision: identical ? retained.status : null });\n continue;\n }\n\n const decision = admittedCount < limit ? 'admitted' : 'denied';\n const record = { id, fingerprint, status: decision };\n ledger.set(id, record);\n records.push(record);\n if (decision === 'admitted') admittedCount += 1;\n events.push({ index, id, status: 'created', decision });\n }\n\n return { ok: true, result: { records, admittedCount, events } };\n};\n" }, { "taskId": "reservation-replay", "arm": "treatment", "repetition": 2, "sourceHash": "529d38a69238b91e4a4e649174caedf2408f0b627d524323be89a91ed229e412", "submittedSource": "const isObject = value => value !== null && typeof value === 'object' && !Array.isArray(value);\nconst isNonemptyString = value => typeof value === 'string' && value.length > 0;\n\nexports.solve = (initial, requests, limit) => {\n const invalidInput = () => ({ ok: false, error: 'invalid-input' });\n if (!Array.isArray(initial) || !Array.isArray(requests) ||\n !Number.isSafeInteger(limit) || limit < 0 || limit > 9) {\n return invalidInput();\n }\n\n const records = [];\n const ledger = new Map();\n let admittedCount = 0;\n\n for (const record of initial) {\n if (!isObject(record) || !isNonemptyString(record.id) ||\n !isNonemptyString(record.fingerprint) ||\n (record.status !== 'admitted' && record.status !== 'denied') ||\n ledger.has(record.id)) {\n return invalidInput();\n }\n const retained = { id: record.id, fingerprint: record.fingerprint, status: record.status };\n records.push(retained);\n ledger.set(retained.id, retained);\n if (retained.status === 'admitted') admittedCount += 1;\n }\n if (admittedCount > limit) return invalidInput();\n\n const events = [];\n for (let index = 0; index < requests.length; index += 1) {\n const request = requests[index];\n if (!isObject(request) || !isNonemptyString(request.id) ||\n !isNonemptyString(request.fingerprint)) {\n events.push({ index, id: null, status: 'invalid', decision: null });\n continue;\n }\n\n const id = request.id;\n const fingerprint = request.fingerprint;\n const retained = ledger.get(id);\n if (retained !== undefined) {\n if (retained.fingerprint === fingerprint) {\n events.push({ index, id, status: 'recovered', decision: retained.status });\n } else {\n events.push({ index, id, status: 'conflict', decision: null });\n }\n continue;\n }\n\n const decision = admittedCount < limit ? 'admitted' : 'denied';\n const record = { id, fingerprint, status: decision };\n records.push(record);\n ledger.set(id, record);\n if (decision === 'admitted') admittedCount += 1;\n events.push({ index, id, status: 'created', decision });\n }\n\n return { ok: true, result: { records, admittedCount, events } };\n};\n" }, { "taskId": "reservation-replay", "arm": "baseline", "repetition": 2, "sourceHash": "f040e56d5f711ad87f6405d4d27cecacc07f0c61a939ee242f2023d3b197d928", "submittedSource": "exports.solve = function solve(initial, requests, limit) {\n const isObject = value => value !== null && typeof value === \"object\" && !Array.isArray(value);\n const isNonemptyString = value => typeof value === \"string\" && value.length > 0;\n const invalidInput = () => ({ ok: false, error: \"invalid-input\" });\n\n if (!Array.isArray(initial) || !Array.isArray(requests) ||\n !Number.isSafeInteger(limit) || limit < 0 || limit > 9) {\n return invalidInput();\n }\n\n const ledger = new Map();\n const records = [];\n let admittedCount = 0;\n\n for (let index = 0; index < initial.length; index++) {\n if (!Object.prototype.hasOwnProperty.call(initial, index)) return invalidInput();\n const record = initial[index];\n if (!isObject(record) || !isNonemptyString(record.id) ||\n !isNonemptyString(record.fingerprint) ||\n (record.status !== \"admitted\" && record.status !== \"denied\") ||\n ledger.has(record.id)) {\n return invalidInput();\n }\n const retained = { id: record.id, fingerprint: record.fingerprint, status: record.status };\n ledger.set(retained.id, retained);\n records.push(retained);\n if (retained.status === \"admitted\") admittedCount++;\n }\n if (admittedCount > limit) return invalidInput();\n\n const events = [];\n for (let index = 0; index < requests.length; index++) {\n const request = Object.prototype.hasOwnProperty.call(requests, index) ? requests[index] : undefined;\n if (!isObject(request) || !isNonemptyString(request.id) || !isNonemptyString(request.fingerprint)) {\n events.push({ index, id: null, status: \"invalid\", decision: null });\n continue;\n }\n\n const id = request.id;\n const fingerprint = request.fingerprint;\n const retained = ledger.get(id);\n if (retained) {\n if (retained.fingerprint === fingerprint) {\n events.push({ index, id, status: \"recovered\", decision: retained.status });\n } else {\n events.push({ index, id, status: \"conflict\", decision: null });\n }\n continue;\n }\n\n const decision = admittedCount < limit ? \"admitted\" : \"denied\";\n const record = { id, fingerprint, status: decision };\n ledger.set(id, record);\n records.push(record);\n if (decision === \"admitted\") admittedCount++;\n events.push({ index, id, status: \"created\", decision });\n }\n\n return { ok: true, result: { records, admittedCount, events } };\n};\n" }, { "taskId": "response-ledger", "arm": "baseline", "repetition": 1, "sourceHash": "8240c276ab123f97540a2ecf5f21ccd19831914c329d297b4c38c453747603f8", "submittedSource": "exports.solve = function solve(records, rootId, rootTurnId) {\n const fail = (error) => ({ ok: false, error });\n const isObject = (value) =>\n value !== null && typeof value === \"object\" && !Array.isArray(value);\n const isId = (value) => typeof value === \"string\" && value.length > 0;\n const counters = [\n \"input_tokens\",\n \"cached_input_tokens\",\n \"cache_write_input_tokens\",\n \"output_tokens\",\n \"reasoning_output_tokens\",\n \"total_tokens\",\n ];\n const zeroUsage = () => ({\n input_tokens: 0,\n cached_input_tokens: 0,\n cache_write_input_tokens: 0,\n output_tokens: 0,\n reasoning_output_tokens: 0,\n total_tokens: 0,\n });\n\n if (!Array.isArray(records) || !isId(rootId) || !isId(rootTurnId)) {\n return fail(\"invalid-input\");\n }\n\n // Validate ownership and owned IDs everywhere before inspecting usage.\n const owned = [];\n for (const record of records) {\n if (!isObject(record) || !isId(record.sessionId) || !isId(record.rootTurnId)) {\n return fail(\"invalid-input\");\n }\n if (record.sessionId !== rootId || record.rootTurnId !== rootTurnId) continue;\n if (!isId(record.threadId) || !isId(record.responseId)) {\n return fail(\"invalid-input\");\n }\n owned.push(record);\n }\n\n const validated = [];\n for (const record of owned) {\n if (!isObject(record.usage)) return fail(\"invalid-usage\");\n const usage = zeroUsage();\n for (const counter of counters) {\n const value = record.usage[counter];\n if (!Number.isSafeInteger(value) || value < 0) return fail(\"invalid-usage\");\n usage[counter] = value;\n }\n if (\n usage.total_tokens !== usage.input_tokens + usage.output_tokens ||\n usage.cached_input_tokens > usage.input_tokens ||\n usage.cache_write_input_tokens > usage.input_tokens ||\n usage.reasoning_output_tokens > usage.output_tokens\n ) {\n return fail(\"invalid-usage\");\n }\n validated.push({ threadId: record.threadId, responseId: record.responseId, usage });\n }\n\n // Resolve all conflicts before aggregation can report overflow.\n const responses = new Map();\n for (const record of validated) {\n const previous = responses.get(record.responseId);\n if (previous) {\n if (\n previous.threadId !== record.threadId ||\n counters.some((counter) => previous.usage[counter] !== record.usage[counter])\n ) {\n return fail(\"conflicting-response\");\n }\n } else {\n responses.set(record.responseId, record);\n }\n }\n\n const usage = zeroUsage();\n const byThread = new Map();\n for (const record of responses.values()) {\n let threadUsage = byThread.get(record.threadId);\n if (!threadUsage) {\n threadUsage = zeroUsage();\n byThread.set(record.threadId, threadUsage);\n }\n for (const counter of counters) {\n const total = usage[counter] + record.usage[counter];\n const threadTotal = threadUsage[counter] + record.usage[counter];\n if (!Number.isSafeInteger(total) || !Number.isSafeInteger(threadTotal)) {\n return fail(\"invalid-usage\");\n }\n usage[counter] = total;\n threadUsage[counter] = threadTotal;\n }\n }\n\n if (responses.size > 0 && !byThread.has(rootId)) return fail(\"missing-root\");\n\n const threads = Array.from(byThread.keys())\n .sort()\n .map((id) => ({ id, usage: byThread.get(id) }));\n return { ok: true, result: { usage, threads, responseCount: responses.size } };\n};\n" }, { "taskId": "response-ledger", "arm": "treatment", "repetition": 1, "sourceHash": "30ef6145f0859a2dfdaf580d8011e6b312404ad2b68fc6c353f21cd603de2972", "submittedSource": "const COUNTERS = [\n \"input_tokens\",\n \"cached_input_tokens\",\n \"cache_write_input_tokens\",\n \"output_tokens\",\n \"reasoning_output_tokens\",\n \"total_tokens\",\n];\n\nconst isObject = (value) =>\n value !== null && typeof value === \"object\" && !Array.isArray(value);\nconst isId = (value) => typeof value === \"string\" && value.length > 0;\nconst zeroUsage = () => Object.fromEntries(COUNTERS.map((key) => [key, 0]));\nconst failure = (error) => ({ ok: false, error });\n\nexports.solve = (records, rootId, rootTurnId) => {\n if (!Array.isArray(records) || !isId(rootId) || !isId(rootTurnId)) {\n return failure(\"invalid-input\");\n }\n\n // Complete structural validation before inspecting any owned usage.\n const owned = [];\n for (const record of records) {\n if (!isObject(record) || !isId(record.sessionId) || !isId(record.rootTurnId)) {\n return failure(\"invalid-input\");\n }\n if (record.sessionId !== rootId || record.rootTurnId !== rootTurnId) continue;\n if (!isId(record.threadId) || !isId(record.responseId)) {\n return failure(\"invalid-input\");\n }\n owned.push(record);\n }\n\n for (const record of owned) {\n const usage = record.usage;\n if (!isObject(usage)) return failure(\"invalid-usage\");\n for (const key of COUNTERS) {\n if (!Number.isSafeInteger(usage[key]) || usage[key] < 0) {\n return failure(\"invalid-usage\");\n }\n }\n if (\n usage.total_tokens !== usage.input_tokens + usage.output_tokens ||\n usage.cached_input_tokens > usage.input_tokens ||\n usage.cache_write_input_tokens > usage.input_tokens ||\n usage.reasoning_output_tokens > usage.output_tokens\n ) {\n return failure(\"invalid-usage\");\n }\n }\n\n // Maps make every response and thread ID an ordinary string key.\n const responses = new Map();\n for (const record of owned) {\n const previous = responses.get(record.responseId);\n if (previous) {\n if (\n previous.threadId !== record.threadId ||\n COUNTERS.some((key) => previous.usage[key] !== record.usage[key])\n ) {\n return failure(\"conflicting-response\");\n }\n } else {\n responses.set(record.responseId, record);\n }\n }\n\n const usage = zeroUsage();\n const threadUsage = new Map();\n for (const record of responses.values()) {\n let thread = threadUsage.get(record.threadId);\n if (!thread) {\n thread = zeroUsage();\n threadUsage.set(record.threadId, thread);\n }\n for (const key of COUNTERS) {\n const globalSum = usage[key] + record.usage[key];\n const threadSum = thread[key] + record.usage[key];\n if (!Number.isSafeInteger(globalSum) || !Number.isSafeInteger(threadSum)) {\n return failure(\"invalid-usage\");\n }\n usage[key] = globalSum;\n thread[key] = threadSum;\n }\n }\n\n if (responses.size > 0 && !threadUsage.has(rootId)) {\n return failure(\"missing-root\");\n }\n\n const threads = Array.from(threadUsage, ([id, usage]) => ({ id, usage }));\n threads.sort((left, right) => (left.id < right.id ? -1 : left.id > right.id ? 1 : 0));\n return { ok: true, result: { usage, threads, responseCount: responses.size } };\n};\n" }, { "taskId": "response-ledger", "arm": "treatment", "repetition": 2, "sourceHash": "1239e2248ea0765ff607c878796ed83a23c0e49f2237f5d2558d05b28c925e7d", "submittedSource": "const COUNTERS = [\n 'input_tokens',\n 'cached_input_tokens',\n 'cache_write_input_tokens',\n 'output_tokens',\n 'reasoning_output_tokens',\n 'total_tokens',\n];\n\nconst isObject = value => value !== null && typeof value === 'object' && !Array.isArray(value);\nconst isId = value => typeof value === 'string' && value.length > 0;\nconst failure = error => ({ ok: false, error });\nconst zeroUsage = () => Object.fromEntries(COUNTERS.map(counter => [counter, 0]));\n\nexports.solve = function solve(records, rootId, rootTurnId) {\n if (!Array.isArray(records) || !isId(rootId) || !isId(rootTurnId)) {\n return failure('invalid-input');\n }\n\n // Complete identity validation before looking at any owned usage.\n const owned = [];\n for (const record of records) {\n if (!isObject(record) || !isId(record.sessionId) || !isId(record.rootTurnId)) {\n return failure('invalid-input');\n }\n if (record.sessionId !== rootId || record.rootTurnId !== rootTurnId) continue;\n if (!isId(record.threadId) || !isId(record.responseId)) {\n return failure('invalid-input');\n }\n owned.push(record);\n }\n\n const validated = [];\n for (const record of owned) {\n if (!isObject(record.usage)) return failure('invalid-usage');\n const usage = {};\n for (const counter of COUNTERS) {\n const value = record.usage[counter];\n if (!Number.isSafeInteger(value) || value < 0) return failure('invalid-usage');\n usage[counter] = value;\n }\n if (\n usage.total_tokens !== usage.input_tokens + usage.output_tokens ||\n usage.cached_input_tokens > usage.input_tokens ||\n usage.cache_write_input_tokens > usage.input_tokens ||\n usage.reasoning_output_tokens > usage.output_tokens\n ) {\n return failure('invalid-usage');\n }\n validated.push({ threadId: record.threadId, responseId: record.responseId, usage });\n }\n\n // IDs are map keys, including names that also occur on Object.prototype.\n const responses = new Map();\n for (const record of validated) {\n const prior = responses.get(record.responseId);\n if (prior) {\n if (\n prior.threadId !== record.threadId ||\n COUNTERS.some(counter => prior.usage[counter] !== record.usage[counter])\n ) {\n return failure('conflicting-response');\n }\n } else {\n responses.set(record.responseId, record);\n }\n }\n\n const usage = zeroUsage();\n const threads = new Map();\n for (const record of responses.values()) {\n let threadUsage = threads.get(record.threadId);\n if (!threadUsage) {\n threadUsage = zeroUsage();\n threads.set(record.threadId, threadUsage);\n }\n for (const counter of COUNTERS) {\n const aggregate = usage[counter] + record.usage[counter];\n const threadAggregate = threadUsage[counter] + record.usage[counter];\n if (!Number.isSafeInteger(aggregate) || !Number.isSafeInteger(threadAggregate)) {\n return failure('invalid-usage');\n }\n usage[counter] = aggregate;\n threadUsage[counter] = threadAggregate;\n }\n }\n\n if (responses.size > 0 && !threads.has(rootId)) return failure('missing-root');\n return {\n ok: true,\n result: {\n usage,\n threads: Array.from(threads.keys()).sort().map(id => ({ id, usage: threads.get(id) })),\n responseCount: responses.size,\n },\n };\n};\n" }, { "taskId": "response-ledger", "arm": "baseline", "repetition": 2, "sourceHash": "5bd297e661baeaa526e02d22a2b6258dd94bc3e285873553cdd9ae42d9ff7c6e", "submittedSource": "const counters = [\n 'input_tokens',\n 'cached_input_tokens',\n 'cache_write_input_tokens',\n 'output_tokens',\n 'reasoning_output_tokens',\n 'total_tokens',\n];\n\nconst isObject = value => value !== null && typeof value === 'object' && !Array.isArray(value);\nconst isId = value => typeof value === 'string' && value.length > 0;\nconst failure = error => ({ ok: false, error });\nconst zeroUsage = () => ({\n input_tokens: 0,\n cached_input_tokens: 0,\n cache_write_input_tokens: 0,\n output_tokens: 0,\n reasoning_output_tokens: 0,\n total_tokens: 0,\n});\n\nexports.solve = function solve(records, rootId, rootTurnId) {\n if (!Array.isArray(records) || !isId(rootId) || !isId(rootTurnId)) {\n return failure('invalid-input');\n }\n\n // Check every ownership and owned-ID field before inspecting any usage.\n const owned = [];\n for (const record of records) {\n if (!isObject(record) || !isId(record.sessionId) || !isId(record.rootTurnId)) {\n return failure('invalid-input');\n }\n if (record.sessionId !== rootId || record.rootTurnId !== rootTurnId) continue;\n if (!isId(record.threadId) || !isId(record.responseId)) return failure('invalid-input');\n owned.push(record);\n }\n\n // Copy only declared counters so extra fields cannot affect replay equality.\n const validated = [];\n for (const record of owned) {\n if (!isObject(record.usage)) return failure('invalid-usage');\n const usage = zeroUsage();\n for (const counter of counters) {\n const value = record.usage[counter];\n if (!Number.isSafeInteger(value) || value < 0) return failure('invalid-usage');\n usage[counter] = value;\n }\n if (\n usage.total_tokens !== usage.input_tokens + usage.output_tokens ||\n usage.cached_input_tokens > usage.input_tokens ||\n usage.cache_write_input_tokens > usage.input_tokens ||\n usage.reasoning_output_tokens > usage.output_tokens\n ) {\n return failure('invalid-usage');\n }\n validated.push({ threadId: record.threadId, responseId: record.responseId, usage });\n }\n\n // Resolve all conflicts before sums, even if an earlier response would overflow.\n const responses = new Map();\n for (const record of validated) {\n const previous = responses.get(record.responseId);\n if (previous) {\n if (\n previous.threadId !== record.threadId ||\n counters.some(counter => previous.usage[counter] !== record.usage[counter])\n ) {\n return failure('conflicting-response');\n }\n } else {\n responses.set(record.responseId, record);\n }\n }\n\n const usage = zeroUsage();\n const threads = new Map();\n for (const record of responses.values()) {\n let threadUsage = threads.get(record.threadId);\n if (!threadUsage) {\n threadUsage = zeroUsage();\n threads.set(record.threadId, threadUsage);\n }\n for (const counter of counters) {\n const aggregate = usage[counter] + record.usage[counter];\n const threadAggregate = threadUsage[counter] + record.usage[counter];\n if (!Number.isSafeInteger(aggregate) || !Number.isSafeInteger(threadAggregate)) {\n return failure('invalid-usage');\n }\n usage[counter] = aggregate;\n threadUsage[counter] = threadAggregate;\n }\n }\n\n if (responses.size > 0 && !threads.has(rootId)) return failure('missing-root');\n\n return {\n ok: true,\n result: {\n usage,\n threads: Array.from(threads.keys()).sort().map(id => ({ id, usage: threads.get(id) })),\n responseCount: responses.size,\n },\n };\n};\n" }, { "taskId": "job-lifecycle", "arm": "treatment", "repetition": 1, "sourceHash": "fe8d971ecd55e3b827380d6d10d8bf5d898cafe238a8dd0d468265583750e7a1", "submittedSource": "const isObject = value => value !== null && typeof value === 'object' && !Array.isArray(value);\nconst isLease = value => typeof value === 'string' && value.length > 0;\nconst isVersion = value => Number.isSafeInteger(value) && value >= 0;\n\nfunction validJob(job) {\n if (!isObject(job) || !isVersion(job.version) ||\n !Number.isSafeInteger(job.progress) || job.progress < 0 || job.progress > 100) {\n return false;\n }\n switch (job.state) {\n case 'pending': return job.lease === null && job.progress === 0;\n case 'running': return isLease(job.lease) && job.progress < 100;\n case 'completed': return job.lease === null && job.progress === 100;\n case 'failed':\n case 'cancelled': return job.lease === null && job.progress < 100;\n default: return false;\n }\n}\n\nfunction validEvent(event) {\n if (!isObject(event) || !isVersion(event.version)) return false;\n switch (event.kind) {\n case 'claim':\n case 'complete':\n case 'fail': return isLease(event.lease);\n case 'progress':\n return isLease(event.lease) && Number.isSafeInteger(event.value) &&\n event.value >= 0 && event.value <= 99;\n case 'cancel':\n return !('lease' in event) || event.lease === null || isLease(event.lease);\n default: return false;\n }\n}\n\nexports.solve = function solve(job, events) {\n if (!validJob(job) || !Array.isArray(events)) {\n return { ok: false, error: 'invalid-input' };\n }\n\n const current = {\n state: job.state,\n lease: job.lease,\n progress: job.progress,\n version: job.version\n };\n const outcomes = [];\n for (const event of events) {\n if (!validEvent(event)) {\n outcomes.push('invalid');\n continue;\n }\n if (event.version <= current.version) {\n outcomes.push('stale');\n continue;\n }\n\n const applicable = event.kind === 'claim'\n ? current.state === 'pending'\n : event.kind === 'cancel'\n ? current.state === 'pending' || current.state === 'running'\n : current.state === 'running';\n if (!applicable) {\n outcomes.push('inapplicable');\n continue;\n }\n\n if (event.kind !== 'claim') {\n const leaseMatches = current.state === 'running'\n ? event.lease === current.lease\n : !('lease' in event) || event.lease === null;\n if (!leaseMatches) {\n outcomes.push('foreign-lease');\n continue;\n }\n }\n\n switch (event.kind) {\n case 'claim':\n current.state = 'running';\n current.lease = event.lease;\n current.progress = 0;\n break;\n case 'progress':\n current.progress = Math.max(current.progress, event.value);\n break;\n case 'complete':\n current.state = 'completed';\n current.progress = 100;\n current.lease = null;\n break;\n case 'fail':\n current.state = 'failed';\n current.lease = null;\n break;\n case 'cancel':\n current.state = 'cancelled';\n current.lease = null;\n break;\n }\n current.version = event.version;\n outcomes.push('updated');\n }\n return { ok: true, result: { job: current, outcomes } };\n};\n" }, { "taskId": "job-lifecycle", "arm": "baseline", "repetition": 1, "sourceHash": "c0860f26fdf4d3945e979f82c831b81eca3ad850fcdecfefe279eec826f4b025", "submittedSource": "const isObject = value => value !== null && typeof value === 'object' && !Array.isArray(value);\nconst isLease = value => typeof value === 'string' && value.length > 0;\nconst isVersion = value => Number.isSafeInteger(value) && value >= 0;\n\nexports.solve = function solve(job, events) {\n if (!isObject(job) || !Array.isArray(events)) {\n return { ok: false, error: 'invalid-input' };\n }\n\n let { state, lease, progress, version } = job;\n if (!Number.isSafeInteger(progress) || progress < 0 || progress > 100 || !isVersion(version)) {\n return { ok: false, error: 'invalid-input' };\n }\n\n switch (state) {\n case 'pending':\n if (lease !== null || progress !== 0) return { ok: false, error: 'invalid-input' };\n break;\n case 'running':\n if (!isLease(lease) || progress >= 100) return { ok: false, error: 'invalid-input' };\n break;\n case 'completed':\n if (lease !== null || progress !== 100) return { ok: false, error: 'invalid-input' };\n break;\n case 'failed':\n case 'cancelled':\n if (lease !== null || progress >= 100) return { ok: false, error: 'invalid-input' };\n break;\n default:\n return { ok: false, error: 'invalid-input' };\n }\n\n const outcomes = [];\n for (const event of events) {\n if (!isObject(event) || !isVersion(event.version)) {\n outcomes.push('invalid');\n continue;\n }\n\n const kind = event.kind;\n const hasLease = 'lease' in event;\n const eventLease = hasLease ? event.lease : null;\n const knownKind = kind === 'claim' || kind === 'progress' || kind === 'complete' ||\n kind === 'fail' || kind === 'cancel';\n if (!knownKind ||\n (kind === 'cancel' ? eventLease !== null && !isLease(eventLease) : !isLease(eventLease)) ||\n (kind === 'progress' && (!Number.isSafeInteger(event.value) || event.value < 0 || event.value > 99))) {\n outcomes.push('invalid');\n continue;\n }\n if (event.version <= version) {\n outcomes.push('stale');\n continue;\n }\n\n const applicable = kind === 'claim' ? state === 'pending' :\n kind === 'cancel' ? state === 'pending' || state === 'running' : state === 'running';\n if (!applicable) {\n outcomes.push('inapplicable');\n continue;\n }\n if (kind !== 'claim' && eventLease !== lease) {\n outcomes.push('foreign-lease');\n continue;\n }\n\n switch (kind) {\n case 'claim':\n state = 'running';\n lease = eventLease;\n progress = 0;\n break;\n case 'progress':\n progress = Math.max(progress, event.value);\n break;\n case 'complete':\n state = 'completed';\n lease = null;\n progress = 100;\n break;\n case 'fail':\n case 'cancel':\n state = kind === 'fail' ? 'failed' : 'cancelled';\n lease = null;\n break;\n }\n version = event.version;\n outcomes.push('updated');\n }\n\n return { ok: true, result: { job: { state, lease, progress, version }, outcomes } };\n};\n" }, { "taskId": "job-lifecycle", "arm": "baseline", "repetition": 2, "sourceHash": "1d0dcb92c87a322b6a689d7862e15a2dbccc2e4b89a7e571288f0cec9fab28ab", "submittedSource": "'use strict';\n\nconst isObject = value => value !== null && typeof value === 'object' && !Array.isArray(value);\nconst isLease = value => typeof value === 'string' && value.length > 0;\nconst isVersion = value => Number.isSafeInteger(value) && value >= 0;\n\nexports.solve = function solve(job, events) {\n if (!isObject(job) || !Array.isArray(events) ||\n !isVersion(job.version) || !Number.isSafeInteger(job.progress) ||\n job.progress < 0 || job.progress > 100) {\n return {ok: false, error: 'invalid-input'};\n }\n\n let validJob = false;\n switch (job.state) {\n case 'pending':\n validJob = job.lease === null && job.progress === 0;\n break;\n case 'running':\n validJob = isLease(job.lease) && job.progress < 100;\n break;\n case 'completed':\n validJob = job.lease === null && job.progress === 100;\n break;\n case 'failed':\n case 'cancelled':\n validJob = job.lease === null && job.progress < 100;\n break;\n }\n if (!validJob) return {ok: false, error: 'invalid-input'};\n\n const current = {\n state: job.state,\n lease: job.lease,\n progress: job.progress,\n version: job.version\n };\n const outcomes = [];\n\n for (const event of events) {\n if (!isObject(event) || !isVersion(event.version)) {\n outcomes.push('invalid');\n continue;\n }\n\n const kind = event.kind;\n const lease = 'lease' in event ? event.lease : null;\n let validEvent = false;\n switch (kind) {\n case 'claim':\n case 'complete':\n case 'fail':\n validEvent = isLease(lease);\n break;\n case 'progress':\n validEvent = isLease(lease) && Number.isSafeInteger(event.value) &&\n event.value >= 0 && event.value <= 99;\n break;\n case 'cancel':\n validEvent = lease === null || isLease(lease);\n break;\n }\n if (!validEvent) {\n outcomes.push('invalid');\n continue;\n }\n if (event.version <= current.version) {\n outcomes.push('stale');\n continue;\n }\n\n const applicable = kind === 'claim' ? current.state === 'pending' :\n kind === 'cancel' ? current.state === 'pending' || current.state === 'running' :\n current.state === 'running';\n if (!applicable) {\n outcomes.push('inapplicable');\n continue;\n }\n if (kind !== 'claim' && lease !== current.lease) {\n outcomes.push('foreign-lease');\n continue;\n }\n\n switch (kind) {\n case 'claim':\n current.state = 'running';\n current.lease = lease;\n current.progress = 0;\n break;\n case 'progress':\n current.progress = Math.max(current.progress, event.value);\n break;\n case 'complete':\n current.state = 'completed';\n current.progress = 100;\n current.lease = null;\n break;\n case 'fail':\n current.state = 'failed';\n current.lease = null;\n break;\n case 'cancel':\n current.state = 'cancelled';\n current.lease = null;\n break;\n }\n current.version = event.version;\n outcomes.push('updated');\n }\n\n return {ok: true, result: {job: current, outcomes}};\n};\n" }, { "taskId": "job-lifecycle", "arm": "treatment", "repetition": 2, "sourceHash": "f0450d7d115fa64026b5ae18b8726aa91e531bf151a6454f3acc8891843e770c", "submittedSource": "const isObject = value => value !== null && typeof value === 'object' && !Array.isArray(value);\nconst isNonemptyString = value => typeof value === 'string' && value.length > 0;\nconst isVersion = value => Number.isSafeInteger(value) && value >= 0;\n\nfunction isValidJob(job) {\n if (!isObject(job) || !isVersion(job.version) ||\n !Number.isSafeInteger(job.progress) || job.progress < 0 || job.progress > 100) {\n return false;\n }\n switch (job.state) {\n case 'pending':\n return job.lease === null && job.progress === 0;\n case 'running':\n return isNonemptyString(job.lease) && job.progress < 100;\n case 'completed':\n return job.lease === null && job.progress === 100;\n case 'failed':\n case 'cancelled':\n return job.lease === null && job.progress < 100;\n default:\n return false;\n }\n}\n\nfunction isValidEvent(event) {\n if (!isObject(event) || !isVersion(event.version)) return false;\n switch (event.kind) {\n case 'progress':\n return isNonemptyString(event.lease) && Number.isSafeInteger(event.value) &&\n event.value >= 0 && event.value <= 99;\n case 'claim':\n case 'complete':\n case 'fail':\n return isNonemptyString(event.lease);\n case 'cancel':\n return !('lease' in event) || event.lease === null || isNonemptyString(event.lease);\n default:\n return false;\n }\n}\n\nexports.solve = function solve(job, events) {\n if (!isValidJob(job) || !Array.isArray(events)) {\n return { ok: false, error: 'invalid-input' };\n }\n\n const current = {\n state: job.state,\n lease: job.lease,\n progress: job.progress,\n version: job.version\n };\n const outcomes = [];\n\n for (let index = 0; index < events.length; index += 1) {\n const event = events[index];\n if (!isValidEvent(event)) {\n outcomes.push('invalid');\n continue;\n }\n if (event.version <= current.version) {\n outcomes.push('stale');\n continue;\n }\n\n const applicable = event.kind === 'claim'\n ? current.state === 'pending'\n : event.kind === 'cancel'\n ? current.state === 'pending' || current.state === 'running'\n : current.state === 'running';\n if (!applicable) {\n outcomes.push('inapplicable');\n continue;\n }\n\n if (event.kind !== 'claim') {\n const leaseMatches = current.state === 'pending'\n ? !('lease' in event) || event.lease === null\n : event.lease === current.lease;\n if (!leaseMatches) {\n outcomes.push('foreign-lease');\n continue;\n }\n }\n\n switch (event.kind) {\n case 'claim':\n current.state = 'running';\n current.lease = event.lease;\n current.progress = 0;\n break;\n case 'progress':\n current.progress = Math.max(current.progress, event.value);\n break;\n case 'complete':\n current.state = 'completed';\n current.lease = null;\n current.progress = 100;\n break;\n case 'fail':\n current.state = 'failed';\n current.lease = null;\n break;\n case 'cancel':\n current.state = 'cancelled';\n current.lease = null;\n break;\n }\n current.version = event.version;\n outcomes.push('updated');\n }\n\n return { ok: true, result: { job: current, outcomes } };\n};\n" } ], "publicationScope": "Frozen, curated study snapshot. Synthetic submitted source and measurements only; no account access, private transcripts, credentials, or live experiment reads. This publication does not change the skill or the original study verdict." }