Publish Shiftedx Bench v0.1.0

.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.venv/
+dist/
+build/
+*.egg-info/
+results/
+vision-fixtures/
+.DS_Store

LICENSE

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

README.md

@@ -0,0 +1,167 @@
+---
+license: apache-2.0
+pretty_name: Shiftedx Bench
+task_categories:
+  - text-generation
+  - question-answering
+  - visual-question-answering
+tags:
+  - evaluation
+  - long-context
+  - mlx
+  - mtplx
+  - tool-calling
+---
+
+# Shiftedx Bench
+
+Shiftedx Bench is a reproducible qualification suite for local language-model deployments. It measures model quality, effective long-context use, tool protocol reliability, multi-turn agent behavior, vision, and runtime performance without collapsing them into a single “intelligence” score.
+
+The project is designed for quantization and speculative-decoding decisions on Apple Silicon, but its API runner works with any OpenAI-compatible chat endpoint.
+
+## What it evaluates
+
+- **Quality:** 50 procedurally varied reasoning, transformation, algorithm, and executable-code cases in the release configuration.
+- **Long context:** exact rendered-token prompts from 4,096 through 260,096 tokens, seven evidence positions, multiple seeds, before/after query placement, and six task families.
+- **Tools:** 30 procedurally varied release cases with strict protocol-level function and argument comparison, including parallel calls and correct refusal to perform underspecified destructive actions.
+- **Agentic behavior:** multi-turn inspect/patch/test, failed-search recovery, false-error handling, and repair loops with deterministic tool environments.
+- **Vision:** deterministic OCR, chart, spatial, and multi-image fixtures.
+- **MTPLX parity:** paired AR, D1, D2, and D3 runs with quality deltas, throughput, and native acceptance telemetry.
+
+Every long-context prompt is built against the model's own tokenizer and chat template. The runner refuses to count a result if the server-reported prompt length differs from the requested rendered-token count.
+
+## Status
+
+Version `0.1.0` is the first public methodology release. It is suitable for local regression and qualification. Public leaderboard claims additionally require the release suite, rotating holdout seeds, raw result publication, and the policy in [docs/leaderboard-policy.md](docs/leaderboard-policy.md).
+
+This benchmark does not claim to replace RULER, HELM Long Context, NoLiMa, LiveCodeBench, BFCL, SWE-bench, or broad academic evaluations. Its distinctive purpose is paired local-deployment qualification across quality, context, multimodality, and runtime acceleration.
+
+## Install
+
+```bash
+python -m venv .venv
+.venv/bin/pip install -e '.[tokenizers,vision,test]'
+.venv/bin/pytest
+```
+
+## Inspect the workload
+
+```bash
+.venv/bin/shiftedx-bench plan-context \
+  --config configs/context-smoke-v1.json \
+  --output context-plan.json
+```
+
+The smoke context suite contains 19 cases and approximately 1.51 million requested input tokens. The release context suite contains 312 cases and approximately 39.53 million requested input tokens per model variant.
+
+After the release grid, verify that the runtime rejects an input beyond its declared boundary instead of silently truncating it:
+
+```bash
+.venv/bin/shiftedx-bench probe-boundary \
+  --tokenizer '<local-model-or-tokenizer-directory>' \
+  --base-url '<openai-compatible-base-url>/v1' \
+  --model '<served-model-id>' \
+  --output results/context-boundary.json
+```
+
+Add `--include-positive` to repeat the maximum usable prompt as part of the boundary probe.
+
+## Run a context smoke test
+
+```bash
+.venv/bin/shiftedx-bench run-context \
+  --config configs/context-smoke-v1.json \
+  --tokenizer '<local-model-or-tokenizer-directory>' \
+  --base-url '<openai-compatible-base-url>/v1' \
+  --model '<served-model-id>' \
+  --output results/context-smoke.jsonl \
+  --stream
+```
+
+The context generator defaults to thinking enabled with medium reasoning effort. Set `--thinking off` or change `--reasoning-effort` only when the same fields are applied to the server request; these template controls are part of the token-count contract.
+
+Results are appended as JSONL and resume by `(case_id, variant)`. API keys are read only from a named environment variable using `--api-key-env`; token values are never accepted as command-line arguments.
+
+## Run qualification lanes
+
+```bash
+.venv/bin/shiftedx-bench run-suite \
+  --suite quality \
+  --config configs/suites-smoke-v1.json \
+  --base-url '<openai-compatible-base-url>/v1' \
+  --model '<served-model-id>' \
+  --output results/quality.jsonl
+
+.venv/bin/shiftedx-bench run-suite \
+  --suite tools \
+  --config configs/suites-smoke-v1.json \
+  --base-url '<openai-compatible-base-url>/v1' \
+  --model '<served-model-id>' \
+  --output results/tools.jsonl
+```
+
+The other suite names are `agentic` and `vision`.
+
+## Compare AR with MTPLX depths
+
+Pass the frozen variant file to the quality, context, tool, or vision runner:
+
+```bash
+.venv/bin/shiftedx-bench run-suite \
+  --suite quality \
+  --config configs/suites-release-v1.json \
+  --variants configs/mtplx-parity-v1.json \
+  --base-url '<openai-compatible-base-url>/v1' \
+  --model '<served-model-id>' \
+  --output results/quality-parity.jsonl
+```
+
+AR is the parent lane. D1, D2, or D3 is promotable only when it has no critical regression and meets a speed threshold declared before the run.
+
+For a context parity run using `configs/mtplx-parity-v1.json`, also pass `--thinking off`. The runner rejects a tokenizer-template mode that disagrees with the variant request rather than accepting a shifted token grid.
+
+## Summarize
+
+```bash
+.venv/bin/shiftedx-bench summarize \
+  results/context-smoke.jsonl results/quality.jsonl results/tools.jsonl \
+  --output results/summary.json
+```
+
+The summary contains category scorecards, bootstrap confidence intervals, length/position heatmap cells, worst-cell context accuracy, effective context length, and paired variant deltas.
+
+## Public-release check
+
+```bash
+.venv/bin/shiftedx-bench validate-release --root .
+```
+
+The check rejects access-token patterns, private keys, user-specific absolute paths, and loopback URLs accidentally captured in public artifacts. Raw outputs must be copied into a clean release tree and scanned before publication.
+
+For an official comparison, derive rotating holdout seeds from a private environment value rather than checking them into source:
+
+```bash
+.venv/bin/shiftedx-bench make-holdout \
+  --template configs/context-release-v1.json \
+  --release-id '<release-id>' \
+  --master-key-env SHIFTEDX_BENCH_HOLDOUT_KEY \
+  --output '<private-output-directory>/context-holdout.json'
+```
+
+## Repository map
+
+```text
+configs/                 frozen smoke, release, and MTPLX contracts
+docs/                    methodology and leaderboard policy
+schemas/                 versioned result and context schemas
+src/shiftedx_bench/      generators, runner, scorers, sandbox, summaries
+tests/                   generator, scorer, mutation, resume, and privacy tests
+```
+
+## Methodology influences
+
+The context design incorporates position sensitivity demonstrated by [Lost in the Middle](https://arxiv.org/abs/2307.03172), task diversity from [RULER](https://github.com/NVIDIA/RULER), and non-literal retrieval motivation from [NoLiMa](https://github.com/adobe-research/NoLiMa). Tool evaluation uses strict structured-call comparison in the spirit of [BFCL](https://gorilla.cs.berkeley.edu/leaderboard). These external datasets are not redistributed here; consult their licenses before combining them with Shiftedx Bench.
+
+## License
+
+Shiftedx Bench's original code, configurations, and procedurally generated fixtures are licensed under Apache-2.0. Model outputs retain any rights or restrictions imposed by the evaluated model and its source license.

SECURITY.md

@@ -0,0 +1,7 @@
+# Security
+
+Do not put API keys in commands, configurations, result files, examples, issues, or model responses. Supply credentials only through a named environment variable and run the public-release scanner before publishing.
+
+Generated Python is screened and executed in a limited subprocess. This reduces accidental risk but is not a hardened boundary for hostile submissions. Any hosted evaluator must additionally use an ephemeral container or virtual machine, disable networking, mount no credentials, cap CPU/memory/files/output, and destroy the environment after each case.
+
+Report vulnerabilities privately to the repository maintainers before public disclosure.

configs/context-release-v1.json

@@ -0,0 +1,32 @@
+{
+  "suite_id": "shiftedx-context-v1-release",
+  "context_window": 262144,
+  "reserved_output_tokens": 2048,
+  "matrices": [
+    {
+      "name": "position-grid",
+      "families": ["single_key"],
+      "lengths": [4096, 8192, 16384, 32768, 65536, 131072, 196608, 229376, 245760, 260096],
+      "positions": [0.01, 0.1, 0.25, 0.5, 0.75, 0.9, 0.99],
+      "seeds": [7319, 42017, 99041],
+      "query_placements": ["after"]
+    },
+    {
+      "name": "challenge-grid",
+      "families": ["binding", "latest_record", "multi_hop", "semantic", "state_tracking"],
+      "lengths": [32768, 131072, 260096],
+      "positions": [0.25, 0.5, 0.75],
+      "seeds": [173, 811],
+      "query_placements": ["after"]
+    },
+    {
+      "name": "query-position",
+      "families": ["latest_record"],
+      "lengths": [65536, 131072, 260096],
+      "positions": [0.5],
+      "seeds": [127, 4099],
+      "query_placements": ["before", "after"]
+    }
+  ]
+}
+

configs/context-smoke-v1.json

@@ -0,0 +1,32 @@
+{
+  "suite_id": "shiftedx-context-v1-smoke",
+  "context_window": 262144,
+  "reserved_output_tokens": 2048,
+  "matrices": [
+    {
+      "name": "position-grid",
+      "families": ["single_key"],
+      "lengths": [4096, 32768, 131072, 260096],
+      "positions": [0.1, 0.5, 0.9],
+      "seeds": [7319],
+      "query_placements": ["after"]
+    },
+    {
+      "name": "challenge-grid",
+      "families": ["binding", "latest_record", "multi_hop", "semantic", "state_tracking"],
+      "lengths": [32768],
+      "positions": [0.5],
+      "seeds": [7319],
+      "query_placements": ["after"]
+    },
+    {
+      "name": "query-position",
+      "families": ["latest_record"],
+      "lengths": [32768],
+      "positions": [0.5],
+      "seeds": [42017],
+      "query_placements": ["before", "after"]
+    }
+  ]
+}
+

configs/mtplx-parity-v1.json

@@ -0,0 +1,38 @@
+[
+  {
+    "label": "ar",
+    "request_overrides": {
+      "generation_mode": "ar",
+      "thinking": {"enabled": false},
+      "mtplx_stats": true
+    }
+  },
+  {
+    "label": "d1",
+    "request_overrides": {
+      "generation_mode": "mtp",
+      "depth": 1,
+      "thinking": {"enabled": false},
+      "mtplx_stats": true
+    }
+  },
+  {
+    "label": "d2",
+    "request_overrides": {
+      "generation_mode": "mtp",
+      "depth": 2,
+      "thinking": {"enabled": false},
+      "mtplx_stats": true
+    }
+  },
+  {
+    "label": "d3",
+    "request_overrides": {
+      "generation_mode": "mtp",
+      "depth": 3,
+      "thinking": {"enabled": false},
+      "mtplx_stats": true
+    }
+  }
+]
+

configs/suites-release-v1.json

@@ -0,0 +1,20 @@
+{
+  "suite_id": "shiftedx-qualification-v1-release",
+  "quality": {
+    "seeds": [173, 811, 4099, 7319, 42017],
+    "families": [
+      "ledger",
+      "shortest_path",
+      "interval_schedule",
+      "table_join",
+      "event_state",
+      "instruction_order",
+      "code_chunks",
+      "code_window",
+      "code_normalize",
+      "code_percentile"
+    ]
+  },
+  "tools": {"seeds": [173, 811, 4099, 7319, 42017]},
+  "vision": {"seeds": [173, 811, 4099, 7319, 42017]}
+}

configs/suites-smoke-v1.json

@@ -0,0 +1,20 @@
+{
+  "suite_id": "shiftedx-qualification-v1-smoke",
+  "quality": {
+    "seeds": [7319],
+    "families": [
+      "ledger",
+      "shortest_path",
+      "interval_schedule",
+      "table_join",
+      "event_state",
+      "instruction_order",
+      "code_chunks",
+      "code_window",
+      "code_normalize",
+      "code_percentile"
+    ]
+  },
+  "tools": {"seeds": [7319]},
+  "vision": {"seeds": [7319]}
+}

docs/leaderboard-policy.md

@@ -0,0 +1,34 @@
+# Leaderboard and claim policy
+
+## Eligible results
+
+A public result must include the run manifest, raw JSONL results, summary, benchmark version, configuration hash, model revision, tokenizer fingerprint, runtime version, hardware, and all request variants. Failed requests and timeouts remain in the denominator.
+
+The evaluated model must be publicly identifiable or accompanied by an immutable artifact hash. Submitters must disclose quantization, mixed-precision overrides, context scaling, KV-cache quantization, speculative decoding, tool template, and reasoning mode.
+
+## Required lanes
+
+“Shiftedx Bench qualified” requires quality, context, tools, agentic, vision when advertised, and AR-versus-acceleration parity. A text-only model may omit vision only when labeled text-only.
+
+Scores are published by lane. There is no official combined intelligence score.
+
+## Repeats and uncertainty
+
+Deterministic lanes use temperature zero and procedural seeds. Stochastic operational settings require at least three trials. Publish paired confidence intervals when comparing a quant, runtime, or decoding depth with its parent.
+
+## Long-context claims
+
+Advertised context size and effective context size are distinct. Effective context length is the greatest evaluated prompt length meeting the declared accuracy threshold; the threshold and aggregation must accompany the number. Also publish the complete length/position heatmap and worst cell.
+
+## Performance claims
+
+Performance comparisons require the same host, power mode, runtime, prompt, output, cache condition, and sampling settings. Report time to first token, prefill telemetry when available, decode/end-to-end throughput, and memory. Cold and warm-prefix results must be labeled separately.
+
+## Contamination and holdouts
+
+Public development cases are expected to become contaminated over time. Official comparisons use a frozen rotating seed set whose commitment is recorded before evaluation and whose concrete cases are disclosed afterward. Changes to generators create a new benchmark version.
+
+## Corrections
+
+Results with missing provenance, silent truncation, changed validators, excluded failures, private prompt modifications, or unreported runtime-specific optimizations are ineligible. Material errors remain visible with a correction note rather than being silently replaced.
+

docs/methodology.md

@@ -0,0 +1,69 @@
+# Methodology
+
+## Measurement contract
+
+Freeze the following before comparing candidates:
+
+- model artifact and revision;
+- tokenizer and chat-template hashes;
+- runtime version and request adapter;
+- context window and output reserve;
+- sampler, reasoning mode, stop behavior, and seed;
+- task configuration and holdout policy;
+- critical zero-regression cases;
+- minimum performance improvement;
+- hardware and cache condition.
+
+Change one declared variable at a time. Compare a quantized candidate with its exact higher-precision parent, and compare MTPLX depths with AR using paired cases.
+
+## Long-context construction
+
+Lengths in the frozen release grid are 4,096, 8,192, 16,384, 32,768, 65,536, 131,072, 196,608, 229,376, 245,760, and 260,096 rendered prompt tokens. The last length reserves 2,048 tokens inside a 262,144-token model context.
+
+Evidence centers are placed at 1%, 10%, 25%, 50%, 75%, 90%, and 99% of the context body. Each prompt records requested and actual evidence positions. Start and end sentinels must both appear in the answer, causing silent front or tail truncation to fail.
+
+The task families are:
+
+1. exact single-key retrieval;
+2. key/value binding among similar identifiers;
+3. current-record selection among stale and test-only records;
+4. multi-hop resolution across distant evidence;
+5. semantic retrieval with reduced lexical overlap;
+6. ordered state updates.
+
+The release configuration also compares queries placed before and after the context. Filler is procedurally generated synthetic telemetry with unique traces and semantically similar records, not a tiny repeated word vocabulary.
+
+## Scoring
+
+Structured tasks require bare, fully parseable JSON. Markdown fences and trailing prose fail. Tool cases compare the emitted protocol calls, names, arguments, order, and no-call behavior. Executable Python is statically screened and evaluated in a resource-limited isolated subprocess.
+
+The Python evaluator is appropriate for trusted local benchmark output, not hostile multi-tenant code. A public submission service must add an operating-system or container sandbox with networking disabled.
+
+## Statistical reporting
+
+Report each lane separately. Required outputs include:
+
+- accuracy and a bootstrap 95% confidence interval;
+- context accuracy by length, position, and family;
+- worst context cell and effective context length at a declared threshold;
+- wall time, time to first token when streaming is supported, and end-to-end token rate;
+- server-reported cached tokens and MTPLX acceptance telemetry when available;
+- paired quality delta and speed ratio for every runtime variant.
+
+Do not infer an intelligence improvement from one or two task changes. Do not combine hardware-dependent throughput with model quality in a single score.
+
+## Public and rotating sets
+
+The checked-in configurations are reproducible development contracts. For a leaderboard release, derive a rotating seed configuration from a private master key, freeze its hash before evaluation, and publish the concrete seeds only after submissions close. Keep calibration prompts, development seeds, and holdout seeds disjoint.
+
+## Sanity controls
+
+Before accepting a new suite version, verify:
+
+- an oracle response passes every case;
+- empty, echo, random, stale-decoy, and truncated responses fail;
+- deliberately mutated code fails hidden tests;
+- duplicate case identifiers are rejected;
+- prompt counts and evidence positions are exact under a real target tokenizer;
+- a server/tokenizer mismatch fails rather than silently changing the score.
+

pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "shiftedx-bench"
+version = "0.1.0"
+description = "Reproducible quality, long-context, tool, vision, and MTPLX qualification for local language models"
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "Apache-2.0"}
+authors = [{name = "Shiftedx"}]
+dependencies = []
+
+[project.optional-dependencies]
+tokenizers = ["transformers>=5.0"]
+vision = ["Pillow>=11.0"]
+test = ["pytest>=8.0"]
+
+[project.scripts]
+shiftedx-bench = "shiftedx_bench.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/shiftedx_bench"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q"
+

schemas/context-config-v1.schema.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://huggingface.co/datasets/Shiftedx/shiftedx-bench/raw/main/schemas/context-config-v1.schema.json",
+  "title": "Shiftedx Bench context matrix",
+  "type": "object",
+  "required": ["suite_id", "context_window", "reserved_output_tokens", "matrices"],
+  "properties": {
+    "suite_id": {"type": "string"},
+    "context_window": {"type": "integer", "minimum": 4096},
+    "reserved_output_tokens": {"type": "integer", "minimum": 1},
+    "matrices": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["name", "families", "lengths", "positions", "seeds"],
+        "properties": {
+          "name": {"type": "string"},
+          "families": {"type": "array", "items": {"type": "string"}},
+          "lengths": {"type": "array", "items": {"type": "integer", "minimum": 1}},
+          "positions": {"type": "array", "items": {"type": "number", "exclusiveMinimum": 0, "exclusiveMaximum": 1}},
+          "seeds": {"type": "array", "items": {"type": "integer"}},
+          "query_placements": {"type": "array", "items": {"enum": ["before", "after"]}}
+        },
+        "additionalProperties": false
+      }
+    }
+  },
+  "additionalProperties": false
+}

schemas/result-v1.schema.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://huggingface.co/datasets/Shiftedx/shiftedx-bench/raw/main/schemas/result-v1.schema.json",
+  "title": "Shiftedx Bench case result",
+  "type": "object",
+  "required": [
+    "schema_version", "run_id", "suite_id", "case_id", "lane", "variant",
+    "passed", "score", "score_max", "response", "telemetry", "metadata", "request_hash"
+  ],
+  "properties": {
+    "schema_version": {"const": "1.0"},
+    "run_id": {"type": "string"},
+    "suite_id": {"type": "string"},
+    "case_id": {"type": "string"},
+    "lane": {"enum": ["quality", "long-context", "tools", "agentic", "vision"]},
+    "variant": {"type": "string"},
+    "passed": {"type": "boolean"},
+    "score": {"type": "number"},
+    "score_max": {"type": "number"},
+    "error": {"type": ["string", "null"]},
+    "response": {"type": "object"},
+    "telemetry": {"type": "object"},
+    "metadata": {"type": "object"},
+    "request_hash": {"type": "string", "pattern": "^[a-f0-9]{64}$"}
+  },
+  "additionalProperties": false
+}

src/shiftedx_bench/__init__.py

@@ -0,0 +1,7 @@
+"""Shiftedx local-model qualification benchmark."""
+
+from .models import BenchCase, CaseResult
+
+__all__ = ["BenchCase", "CaseResult"]
+__version__ = "0.1.0"
+

src/shiftedx_bench/agentic.py

@@ -0,0 +1,263 @@
+from __future__ import annotations
+
+import json
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+from .api import OpenAIClient
+from .scoring import score_response
+from .tools import function_tool
+from .util import append_jsonl, sha256_json
+
+
+READ = function_tool("read_file", {"path": {"type": "string"}}, ["path"])
+SEARCH = function_tool("file_search", {"query": {"type": "string"}}, ["query"])
+SESSION = function_tool("session_search", {"query": {"type": "string"}}, ["query"])
+TESTS = function_tool("run_tests", {}, [])
+PATCH = function_tool("apply_patch", {"path": {"type": "string"}, "patch": {"type": "string"}}, ["path", "patch"])
+LOGS = function_tool("read_logs", {"service": {"type": "string"}}, ["service"])
+
+
+@dataclass
+class AgentScenario:
+    case_id: str
+    prompt: str
+    tools: list[dict[str, Any]]
+    required_calls: set[str]
+    expected_final: dict[str, Any]
+    dispatch: Callable[[str, dict[str, Any], dict[str, Any]], str]
+    max_turns: int = 8
+    max_tool_calls: int = 8
+
+
+def _bugfix(name: str, args: dict[str, Any], state: dict[str, Any]) -> str:
+    if name == "file_search": return "/repo/path_utils.py\n/repo/test_path_utils.py"
+    if name == "read_file":
+        if str(args.get("path", "")).endswith("test_path_utils.py"):
+            return "assert parent('') == '.'\nassert parent('a/b') == 'a'\n"
+        if str(args.get("path", "")).endswith("path_utils.py"):
+            return "def parent(path):\n    parts = path.split('/')\n    parts.pop()\n    return '/'.join(parts) or '.'\n"
+        return "FileNotFoundError"
+    if name == "apply_patch":
+        patch = str(args.get("patch", ""))
+        state["patched"] = "if" in patch and "path" in patch
+        return "Patch applied." if state["patched"] else "Patch rejected: empty-path guard absent."
+    if name == "run_tests": return "2 passed" if state.get("patched") else "1 failed: IndexError"
+    return "Unknown tool"
+
+
+def _recovery(name: str, args: dict[str, Any], state: dict[str, Any]) -> str:
+    if name == "session_search": return '{"error":"index unavailable","retryable":false}'
+    if name == "file_search": return "/configs/staging/deploy.yaml: endpoint: https://staging.example:7443"
+    if name == "read_file": return "service: atlas\nendpoint: https://staging.example:7443\n"
+    return "Unknown tool"
+
+
+def _false_error(name: str, args: dict[str, Any], state: dict[str, Any]) -> str:
+    if name == "read_logs":
+        return json.dumps({"status": "healthy", "message": "No errors detected", "error_budget": "99.9%"})
+    return "Unknown tool"
+
+
+def _repair(name: str, args: dict[str, Any], state: dict[str, Any]) -> str:
+    if name == "run_tests": return "12 passed" if state.get("patched") else "11 passed, 1 failed: backoff"
+    if name == "file_search": return "/repo/retry.py\n/repo/test_retry.py"
+    if name == "read_file":
+        return "def retry_delays(n): return list(range(1,n+1))" if str(args.get("path", "")).endswith("retry.py") else "assert retry_delays(3)==[1,2,4]"
+    if name == "apply_patch":
+        patch = str(args.get("patch", ""))
+        state["patched"] = "2 **" in patch or "2**" in patch or "1 <<" in patch
+        return "Patch applied." if state["patched"] else "Patch does not implement exponential backoff."
+    return "Unknown tool"
+
+
+def _parallel_config(name: str, args: dict[str, Any], state: dict[str, Any]) -> str:
+    if name != "read_file": return "Unknown tool"
+    path = str(args.get("path", ""))
+    if path == "/configs/app.yaml": return "api_version: v3\ntimeout_seconds: 30"
+    if path == "/configs/worker.yaml": return "api_version: v2\ntimeout_seconds: 30"
+    return "FileNotFoundError"
+
+
+def _wrong_path(name: str, args: dict[str, Any], state: dict[str, Any]) -> str:
+    if name == "read_file":
+        path = str(args.get("path", ""))
+        if path == "/repo/config/prod.toml": return "FileNotFoundError"
+        if path == "/repo/configs/prod.toml": return 'database_host = "prod-db"\npool_size = 20'
+        return "FileNotFoundError"
+    if name == "file_search": return "/repo/configs/prod.toml"
+    return "Unknown tool"
+
+
+def scenarios() -> list[AgentScenario]:
+    final = "When complete, return bare JSON only."
+    return [
+        AgentScenario(
+            "inspect_patch_test",
+            "Fix the empty-path bug in path_utils.parent. Inspect source and tests, patch it, and run tests. " + final,
+            [SEARCH, READ, PATCH, TESTS],
+            {"read_file", "apply_patch", "run_tests"},
+            {"status": "passed"},
+            _bugfix,
+        ),
+        AgentScenario(
+            "failed_search_recovery",
+            "Find the staging endpoint. Search prior sessions first, recover with repository tools if unavailable, and verify the file. " + final,
+            [SESSION, SEARCH, READ],
+            {"session_search", "file_search", "read_file"},
+            {"endpoint": "https://staging.example:7443"},
+            _recovery,
+            max_tool_calls=4,
+        ),
+        AgentScenario(
+            "false_error_payload",
+            "Check payments health. Do not retry a successful result whose text merely contains the word error. " + final,
+            [LOGS],
+            {"read_logs"},
+            {"status": "healthy", "error_budget": "99.9%"},
+            _false_error,
+            max_turns=4,
+            max_tool_calls=1,
+        ),
+        AgentScenario(
+            "repair_loop",
+            "Run tests, diagnose the backoff failure, make the smallest source fix, rerun tests, and stop only when green. " + final,
+            [TESTS, SEARCH, READ, PATCH],
+            {"run_tests", "read_file", "apply_patch"},
+            {"status": "passed", "tests": 12},
+            _repair,
+            max_tool_calls=7,
+        ),
+        AgentScenario(
+            "parallel_config_review",
+            "Read /configs/app.yaml and /configs/worker.yaml, preferably in parallel. Report both API versions. " + final,
+            [READ],
+            {"read_file"},
+            {"app_version": "v3", "worker_version": "v2"},
+            _parallel_config,
+            max_turns=5,
+            max_tool_calls=2,
+        ),
+        AgentScenario(
+            "wrong_path_recovery",
+            "Read /repo/config/prod.toml and report database host and pool size. If missing, locate the real file. " + final,
+            [READ, SEARCH],
+            {"read_file", "file_search"},
+            {"database_host": "prod-db", "pool_size": 20},
+            _wrong_path,
+            max_turns=6,
+            max_tool_calls=3,
+        ),
+    ]
+
+
+def _arguments(call: dict[str, Any]) -> dict[str, Any]:
+    raw = (call.get("function") or {}).get("arguments", {})
+    return json.loads(raw) if isinstance(raw, str) else raw
+
+
+def run_agentic_cases(
+    *,
+    client: OpenAIClient,
+    model: str,
+    output_path: Path,
+    request_overrides: dict[str, Any] | None = None,
+    limit: int | None = None,
+) -> list[dict[str, Any]]:
+    rows = []
+    run_id = str(uuid.uuid4())
+    system = (
+        "You are an autonomous coding agent in a deterministic sandbox. Use supplied tools, never invent "
+        "results, recover from failures, verify completion, and obey the requested final JSON format."
+    )
+    selected = scenarios()
+    if limit is not None:
+        selected = selected[:limit]
+    for scenario in selected:
+        messages: list[dict[str, Any]] = [
+            {"role": "system", "content": system},
+            {"role": "user", "content": scenario.prompt},
+        ]
+        state: dict[str, Any] = {}
+        call_names: list[str] = []
+        turn_telemetry: list[dict[str, Any]] = []
+        response: dict[str, Any] = {}
+        error = None
+        for _ in range(scenario.max_turns):
+            payload = {
+                "model": model,
+                "messages": messages,
+                "tools": scenario.tools,
+                "tool_choice": "auto",
+                "temperature": 0,
+                "max_tokens": 500,
+            }
+            payload.update(request_overrides or {})
+            response = client.complete(payload)
+            turn_telemetry.append({
+                "wall_s": response.get("wall_s"),
+                "prompt_tokens": response.get("prompt_tokens"),
+                "completion_tokens": response.get("completion_tokens"),
+                "ttft_s": response.get("ttft_s"),
+                "mtplx_stats": response.get("mtplx_stats") or {},
+            })
+            calls = response.get("tool_calls") or []
+            if not calls:
+                break
+            assistant = {"role": "assistant", "content": response.get("content") or "", "tool_calls": calls}
+            messages.append(assistant)
+            for index, call in enumerate(calls):
+                name = str((call.get("function") or {}).get("name"))
+                call_names.append(name)
+                if len(call_names) > scenario.max_tool_calls:
+                    error = "tool-call budget exceeded"
+                    break
+                try:
+                    result = scenario.dispatch(name, _arguments(call), state)
+                except Exception as exc:
+                    result = json.dumps({"error": f"dispatcher failure: {exc}"})
+                messages.append(
+                    {
+                        "role": "tool",
+                        "tool_call_id": call.get("id") or f"call-{index}",
+                        "content": result,
+                    }
+                )
+            if error:
+                break
+        score = score_response("strict_json_subset", scenario.expected_final, response)
+        required_ok = scenario.required_calls.issubset(call_names)
+        passed = score.passed and required_ok and error is None
+        if not required_ok:
+            error = f"missing required calls: {sorted(scenario.required_calls - set(call_names))}"
+        elif not score.passed:
+            error = score.error
+        row = {
+            "schema_version": "1.0",
+            "run_id": run_id,
+            "suite_id": "shiftedx-agentic-v1",
+            "case_id": scenario.case_id,
+            "lane": "agentic",
+            "variant": "default",
+            "passed": passed,
+            "score": float(passed),
+            "score_max": 1.0,
+            "error": error,
+            "response": {**response, "transcript": messages},
+            "telemetry": {
+                "tool_call_count": len(call_names),
+                "tool_calls": call_names,
+                "turns": turn_telemetry,
+                "wall_s": sum(float(item.get("wall_s") or 0) for item in turn_telemetry),
+                "prompt_tokens": sum(int(item.get("prompt_tokens") or 0) for item in turn_telemetry),
+                "completion_tokens": sum(int(item.get("completion_tokens") or 0) for item in turn_telemetry),
+                "ttft_s": next((item.get("ttft_s") for item in turn_telemetry if item.get("ttft_s") is not None), None),
+            },
+            "metadata": {"max_turns": scenario.max_turns, "max_tool_calls": scenario.max_tool_calls},
+            "request_hash": sha256_json({"messages": messages[:2], "tools": scenario.tools}),
+        }
+        append_jsonl(output_path, [row])
+        rows.append(row)
+    return rows

src/shiftedx_bench/api.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import json
+import time
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class OpenAIClient:
+    base_url: str
+    api_key: str | None = None
+    timeout_s: float = 600.0
+
+    def _request(self, payload: dict[str, Any]):
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        return urllib.request.Request(
+            self.base_url.rstrip("/") + "/chat/completions",
+            data=json.dumps(payload).encode("utf-8"),
+            headers=headers,
+        )
+
+    def complete(self, payload: dict[str, Any], *, stream: bool = False) -> dict[str, Any]:
+        body = dict(payload)
+        body["stream"] = bool(stream)
+        request = self._request(body)
+        started = time.perf_counter()
+        try:
+            with urllib.request.urlopen(request, timeout=self.timeout_s) as response:
+                if stream:
+                    value = self._read_stream(response, started)
+                else:
+                    value = json.loads(response.read().decode("utf-8"))
+        except urllib.error.HTTPError as exc:
+            detail = exc.read().decode("utf-8", errors="replace")[-4000:]
+            raise RuntimeError(f"HTTP {exc.code}: {detail}") from exc
+        wall_s = time.perf_counter() - started
+        return self._normalize(value, wall_s=wall_s, ttft_s=value.pop("_ttft_s", None))
+
+    @staticmethod
+    def _read_stream(response: Any, started: float) -> dict[str, Any]:
+        content: list[str] = []
+        reasoning: list[str] = []
+        usage: dict[str, Any] = {}
+        stats: dict[str, Any] = {}
+        finish_reason = None
+        first_token_at = None
+        model = None
+        for raw_line in response:
+            line = raw_line.decode("utf-8", errors="replace").strip()
+            if not line.startswith("data:"):
+                continue
+            data = line[5:].strip()
+            if data == "[DONE]":
+                break
+            chunk = json.loads(data)
+            model = chunk.get("model") or model
+            usage = chunk.get("usage") or usage
+            stats = chunk.get("mtplx_stats") or stats
+            choice = (chunk.get("choices") or [{}])[0]
+            delta = choice.get("delta") or {}
+            text = delta.get("content") or ""
+            thought = delta.get("reasoning_content") or ""
+            if first_token_at is None and (text or thought):
+                first_token_at = time.perf_counter()
+            content.append(text)
+            reasoning.append(thought)
+            finish_reason = choice.get("finish_reason") or finish_reason
+        return {
+            "model": model,
+            "choices": [
+                {
+                    "finish_reason": finish_reason,
+                    "message": {
+                        "role": "assistant",
+                        "content": "".join(content),
+                        "reasoning_content": "".join(reasoning),
+                    },
+                }
+            ],
+            "usage": usage,
+            "mtplx_stats": stats,
+            "_ttft_s": None if first_token_at is None else first_token_at - started,
+        }
+
+    @staticmethod
+    def _normalize(value: dict[str, Any], *, wall_s: float, ttft_s: float | None) -> dict[str, Any]:
+        choice = (value.get("choices") or [{}])[0]
+        message = choice.get("message") or {}
+        usage = value.get("usage") or {}
+        stats = value.get("mtplx_stats") or usage.get("mtplx_stats") or {}
+        if ttft_s is None and isinstance(stats.get("ttft_s"), (int, float)):
+            ttft_s = float(stats["ttft_s"])
+        completion_tokens = usage.get("completion_tokens")
+        prompt_tokens = usage.get("prompt_tokens")
+        return {
+            "model": value.get("model"),
+            "content": message.get("content") or "",
+            "reasoning_content": message.get("reasoning_content") or "",
+            "tool_calls": message.get("tool_calls") or [],
+            "finish_reason": choice.get("finish_reason"),
+            "usage": usage,
+            "mtplx_stats": stats,
+            "wall_s": wall_s,
+            "ttft_s": ttft_s,
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": completion_tokens,
+            "end_to_end_tokens_per_second": (
+                completion_tokens / wall_s
+                if isinstance(completion_tokens, int) and wall_s > 0
+                else None
+            ),
+            "prefill_tokens_per_second": (
+                stats.get("prefill_tok_s")
+                or (
+                    stats.get("new_prefill_tokens") / stats.get("prefill_elapsed_s")
+                    if isinstance(stats.get("new_prefill_tokens"), (int, float))
+                    and isinstance(stats.get("prefill_elapsed_s"), (int, float))
+                    and stats.get("prefill_elapsed_s")
+                    else None
+                )
+            ),
+            "decode_tokens_per_second": stats.get("decode_tok_s") or stats.get("tok_s"),
+            "active_memory_bytes": stats.get("active_memory_bytes"),
+            "cache_memory_bytes": stats.get("cache_memory_bytes"),
+        }

src/shiftedx_bench/boundary.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import re
+from dataclasses import replace
+from typing import Any
+
+from .api import OpenAIClient
+from .context import ContextSpec, build_context_case
+from .runner import build_payload
+from .tokenizer import TokenizerProtocol
+
+
+EXPECTED_REJECTION = re.compile(r"HTTP (?:400|413|422):")
+
+
+def probe_context_boundary(
+    *,
+    client: OpenAIClient,
+    tokenizer: TokenizerProtocol,
+    model: str,
+    context_window: int,
+    reserved_output_tokens: int,
+    include_positive: bool = False,
+) -> dict[str, Any]:
+    report: dict[str, Any] = {
+        "schema_version": "1.0",
+        "context_window": context_window,
+        "reserved_output_tokens": reserved_output_tokens,
+        "maximum_usable_prompt_tokens": context_window - reserved_output_tokens,
+    }
+    if include_positive:
+        spec = ContextSpec(
+            "shiftedx-context-boundary-v1", "positive", "single_key",
+            context_window - reserved_output_tokens, 0.5, 7319,
+        )
+        case = build_context_case(spec, tokenizer)
+        response = client.complete(build_payload(case, model, {"label": "positive"}), stream=True)
+        report["positive"] = {
+            "passed": response.get("prompt_tokens") == spec.target_tokens,
+            "reported_prompt_tokens": response.get("prompt_tokens"),
+            "finish_reason": response.get("finish_reason"),
+        }
+
+    oversize = context_window + 1
+    spec = ContextSpec("shiftedx-context-boundary-v1", "negative", "single_key", oversize, 0.5, 99041)
+    case = replace(build_context_case(spec, tokenizer), max_output_tokens=1)
+    try:
+        response = client.complete(build_payload(case, model, {"label": "negative"}))
+        report["negative"] = {
+            "passed": False,
+            "error": "server accepted an oversized rendered prompt",
+            "reported_prompt_tokens": response.get("prompt_tokens"),
+        }
+    except Exception as exc:
+        error = f"{type(exc).__name__}: {exc}"
+        report["negative"] = {
+            "passed": bool(EXPECTED_REJECTION.search(error)),
+            "error": error,
+            "reported_prompt_tokens": None,
+        }
+    report["passed"] = report["negative"]["passed"] and (
+        not include_positive or report.get("positive", {}).get("passed", False)
+    )
+    return report
+

src/shiftedx_bench/cli.py

@@ -0,0 +1,301 @@
+from __future__ import annotations
+
+import argparse
+import json
+import uuid
+from dataclasses import replace
+from pathlib import Path
+from typing import Any
+
+from .agentic import run_agentic_cases
+from .api import OpenAIClient
+from .boundary import probe_context_boundary
+from .context import build_context_case, expand_context_config
+from .holdout import derive_holdout_config
+from .provenance import make_run_manifest, write_manifest
+from .quality import generate_quality_cases
+from .release import scan_public_tree
+from .runner import api_key_from_env, run_cases
+from .summary import summarize_results
+from .tokenizer import TransformersTokenizer
+from .tools import generate_tool_cases
+from .util import read_json, read_jsonl, write_json
+from .vision import generate_vision_cases
+
+
+def _variants(path: Path | None) -> list[dict[str, Any]]:
+    if path is None:
+        return [{"label": "default", "request_overrides": {}}]
+    value = read_json(path)
+    if not isinstance(value, list) or not value:
+        raise ValueError("Variant file must contain a non-empty JSON array")
+    return value
+
+
+def _client(args: argparse.Namespace) -> OpenAIClient:
+    return OpenAIClient(
+        base_url=args.base_url,
+        api_key=api_key_from_env(args.api_key_env),
+        timeout_s=args.timeout,
+    )
+
+
+def plan_context(args: argparse.Namespace) -> None:
+    config = read_json(args.config)
+    specs = expand_context_config(config)
+    value = {
+        "schema_version": "1.0",
+        "suite_id": config["suite_id"],
+        "cases": len(specs),
+        "total_requested_prompt_tokens": sum(item.target_tokens for item in specs),
+        "by_matrix": {},
+        "specs": [item.__dict__ | {"case_id": item.case_id} for item in specs],
+    }
+    for spec in specs:
+        value["by_matrix"][spec.matrix] = value["by_matrix"].get(spec.matrix, 0) + 1
+    write_json(args.output, value)
+
+
+def _tokenizer(args: argparse.Namespace) -> TransformersTokenizer:
+    return TransformersTokenizer(
+        args.tokenizer,
+        enable_thinking=args.thinking == "on",
+        reasoning_effort=args.reasoning_effort,
+        preserve_thinking=True,
+    )
+
+
+def _reasoning_request_overrides(args: argparse.Namespace) -> dict[str, Any]:
+    value: dict[str, Any] = {"thinking": {"enabled": args.thinking == "on"}}
+    if args.reasoning_effort:
+        value["reasoning_effort"] = args.reasoning_effort
+    return value
+
+
+def _validate_context_variant_profile(args: argparse.Namespace, variants: list[dict[str, Any]]) -> None:
+    declared = {
+        bool((variant.get("request_overrides", {}).get("thinking") or {}).get("enabled"))
+        for variant in variants
+        if "thinking" in (variant.get("request_overrides") or {})
+    }
+    if len(declared) > 1:
+        raise ValueError("All variants in one exact-token context run must use the same thinking mode")
+    if declared and declared != {args.thinking == "on"}:
+        raise ValueError("--thinking must match the variant file so local and server templates are identical")
+
+
+def inspect_context(args: argparse.Namespace) -> None:
+    config = read_json(args.config)
+    specs = expand_context_config(config)
+    selected = next((item for item in specs if item.case_id == args.case_id), None)
+    if selected is None:
+        raise ValueError(f"Unknown case identifier: {args.case_id}")
+    tokenizer = _tokenizer(args)
+    case = build_context_case(selected, tokenizer)
+    value = case.to_dict(include_expected=True)
+    if not args.include_prompt:
+        value["messages"] = [{"role": item["role"], "content": "<omitted>"} for item in case.messages]
+    write_json(args.output, value)
+
+
+def run_context(args: argparse.Namespace) -> None:
+    config = read_json(args.config)
+    specs = expand_context_config(config)
+    if args.matrix:
+        specs = [item for item in specs if item.matrix == args.matrix]
+    if args.limit is not None:
+        specs = specs[: args.limit]
+    tokenizer = _tokenizer(args)
+    variants = _variants(args.variants)
+    _validate_context_variant_profile(args, variants)
+    run_id = str(uuid.uuid4())
+    manifest = make_run_manifest(
+        run_id=run_id,
+        suite_id=config["suite_id"],
+        model=args.model,
+        config_path=args.config,
+        tokenizer_fingerprint=tokenizer.fingerprint,
+        variants=variants,
+    )
+    manifest["planned_cases"] = len(specs)
+    manifest["requested_prompt_tokens"] = sum(item.target_tokens for item in specs)
+    write_manifest(args.output.with_suffix(".manifest.json"), manifest)
+    reasoning_overrides = _reasoning_request_overrides(args)
+    cases = (
+        replace(build_context_case(spec, tokenizer), request_overrides=reasoning_overrides)
+        for spec in specs
+    )
+    run_cases(
+        cases,
+        client=_client(args),
+        model=args.model,
+        output_path=args.output,
+        variants=variants,
+        run_id=run_id,
+        stream=args.stream,
+    )
+
+
+def run_suite(args: argparse.Namespace) -> None:
+    config = read_json(args.config)
+    variants = _variants(args.variants)
+    if args.suite == "quality":
+        cases = generate_quality_cases(config["quality"]["seeds"], config["quality"].get("families"))
+        suite_id = "shiftedx-quality-v1"
+    elif args.suite == "tools":
+        cases = generate_tool_cases(config["tools"]["seeds"])
+        suite_id = "shiftedx-tools-v1"
+    elif args.suite == "vision":
+        cases = generate_vision_cases(args.output.parent / "vision-fixtures", config["vision"]["seeds"])
+        suite_id = "shiftedx-vision-v1"
+    elif args.suite == "agentic":
+        if len(variants) != 1:
+            raise ValueError("Agentic runner currently accepts one request variant per invocation")
+        run_agentic_cases(
+            client=_client(args), model=args.model, output_path=args.output,
+            request_overrides=variants[0].get("request_overrides") or {},
+            limit=args.limit,
+        )
+        return
+    else:
+        raise ValueError(args.suite)
+    if args.limit is not None:
+        cases = cases[: args.limit]
+    run_id = str(uuid.uuid4())
+    write_manifest(
+        args.output.with_suffix(".manifest.json"),
+        make_run_manifest(
+            run_id=run_id, suite_id=suite_id, model=args.model, config_path=args.config,
+            tokenizer_fingerprint=None, variants=variants,
+        ),
+    )
+    run_cases(
+        cases,
+        client=_client(args), model=args.model, output_path=args.output,
+        variants=variants, run_id=run_id, stream=args.stream,
+    )
+
+
+def summarize(args: argparse.Namespace) -> None:
+    rows = []
+    for path in args.inputs:
+        rows.extend(read_jsonl(path))
+    write_json(args.output, summarize_results(rows, args.effective_threshold))
+
+
+def validate_release(args: argparse.Namespace) -> None:
+    result = scan_public_tree(args.root)
+    if args.output:
+        write_json(args.output, result)
+    else:
+        print(json.dumps(result, indent=2, sort_keys=True))
+    if not result["ok"]:
+        raise SystemExit(1)
+
+
+def make_holdout(args: argparse.Namespace) -> None:
+    master_key = api_key_from_env(args.master_key_env)
+    if master_key is None:
+        raise RuntimeError("Holdout master key is required")
+    config = derive_holdout_config(read_json(args.template), master_key, args.release_id)
+    write_json(args.output, config)
+
+
+def probe_boundary(args: argparse.Namespace) -> None:
+    tokenizer = _tokenizer(args)
+    result = probe_context_boundary(
+        client=_client(args), tokenizer=tokenizer, model=args.model,
+        context_window=args.context_window, reserved_output_tokens=args.reserved_output_tokens,
+        include_positive=args.include_positive,
+    )
+    write_json(args.output, result)
+    if not result["passed"]:
+        raise SystemExit(1)
+
+
+def add_runtime_arguments(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--base-url", required=True, help="OpenAI-compatible base URL ending in /v1")
+    parser.add_argument("--model", required=True)
+    parser.add_argument("--output", required=True, type=Path)
+    parser.add_argument("--api-key-env", help="Environment-variable name containing the API key")
+    parser.add_argument("--timeout", type=float, default=900)
+    parser.add_argument("--variants", type=Path)
+    parser.add_argument("--limit", type=int)
+    parser.add_argument("--stream", action="store_true")
+
+
+def add_tokenizer_profile_arguments(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--tokenizer", required=True, type=Path)
+    parser.add_argument("--thinking", choices=["on", "off"], default="on")
+    parser.add_argument("--reasoning-effort", default="medium")
+
+
+def make_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="shiftedx-bench")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    command = subparsers.add_parser("plan-context")
+    command.add_argument("--config", required=True, type=Path)
+    command.add_argument("--output", required=True, type=Path)
+    command.set_defaults(func=plan_context)
+
+    command = subparsers.add_parser("inspect-context")
+    command.add_argument("--config", required=True, type=Path)
+    add_tokenizer_profile_arguments(command)
+    command.add_argument("--case-id", required=True)
+    command.add_argument("--output", required=True, type=Path)
+    command.add_argument("--include-prompt", action="store_true")
+    command.set_defaults(func=inspect_context)
+
+    command = subparsers.add_parser("run-context")
+    add_runtime_arguments(command)
+    command.add_argument("--config", required=True, type=Path)
+    add_tokenizer_profile_arguments(command)
+    command.add_argument("--matrix")
+    command.set_defaults(func=run_context)
+
+    command = subparsers.add_parser("run-suite")
+    add_runtime_arguments(command)
+    command.add_argument("--config", required=True, type=Path)
+    command.add_argument("--suite", required=True, choices=["quality", "tools", "agentic", "vision"])
+    command.set_defaults(func=run_suite)
+
+    command = subparsers.add_parser("summarize")
+    command.add_argument("inputs", nargs="+", type=Path)
+    command.add_argument("--output", required=True, type=Path)
+    command.add_argument("--effective-threshold", type=float, default=0.90)
+    command.set_defaults(func=summarize)
+
+    command = subparsers.add_parser("validate-release")
+    command.add_argument("--root", required=True, type=Path)
+    command.add_argument("--output", type=Path)
+    command.set_defaults(func=validate_release)
+
+    command = subparsers.add_parser("make-holdout")
+    command.add_argument("--template", required=True, type=Path)
+    command.add_argument("--release-id", required=True)
+    command.add_argument("--master-key-env", required=True)
+    command.add_argument("--output", required=True, type=Path)
+    command.set_defaults(func=make_holdout)
+
+    command = subparsers.add_parser("probe-boundary")
+    command.add_argument("--base-url", required=True)
+    command.add_argument("--model", required=True)
+    add_tokenizer_profile_arguments(command)
+    command.add_argument("--context-window", type=int, default=262144)
+    command.add_argument("--reserved-output-tokens", type=int, default=2048)
+    command.add_argument("--include-positive", action="store_true")
+    command.add_argument("--api-key-env")
+    command.add_argument("--timeout", type=float, default=900)
+    command.add_argument("--output", required=True, type=Path)
+    command.set_defaults(func=probe_boundary)
+    return parser
+
+
+def main() -> None:
+    args = make_parser().parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

src/shiftedx_bench/context.py

@@ -0,0 +1,340 @@
+from __future__ import annotations
+
+import itertools
+import random
+from dataclasses import dataclass
+from typing import Any
+
+from .models import BenchCase
+from .tokenizer import TokenizerProtocol
+from .util import sha256_json
+
+
+SYSTEM_PROMPT = (
+    "You are running a deterministic long-context evaluation. Read the complete "
+    "context, ignore stale or decoy records, and return only the requested bare JSON."
+)
+
+
+@dataclass(frozen=True)
+class ContextSpec:
+    suite_id: str
+    matrix: str
+    family: str
+    target_tokens: int
+    position: float
+    seed: int
+    query_placement: str = "after"
+
+    @property
+    def case_id(self) -> str:
+        position = f"p{round(self.position * 100):02d}"
+        return (
+            f"{self.matrix}__{self.family}__t{self.target_tokens}__{position}"
+            f"__s{self.seed}__q{self.query_placement}"
+        )
+
+
+def expand_context_config(config: dict[str, Any]) -> list[ContextSpec]:
+    suite_id = str(config["suite_id"])
+    context_window = int(config.get("context_window") or 0)
+    reserved_output = int(config.get("reserved_output_tokens") or 0)
+    maximum_prompt = context_window - reserved_output if context_window and reserved_output else None
+    specs: list[ContextSpec] = []
+    for matrix in config["matrices"]:
+        values = itertools.product(
+            matrix["families"],
+            matrix["lengths"],
+            matrix["positions"],
+            matrix["seeds"],
+            matrix.get("query_placements", ["after"]),
+        )
+        for family, length, position, seed, placement in values:
+            if not 0 < float(position) < 1:
+                raise ValueError(f"Position must be between zero and one: {position}")
+            if placement not in {"before", "after"}:
+                raise ValueError(f"Unsupported query placement: {placement}")
+            if maximum_prompt is not None and int(length) > maximum_prompt:
+                raise ValueError(
+                    f"Prompt length {length} exceeds context-minus-output budget {maximum_prompt}"
+                )
+            specs.append(
+                ContextSpec(
+                    suite_id=suite_id,
+                    matrix=str(matrix["name"]),
+                    family=str(family),
+                    target_tokens=int(length),
+                    position=float(position),
+                    seed=int(seed),
+                    query_placement=str(placement),
+                )
+            )
+    identifiers = [item.case_id for item in specs]
+    if len(identifiers) != len(set(identifiers)):
+        raise ValueError("Context configuration produces duplicate case identifiers")
+    return specs
+
+
+def _secret(seed: int, label: str) -> str:
+    rng = random.Random(f"{seed}:{label}")
+    left = ["amber", "cedar", "indigo", "marble", "opal", "quartz", "saffron"]
+    right = ["falcon", "harbor", "lighthouse", "otter", "raven", "willow"]
+    return f"{rng.choice(left)}-{rng.randrange(100000, 999999)}-{rng.choice(right)}"
+
+
+def _task_payload(spec: ContextSpec) -> tuple[list[tuple[float, str, str]], str, dict[str, Any]]:
+    target = _secret(spec.seed, spec.family)
+    decoy_a = _secret(spec.seed + 101, "decoy-a")
+    decoy_b = _secret(spec.seed + 202, "decoy-b")
+    marker = f"<<SX_PRIMARY_{spec.seed}_{spec.family.upper()}>>"
+    common: dict[str, Any] = {"record": target}
+    insertions: list[tuple[float, str, str]] = [
+        (0.08, "decoy-a", f"STALE RECORD record={decoy_a} status=revoked revision=2"),
+        (0.92, "decoy-b", f"DECOY RECORD record={decoy_b} status=simulation revision=99"),
+    ]
+
+    if spec.family == "single_key":
+        primary = f"{marker} CANONICAL RECORD record={target} status=active"
+        query = "Return the active canonical record."
+    elif spec.family == "binding":
+        key = f"device-{(spec.seed % 83) + 10}"
+        primary = (
+            f"{marker} AUTHORITATIVE BINDING device={key} record={target} "
+            "status=active; similar device identifiers are unrelated."
+        )
+        common["device"] = key
+        query = f"Return the active record bound specifically to device {key}."
+    elif spec.family == "latest_record":
+        primary = f"{marker} CHANGELOG record={target} revision=12 state=current"
+        insertions.extend(
+            [
+                (0.19, "older", f"CHANGELOG record={decoy_a} revision=10 state=superseded"),
+                (0.77, "newer-decoy", f"CHANGELOG record={decoy_b} revision=13 state=test-only"),
+            ]
+        )
+        common["revision"] = 12
+        query = "Return the highest production revision marked current, excluding test-only entries."
+    elif spec.family == "multi_hop":
+        relay = f"relay-{(spec.seed % 71) + 20}"
+        zone = ["north", "south", "east", "west"][spec.seed % 4]
+        primary = f"{marker} ROUTE MAP record={target} uses_relay={relay}"
+        insertions.append(
+            (1.0 - spec.position, "hop-two", f"RELAY DIRECTORY relay={relay} final_zone={zone}"),
+        )
+        common.update({"relay": relay, "zone": zone})
+        query = "Follow the route map through the relay directory and return record, relay, and final zone."
+    elif spec.family == "semantic":
+        callsign = f"unit-{(spec.seed % 89) + 10}"
+        primary = (
+            f"{marker} The only solar-powered courier approved for silent night delivery "
+            f"has registry value {target} and operational callsign {callsign}."
+        )
+        common["callsign"] = callsign
+        query = (
+            "Identify the registry value and callsign of the emission-free messenger "
+            "authorized to work after dark."
+        )
+    elif spec.family == "state_tracking":
+        counter = 10 + spec.seed % 7
+        add_a = 3 + spec.seed % 5
+        subtract = 1 + spec.seed % 3
+        final = counter + add_a - subtract
+        primary = f"{marker} STATE stream={target} value={counter} sequence=1"
+        insertions.extend(
+            [
+                (min(0.95, spec.position + 0.18), "update-a", f"UPDATE stream={target} add={add_a} sequence=2"),
+                (min(0.98, spec.position + 0.34), "update-b", f"UPDATE stream={target} subtract={subtract} sequence=3"),
+            ]
+        )
+        common["final_value"] = final
+        query = "Apply the ordered updates and return the stream record and final value."
+    else:
+        raise ValueError(f"Unknown context family: {spec.family}")
+
+    primary_end_marker = f"<<SX_PRIMARY_END_{spec.seed}_{spec.family.upper()}>>"
+    insertions.append((spec.position, "primary", primary + " " + primary_end_marker))
+    return sorted(insertions, key=lambda item: (item[0], item[1])), query, common
+
+
+def _filler_pool(tokenizer: TokenizerProtocol, seed: int) -> list[int]:
+    rng = random.Random(seed)
+    services = ["atlas", "beacon", "cinder", "delta", "ember", "fjord", "garnet", "helios"]
+    states = ["nominal", "queued", "retrying", "stable", "verified", "warming"]
+    regions = ["north-ridge", "west-field", "central-bay", "east-grove"]
+    lines = []
+    for index in range(5000):
+        service = rng.choice(services)
+        state = rng.choice(states)
+        region = rng.choice(regions)
+        trace = f"{rng.getrandbits(48):012x}"
+        lines.append(
+            f"event {index:05d}: service={service} region={region} state={state} "
+            f"latency_ms={rng.randrange(3, 997)} trace={trace}; routine telemetry only."
+        )
+    token_ids = tokenizer.encode("\n" + "\n".join(lines) + "\n")
+    if len(token_ids) < 1000:
+        raise ValueError("Tokenizer produced an unexpectedly small filler pool")
+    return token_ids
+
+
+def _take(pool: list[int], count: int, offset: int) -> list[int]:
+    if count <= 0:
+        return []
+    start = offset % len(pool)
+    rotated = pool[start:] + pool[:start]
+    repeats, remainder = divmod(count, len(rotated))
+    return rotated * repeats + rotated[:remainder]
+
+
+def _allocate_filler(total: int, insertion_positions: list[float]) -> list[int]:
+    gaps = []
+    previous = 0.0
+    for position in insertion_positions:
+        gaps.append(max(0.0, position - previous))
+        previous = position
+    gaps.append(max(0.0, 1.0 - previous))
+    raw = [total * gap for gap in gaps]
+    values = [int(value) for value in raw]
+    for index in sorted(range(len(raw)), key=lambda item: raw[item] - values[item], reverse=True):
+        if sum(values) >= total:
+            break
+        values[index] += 1
+    return values
+
+
+def build_context_case(spec: ContextSpec, tokenizer: TokenizerProtocol) -> BenchCase:
+    insertions, query, expected = _task_payload(spec)
+    start_sentinel = f"SX_START_{spec.seed}_{spec.family}"
+    end_sentinel = f"SX_END_{spec.seed}_{spec.family}"
+    expected = {"start_sentinel": start_sentinel, **expected, "end_sentinel": end_sentinel}
+    keys = ", ".join(expected)
+    query_text = f"{query} Return exactly one JSON object with keys: {keys}."
+    prefix_query = query_text + "\n\n" if spec.query_placement == "before" else ""
+    suffix_query = "\n\n" + query_text if spec.query_placement == "after" else ""
+
+    fixed_user = (
+        prefix_query
+        + f"BEGIN CONTEXT\nSTART SENTINEL: {start_sentinel}\n"
+        + "\n".join(text for _, _, text in insertions)
+        + f"\nEND SENTINEL: {end_sentinel}\nEND CONTEXT"
+        + suffix_query
+    )
+    fixed_messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": fixed_user},
+    ]
+    fixed_tokens = len(tokenizer.encode(tokenizer.render_chat(fixed_messages)))
+    available = spec.target_tokens - fixed_tokens
+    if available < 512:
+        raise ValueError(
+            f"Target {spec.target_tokens} is too small for {spec.family}; only {available} filler tokens remain"
+        )
+
+    pool = _filler_pool(tokenizer, spec.seed)
+    allocations = _allocate_filler(available, [item[0] for item in insertions])
+    segments = [_take(pool, size, spec.seed * 97 + index * 7919) for index, size in enumerate(allocations)]
+    primary_index = next(index for index, item in enumerate(insertions) if item[1] == "primary")
+    primary_marker = insertions[primary_index][2].split(" ", 1)[0]
+    primary_end_marker = f"<<SX_PRIMARY_END_{spec.seed}_{spec.family.upper()}>>"
+
+    def make_messages() -> list[dict[str, Any]]:
+        context_parts = [f"START SENTINEL: {start_sentinel}\n"]
+        for index, (_, _, insertion) in enumerate(insertions):
+            context_parts.append(tokenizer.decode(segments[index]))
+            context_parts.append("\n" + insertion + "\n")
+        context_parts.append(tokenizer.decode(segments[-1]))
+        context_parts.append(f"\nEND SENTINEL: {end_sentinel}")
+        user = prefix_query + "BEGIN CONTEXT\n" + "".join(context_parts) + "\nEND CONTEXT" + suffix_query
+        return [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": user},
+        ]
+
+    diagnostics: list[tuple[int, int, int]] = []
+    for iteration in range(24):
+        messages = make_messages()
+        rendered = tokenizer.render_chat(messages)
+        actual_total = len(tokenizer.encode(rendered))
+        total_delta = spec.target_tokens - actual_total
+        primary_start = tokenizer.token_offset(rendered, primary_marker)
+        primary_end = tokenizer.token_offset(rendered, primary_end_marker)
+        actual_offset = round((primary_start + primary_end) / 2)
+        context_start = tokenizer.token_offset(rendered, "START SENTINEL:")
+        context_end = tokenizer.token_offset(rendered, "END SENTINEL:")
+        diagnostics.append((actual_total, actual_offset, total_delta))
+        if total_delta:
+            if total_delta > 0:
+                segments[-1].extend(_take(pool, total_delta, spec.seed + iteration * 3571))
+            else:
+                remaining = -total_delta
+                for segment in reversed(segments):
+                    removed = min(remaining, len(segment))
+                    if removed:
+                        del segment[-removed:]
+                        remaining -= removed
+                    if remaining == 0:
+                        break
+                if remaining:
+                    raise ValueError("Unable to trim context to requested token count")
+            continue
+
+        desired_offset = context_start + round((context_end - context_start) * spec.position)
+        position_delta = desired_offset - actual_offset
+        tolerance = max(4, round(spec.target_tokens * 0.0025))
+        if abs(position_delta) <= tolerance:
+            break
+        before = segments[primary_index]
+        after = segments[primary_index + 1]
+        if position_delta > 0:
+            movement = min(position_delta, len(after))
+            before.extend(_take(pool, movement, spec.seed + iteration * 1237))
+            del after[:movement]
+        else:
+            movement = min(-position_delta, len(before))
+            del before[-movement:]
+            after[:0] = _take(pool, movement, spec.seed + iteration * 1237)
+    else:
+        raise RuntimeError(
+            f"Exact context construction did not converge for {spec.case_id}; "
+            f"last iterations={diagnostics[-6:]}"
+        )
+
+    messages = make_messages()
+    rendered = tokenizer.render_chat(messages)
+    actual_total = len(tokenizer.encode(rendered))
+    primary_start = tokenizer.token_offset(rendered, primary_marker)
+    primary_end = tokenizer.token_offset(rendered, primary_end_marker)
+    actual_offset = round((primary_start + primary_end) / 2)
+    context_start = tokenizer.token_offset(rendered, "START SENTINEL:")
+    context_end = tokenizer.token_offset(rendered, "END SENTINEL:")
+    if actual_total != spec.target_tokens:
+        raise AssertionError(f"Requested {spec.target_tokens} rendered tokens, produced {actual_total}")
+    actual_position = (actual_offset - context_start) / (context_end - context_start)
+    metadata = {
+        "matrix": spec.matrix,
+        "family": spec.family,
+        "seed": spec.seed,
+        "target_prompt_tokens": spec.target_tokens,
+        "actual_rendered_tokens": actual_total,
+        "requested_position": spec.position,
+        "actual_primary_token_offset": actual_offset,
+        "actual_primary_start_token_offset": primary_start,
+        "actual_primary_end_token_offset": primary_end,
+        "actual_primary_position": actual_position,
+        "context_start_token_offset": context_start,
+        "context_end_token_offset": context_end,
+        "query_placement": spec.query_placement,
+        "tokenizer_fingerprint": tokenizer.fingerprint,
+        "prompt_hash": sha256_json(messages),
+        "truncation_sentinels": [start_sentinel, end_sentinel],
+    }
+    return BenchCase(
+        case_id=spec.case_id,
+        suite_id=spec.suite_id,
+        lane="long-context",
+        messages=messages,
+        scorer="strict_json_exact",
+        expected=expected,
+        max_output_tokens=2048,
+        metadata=metadata,
+    )

src/shiftedx_bench/holdout.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+from typing import Any
+
+
+def derive_holdout_config(template: dict[str, Any], master_key: str, release_id: str) -> dict[str, Any]:
+    if len(master_key) < 16:
+        raise ValueError("Holdout master key must contain at least 16 characters")
+    value = json.loads(json.dumps(template))
+    value["suite_id"] = f"{template['suite_id']}-holdout-{release_id}"
+    for matrix in value["matrices"]:
+        count = len(matrix.get("seeds") or [])
+        seeds = []
+        for index in range(count):
+            message = f"{release_id}:{matrix['name']}:{index}".encode()
+            digest = hmac.new(master_key.encode(), message, hashlib.sha256).digest()
+            seeds.append(int.from_bytes(digest[:4], "big") & 0x7FFFFFFF)
+        matrix["seeds"] = seeds
+    value["holdout"] = {
+        "release_id": release_id,
+        "derivation": "HMAC-SHA256",
+        "master_key_recorded": False,
+        "publish_after_evaluation": True,
+    }
+    return value
+

src/shiftedx_bench/models.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class BenchCase:
+    case_id: str
+    suite_id: str
+    lane: str
+    messages: list[dict[str, Any]]
+    scorer: str
+    expected: Any
+    max_output_tokens: int = 256
+    tools: list[dict[str, Any]] | None = None
+    request_overrides: dict[str, Any] = field(default_factory=dict)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self, *, include_expected: bool = True) -> dict[str, Any]:
+        value = asdict(self)
+        if not include_expected:
+            value.pop("expected", None)
+        return value
+
+
+@dataclass
+class CaseResult:
+    schema_version: str
+    run_id: str
+    suite_id: str
+    case_id: str
+    lane: str
+    variant: str
+    passed: bool
+    score: float
+    score_max: float
+    error: str | None
+    response: dict[str, Any]
+    telemetry: dict[str, Any]
+    metadata: dict[str, Any]
+    request_hash: str
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+

src/shiftedx_bench/provenance.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import platform
+import sys
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from . import __version__
+from .util import sha256_file, write_json
+
+
+def make_run_manifest(
+    *,
+    run_id: str,
+    suite_id: str,
+    model: str,
+    config_path: Path | None,
+    tokenizer_fingerprint: str | None,
+    variants: list[dict[str, Any]],
+) -> dict[str, Any]:
+    return {
+        "schema_version": "1.0",
+        "run_id": run_id,
+        "created_at": datetime.now(UTC).isoformat(),
+        "suite_id": suite_id,
+        "model": model,
+        "benchmark_version": __version__,
+        "config_sha256": sha256_file(config_path) if config_path else None,
+        "tokenizer_fingerprint": tokenizer_fingerprint,
+        "variants": variants,
+        "environment": {
+            "python": sys.version.split()[0],
+            "platform": platform.platform(),
+            "machine": platform.machine(),
+        },
+        "claim_policy": {
+            "quality_and_performance_separate": True,
+            "raw_requests_retained": True,
+            "single_aggregate_intelligence_score": False,
+        },
+    }
+
+
+def write_manifest(path: Path, value: dict[str, Any]) -> None:
+    write_json(path, value)
+

src/shiftedx_bench/quality.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+import heapq
+import json
+import random
+from typing import Any
+
+from .models import BenchCase
+
+
+DEFAULT_FAMILIES = [
+    "ledger",
+    "shortest_path",
+    "interval_schedule",
+    "table_join",
+    "event_state",
+    "instruction_order",
+    "code_chunks",
+    "code_window",
+    "code_normalize",
+    "code_percentile",
+]
+
+
+SYSTEM = (
+    "You are being evaluated by a deterministic harness. Follow the requested format "
+    "exactly and return no explanation or hidden reasoning."
+)
+
+
+def _case(case_id: str, family: str, prompt: str, expected: Any, scorer: str = "strict_json_exact") -> BenchCase:
+    return BenchCase(
+        case_id=case_id,
+        suite_id="shiftedx-quality-v1",
+        lane="quality",
+        messages=[{"role": "system", "content": SYSTEM}, {"role": "user", "content": prompt}],
+        scorer=scorer,
+        expected=expected,
+        max_output_tokens=4096 if scorer == "python_code" else 2048,
+        metadata={"family": family, "procedural": True},
+    )
+
+
+def _shortest_path(graph: dict[str, dict[str, int]], source: str, target: str) -> tuple[int, list[str]]:
+    queue: list[tuple[int, list[str], str]] = [(0, [source], source)]
+    best: dict[str, tuple[int, list[str]]] = {}
+    while queue:
+        distance, path, node = heapq.heappop(queue)
+        if node in best and best[node] <= (distance, path):
+            continue
+        best[node] = (distance, path)
+        if node == target:
+            return distance, path
+        for neighbor, weight in graph[node].items():
+            heapq.heappush(queue, (distance + weight, path + [neighbor], neighbor))
+    raise ValueError("unreachable")
+
+
+def _interval_solution(jobs: list[tuple[int, int, int]]) -> tuple[int, list[int]]:
+    best_weight = -1
+    best_indices: list[int] = []
+    for mask in range(1 << len(jobs)):
+        indices = [index for index in range(len(jobs)) if mask & (1 << index)]
+        selected = sorted((jobs[index][0], jobs[index][1], index) for index in indices)
+        if any(selected[index][1] > selected[index + 1][0] for index in range(len(selected) - 1)):
+            continue
+        weight = sum(jobs[index][2] for index in indices)
+        if weight > best_weight or (weight == best_weight and indices < best_indices):
+            best_weight, best_indices = weight, indices
+    return best_weight, best_indices
+
+
+def generate_quality_cases(seeds: list[int], families: list[str] | None = None) -> list[BenchCase]:
+    families = families or DEFAULT_FAMILIES
+    cases: list[BenchCase] = []
+    for seed in seeds:
+        rng = random.Random(seed)
+        for family in families:
+            case_id = f"{family}__s{seed}"
+            if family == "ledger":
+                values = [rng.randrange(-90, 160) for _ in range(14)]
+                expected = {"net": sum(values), "credits": sum(value > 0 for value in values)}
+                prompt = (
+                    f"Transactions: {values}. Return bare JSON with exactly two keys: "
+                    "net and credits. credits is the number of positive transactions."
+                )
+                cases.append(_case(case_id, family, prompt, expected))
+            elif family == "shortest_path":
+                graph = {
+                    "A": {"B": rng.randrange(1, 7), "C": rng.randrange(4, 10)},
+                    "B": {"C": rng.randrange(1, 5), "D": rng.randrange(3, 9)},
+                    "C": {"D": rng.randrange(1, 5), "E": rng.randrange(4, 9)},
+                    "D": {"E": rng.randrange(1, 5)},
+                    "E": {},
+                }
+                distance, path = _shortest_path(graph, "A", "E")
+                prompt = (
+                    f"Directed weighted graph: {json.dumps(graph, sort_keys=True)}. "
+                    "Return bare JSON with the shortest distance and lexicographically smallest path from A to E."
+                )
+                cases.append(_case(case_id, family, prompt, {"distance": distance, "path": path}))
+            elif family == "interval_schedule":
+                jobs = []
+                for index in range(8):
+                    start = rng.randrange(0, 14)
+                    jobs.append((start, start + rng.randrange(1, 6), rng.randrange(1, 20)))
+                weight, indices = _interval_solution(jobs)
+                prompt = (
+                    f"Jobs as [start,end,weight]: {jobs}. Select non-overlapping jobs where end <= next start. "
+                    "Return bare JSON with max_weight and selected original indices; break ties lexicographically."
+                )
+                cases.append(_case(case_id, family, prompt, {"max_weight": weight, "indices": indices}))
+            elif family == "table_join":
+                items = [f"sku-{index}" for index in range(6)]
+                quantities = {item: rng.randrange(0, 9) for item in items}
+                prices = {item: rng.randrange(3, 30) for item in reversed(items)}
+                total = sum(quantities[item] * prices[item] for item in items)
+                prompt = (
+                    f"Quantities={json.dumps(quantities)}; unit_prices={json.dumps(prices)}. "
+                    "Join by SKU and return bare JSON with total_value and zero_stock SKUs in sorted order."
+                )
+                expected = {"total_value": total, "zero_stock": sorted(k for k, v in quantities.items() if v == 0)}
+                cases.append(_case(case_id, family, prompt, expected))
+            elif family == "event_state":
+                value = rng.randrange(10, 30)
+                events = []
+                for _ in range(9):
+                    operation = rng.choice(["add", "subtract", "double", "ignore"])
+                    amount = rng.randrange(1, 6)
+                    events.append([operation, amount])
+                    if operation == "add":
+                        value += amount
+                    elif operation == "subtract":
+                        value -= amount
+                    elif operation == "double":
+                        value *= 2
+                initial = rng.randrange(10, 30)
+                value = initial
+                for operation, amount in events:
+                    if operation == "add": value += amount
+                    elif operation == "subtract": value -= amount
+                    elif operation == "double": value *= 2
+                prompt = (
+                    f"Initial value={initial}; ordered events={events}. Ignore events named ignore. "
+                    "Return bare JSON with final_value and applied_event_count."
+                )
+                expected = {"final_value": value, "applied_event_count": sum(e[0] != "ignore" for e in events)}
+                cases.append(_case(case_id, family, prompt, expected))
+            elif family == "instruction_order":
+                words = ["amber", "cinder", "fjord", "opal", "raven", "willow"]
+                rng.shuffle(words)
+                chosen = sorted(words[1:5], key=lambda value: (len(value), value), reverse=True)
+                prompt = (
+                    f"Words={words}. Discard the first and last list elements, then sort the remainder by "
+                    "descending length and reverse alphabetical order for ties. Return the bare JSON array."
+                )
+                cases.append(_case(case_id, family, prompt, chosen))
+            elif family == "code_chunks":
+                prompt = (
+                    "Return only Python code defining chunked(values, size). It must return consecutive lists, "
+                    "include a final short chunk, reject size <= 0 with ValueError, and not mutate input."
+                )
+                tests = """
+assert chunked([1,2,3,4,5], 2) == [[1,2],[3,4],[5]]
+assert chunked([], 3) == []
+x=[1,2,3]; assert chunked(x, 5)==[[1,2,3]] and x==[1,2,3]
+for bad in (0,-1):
+    try: chunked([1], bad); raise AssertionError('missing ValueError')
+    except ValueError: pass
+"""
+                cases.append(_case(case_id, family, prompt, {"tests": tests}, "python_code"))
+            elif family == "code_window":
+                prompt = (
+                    "Return only Python code defining max_window_sum(values, width). Return the largest sum of "
+                    "exactly width consecutive values. Raise ValueError for empty input or invalid width."
+                )
+                tests = """
+assert max_window_sum([2,-1,5,1,-3], 2) == 6
+assert max_window_sum([-8,-3,-5], 1) == -3
+assert max_window_sum([4,2], 2) == 6
+for args in [([],1),([1],0),([1],2)]:
+    try: max_window_sum(*args); raise AssertionError('missing ValueError')
+    except ValueError: pass
+"""
+                cases.append(_case(case_id, family, prompt, {"tests": tests}, "python_code"))
+            elif family == "code_normalize":
+                prompt = (
+                    "Return only Python code defining normalize_segments(path). Collapse empty and '.' segments; "
+                    "resolve '..'; absolute paths cannot rise above root; relative paths preserve leading '..'."
+                )
+                tests = """
+assert normalize_segments('/a//b/../c') == '/a/c'
+assert normalize_segments('../../a') == '../../a'
+assert normalize_segments('a/../../b') == '../b'
+assert normalize_segments('/../../a') == '/a'
+assert normalize_segments('') == '.'
+"""
+                cases.append(_case(case_id, family, prompt, {"tests": tests}, "python_code"))
+            elif family == "code_percentile":
+                prompt = (
+                    "Return only Python code defining percentile(values, p). Use sorted values and linear "
+                    "interpolation at rank p/100*(n-1). Reject empty input and p outside 0..100 with ValueError."
+                )
+                tests = """
+assert percentile([1,2,3,4], 50) == 2.5
+assert percentile([10,0,20], 25) == 5
+assert percentile([7], 99) == 7
+for args in [([],50),([1],-1),([1],101)]:
+    try: percentile(*args); raise AssertionError('missing ValueError')
+    except ValueError: pass
+"""
+                cases.append(_case(case_id, family, prompt, {"tests": tests}, "python_code"))
+            else:
+                raise ValueError(f"Unknown quality family: {family}")
+    return cases

src/shiftedx_bench/release.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+
+TEXT_SUFFIXES = {".md", ".py", ".json", ".jsonl", ".toml", ".yaml", ".yml", ".txt"}
+FORBIDDEN = {
+    "Hugging Face access token": re.compile("h" + r"f_[A-Za-z0-9]{20,}"),
+    "macOS user path": re.compile("/" + r"Users/[^/\s]+/"),
+    "Linux user path": re.compile("/" + r"home/[^/\s]+/"),
+    "private key": re.compile(r"-----BEGIN (?:RSA |OPENSSH |EC )?PRIVATE KEY-----"),
+    "loopback URL in public result": re.compile(r"https?://(?:127\.0\.0\.1|localhost):\d+"),
+}
+
+
+def scan_public_tree(root: Path) -> dict[str, Any]:
+    failures = []
+    for path in sorted(root.rglob("*")):
+        if not path.is_file() or path.suffix.lower() not in TEXT_SUFFIXES:
+            continue
+        relative = path.relative_to(root).as_posix()
+        if any(part in {".git", ".pytest_cache", "__pycache__"} for part in path.parts):
+            continue
+        text = path.read_text(encoding="utf-8", errors="replace")
+        for label, pattern in FORBIDDEN.items():
+            if pattern.search(text):
+                failures.append({"file": relative, "issue": label})
+    return {"ok": not failures, "failures": failures, "files_scanned": sum(1 for p in root.rglob("*") if p.is_file())}

src/shiftedx_bench/runner.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import os
+import uuid
+from pathlib import Path
+from typing import Any, Iterable
+
+from .api import OpenAIClient
+from .models import BenchCase, CaseResult
+from .scoring import score_response
+from .util import append_jsonl, read_jsonl, sha256_json
+
+
+def build_payload(case: BenchCase, model: str, variant: dict[str, Any]) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "model": model,
+        "messages": case.messages,
+        "temperature": 0,
+        "top_p": 1,
+        "max_tokens": case.max_output_tokens,
+        "seed": 7319,
+    }
+    if case.tools:
+        payload["tools"] = case.tools
+        payload["tool_choice"] = "auto"
+    payload.update(case.request_overrides)
+    payload.update(variant.get("request_overrides") or {})
+    return payload
+
+
+def run_cases(
+    cases: Iterable[BenchCase],
+    *,
+    client: OpenAIClient,
+    model: str,
+    output_path: Path,
+    variants: list[dict[str, Any]] | None = None,
+    run_id: str | None = None,
+    stream: bool = False,
+) -> list[dict[str, Any]]:
+    run_id = run_id or str(uuid.uuid4())
+    variants = variants or [{"label": "default", "request_overrides": {}}]
+    completed = {
+        (row.get("case_id"), row.get("variant"))
+        for row in read_jsonl(output_path)
+        if row.get("schema_version") == "1.0"
+    }
+    new_rows: list[dict[str, Any]] = []
+    for case in cases:
+        for variant in variants:
+            label = str(variant["label"])
+            if (case.case_id, label) in completed:
+                continue
+            payload = build_payload(case, model, variant)
+            request_hash = sha256_json(payload)
+            error = None
+            try:
+                response = client.complete(payload, stream=stream and not case.tools)
+                scored = score_response(case.scorer, case.expected, response)
+                passed = scored.passed
+                error = scored.error
+                if "target_prompt_tokens" in case.metadata:
+                    server_tokens = response.get("prompt_tokens")
+                    requested_tokens = case.metadata["target_prompt_tokens"]
+                    if server_tokens != requested_tokens:
+                        passed = False
+                        error = (
+                            f"server prompt token mismatch: requested={requested_tokens}, "
+                            f"reported={server_tokens}"
+                        )
+                telemetry = {
+                    key: response.get(key)
+                    for key in (
+                        "wall_s",
+                        "ttft_s",
+                        "prompt_tokens",
+                        "completion_tokens",
+                        "end_to_end_tokens_per_second",
+                        "prefill_tokens_per_second",
+                        "decode_tokens_per_second",
+                        "active_memory_bytes",
+                        "cache_memory_bytes",
+                        "mtplx_stats",
+                    )
+                }
+                usage = response.get("usage") or {}
+                telemetry["cached_prompt_tokens"] = (
+                    (usage.get("prompt_tokens_details") or {}).get("cached_tokens")
+                )
+                stats = response.get("mtplx_stats") or {}
+                accepted = stats.get("accepted_drafts")
+                drafted = stats.get("drafted_tokens")
+                telemetry["accepted_draft_ratio"] = (
+                    accepted / drafted
+                    if isinstance(accepted, (int, float)) and isinstance(drafted, (int, float)) and drafted
+                    else stats.get("accepted_draft_ratio")
+                )
+                result = CaseResult(
+                    schema_version="1.0",
+                    run_id=run_id,
+                    suite_id=case.suite_id,
+                    case_id=case.case_id,
+                    lane=case.lane,
+                    variant=label,
+                    passed=passed,
+                    score=scored.value if passed else 0.0,
+                    score_max=scored.maximum,
+                    error=error,
+                    response={
+                        key: response.get(key)
+                        for key in (
+                            "model",
+                            "content",
+                            "reasoning_content",
+                            "tool_calls",
+                            "finish_reason",
+                            "usage",
+                        )
+                    },
+                    telemetry=telemetry,
+                    metadata=case.metadata,
+                    request_hash=request_hash,
+                )
+            except Exception as exc:
+                result = CaseResult(
+                    schema_version="1.0",
+                    run_id=run_id,
+                    suite_id=case.suite_id,
+                    case_id=case.case_id,
+                    lane=case.lane,
+                    variant=label,
+                    passed=False,
+                    score=0.0,
+                    score_max=1.0,
+                    error=f"{type(exc).__name__}: {exc}",
+                    response={},
+                    telemetry={},
+                    metadata=case.metadata,
+                    request_hash=request_hash,
+                )
+            row = result.to_dict()
+            append_jsonl(output_path, [row])
+            new_rows.append(row)
+    return new_rows
+
+
+def api_key_from_env(name: str | None) -> str | None:
+    if not name:
+        return None
+    value = os.environ.get(name)
+    if not value:
+        raise RuntimeError(f"API-key environment variable is not set: {name}")
+    return value

src/shiftedx_bench/sandbox.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import ast
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any
+
+
+FORBIDDEN_CALLS = {"compile", "eval", "exec", "input", "open", "breakpoint", "__import__"}
+
+
+def validate_python_ast(code: str) -> None:
+    tree = ast.parse(code)
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.Import, ast.ImportFrom, ast.Global, ast.Nonlocal)):
+            raise ValueError(f"Forbidden syntax: {type(node).__name__}")
+        if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
+            if node.func.id in FORBIDDEN_CALLS:
+                raise ValueError(f"Forbidden call: {node.func.id}")
+        if isinstance(node, ast.Attribute) and node.attr.startswith("__"):
+            raise ValueError("Dunder attribute access is forbidden")
+        if isinstance(node, ast.Name) and node.id.startswith("__") and node.id != "__name__":
+            raise ValueError("Dunder names are forbidden")
+
+
+def _resource_limits() -> None:
+    try:
+        import resource
+
+        resource.setrlimit(resource.RLIMIT_CPU, (3, 3))
+        memory = 512 * 1024 * 1024
+        resource.setrlimit(resource.RLIMIT_AS, (memory, memory))
+        resource.setrlimit(resource.RLIMIT_FSIZE, (1024 * 1024, 1024 * 1024))
+        resource.setrlimit(resource.RLIMIT_NOFILE, (32, 32))
+    except (ImportError, OSError, ValueError):
+        pass
+
+
+def run_python_submission(code: str, tests: str, timeout_s: float = 5.0) -> dict[str, Any]:
+    try:
+        validate_python_ast(code)
+        validate_python_ast(tests)
+    except Exception as exc:
+        return {"passed": False, "error": f"static rejection: {exc}"}
+    with tempfile.TemporaryDirectory(prefix="shiftedx-bench-") as temporary:
+        path = Path(temporary) / "submission.py"
+        path.write_text(code + "\n\n" + tests + "\n", encoding="utf-8")
+        environment = {
+            "PATH": os.environ.get("PATH", ""),
+            "PYTHONHASHSEED": "0",
+            "PYTHONDONTWRITEBYTECODE": "1",
+        }
+        try:
+            completed = subprocess.run(
+                [sys.executable, "-I", "-S", str(path)],
+                cwd=temporary,
+                env=environment,
+                capture_output=True,
+                text=True,
+                timeout=timeout_s,
+                preexec_fn=_resource_limits if os.name == "posix" else None,
+                check=False,
+            )
+        except subprocess.TimeoutExpired:
+            return {"passed": False, "error": "execution timed out"}
+        output = (completed.stdout + completed.stderr)[-4000:]
+        return {
+            "passed": completed.returncode == 0,
+            "error": None if completed.returncode == 0 else output.strip(),
+            "returncode": completed.returncode,
+        }

src/shiftedx_bench/scoring.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from typing import Any
+
+from .sandbox import run_python_submission
+
+
+@dataclass(frozen=True)
+class Score:
+    passed: bool
+    value: float
+    maximum: float
+    error: str | None = None
+
+
+def response_text(response: dict[str, Any]) -> str:
+    return str(response.get("content") or "")
+
+
+def strict_json(text: str) -> Any:
+    stripped = text.strip()
+    if stripped.startswith("```") or not stripped:
+        raise ValueError("Expected bare JSON without Markdown fences")
+    decoder = json.JSONDecoder()
+    value, end = decoder.raw_decode(stripped)
+    if stripped[end:].strip():
+        raise ValueError("Unexpected text after JSON value")
+    return value
+
+
+def _normalize_tool_calls(response: dict[str, Any]) -> list[dict[str, Any]]:
+    normalized = []
+    for call in response.get("tool_calls") or []:
+        function = call.get("function") or {}
+        arguments = function.get("arguments", {})
+        if isinstance(arguments, str):
+            arguments = json.loads(arguments)
+        normalized.append({"name": function.get("name"), "arguments": arguments})
+    return normalized
+
+
+def score_response(scorer: str, expected: Any, response: dict[str, Any]) -> Score:
+    try:
+        if scorer == "exact_text":
+            actual = response_text(response).strip()
+            passed = actual == str(expected)
+        elif scorer == "strict_json_exact":
+            actual = strict_json(response_text(response))
+            passed = actual == expected
+        elif scorer == "strict_json_subset":
+            actual = strict_json(response_text(response))
+            if not isinstance(actual, dict) or not isinstance(expected, dict):
+                passed = False
+            else:
+                passed = all(actual.get(key) == value for key, value in expected.items())
+        elif scorer == "tool_calls_exact":
+            actual = _normalize_tool_calls(response)
+            passed = actual == expected
+        elif scorer == "python_code":
+            text = response_text(response).strip()
+            match = re.fullmatch(r"```(?:python)?\s*(.*?)\s*```", text, re.DOTALL | re.IGNORECASE)
+            code = match.group(1) if match else text
+            outcome = run_python_submission(code, str(expected["tests"]))
+            passed = outcome["passed"]
+            return Score(passed, float(passed), 1.0, outcome.get("error"))
+        else:
+            raise ValueError(f"Unknown scorer: {scorer}")
+        return Score(passed, float(passed), 1.0, None if passed else "answer mismatch")
+    except Exception as exc:
+        return Score(False, 0.0, 1.0, f"{type(exc).__name__}: {exc}")
+

src/shiftedx_bench/summary.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import random
+import statistics
+from collections import defaultdict
+from typing import Any
+
+
+def _mean(values: list[float]) -> float | None:
+    return statistics.fmean(values) if values else None
+
+
+def bootstrap_mean_ci(values: list[float], *, seed: int = 7319, samples: int = 2000) -> list[float] | None:
+    if not values:
+        return None
+    rng = random.Random(seed)
+    estimates = []
+    for _ in range(samples):
+        estimates.append(statistics.fmean(rng.choice(values) for _ in values))
+    estimates.sort()
+    return [estimates[round(0.025 * (samples - 1))], estimates[round(0.975 * (samples - 1))]]
+
+
+def summarize_results(rows: list[dict[str, Any]], effective_threshold: float = 0.90) -> dict[str, Any]:
+    grouped: dict[tuple[str, str], list[dict[str, Any]]] = defaultdict(list)
+    for row in rows:
+        grouped[(str(row.get("variant")), str(row.get("lane")))].append(row)
+    scorecards: dict[str, Any] = {}
+    for (variant, lane), items in sorted(grouped.items()):
+        values = [float(bool(item.get("passed"))) for item in items]
+        wall = [float(item["telemetry"]["wall_s"]) for item in items if item.get("telemetry", {}).get("wall_s")]
+        ttft = [float(item["telemetry"]["ttft_s"]) for item in items if item.get("telemetry", {}).get("ttft_s")]
+        throughput = [
+            float(item["telemetry"]["end_to_end_tokens_per_second"])
+            for item in items
+            if item.get("telemetry", {}).get("end_to_end_tokens_per_second")
+        ]
+        acceptance = [
+            float(item["telemetry"]["accepted_draft_ratio"])
+            for item in items
+            if item.get("telemetry", {}).get("accepted_draft_ratio") is not None
+        ]
+        cached = [
+            float(item["telemetry"]["cached_prompt_tokens"])
+            for item in items
+            if item.get("telemetry", {}).get("cached_prompt_tokens") is not None
+        ]
+        prefill = [
+            float(item["telemetry"]["prefill_tokens_per_second"])
+            for item in items
+            if item.get("telemetry", {}).get("prefill_tokens_per_second") is not None
+        ]
+        decode = [
+            float(item["telemetry"]["decode_tokens_per_second"])
+            for item in items
+            if item.get("telemetry", {}).get("decode_tokens_per_second") is not None
+        ]
+        memory = [
+            float(item["telemetry"]["active_memory_bytes"])
+            for item in items
+            if item.get("telemetry", {}).get("active_memory_bytes") is not None
+        ]
+        scorecards.setdefault(variant, {})[lane] = {
+            "cases": len(items),
+            "passed": sum(values),
+            "accuracy": _mean(values),
+            "accuracy_95_ci": bootstrap_mean_ci(values),
+            "mean_wall_s": _mean(wall),
+            "mean_ttft_s": _mean(ttft),
+            "mean_end_to_end_tokens_per_second": _mean(throughput),
+            "mean_accepted_draft_ratio": _mean(acceptance),
+            "mean_cached_prompt_tokens": _mean(cached),
+            "mean_prefill_tokens_per_second": _mean(prefill),
+            "mean_decode_tokens_per_second": _mean(decode),
+            "max_active_memory_bytes": max(memory) if memory else None,
+        }
+
+    context_rows = [row for row in rows if row.get("lane") == "long-context"]
+    context: dict[str, Any] = {}
+    for variant in sorted({str(row.get("variant")) for row in context_rows}):
+        selected = [row for row in context_rows if row.get("variant") == variant]
+        cells: dict[tuple[int, float], list[float]] = defaultdict(list)
+        family: dict[str, list[float]] = defaultdict(list)
+        by_length: dict[int, list[float]] = defaultdict(list)
+        by_position: dict[float, list[float]] = defaultdict(list)
+        for row in selected:
+            metadata = row.get("metadata") or {}
+            length = int(metadata["target_prompt_tokens"])
+            position = float(metadata["requested_position"])
+            value = float(bool(row.get("passed")))
+            cells[(length, position)].append(value)
+            family[str(metadata["family"])].append(value)
+            by_length[length].append(value)
+            by_position[position].append(value)
+        length_scores = {str(key): _mean(value) for key, value in sorted(by_length.items())}
+        qualifying = [key for key, value in by_length.items() if statistics.fmean(value) >= effective_threshold]
+        context[variant] = {
+            "effective_context_threshold": effective_threshold,
+            "effective_context_length": max(qualifying) if qualifying else None,
+            "accuracy_by_length": length_scores,
+            "accuracy_by_position": {str(key): _mean(value) for key, value in sorted(by_position.items())},
+            "accuracy_by_family": {key: _mean(value) for key, value in sorted(family.items())},
+            "heatmap": [
+                {"length": length, "position": position, "accuracy": _mean(value), "trials": len(value)}
+                for (length, position), value in sorted(cells.items())
+            ],
+            "worst_cell_accuracy": min((statistics.fmean(value) for value in cells.values()), default=None),
+        }
+
+    variants = sorted({str(row.get("variant")) for row in rows})
+    parity: dict[str, Any] = {}
+    if len(variants) > 1:
+        baseline = variants[0]
+        baseline_rows = {row["case_id"]: row for row in rows if row.get("variant") == baseline}
+        for variant in variants[1:]:
+            paired = []
+            speed_ratios = []
+            for row in rows:
+                if row.get("variant") != variant or row["case_id"] not in baseline_rows:
+                    continue
+                parent = baseline_rows[row["case_id"]]
+                paired.append(float(bool(row.get("passed"))) - float(bool(parent.get("passed"))))
+                parent_speed = parent.get("telemetry", {}).get("end_to_end_tokens_per_second")
+                candidate_speed = row.get("telemetry", {}).get("end_to_end_tokens_per_second")
+                if parent_speed and candidate_speed:
+                    speed_ratios.append(float(candidate_speed) / float(parent_speed))
+            parity[variant] = {
+                "baseline": baseline,
+                "paired_quality_delta": _mean(paired),
+                "paired_quality_delta_95_ci": bootstrap_mean_ci(paired),
+                "mean_speed_ratio": _mean(speed_ratios),
+                "paired_cases": len(paired),
+            }
+
+    return {
+        "schema_version": "1.0",
+        "rows": len(rows),
+        "scorecards": scorecards,
+        "context": context,
+        "parity": parity,
+        "interpretation": {
+            "single_intelligence_score": None,
+            "note": "Quality, context, tools, vision, agentic reliability, and performance are reported separately.",
+        },
+    }

src/shiftedx_bench/tokenizer.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+from typing import Any, Protocol
+
+
+class TokenizerProtocol(Protocol):
+    def encode(self, text: str) -> list[int]: ...
+    def decode(self, token_ids: list[int]) -> str: ...
+    def render_chat(self, messages: list[dict[str, Any]]) -> str: ...
+    def token_offset(self, rendered_text: str, substring: str) -> int: ...
+    @property
+    def fingerprint(self) -> str: ...
+
+
+class TransformersTokenizer:
+    def __init__(
+        self,
+        model_path: str | Path,
+        *,
+        enable_thinking: bool = True,
+        reasoning_effort: str | None = "medium",
+        preserve_thinking: bool = True,
+    ):
+        try:
+            from transformers import AutoTokenizer
+        except ImportError as exc:
+            raise RuntimeError(
+                "Install shiftedx-bench[tokenizers] to use a Transformers tokenizer"
+            ) from exc
+        self.model_path = Path(model_path).expanduser().resolve()
+        self._tokenizer = AutoTokenizer.from_pretrained(
+            self.model_path, local_files_only=True, trust_remote_code=True
+        )
+        self.enable_thinking = enable_thinking
+        self.reasoning_effort = reasoning_effort
+        self.preserve_thinking = preserve_thinking
+        digest = hashlib.sha256()
+        for name in ("tokenizer.json", "tokenizer_config.json", "special_tokens_map.json"):
+            path = self.model_path / name
+            if path.exists():
+                digest.update(name.encode())
+                digest.update(path.read_bytes())
+        digest.update(
+            repr((self.enable_thinking, self.reasoning_effort, self.preserve_thinking)).encode()
+        )
+        self._fingerprint = digest.hexdigest()
+
+    def encode(self, text: str) -> list[int]:
+        return list(self._tokenizer.encode(text, add_special_tokens=False))
+
+    def decode(self, token_ids: list[int]) -> str:
+        return self._tokenizer.decode(
+            token_ids, skip_special_tokens=False, clean_up_tokenization_spaces=False
+        )
+
+    def render_chat(self, messages: list[dict[str, Any]]) -> str:
+        kwargs: dict[str, Any] = {
+            "tokenize": False,
+            "add_generation_prompt": True,
+            "enable_thinking": self.enable_thinking,
+            "preserve_thinking": self.preserve_thinking,
+        }
+        if self.reasoning_effort:
+            kwargs["reasoning_effort"] = self.reasoning_effort
+        try:
+            value = self._tokenizer.apply_chat_template(messages, **kwargs)
+        except TypeError:
+            value = self._tokenizer.apply_chat_template(
+                messages, tokenize=False, add_generation_prompt=True
+            )
+        if not isinstance(value, str):
+            raise TypeError("Tokenizer chat template did not return text")
+        return value
+
+    def token_offset(self, rendered_text: str, substring: str) -> int:
+        char_offset = rendered_text.find(substring)
+        if char_offset < 0:
+            raise ValueError(f"Substring not present in rendered prompt: {substring!r}")
+        encoded = self._tokenizer(
+            rendered_text,
+            add_special_tokens=False,
+            return_offsets_mapping=True,
+        )
+        for index, (start, end) in enumerate(encoded["offset_mapping"]):
+            if start <= char_offset < end or start == char_offset:
+                return index
+        raise ValueError("Could not map substring to a token offset")
+
+    @property
+    def fingerprint(self) -> str:
+        return self._fingerprint

src/shiftedx_bench/tools.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import random
+from typing import Any
+
+from .models import BenchCase
+
+
+def function_tool(name: str, properties: dict[str, Any], required: list[str]) -> dict[str, Any]:
+    return {
+        "type": "function",
+        "function": {
+            "name": name,
+            "description": f"Execute {name}.",
+            "parameters": {
+                "type": "object",
+                "properties": properties,
+                "required": required,
+                "additionalProperties": False,
+            },
+        },
+    }
+
+
+SEARCH = function_tool("search_records", {"query": {"type": "string"}, "limit": {"type": "integer"}}, ["query", "limit"])
+READ = function_tool("read_file", {"path": {"type": "string"}}, ["path"])
+WEATHER = function_tool("weather", {"city": {"type": "string"}, "units": {"type": "string", "enum": ["c", "f"]}}, ["city", "units"])
+DELETE = function_tool("delete_record", {"record_id": {"type": "string"}}, ["record_id"])
+
+
+def _case(identifier: str, prompt: str, tools: list[dict[str, Any]], expected: list[dict[str, Any]]) -> BenchCase:
+    return BenchCase(
+        case_id=identifier,
+        suite_id="shiftedx-tools-v1",
+        lane="tools",
+        messages=[
+            {"role": "system", "content": "Use tools only when required. Never invent arguments."},
+            {"role": "user", "content": prompt},
+        ],
+        scorer="tool_calls_exact",
+        expected=expected,
+        max_output_tokens=1024,
+        tools=tools,
+        metadata={"strict_protocol_scoring": True},
+    )
+
+
+def generate_tool_cases(seeds: list[int] | None = None) -> list[BenchCase]:
+    cases = []
+    for seed in seeds or [7319]:
+        rng = random.Random(seed)
+        service = rng.choice(["atlas", "beacon", "cinder", "delta"])
+        limit = rng.randrange(2, 7)
+        city = rng.choice(["Reykjavík", "Nairobi", "Osaka", "Quito"])
+        record_id = f"rec-{rng.randrange(1000, 9999)}"
+        paths = [f"/config/{service}.yaml", f"/config/{service}-worker.yaml"]
+        cases.extend([
+            _case(
+                f"single_exact__s{seed}",
+                f"Look up records matching 'staging {service}' and return at most {limit}.",
+                [SEARCH, READ],
+                [{"name": "search_records", "arguments": {"query": f"staging {service}", "limit": limit}}],
+            ),
+            _case(
+                f"enum_exact__s{seed}",
+                f"Check the weather in {city} using Celsius.",
+                [WEATHER, SEARCH],
+                [{"name": "weather", "arguments": {"city": city, "units": "c"}}],
+            ),
+            _case(
+                f"parallel_exact__s{seed}",
+                f"Read {paths[0]} and {paths[1]} in parallel.",
+                [READ],
+                [
+                    {"name": "read_file", "arguments": {"path": paths[0]}},
+                    {"name": "read_file", "arguments": {"path": paths[1]}},
+                ],
+            ),
+            _case(
+                f"irrelevant_no_call__s{seed}",
+                "Without using any tool, answer with the single word READY.",
+                [SEARCH, READ, WEATHER],
+                [],
+            ),
+            _case(
+                f"destructive_requires_identifier__s{seed}",
+                f"Delete record {record_id}. Do not delete anything else.",
+                [DELETE, SEARCH],
+                [{"name": "delete_record", "arguments": {"record_id": record_id}}],
+            ),
+            _case(
+                f"do_not_infer_destructive__s{seed}",
+                "The old record may need deleting, but I have not supplied its identifier. Explain what is missing.",
+                [DELETE, SEARCH],
+                [],
+            ),
+        ])
+    return cases

src/shiftedx_bench/util.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Any, Iterable
+
+
+def canonical_json(value: Any) -> str:
+    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+
+
+def sha256_json(value: Any) -> str:
+    return hashlib.sha256(canonical_json(value).encode("utf-8")).hexdigest()
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def read_json(path: Path) -> Any:
+    with path.open(encoding="utf-8") as stream:
+        return json.load(stream)
+
+
+def write_json(path: Path, value: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as stream:
+        json.dump(value, stream, ensure_ascii=False, indent=2, sort_keys=True)
+        stream.write("\n")
+
+
+def append_jsonl(path: Path, values: Iterable[dict[str, Any]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a", encoding="utf-8") as stream:
+        for value in values:
+            stream.write(canonical_json(value) + "\n")
+
+
+def read_jsonl(path: Path) -> list[dict[str, Any]]:
+    if not path.exists():
+        return []
+    rows = []
+    with path.open(encoding="utf-8") as stream:
+        for line_number, line in enumerate(stream, start=1):
+            if not line.strip():
+                continue
+            try:
+                rows.append(json.loads(line))
+            except json.JSONDecodeError as exc:
+                raise ValueError(f"Invalid JSONL at {path}:{line_number}: {exc}") from exc
+    return rows
+

src/shiftedx_bench/vision.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import base64
+import hashlib
+import io
+import random
+from pathlib import Path
+from typing import Any
+
+from .models import BenchCase
+
+
+def _png_data(image: Any) -> tuple[str, str, bytes]:
+    stream = io.BytesIO()
+    image.save(stream, format="PNG")
+    data = stream.getvalue()
+    digest = hashlib.sha256(data).hexdigest()
+    return "data:image/png;base64," + base64.b64encode(data).decode("ascii"), digest, data
+
+
+def _message(prompt: str, images: list[str]) -> list[dict[str, Any]]:
+    content: list[dict[str, Any]] = [{"type": "text", "text": prompt}]
+    content.extend({"type": "image_url", "image_url": {"url": value}} for value in images)
+    return [
+        {"role": "system", "content": "Inspect every supplied image and return only bare JSON."},
+        {"role": "user", "content": content},
+    ]
+
+
+def generate_vision_cases(output_dir: Path, seeds: list[int]) -> list[BenchCase]:
+    try:
+        from PIL import Image, ImageDraw, ImageFont
+    except ImportError as exc:
+        raise RuntimeError("Install shiftedx-bench[vision] to generate vision fixtures") from exc
+    output_dir.mkdir(parents=True, exist_ok=True)
+    font = ImageFont.load_default(size=28)
+    cases = []
+    for seed in seeds:
+        rng = random.Random(seed)
+        code = f"SX-{rng.randrange(1000,9999)}-{rng.choice(['OPAL','RAVEN','CEDAR'])}"
+        image = Image.new("RGB", (900, 300), "#f5f1e8")
+        draw = ImageDraw.Draw(image)
+        draw.rectangle((40, 35, 860, 265), outline="#111111", width=5)
+        draw.text((90, 115), code, fill="#111111", font=font)
+        uri, digest, data = _png_data(image)
+        (output_dir / f"ocr-s{seed}.png").write_bytes(data)
+        cases.append(
+            BenchCase(
+                case_id=f"ocr__s{seed}", suite_id="shiftedx-vision-v1", lane="vision",
+                messages=_message("Read the boxed identifier. Return JSON with key identifier.", [uri]),
+                scorer="strict_json_exact", expected={"identifier": code}, max_output_tokens=1024,
+                metadata={"family": "ocr", "fixture_sha256": [digest]},
+            )
+        )
+
+        values = [rng.randrange(2, 10) for _ in range(4)]
+        labels = ["A", "B", "C", "D"]
+        chart = Image.new("RGB", (900, 550), "white")
+        draw = ImageDraw.Draw(chart)
+        colors = ["#e63946", "#457b9d", "#2a9d8f", "#f4a261"]
+        for index, (label, value) in enumerate(zip(labels, values)):
+            x0 = 100 + index * 190
+            draw.rectangle((x0, 470 - value * 38, x0 + 100, 470), fill=colors[index])
+            draw.text((x0 + 35, 480), label, fill="black", font=font)
+            draw.text((x0 + 35, 430 - value * 38), str(value), fill="black", font=font)
+        uri, digest, data = _png_data(chart)
+        (output_dir / f"chart-s{seed}.png").write_bytes(data)
+        maximum = max(values)
+        cases.append(
+            BenchCase(
+                case_id=f"chart__s{seed}", suite_id="shiftedx-vision-v1", lane="vision",
+                messages=_message("Return the label of the tallest bar and the sum of all four values.", [uri]),
+                scorer="strict_json_exact",
+                expected={"tallest": labels[values.index(maximum)], "sum": sum(values)}, max_output_tokens=1024,
+                metadata={"family": "chart", "fixture_sha256": [digest]},
+            )
+        )
+
+        spatial = Image.new("RGB", (900, 360), "#eeeeee")
+        draw = ImageDraw.Draw(spatial)
+        order = ["red", "green", "blue"]
+        rng.shuffle(order)
+        color_values = {"red": "#d62828", "green": "#2a9d4b", "blue": "#2463eb"}
+        for index, color in enumerate(order):
+            x = 170 + index * 280
+            draw.ellipse((x - 70, 110, x + 70, 250), fill=color_values[color])
+        uri, digest, data = _png_data(spatial)
+        (output_dir / f"spatial-s{seed}.png").write_bytes(data)
+        cases.append(
+            BenchCase(
+                case_id=f"spatial__s{seed}", suite_id="shiftedx-vision-v1", lane="vision",
+                messages=_message("List the circle colors from left to right as a JSON array.", [uri]),
+                scorer="strict_json_exact", expected=order, max_output_tokens=1024,
+                metadata={"family": "spatial", "fixture_sha256": [digest]},
+            )
+        )
+
+        before = Image.new("RGB", (500, 240), "white")
+        after = Image.new("RGB", (500, 240), "white")
+        for canvas, status in ((before, "PENDING"), (after, "COMPLETE")):
+            draw = ImageDraw.Draw(canvas)
+            draw.rectangle((30, 30, 470, 210), outline="black", width=4)
+            draw.text((90, 100), f"JOB {seed}: {status}", fill="black", font=font)
+        uri_a, digest_a, data_a = _png_data(before)
+        uri_b, digest_b, data_b = _png_data(after)
+        (output_dir / f"multi-before-s{seed}.png").write_bytes(data_a)
+        (output_dir / f"multi-after-s{seed}.png").write_bytes(data_b)
+        cases.append(
+            BenchCase(
+                case_id=f"multi_image__s{seed}", suite_id="shiftedx-vision-v1", lane="vision",
+                messages=_message("Compare image one with image two. Return job number and changed status.", [uri_a, uri_b]),
+                scorer="strict_json_exact", expected={"job": seed, "from": "PENDING", "to": "COMPLETE"},
+                max_output_tokens=1024,
+                metadata={"family": "multi-image", "fixture_sha256": [digest_a, digest_b]},
+            )
+        )
+    return cases

tests/conftest.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "src"))
+

tests/test_context.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from shiftedx_bench.context import ContextSpec, build_context_case, expand_context_config
+from shiftedx_bench.boundary import probe_context_boundary
+from shiftedx_bench.holdout import derive_holdout_config
+
+
+class CharTokenizer:
+    fingerprint = "char-tokenizer-v1"
+
+    def encode(self, text: str) -> list[int]:
+        return [ord(value) for value in text]
+
+    def decode(self, token_ids: list[int]) -> str:
+        return "".join(chr(value) for value in token_ids)
+
+    def render_chat(self, messages):
+        return "".join(f"<{item['role']}>\n{item['content']}\n" for item in messages) + "<assistant>\n"
+
+    def token_offset(self, rendered_text: str, substring: str) -> int:
+        value = rendered_text.index(substring)
+        return len(self.encode(rendered_text[:value]))
+
+
+def test_smoke_plan_has_expected_coverage():
+    root = Path(__file__).resolve().parents[1]
+    config = json.loads((root / "configs/context-smoke-v1.json").read_text())
+    specs = expand_context_config(config)
+    assert len(specs) == 19
+    assert {spec.target_tokens for spec in specs} >= {4096, 32768, 131072, 260096}
+    assert {spec.query_placement for spec in specs} == {"before", "after"}
+
+
+@pytest.mark.parametrize(
+    "family",
+    ["single_key", "binding", "latest_record", "multi_hop", "semantic", "state_tracking"],
+)
+@pytest.mark.parametrize("position", [0.01, 0.5, 0.99])
+def test_context_is_exact_and_positioned(family: str, position: float):
+    spec = ContextSpec("suite", "matrix", family, 12000, position, 173)
+    case = build_context_case(spec, CharTokenizer())
+    assert case.metadata["actual_rendered_tokens"] == 12000
+    assert abs(case.metadata["actual_primary_position"] - position) <= 0.003
+    assert set(case.expected) >= {"start_sentinel", "end_sentinel", "record"}
+
+
+def test_rejects_duplicate_identifiers():
+    config = {
+        "suite_id": "x",
+        "matrices": [{
+            "name": "m", "families": ["single_key", "single_key"], "lengths": [4096],
+            "positions": [0.5], "seeds": [1]
+        }],
+    }
+    with pytest.raises(ValueError, match="duplicate"):
+        expand_context_config(config)
+
+
+def test_holdout_derivation_is_stable_and_release_specific():
+    template = {
+        "suite_id": "x", "context_window": 8192, "reserved_output_tokens": 512,
+        "matrices": [{"name":"m","families":["single_key"],"lengths":[4096],"positions":[.5],"seeds":[1,2]}],
+    }
+    first = derive_holdout_config(template, "a sufficiently long private key", "r1")
+    second = derive_holdout_config(template, "a sufficiently long private key", "r1")
+    third = derive_holdout_config(template, "a sufficiently long private key", "r2")
+    assert first == second
+    assert first["matrices"][0]["seeds"] != third["matrices"][0]["seeds"]
+    assert "private key" not in str(first)
+
+
+def test_rejects_prompt_beyond_reserved_output_budget():
+    config = {
+        "suite_id":"x", "context_window":4096, "reserved_output_tokens":512,
+        "matrices":[{"name":"m","families":["single_key"],"lengths":[3585],"positions":[.5],"seeds":[1]}],
+    }
+    with pytest.raises(ValueError, match="exceeds"):
+        expand_context_config(config)
+
+
+def test_boundary_probe_requires_explicit_server_rejection():
+    class RejectingClient:
+        def complete(self, payload, stream=False):
+            raise RuntimeError("HTTP 400: context window exceeded")
+
+    result = probe_context_boundary(
+        client=RejectingClient(), tokenizer=CharTokenizer(), model="m",
+        context_window=4096, reserved_output_tokens=512,
+    )
+    assert result["passed"]

tests/test_quality_tools_vision.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from shiftedx_bench.quality import generate_quality_cases
+from shiftedx_bench.scoring import score_response
+from shiftedx_bench.tools import generate_tool_cases
+from shiftedx_bench.vision import generate_vision_cases
+
+
+def test_quality_release_seed_produces_unique_cases():
+    cases = generate_quality_cases([173, 811])
+    assert len(cases) == 20
+    assert len({case.case_id for case in cases}) == 20
+    assert {case.scorer for case in cases} == {"strict_json_exact", "python_code"}
+
+
+def test_every_tool_case_accepts_its_oracle_response():
+    for case in generate_tool_cases():
+        calls = [
+            {"function": {"name": item["name"], "arguments": item["arguments"]}}
+            for item in case.expected
+        ]
+        assert score_response(case.scorer, case.expected, {"tool_calls": calls}).passed
+
+
+def test_tool_release_seeds_produce_unique_cases():
+    cases = generate_tool_cases([173, 811])
+    assert len(cases) == 12
+    assert len({case.case_id for case in cases}) == 12
+
+
+def test_vision_fixtures_are_deterministic(tmp_path):
+    first = generate_vision_cases(tmp_path / "a", [173])
+    second = generate_vision_cases(tmp_path / "b", [173])
+    assert len(first) == 4
+    assert [case.expected for case in first] == [case.expected for case in second]
+    assert [case.metadata["fixture_sha256"] for case in first] == [case.metadata["fixture_sha256"] for case in second]

tests/test_runner_summary_release.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from shiftedx_bench.models import BenchCase
+from shiftedx_bench.release import scan_public_tree
+from shiftedx_bench.runner import run_cases
+from shiftedx_bench.summary import summarize_results
+from shiftedx_bench.util import read_jsonl
+
+
+class FakeClient:
+    def __init__(self, prompt_tokens=10): self.prompt_tokens = prompt_tokens
+    def complete(self, payload, stream=False):
+        return {
+            "content": '{"answer":7}', "reasoning_content": "", "tool_calls": [],
+            "finish_reason": "stop", "usage": {"prompt_tokens": self.prompt_tokens, "completion_tokens": 5},
+            "prompt_tokens": self.prompt_tokens, "completion_tokens": 5, "wall_s": 1.0,
+            "ttft_s": 0.2, "end_to_end_tokens_per_second": 5.0, "mtplx_stats": {},
+        }
+
+
+def test_runner_resumes_and_enforces_server_token_count(tmp_path):
+    case = BenchCase(
+        case_id="c", suite_id="s", lane="long-context", messages=[{"role":"user","content":"x"}],
+        scorer="strict_json_exact", expected={"answer": 7},
+        metadata={"target_prompt_tokens": 10, "requested_position": .5, "family": "single"},
+    )
+    output = tmp_path / "results.jsonl"
+    run_cases([case], client=FakeClient(), model="m", output_path=output)
+    run_cases([case], client=FakeClient(), model="m", output_path=output)
+    rows = read_jsonl(output)
+    assert len(rows) == 1 and rows[0]["passed"]
+
+    mismatch = tmp_path / "mismatch.jsonl"
+    run_cases([case], client=FakeClient(prompt_tokens=9), model="m", output_path=mismatch)
+    assert not read_jsonl(mismatch)[0]["passed"]
+
+
+def test_summary_separates_scorecards_and_context():
+    rows = []
+    for length, passed in [(4096, True), (8192, True), (16384, False)]:
+        rows.append({
+            "variant":"ar", "lane":"long-context", "case_id":str(length), "passed":passed,
+            "metadata":{"target_prompt_tokens":length,"requested_position":.5,"family":"single"},
+            "telemetry":{"wall_s":1.0,"ttft_s":.1,"end_to_end_tokens_per_second":10.0},
+        })
+    summary = summarize_results(rows, effective_threshold=.9)
+    assert summary["context"]["ar"]["effective_context_length"] == 8192
+    assert summary["interpretation"]["single_intelligence_score"] is None
+
+
+def test_public_scan_detects_tokens_and_user_paths(tmp_path):
+    clean = tmp_path / "clean"
+    clean.mkdir()
+    (clean / "README.md").write_text("public documentation")
+    assert scan_public_tree(clean)["ok"]
+    fake_token = "h" + "f_" + "abcdefghijklmnopqrstuvwxyz1234"
+    fake_path = "/" + "Users/example/private"
+    (clean / "bad.txt").write_text(fake_token + "\n" + fake_path)
+    result = scan_public_tree(clean)
+    assert not result["ok"]
+    assert {item["issue"] for item in result["failures"]} >= {"Hugging Face access token", "macOS user path"}

tests/test_scoring_and_sandbox.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from shiftedx_bench.sandbox import run_python_submission
+from shiftedx_bench.scoring import score_response
+
+
+def test_strict_json_rejects_fences_and_extra_text():
+    expected = {"value": 7}
+    assert score_response("strict_json_exact", expected, {"content": '{"value":7}'}).passed
+    assert not score_response("strict_json_exact", expected, {"content": '```json\n{"value":7}\n```'}).passed
+    assert not score_response("strict_json_exact", expected, {"content": '{"value":7} done'}).passed
+
+
+def test_tool_scoring_is_protocol_exact():
+    expected = [{"name": "read_file", "arguments": {"path": "/a"}}]
+    good = {"tool_calls": [{"function": {"name": "read_file", "arguments": '{"path":"/a"}'}}]}
+    bad = {"content": "I would call read_file on /a", "tool_calls": []}
+    assert score_response("tool_calls_exact", expected, good).passed
+    assert not score_response("tool_calls_exact", expected, bad).passed
+
+
+def test_python_sandbox_accepts_solution_and_rejects_imports():
+    outcome = run_python_submission("def add(a,b): return a+b", "assert add(2,3)==5")
+    assert outcome["passed"], outcome
+    rejected = run_python_submission("import os\ndef add(a,b): return a+b", "assert add(2,3)==5")
+    assert not rejected["passed"]
+    assert "static rejection" in rejected["error"]
+
+
+def test_python_sandbox_catches_mutant():
+    outcome = run_python_submission("def add(a,b): return a-b", "assert add(2,3)==5")
+    assert not outcome["passed"]
+
+
+def test_context_oracle_and_truncation_control():
+    expected = {"start_sentinel": "START", "record": "opal", "end_sentinel": "END"}
+    oracle = {"content": '{"start_sentinel":"START","record":"opal","end_sentinel":"END"}'}
+    truncated = {"content": '{"start_sentinel":"START","record":"opal"}'}
+    assert score_response("strict_json_exact", expected, oracle).passed
+    assert not score_response("strict_json_exact", expected, truncated).passed