Publish clean Decision model repository

Signed-off-by: Xunzhuo <[email protected]>

Dockerfile.runtime

@@ -1,12 +0,0 @@
-# Public base verified by manifest digest and critical PyTorch file hashes.
-# CPU build/import validation is separate from model GPU qualification; see RUNTIME.md.
-FROM vllm/vllm-openai-rocm@sha256:1fd21abe66455b4df5a2e83629e97cdcc9d58913b16052d8118b92b239792339
-COPY runtime-fla-requirements.lock /tmp/runtime-fla-requirements.lock
-RUN python3 -m pip install --no-cache-dir --no-index --no-deps --require-hashes     --target /opt/decision-fla -r /tmp/runtime-fla-requirements.lock
-ENV PYTHONPATH=/opt/decision-fla
-COPY pyproject.toml /opt/decision-wrapper/pyproject.toml
-COPY src/ /opt/decision-wrapper/src/
-RUN python3 -m pip install --no-cache-dir --no-deps --no-build-isolation /opt/decision-wrapper
-WORKDIR /model
-ENTRYPOINT []
-CMD ["/bin/bash"]

MATERIALS.json

@@ -1,28 +0,0 @@
-{
-  "kind": "latest-public-comparison-documents",
-  "public_models": 15,
-  "scored_questions": 3766,
-  "tasks": 54,
-  "source_statistics_sha256": "8406aea215dc1c4ee2645130c94472b336bb065ba46c6efac4f742589499463b",
-  "files": {
-    ".gitattributes": "f0cd3e623808977834bdd29b1ac3258f54a5d581affa46a7e7ab8587da26cdd9",
-    "DIAGNOSTICS.md": "cc8c0a378013d1cfb87ec775344180047136109cbc236a23da02201c0a7c5baa",
-    "EVALUATION.md": "10744aeed1a113597e644d0b3f4787a91299f055701f22c8cd34843276a7df2a",
-    "QUESTION-SCALING.md": "02e8d66f6c6dc2a38f39748247c521e40648d2b673eba95f7be78ee729e929d7",
-    "README.md": "ff11f99561dea4a557bf8b5f135374bfbd79c576beaf9f74d92aa94971d6ada5",
-    "SENSITIVITY.md": "6bda57a973be2c1afcca5f579b37d1979fa89ff0b1ef171b6d8414e6215d2bc5",
-    "TASKS.md": "573086057e6d87135f119ad95fda16a46f9e8a5e1109430f0a1b8a5da7d99247",
-    "USAGE.md": "a5474ee65259f977ee0410a1d1d35a9662cb904c7953bef44fbf39a883361721",
-    "WEIGHTING.md": "6bda57a973be2c1afcca5f579b37d1979fa89ff0b1ef171b6d8414e6215d2bc5",
-    "assets/decision-matrix.pdf": "3b4f10c3f00820d4b82b11a48401a8c360304c4e7cda90a6e7133c76d18ca41b",
-    "assets/decision-matrix.png": "cb0c583975fc6848f0d3ca7ed11da48347f7431f91f4debf699b3fb039a0a696",
-    "assets/decision-matrix.svg": "fc83d1c36264098fce20ca9f000aedc04473c7a16295fa5d16a82afeee2342fc",
-    "assets/decision-nox-4b-header.png": "c79b9a7b122e7e72485095ed28ba2ff515a81e1ab49a778654b0cddbe2ecafac",
-    "assets/decision-ranking.pdf": "e2d6ecdab0599e65db77b520669e90b32fad6d10c85bb15dcd77bec1ed6ec51f",
-    "assets/decision-ranking.png": "9bb5e1487f2b66215624e67a72bda0d1c3f4ad6cd931089aa5bd7211f3be02b9",
-    "assets/decision-ranking.svg": "c8600115c3fafbf03e0b06cc6e3da016e4f74473df4f2d4575ae1c9721c99b8e",
-    "metrics/benchmark.json": "86dc156356ee80eb849808f6e0d5237157f63d121ae6992c9a833691912ef76c",
-    "metrics/evaluation-provenance.json": "f9c087bd92e6cdfdc4c4dabc0ec335bb837a79715577a7355012d3a21f81c8e9",
-    "metrics/question-scaling.json": "3aaab58d54b78ccfd08b74f7f45697eee63a6d45ca9819d22da3ee9d437d47b8"
-  }
-}

NORMALIZATION_RUNTIME.md

@@ -1,5 +0,0 @@
-# Validated normalization runtime
-
-This Nox bundle installs its recorded FLA normalization profile through the default public entrypoint. It requires the pinned ROCm runtime on gfx942 and a fresh process. The profile covers dimension 128, BF16 input/output, FP32 reciprocal norms, and buckets 1–64 for the actual 32 normalized value heads, batch size at most 8 and complete inputs at most 16,384 tokens. Unknown keys fail closed. Weights, tokenizer, prompt, readout and temperature remain unchanged from the source export.
-
-No private compilation cache is required. Other FLA kernels retain normal runtime behavior. Numerical validation of this newly bound bundle is still required. Earlier latency measurements do not measure this runtime or candidate.

NULL_DESCRIPTION_RENDERING.json

@@ -1,7 +0,0 @@
-{
-  "rule": "For Choice only, replace a null description with its original key text before tokenization.",
-  "preserved": "Non-null descriptions including empty string; keys/order; Noul and Score; original request; weights/tokenizer/temperature/numeric runtime.",
-  "source_bundle_manifest_sha256": "83876db506b2d98e3e8ce7d34310b21f97bac30d4f5aef3371053798bff08830",
-  "qualification": "Candidate only; full fixed benchmark and independent public loading proof required.",
-  "not_a_weight_training_update": true
-}

README.md

@@ -7,7 +7,6 @@ tags:
 - decision-model
 - classification
 - qwen3_5
-- custom-code
 - pytorch
 - rocm
 ---
@@ -58,75 +57,38 @@ Accuracy (%). Overall weights: Decisions **30%**, Composition **25%**, Reading *
 
 ![Capability matrix](assets/decision-matrix.png)
 
-[All 54 tasks](TASKS.md) · [Order, missing-evidence and calibration diagnostics](DIAGNOSTICS.md) · [Methods and uncertainty](EVALUATION.md)
+[All 54 tasks](evaluation/TASKS.md) · [Order, missing-evidence and calibration diagnostics](evaluation/DIAGNOSTICS.md) · [Methods and uncertainty](evaluation/EVALUATION.md)
 
 ## More questions, one request
 
 ![Question-count latency](assets/decision-question-scaling.png)
 
-Distinct Choice questions at a fixed **499 input tokens per question**. Thirty measurements per point across six independently loaded processes on an otherwise idle AMD gfx942 GPU. Python latency includes tokenization and inference; loading and network are excluded. These measurements precede null-description normalization and use explicit descriptions. [p50, p95 and measurement scope](QUESTION-SCALING.md).
+Distinct Choice questions at a fixed **499 input tokens per question**. Thirty measurements per point across six independently loaded processes on an otherwise idle AMD gfx942 GPU. Python latency includes tokenization and inference; loading and network are excluded. These measurements precede null-description normalization and use explicit descriptions. [p50, p95 and measurement scope](evaluation/QUESTION-SCALING.md).
 
-## Use Nox-4B
-
-Use the [official TypeSafe Python SDK](https://docs.typesafe.ai/sdk/python/usage) with your SystemOne-compatible endpoint, configured to serve `Decision-1.0-Nox-4B`. Replace the example URL and API key with your own.
+## Download the complete model repository
 
 ```bash
-pip install typesafe-sdk
+hf download llm-semantic-router/Decision-1.0-Nox-4B --local-dir Decision-1.0-Nox-4B
 ```
 
-```python
-from typesafe_sdk import Choice, Noul, TypeSafeClient
-
-with TypeSafeClient(
-    api_key="YOUR_ENDPOINT_API_KEY",
-    base_url="https://your-decision-endpoint.example",
-    model="Decision-1.0-Nox-4B",
-) as client:
-    result = client.system_one(
-        state="Customer reports a duplicate charge and asks for a refund.",
-        questions={
-            "route": Choice(
-                instructions="Which team should handle this request?",
-                criteria={"billing": "Payments and refunds", "technical": "Product faults"},
-            ),
-            "refund_requested": Noul(instructions="Did the customer request a refund?"),
-        },
-    )
-    print(result.choices["route"].choice)
-    print(result.nouls["refund_requested"].noul)
-```
+This downloads the complete model release. The root `config.json` lists the backbone, tokenizer, decision head, and calibration files.
+
+## Serve with vLLM Semantic Router
 
-The same request with curl:
+This repository contains model data only. Use the vLLM Semantic Router Decision runtime to load `llm-semantic-router/Decision-1.0-Nox-4B` and serve Choice, Noul, and Score requests. The serving implementation and its dependencies live in vLLM Semantic Router; this release does not bundle executable model code. `transformers.AutoModel.from_pretrained` cannot load the custom Decision head directly.
+
+After configuring a compatible Decision endpoint, send a [SystemOne request](https://docs.typesafe.ai/api) (replace the placeholder URL and key):
 
 ```bash
 curl -X POST 'https://your-decision-endpoint.example/v1/systemone' \
   -H 'Authorization: Bearer YOUR_ENDPOINT_API_KEY' \
   -H 'Content-Type: application/json' \
-  --data-raw '{
-  "model": "Decision-1.0-Nox-4B",
-  "state": "Customer reports a duplicate charge and asks for a refund.",
-  "questions": {
-    "route": {
-      "type": "choice",
-      "instructions": "Which team should handle this request?",
-      "criteria": {
-        "billing": "Payments and refunds",
-        "technical": "Product faults"
-      }
-    },
-    "refund_requested": {
-      "type": "noul",
-      "instructions": "Did the customer request a refund?"
-    }
-  }
-}'
+  --data-raw '{"model":"Decision-1.0-Nox-4B","state":"Customer requests a refund.","questions":{"route":{"type":"choice","instructions":"Which team should handle this?","criteria":{"billing":"Payments and refunds","technical":"Product faults"}}}}'
 ```
 
-[Typed request and response guide](USAGE.md) · [Model runtime requirements](RUNTIME.md)
-
-Choice candidates with a null description use their ID text, which may increase input tokens.
+The Hugging Face repository is a model download, not a hosted inference endpoint.
 
-The complete state, question and candidates must fit 16,384 tokens; overflow is rejected. The bundled normalization profile loads automatically. AMD gfx942 is validated; CPU/MPS are unsupported and NVIDIA is unqualified. Use a fresh Python process when switching profiles.
+The published model's complete state, question, and candidates have a 16,384-token input limit. See the [evaluation scope](evaluation/EVALUATION.md) for measured conditions.
 
 ## Architecture
 
@@ -134,6 +96,6 @@ The complete state, question and candidates must fit 16,384 tokens; overflow is
 
 A causal Qwen3.5 text backbone combines gated linear and full attention. A shared candidate head reads candidate endpoints and the final query vector. Each question uses one forward pass; questions run independently in batches of eight.
 
-[Candidate head](assets/readout.png) · [Vector architecture](assets/architecture.svg) · [Inference code](code/decision_model.py)
+[Candidate head](assets/readout.png) · [Vector architecture](assets/architecture.svg)
 
 Adapted from [Qwen3.5-4B](https://huggingface.co/Qwen/Qwen3.5-4B). It evaluates supplied evidence without live retrieval; confidence does not guarantee correctness. [License](LICENSE) · [Attributions](ATTRIBUTIONS.md).

RUNTIME-RELEASE.json

@@ -1,11 +0,0 @@
-{
-  "release": "v1.3.2",
-  "kind": "SystemOne Choice null-description semantics",
-  "rule": "A null Choice description uses the original candidate key as its description.",
-  "weights_tokenizer_temperature_unchanged": true,
-  "explicit_descriptions_and_Noul_Score_unchanged": true,
-  "bundle_manifest_sha256": "7d9b06bc25a75b1f131aabd280df0ef2777bf69db98574a300067ace40c61c9c",
-  "qualified_statistics_sha256": "b319a993ac569ea1fa8da027ccb2195868557e4efe232a5d06091db2884086be",
-  "exact_public_contract_proof_sha256": "ebf27c7aa2bb4a12ba2cbb27e4096e46cb43ac4a20b9d3e1bc34f62777a1e63a",
-  "runtime_note": "This is an API rendering improvement, not a newly trained checkpoint."
-}

RUNTIME.md

@@ -1,52 +0,0 @@
-# Public ROCm runtime
-
-The package has a public, digest-pinned installation path. `Dockerfile.runtime` starts from `vllm/vllm-openai-rocm@sha256:1fd21abe66455b4df5a2e83629e97cdcc9d58913b16052d8118b92b239792339`, adds two hash-checked FLA wheels, and installs this repository's loading wrapper. It keeps the base image's ROCm PyTorch and Triton builds. The vLLM server is not used by Decision inference.
-
-**Validation boundary:** the public registry manifest, base-image ancestry, package metadata and critical PyTorch binary hashes have been checked. The recipe built successfully and passed CPU imports and real AMD ROCm gfx942 GPU GPU inference for both released bundles. On the packaged three-question Choice/Noul/Score example, its complete responses matched the qualified research runtime exactly; the wrapper matched the direct engine and rejected an oversized complete input. Evidence is in `runtime-build-provenance.json`. This example establishes a working public installation path; it is not a full rerun of the quality or timing benchmark. Published benchmark results use the qualified runtime in each bundle's `runtime.json`.
-
-## Build and run
-
-Use an AMD ROCm-compatible Linux host with Docker and the required GPU driver. Check the [AMD PyTorch installation and host prerequisites](https://rocm.docs.amd.com/projects/ai-ecosystem/en/latest/frameworks/pytorch/install.html). CPU and MPS inference are not supported by this model engine; no NVIDIA validation is claimed.
-
-Run these commands from the downloaded model repository containing `Dockerfile.runtime`, `runtime-fla-requirements.lock`, `pyproject.toml`, `src/`, and the model bundle:
-
-```bash
-docker build --pull -f Dockerfile.runtime -t decision-runtime:1.0 .
-mkdir -p runtime-output
-docker run --rm \
-  --device=/dev/kfd --device=/dev/dri --group-add video --ipc=host \
-  -v "$PWD":/model:ro -v "$PWD/runtime-output":/output \
-  decision-runtime:1.0 \
-  python3 -m decision.example /model --local-files-only --output /output/example.json
-```
-
-This loads locally without a Hub token. The example tests Choice, Noul and Score through the wrapper and compares them with the frozen direct engine; inspect its actual result rather than assuming a predicted answer. Keep the runtime checks enabled. If they report a mismatch, resolve the cause before using this environment to reproduce benchmark claims. The explicit `allow_unvalidated_runtime=True` option is for separately labeled experiments, not benchmark reproduction.
-
-The image is large because its public base includes the vLLM development environment. No Decision weights, dataset, user credentials or private runtime image are required to build it. Model weights are mounted at execution time.
-
-## What is pinned
-
-The public base locks the existing OS, ROCm libraries and Python dependency environment by content digest. Its exact observed core versions are:
-
-| Component | Observed value |
-|---|---|
-| Python | 3.12.13 |
-| PyTorch | 2.12.0+git6bbd260 |
-| PyTorch commit | 6bbd26020da1c6dc198625dfcdd968b1e4e6b1c5 |
-| ROCm userspace / HIP build | 7.2.3 / 7.2.53211 |
-| Triton distribution / imported version | 3.7.1+gitf0b55c07 / 3.7.1 |
-| Transformers | 5.17.0 |
-| Tokenizers / Safetensors | 0.23.2 / 0.8.0 |
-| NumPy / Einops | 2.3.5 / 0.8.2 |
-| Hugging Face Hub | 1.31.0 |
-| FLA core / Flash Linear Attention | 0.5.2 / 0.5.2 |
-
-`runtime-provenance.json` records the live registry manifest response, 36 shared base layers, selected actual binary SHA256 values, observed versions, wheel URLs and wheel hashes. The FLA wheels were downloaded and their SHA256 values matched the qualified overlay. `runtime-fla-requirements.lock` intentionally covers only that overlay; it is not a standalone dependency lock for an arbitrary system.
-
-The official [FLA installation guide](https://github.com/fla-org/flash-linear-attention/blob/main/INSTALL.md) separates backend PyTorch installation from FLA and documents `--no-deps` for pre-release/custom Torch builds. This recipe uses that boundary and never asks pip to replace Torch or Triton. Transformers is supplied by the pinned base; see its [official installation documentation](https://huggingface.co/docs/transformers/installation) for the general package installation model.
-
-## Portability boundary
-
-The public [PyTorch ROCm 7.2 wheel index](https://download.pytorch.org/whl/rocm7.2/torch/) contains ordinary release wheels such as `2.12.0+rocm7.2`. They are a different artifact from the qualified `2.12.0+git6bbd260` build and are not interchangeable evidence. The latter's [source commit is public](https://github.com/pytorch/pytorch/commit/6bbd26020da1c6dc198625dfcdd968b1e4e6b1c5), but a source commit alone does not reproduce compiler flags, linked libraries and binary behavior.
-
-An alternative runtime must recheck the installed versions, actual FLA Gated DeltaNet dispatch, BF16 backbone plus FP32 head, fixed prompt rendering, batch size eight, and model output agreement. Runtime changes can shift probabilities near a decision boundary even with identical weights. The supplied engine uses FLA Gated DeltaNet, reference PyTorch causal convolution and SDPA; selecting a different kernel is a new runtime configuration.

RUNTIME_BINDING.json

@@ -1,76 +0,0 @@
-{
-  "source_bundle_manifest_sha256": "d437bc0149bcb8c9891fbb33c5abc4c2336c3a89ab6cfa0981da5a7f1d19f1f4",
-  "profile_sha256": "be32858d15233e0a3fbee0e4257fb02be0b3439deee4eb9c3f61151df7b73850",
-  "profile_validation_receipt_sha256": "7a66474325b5575fdd15a33e5e0340c19e809bdcc22adf4cbb45baa0e1b32693",
-  "unchanged_files": [
-    {
-      "file": "backbone/config.json",
-      "bytes": 1978,
-      "sha256": "ae3a463b32e95b6cc207a7af4f1defb4195f388eb6f9ff19d2690b73d4966953"
-    },
-    {
-      "file": "backbone/model-00001-of-00003.safetensors",
-      "bytes": 3991295368,
-      "sha256": "5ebccc395ef9fa4d61c79894ecefcdaa2a319c1c154221e1ad73663b6f82aacc"
-    },
-    {
-      "file": "backbone/model-00002-of-00003.safetensors",
-      "bytes": 3979828128,
-      "sha256": "990e2e79fc1ab009df9846ef9fddb31f4b988589bbda84f4728dbaa4196d7fcd"
-    },
-    {
-      "file": "backbone/model-00003-of-00003.safetensors",
-      "bytes": 440425856,
-      "sha256": "c47859a3192bdae5003e4732fb911c8dddcf6e8caa167b4971e3a9801b828d64"
-    },
-    {
-      "file": "backbone/model.safetensors.index.json",
-      "bytes": 33047,
-      "sha256": "1602d52e38d81586af85bc4ce29ce082c5fc5877c763b1ebcab7545320016599"
-    },
-    {
-      "file": "chat_template.jinja",
-      "bytes": 7756,
-      "sha256": "a4aee8afcf2e0711942cf848899be66016f8d14a889ff9ede07bca099c28f715"
-    },
-    {
-      "file": "code/decision_model.py",
-      "bytes": 10114,
-      "sha256": "d3e28489c09f3bd7130e2d43d92e0b5c4a08e25b09b21303904defb0ff1c3646"
-    },
-    {
-      "file": "code/predict.py",
-      "bytes": 3164,
-      "sha256": "02352e8385ab47157b6459910da54d962e5da4bb4940d571faedc86bc5da9aee"
-    },
-    {
-      "file": "decision_config.json",
-      "bytes": 753,
-      "sha256": "443a9b3f191a8387915c606de8303700fc1a069fe7c8ad46a0eba5528a2549a8"
-    },
-    {
-      "file": "decision_head.safetensors",
-      "bytes": 10529624,
-      "sha256": "9cb6f639714e31bcb76b58eaf94af0b72ac3db9d091ebcda45d9b575efd489de"
-    },
-    {
-      "file": "temperature.json",
-      "bytes": 6083,
-      "sha256": "69d80e5b215e2c1e6872f146fdb7ea5aa95c9fd678ef96208960d50e4e7b635d"
-    },
-    {
-      "file": "tokenizer.json",
-      "bytes": 19989325,
-      "sha256": "06b9509352d2af50381ab2247e083b80d32d5c0aba91c272ca9ff729b6a0e523"
-    },
-    {
-      "file": "tokenizer_config.json",
-      "bytes": 1123,
-      "sha256": "bee8eba30f0eb4af73c0fe2cd06d0f89b657d7819941c438157ec42f7c80ea87"
-    }
-  ],
-  "training_selection_calibration_unchanged": true,
-  "recomputed_or_recalibrated": false,
-  "private_compiled_cache_required": false,
-  "new_bundle_offline_proof_required": true
-}

SERVING_OPTIMIZATION.json

@@ -1,34 +0,0 @@
-{
-  "format": "joint-serving-runtime-candidate-v1",
-  "family": "Nox",
-  "source_publication_revision": "ad089ad3a5dc9a7a21e6d96db546bb53e2212654",
-  "source_bundle_manifest_sha256": "92d7f5be5e1ef21ee682f574b35cc01de4dd8ab16b8aa6edf0dfbdfcfcfabba3",
-  "source_release_manifest_sha256": "3e11cc6011860ea245c53eb44b9da61a85d5feb5c6caa5da95428d63ede6d712",
-  "source_api_sha256": "1b068eccdffd3c3b67bfa52f8f526e6b482d92551c927668ad28a794767f8a40",
-  "candidate_api_sha256": "273f6f10f22d5a68b8db34cfcbd35407fb43d8030f6d7cd188bcf118dd90a152",
-  "changed_inference_files": [
-    "code/decision_api.py"
-  ],
-  "held_fixed": [
-    "weights",
-    "tokenizer",
-    "prompt",
-    "temperature",
-    "normalization_profile",
-    "BF16_backbone_FP32_head",
-    "batch8",
-    "input_limit16384",
-    "public_wrapper"
-  ],
-  "shared_state_neural_cache": false,
-  "cross_request_cache": false,
-  "timing_evidence": {
-    "analysis/decoder-joint-serving-v1/COMPLETED-PARITY.json": "4187fb76432eb69b263cb6d5ad55f10a09aef384fe405f3ad204acf1edc761b5",
-    "analysis/decoder-joint-timing-v1/INDEPENDENTLY-REVIEWED.json": "1b416c8556c2305ffd18bd1e3cd523964820a5e2a3029cf447f20b2829ba82f7",
-    "results/joint-serving-timing-v1/summary/SUMMARY.json": "501f25efd1813b566d77e98278229440b7a3b4a2358def1462c0171a33e9f3be",
-    "analysis/decoder4b/joint-timing-actual-review-v1/REVIEW.json": "e94fec9d9c6d487200ef7ea1cf82319b33c4836c08d83f0b856bf8590f2fbee6"
-  },
-  "candidate_default_entrypoint_proof_required": true,
-  "published": false,
-  "adoption_authorized": false
-}

SOURCE_BUNDLE_MANIFEST.json

@@ -1,173 +0,0 @@
-{
-  "format": "research-pointer-bundle-v1",
-  "status": "candidate-export-awaiting-independent-reload-and-quality-gates",
-  "files": [
-    {
-      "file": "backbone/config.json",
-      "bytes": 1978,
-      "sha256": "ae3a463b32e95b6cc207a7af4f1defb4195f388eb6f9ff19d2690b73d4966953"
-    },
-    {
-      "file": "backbone/model-00001-of-00003.safetensors",
-      "bytes": 3991295368,
-      "sha256": "5ebccc395ef9fa4d61c79894ecefcdaa2a319c1c154221e1ad73663b6f82aacc"
-    },
-    {
-      "file": "backbone/model-00002-of-00003.safetensors",
-      "bytes": 3979828128,
-      "sha256": "990e2e79fc1ab009df9846ef9fddb31f4b988589bbda84f4728dbaa4196d7fcd"
-    },
-    {
-      "file": "backbone/model-00003-of-00003.safetensors",
-      "bytes": 440425856,
-      "sha256": "c47859a3192bdae5003e4732fb911c8dddcf6e8caa167b4971e3a9801b828d64"
-    },
-    {
-      "file": "backbone/model.safetensors.index.json",
-      "bytes": 33047,
-      "sha256": "1602d52e38d81586af85bc4ce29ce082c5fc5877c763b1ebcab7545320016599"
-    },
-    {
-      "file": "chat_template.jinja",
-      "bytes": 7756,
-      "sha256": "a4aee8afcf2e0711942cf848899be66016f8d14a889ff9ede07bca099c28f715"
-    },
-    {
-      "file": "code/decision_api.py",
-      "bytes": 6724,
-      "sha256": "147b2fec32cbbbbb1b92cf2a19bb887f9d945e4974e141ca7ea93b8c542f5b21"
-    },
-    {
-      "file": "code/decision_model.py",
-      "bytes": 10114,
-      "sha256": "d3e28489c09f3bd7130e2d43d92e0b5c4a08e25b09b21303904defb0ff1c3646"
-    },
-    {
-      "file": "code/predict.py",
-      "bytes": 3164,
-      "sha256": "02352e8385ab47157b6459910da54d962e5da4bb4940d571faedc86bc5da9aee"
-    },
-    {
-      "file": "decision_config.json",
-      "bytes": 753,
-      "sha256": "443a9b3f191a8387915c606de8303700fc1a069fe7c8ad46a0eba5528a2549a8"
-    },
-    {
-      "file": "decision_head.safetensors",
-      "bytes": 10529624,
-      "sha256": "9cb6f639714e31bcb76b58eaf94af0b72ac3db9d091ebcda45d9b575efd489de"
-    },
-    {
-      "file": "runtime.json",
-      "bytes": 378,
-      "sha256": "c5d3521358b2817f4e56ea8150c5c612139b4e2b2c5bb09f512d9a7c0b5298b9"
-    },
-    {
-      "file": "temperature.json",
-      "bytes": 6083,
-      "sha256": "69d80e5b215e2c1e6872f146fdb7ea5aa95c9fd678ef96208960d50e4e7b635d"
-    },
-    {
-      "file": "tokenizer.json",
-      "bytes": 19989325,
-      "sha256": "06b9509352d2af50381ab2247e083b80d32d5c0aba91c272ca9ff729b6a0e523"
-    },
-    {
-      "file": "tokenizer_config.json",
-      "bytes": 1123,
-      "sha256": "bee8eba30f0eb4af73c0fe2cd06d0f89b657d7819941c438157ec42f7c80ea87"
-    }
-  ],
-  "tensors": [
-    {
-      "file": "backbone/model-00001-of-00003.safetensors",
-      "elements": 1995638528,
-      "elements_by_dtype": {
-        "BF16": 1995638528
-      }
-    },
-    {
-      "file": "backbone/model-00002-of-00003.safetensors",
-      "elements": 1989900928,
-      "elements_by_dtype": {
-        "BF16": 1989900928
-      }
-    },
-    {
-      "file": "backbone/model-00003-of-00003.safetensors",
-      "elements": 220211840,
-      "elements_by_dtype": {
-        "BF16": 220211840
-      }
-    },
-    {
-      "file": "decision_head.safetensors",
-      "elements": 2632192,
-      "elements_by_dtype": {
-        "F32": 2632192
-      }
-    }
-  ],
-  "source_checkpoint_files": [
-    {
-      "file": "backbone/config.json",
-      "bytes": 1977,
-      "sha256": "a5ed4156fda05f0f9149c66964d6165916754e7355488a8a07d9b0398acdbdb9"
-    },
-    {
-      "file": "backbone/model-00001-of-00005.safetensors",
-      "bytes": 3992269864,
-      "sha256": "d65565b8988a20b07988db09ed2321111e57b4fe656112fe4636715f8418c40b"
-    },
-    {
-      "file": "backbone/model-00002-of-00005.safetensors",
-      "bytes": 3990302320,
-      "sha256": "99197c2df234da167190a18b34efe6275622687500346ad3d42d9fad6b25d52d"
-    },
-    {
-      "file": "backbone/model-00003-of-00005.safetensors",
-      "bytes": 3937871784,
-      "sha256": "0d0af48a06e40b0afdcb7aa02cf6d8d6df885ccc9e2593e3db72cd3a92e798a7"
-    },
-    {
-      "file": "backbone/model-00004-of-00005.safetensors",
-      "bytes": 3926578128,
-      "sha256": "b960486d5d833e016c9e2a32d42214db14a8e48afef49d61a7f514f8c636a264"
-    },
-    {
-      "file": "backbone/model-00005-of-00005.safetensors",
-      "bytes": 976029360,
-      "sha256": "994dac35c408a89d89768febad1ed52a255da62f7924f86bd76371381e9cc751"
-    },
-    {
-      "file": "decision_config.json",
-      "bytes": 1070,
-      "sha256": "3324b9318a873fc27a8610e19d6d7ba82b0890a49011abbc8b097bdf429e6747"
-    },
-    {
-      "file": "decision_head.safetensors",
-      "bytes": 10529624,
-      "sha256": "9cb6f639714e31bcb76b58eaf94af0b72ac3db9d091ebcda45d9b575efd489de"
-    },
-    {
-      "file": "tokenizer.json",
-      "bytes": 19989325,
-      "sha256": "06b9509352d2af50381ab2247e083b80d32d5c0aba91c272ca9ff729b6a0e523"
-    },
-    {
-      "file": "tokenizer_config.json",
-      "bytes": 1123,
-      "sha256": "bee8eba30f0eb4af73c0fe2cd06d0f89b657d7819941c438157ec42f7c80ea87"
-    }
-  ],
-  "source_model_code_sha256": "d3e28489c09f3bd7130e2d43d92e0b5c4a08e25b09b21303904defb0ff1c3646",
-  "source_api_code_sha256": "147b2fec32cbbbbb1b92cf2a19bb887f9d945e4974e141ca7ea93b8c542f5b21",
-  "dev_sha256": "45b4cd46acc4be53b95c7ed8f333b3533972296a4d0557c7b8c48c9cab6ced61",
-  "production_predictions_sha256": "ba311f5a6bc73182651bdf5c9744f0ed95921110501ddc93dcfd20a1d06bceff",
-  "temperature_sha256": "69d80e5b215e2c1e6872f146fdb7ea5aa95c9fd678ef96208960d50e4e7b635d",
-  "runtime_sha256": "c5d3521358b2817f4e56ea8150c5c612139b4e2b2c5bb09f512d9a7c0b5298b9",
-  "production_batch_size": 8,
-  "input_length_limit": 16384,
-  "original_checkpoint_name": "winner",
-  "no_publication_performed": true
-}

USAGE.md

@@ -1,59 +0,0 @@
-# Use Nox-4B
-
-The examples below use the [official TypeSafe SDK](https://docs.typesafe.ai/sdk/python/usage) and the standard [SystemOne HTTP request](https://docs.typesafe.ai/api). Configure your endpoint to serve `Decision-1.0-Nox-4B`, then replace the example URL and API key. A Hugging Face model repository is a weights download, not an inference endpoint.
-
-```bash
-pip install typesafe-sdk
-```
-
-```python
-from typesafe_sdk import Choice, Noul, TypeSafeClient
-
-with TypeSafeClient(
-    api_key="YOUR_ENDPOINT_API_KEY",
-    base_url="https://your-decision-endpoint.example",
-    model="Decision-1.0-Nox-4B",
-) as client:
-    result = client.system_one(
-        state="Customer reports a duplicate charge and asks for a refund.",
-        questions={
-            "route": Choice(
-                instructions="Which team should handle this request?",
-                criteria={"billing": "Payments and refunds", "technical": "Product faults"},
-            ),
-            "refund_requested": Noul(instructions="Did the customer request a refund?"),
-        },
-    )
-    print(result.choices["route"].choice)
-    print(result.nouls["refund_requested"].noul)
-```
-
-```bash
-curl -X POST 'https://your-decision-endpoint.example/v1/systemone' \
-  -H 'Authorization: Bearer YOUR_ENDPOINT_API_KEY' \
-  -H 'Content-Type: application/json' \
-  --data-raw '{
-  "model": "Decision-1.0-Nox-4B",
-  "state": "Customer reports a duplicate charge and asks for a refund.",
-  "questions": {
-    "route": {
-      "type": "choice",
-      "instructions": "Which team should handle this request?",
-      "criteria": {
-        "billing": "Payments and refunds",
-        "technical": "Product faults"
-      }
-    },
-    "refund_requested": {
-      "type": "noul",
-      "instructions": "Did the customer request a refund?"
-    }
-  }
-}'
-```
-
-The state can be text or JSON-compatible structured data. Question IDs and Choice IDs are preserved in the response. Choice uses 2–255 options; Noul returns `noul`, the probability of a condition being true; Score uses 2–10 rubric descriptions ordered from index zero. A request can contain many questions.
-
-Choice returns `choice`, `probabilities` and `confidence`. Score returns an expected zero-based `score`, a probability distribution and `legend`. Local Decision confidence is normalized maximum probability, `(K × max(p) − 1)/(K − 1)`; it does not reproduce an unpublished provider confidence statistic. An HTTP integration must supply `usage.input_tokens` and `usage.output_tokens`; counting generated tokens as zero is appropriate for this non-generative model, not a claim about provider billing.
-
-The native runtime processes independent complete questions in batches of eight. Each complete rendered question, including state, instructions and criteria, must fit 16,384 tokens; overflow is rejected. [Runtime and hardware requirements](RUNTIME.md).

WEIGHTING.md

@@ -1,21 +0,0 @@
-# Weight sensitivity
-
-The current product-priority weights were chosen after observing results. This comparison holds every model and prediction fixed; reweighting is not a training improvement.
-
-| Model | Current 30/25/15/15/15 | Prior 25/25/15/15/20 | Original four-panel mean |
-|---|---:|---:|---:|
-| Lux-9B | 77.40 | 77.07 | 79.69 |
-| Nox-4B | 73.09 | 72.42 | 75.03 |
-| Kev-9B | 71.89 | 72.01 | 73.19 |
-| Kev-4B | 70.09 | 70.30 | 71.73 |
-| Qwen3.5-9B | 69.73 | 69.70 | 71.99 |
-| Decider | 67.71 | 67.97 | 71.75 |
-| Qwen3.5-4B | 67.29 | 67.24 | 70.25 |
-| Sol-2B | 66.32 | 65.48 | 70.14 |
-| Eos-0.8B | 61.89 | 61.19 | 65.99 |
-| Kev-0.8B | 58.28 | 58.33 | 59.75 |
-| Qwen3.5-2B | 57.24 | 57.20 | 60.54 |
-| Kai-0.6B | 53.52 | 53.05 | 55.82 |
-| Laya · English | 51.03 | 50.85 | 51.76 |
-| Laya · Multilingual | 47.19 | 47.18 | 48.56 |
-| Jev | 81.05 | 81.45 | 82.45 |

bundle-manifest.json

@@ -1,243 +0,0 @@
-{
-  "format": "research-pointer-bundle-v1",
-  "status": "null-description-candidate-awaiting-public-proof-and-full-regression",
-  "files": [
-    {
-      "file": "NORMALIZATION_RUNTIME.md",
-      "bytes": 756,
-      "sha256": "cf8e6ce1f07687a68b6adeb98e6704b8f292cb6adc7b10e4b84e8e70aa5472e5"
-    },
-    {
-      "file": "NULL_DESCRIPTION_RENDERING.json",
-      "bytes": 514,
-      "sha256": "3b531cab60cba35648ab71fe4be7fd1af619f02ee337e3beed6296fdfc8b9ec8"
-    },
-    {
-      "file": "RUNTIME_BINDING.json",
-      "bytes": 2621,
-      "sha256": "fb76d9fc9147e15a678eb91dfc40d7039845a4eaebdecce041a5c9e76c3d3e0f"
-    },
-    {
-      "file": "SERVING_OPTIMIZATION.json",
-      "bytes": 1548,
-      "sha256": "fe2fd8c3e046faec139b8685eed693db0e6aa5235ebe5f860bc9f6dd1888c8ad"
-    },
-    {
-      "file": "SOURCE_BUNDLE_MANIFEST.json",
-      "bytes": 5637,
-      "sha256": "d437bc0149bcb8c9891fbb33c5abc4c2336c3a89ab6cfa0981da5a7f1d19f1f4"
-    },
-    {
-      "file": "backbone/config.json",
-      "bytes": 1978,
-      "sha256": "ae3a463b32e95b6cc207a7af4f1defb4195f388eb6f9ff19d2690b73d4966953"
-    },
-    {
-      "file": "backbone/model-00001-of-00003.safetensors",
-      "bytes": 3991295368,
-      "sha256": "5ebccc395ef9fa4d61c79894ecefcdaa2a319c1c154221e1ad73663b6f82aacc"
-    },
-    {
-      "file": "backbone/model-00002-of-00003.safetensors",
-      "bytes": 3979828128,
-      "sha256": "990e2e79fc1ab009df9846ef9fddb31f4b988589bbda84f4728dbaa4196d7fcd"
-    },
-    {
-      "file": "backbone/model-00003-of-00003.safetensors",
-      "bytes": 440425856,
-      "sha256": "c47859a3192bdae5003e4732fb911c8dddcf6e8caa167b4971e3a9801b828d64"
-    },
-    {
-      "file": "backbone/model.safetensors.index.json",
-      "bytes": 33047,
-      "sha256": "1602d52e38d81586af85bc4ce29ce082c5fc5877c763b1ebcab7545320016599"
-    },
-    {
-      "file": "chat_template.jinja",
-      "bytes": 7756,
-      "sha256": "a4aee8afcf2e0711942cf848899be66016f8d14a889ff9ede07bca099c28f715"
-    },
-    {
-      "file": "code/decision_api.py",
-      "bytes": 10978,
-      "sha256": "6716bdabca3cd2f1aa447d42a6cf53ee62d7ea97984a01f16b4c09fac8aaf17e"
-    },
-    {
-      "file": "code/decision_model.py",
-      "bytes": 10114,
-      "sha256": "d3e28489c09f3bd7130e2d43d92e0b5c4a08e25b09b21303904defb0ff1c3646"
-    },
-    {
-      "file": "code/predict.py",
-      "bytes": 3164,
-      "sha256": "02352e8385ab47157b6459910da54d962e5da4bb4940d571faedc86bc5da9aee"
-    },
-    {
-      "file": "code/profile_guard.py",
-      "bytes": 6184,
-      "sha256": "061d6ba3edf032038b074b061879a1ff81cfd2928fc0131c66b15563f7822509"
-    },
-    {
-      "file": "code/runtime_profile.py",
-      "bytes": 2857,
-      "sha256": "3e26ed65f2cd706def209761421cb8fc825281e5c1ed8f168350365ad803dc96"
-    },
-    {
-      "file": "decision_config.json",
-      "bytes": 753,
-      "sha256": "443a9b3f191a8387915c606de8303700fc1a069fe7c8ad46a0eba5528a2549a8"
-    },
-    {
-      "file": "decision_head.safetensors",
-      "bytes": 10529624,
-      "sha256": "9cb6f639714e31bcb76b58eaf94af0b72ac3db9d091ebcda45d9b575efd489de"
-    },
-    {
-      "file": "pyproject.toml",
-      "bytes": 436,
-      "sha256": "135a9516e87ca2fb41ef54a974e29132256b6c2d528a1cbdea1001e28f306946"
-    },
-    {
-      "file": "runtime-profile/l2norm_fwd_kernel.json",
-      "bytes": 26330,
-      "sha256": "d7ed7c9962a48efdfa76ed695c8bdc0f56afe1397c202c936eb78315e87a26df"
-    },
-    {
-      "file": "runtime-profile/profile.json",
-      "bytes": 35040,
-      "sha256": "be32858d15233e0a3fbee0e4257fb02be0b3439deee4eb9c3f61151df7b73850"
-    },
-    {
-      "file": "runtime.json",
-      "bytes": 1112,
-      "sha256": "78a2c21f8138beeffb3e6b1c11e03cb48972a78ca5ef3d1f58c50651031c34b6"
-    },
-    {
-      "file": "src/decision/__init__.py",
-      "bytes": 167,
-      "sha256": "70de37df98b6fc8e3b9f9d43935ba31a32350496214c11adf8c5fba72c433313"
-    },
-    {
-      "file": "src/decision/example.py",
-      "bytes": 3581,
-      "sha256": "a54dec885f92c2d38d07ef2333dff51965be52bc119f772cc74200ed314e69b6"
-    },
-    {
-      "file": "src/decision/model.py",
-      "bytes": 9415,
-      "sha256": "ba240d7493fc29203fe036966f0ab911200cd4a9252b50b05423409977639ee0"
-    },
-    {
-      "file": "temperature.json",
-      "bytes": 6083,
-      "sha256": "69d80e5b215e2c1e6872f146fdb7ea5aa95c9fd678ef96208960d50e4e7b635d"
-    },
-    {
-      "file": "tokenizer.json",
-      "bytes": 19989325,
-      "sha256": "06b9509352d2af50381ab2247e083b80d32d5c0aba91c272ca9ff729b6a0e523"
-    },
-    {
-      "file": "tokenizer_config.json",
-      "bytes": 1123,
-      "sha256": "bee8eba30f0eb4af73c0fe2cd06d0f89b657d7819941c438157ec42f7c80ea87"
-    }
-  ],
-  "tensors": [
-    {
-      "file": "backbone/model-00001-of-00003.safetensors",
-      "elements": 1995638528,
-      "elements_by_dtype": {
-        "BF16": 1995638528
-      }
-    },
-    {
-      "file": "backbone/model-00002-of-00003.safetensors",
-      "elements": 1989900928,
-      "elements_by_dtype": {
-        "BF16": 1989900928
-      }
-    },
-    {
-      "file": "backbone/model-00003-of-00003.safetensors",
-      "elements": 220211840,
-      "elements_by_dtype": {
-        "BF16": 220211840
-      }
-    },
-    {
-      "file": "decision_head.safetensors",
-      "elements": 2632192,
-      "elements_by_dtype": {
-        "F32": 2632192
-      }
-    }
-  ],
-  "source_checkpoint_files": [
-    {
-      "file": "backbone/config.json",
-      "bytes": 1977,
-      "sha256": "a5ed4156fda05f0f9149c66964d6165916754e7355488a8a07d9b0398acdbdb9"
-    },
-    {
-      "file": "backbone/model-00001-of-00005.safetensors",
-      "bytes": 3992269864,
-      "sha256": "d65565b8988a20b07988db09ed2321111e57b4fe656112fe4636715f8418c40b"
-    },
-    {
-      "file": "backbone/model-00002-of-00005.safetensors",
-      "bytes": 3990302320,
-      "sha256": "99197c2df234da167190a18b34efe6275622687500346ad3d42d9fad6b25d52d"
-    },
-    {
-      "file": "backbone/model-00003-of-00005.safetensors",
-      "bytes": 3937871784,
-      "sha256": "0d0af48a06e40b0afdcb7aa02cf6d8d6df885ccc9e2593e3db72cd3a92e798a7"
-    },
-    {
-      "file": "backbone/model-00004-of-00005.safetensors",
-      "bytes": 3926578128,
-      "sha256": "b960486d5d833e016c9e2a32d42214db14a8e48afef49d61a7f514f8c636a264"
-    },
-    {
-      "file": "backbone/model-00005-of-00005.safetensors",
-      "bytes": 976029360,
-      "sha256": "994dac35c408a89d89768febad1ed52a255da62f7924f86bd76371381e9cc751"
-    },
-    {
-      "file": "decision_config.json",
-      "bytes": 1070,
-      "sha256": "3324b9318a873fc27a8610e19d6d7ba82b0890a49011abbc8b097bdf429e6747"
-    },
-    {
-      "file": "decision_head.safetensors",
-      "bytes": 10529624,
-      "sha256": "9cb6f639714e31bcb76b58eaf94af0b72ac3db9d091ebcda45d9b575efd489de"
-    },
-    {
-      "file": "tokenizer.json",
-      "bytes": 19989325,
-      "sha256": "06b9509352d2af50381ab2247e083b80d32d5c0aba91c272ca9ff729b6a0e523"
-    },
-    {
-      "file": "tokenizer_config.json",
-      "bytes": 1123,
-      "sha256": "bee8eba30f0eb4af73c0fe2cd06d0f89b657d7819941c438157ec42f7c80ea87"
-    }
-  ],
-  "source_model_code_sha256": "d3e28489c09f3bd7130e2d43d92e0b5c4a08e25b09b21303904defb0ff1c3646",
-  "source_api_code_sha256": "6716bdabca3cd2f1aa447d42a6cf53ee62d7ea97984a01f16b4c09fac8aaf17e",
-  "dev_sha256": "45b4cd46acc4be53b95c7ed8f333b3533972296a4d0557c7b8c48c9cab6ced61",
-  "production_predictions_sha256": "ba311f5a6bc73182651bdf5c9744f0ed95921110501ddc93dcfd20a1d06bceff",
-  "temperature_sha256": "69d80e5b215e2c1e6872f146fdb7ea5aa95c9fd678ef96208960d50e4e7b635d",
-  "runtime_sha256": "78a2c21f8138beeffb3e6b1c11e03cb48972a78ca5ef3d1f58c50651031c34b6",
-  "production_batch_size": 8,
-  "input_length_limit": 16384,
-  "original_checkpoint_name": "winner",
-  "no_publication_performed": true,
-  "source_bundle_manifest_sha256": "83876db506b2d98e3e8ce7d34310b21f97bac30d4f5aef3371053798bff08830",
-  "normalization_profile_sha256": "be32858d15233e0a3fbee0e4257fb02be0b3439deee4eb9c3f61151df7b73850",
-  "public_wrapper_included": true,
-  "source_published_bundle_manifest_sha256": "92d7f5be5e1ef21ee682f574b35cc01de4dd8ab16b8aa6edf0dfbdfcfcfabba3",
-  "serving_optimization_sha256": "fe2fd8c3e046faec139b8685eed693db0e6aa5235ebe5f860bc9f6dd1888c8ad"
-}

code/decision_api.py

@@ -1,198 +0,0 @@
-"""Typed local inference adapter for the research decision checkpoints.
-
-The response schema resembles TypeSafe's primitives. Confidence uses this
-implementation's documented normalized maximum probability, not a claimed
-reimplementation of TypeSafe's unpublished statistic. No text generation.
-"""
-from __future__ import annotations
-import importlib.util
-import math
-from pathlib import Path
-
-
-def prepare_runtime_profile(checkpoint, device='cuda:0'):
-    # This profile is verified before any dependency import can choose kernels.
-    import hashlib, json, sys
-    root=Path(checkpoint);runtime=json.loads((root/'runtime.json').read_text())
-    spec=runtime.get('normalization_profile')
-    if spec is None:
-        if '_decision_process_normalization_profile_v1' in sys.modules:
-            raise RuntimeError('Use separate processes for profiled and unprofiled models')
-        return None
-    import torch
-    target=torch.device(device)
-    if target.type!='cuda' or not torch.cuda.is_available():
-        raise RuntimeError('The bound profile requires a ROCm CUDA device')
-    arch=getattr(torch.cuda.get_device_properties(target),'gcnArchName','').split(':')[0]
-    if arch!=spec['validated_arch']:
-        raise RuntimeError('Target GPU architecture does not match the bound profile: '+arch)
-    relative=Path(spec['loader_file'])
-    if relative.is_absolute() or '..' in relative.parts:raise ValueError('Unsafe profile loader path')
-    path=root/relative
-    if hashlib.sha256(path.read_bytes()).hexdigest()!=spec['loader_sha256']:
-        raise ValueError('Bound runtime profile loader changed')
-    definition=importlib.util.spec_from_file_location('decision_bundle_runtime_profile',path)
-    module=importlib.util.module_from_spec(definition);definition.loader.exec_module(module)
-    return module.ensure_profile(root)
-
-
-def question_row(state, name, question):
-    kind=question.get('type')
-    if kind not in {'choice','noul','score'}:raise ValueError('Unknown question type')
-    if 'instructions' not in question:raise ValueError('instructions is required')
-    criteria=question.get('criteria')
-    if kind=='noul':
-        criteria={} if criteria is None else criteria
-        if not isinstance(criteria,dict) or set(criteria)-{'true','false'}:
-            raise ValueError('noul criteria may contain only true and false')
-        options=[{'key':'false','description':criteria.get('false','The answer to the question is no.')},
-                 {'key':'true','description':criteria.get('true','The answer to the question is yes.')}]
-    elif kind=='score':
-        if not isinstance(criteria,list) or not 2<=len(criteria)<=10:
-            raise ValueError('score requires an ordered list of 2..10 criteria')
-        options=[{'key':str(i),'description':value} for i,value in enumerate(criteria)]
-    else:
-        if not isinstance(criteria,dict) or not 2<=len(criteria)<=255:
-            raise ValueError('choice requires a mapping of 2..255 criteria')
-        if not all(isinstance(k,str) for k in criteria):raise ValueError('Choice keys must be strings')
-        options=[{'key':key,'description':key if value is None else value} for key,value in criteria.items()]
-    # The question name is used for bookkeeping only; encoders never render id.
-    return {'id':name,'state':state,'instructions':question['instructions'],
-            'options':options,'task_type':kind,'family':'inference'}
-
-
-def typed_answer(row, probabilities):
-    p=[float(v) for v in probabilities];k=len(row['options'])
-    if len(p)!=k or any(not math.isfinite(v) or v<0 for v in p):
-        raise ValueError('Invalid probability vector')
-    total=sum(p)
-    if total<=0 or abs(total-1)>1e-4:raise ValueError('Probabilities must sum to one')
-    p=[v/total for v in p];selected=max(range(k),key=p.__getitem__)
-    kind=row['task_type']
-    if kind=='noul':
-        keys=[o['key'] for o in row['options']]
-        if set(keys)!={'false','true'}:raise ValueError('Native noul rows require false/true keys')
-        return {'type':'noul','noul':p[keys.index('true')]}
-    answer={'type':kind,'probabilities':{o['key']:v for o,v in zip(row['options'],p)},
-            'confidence':max(0.,min(1.,(k*max(p)-1)/(k-1)))}
-    if kind=='choice':answer['choice']=row['options'][selected]['key']
-    else:
-        if [o['key'] for o in row['options']] != [str(i) for i in range(k)]:
-            raise ValueError('Native score rows require ordered numeric level keys')
-        answer['score']=sum(i*v for i,v in enumerate(p))
-        answer['legend']={str(i):o['description'] for i,o in enumerate(row['options'])}
-    return answer
-
-
-class DecisionEngine:
-    def __init__(self, checkpoint, model_code, *, device='cuda:0', max_length=16384,
-                 batch_size=8, temperatures=None, model_name='local-decision-research'):
-        self.normalization_profile=prepare_runtime_profile(checkpoint, device=device)
-        import torch
-        path=Path(model_code)/'decision_model.py'
-        spec=importlib.util.spec_from_file_location('research_decision_runtime',path)
-        module=importlib.util.module_from_spec(spec);spec.loader.exec_module(module)
-        model,tokenizer=module.DecisionModel.from_checkpoint(checkpoint,dtype=torch.bfloat16)
-        self.model=model.to(device).eval();self.tokenizer=tokenizer;self.module=module
-        self.device=device;self.max_length=max_length;self.batch_size=batch_size
-        self.temperatures=temperatures or {};self.model_name=model_name
-        if batch_size<1 or max_length<1:raise ValueError('Positive batch_size/max_length required')
-        if any(not math.isfinite(v) or v<=0 for v in self.temperatures.values()):
-            raise ValueError('Temperatures must be finite positive numbers')
-
-    def predict_rows(self, rows):
-        import torch
-        encoded=encode_request(rows,self.tokenizer,self.module,self.max_length)
-        pad=self.tokenizer.pad_token_id if self.tokenizer.pad_token_id is not None else self.tokenizer.eos_token_id
-        records=[]
-        with torch.inference_mode():
-            for start in range(0,len(rows),self.batch_size):
-                items=encoded[start:start+self.batch_size]
-                batch={key:value.to(self.device) if torch.is_tensor(value) else value
-                       for key,value in self.module.collate(items,pad).items()}
-                with torch.autocast('cuda',dtype=torch.bfloat16):logits=self.model(**batch)
-                # Preserve each row's original float/temperature/softmax math,
-                # but defer host synchronization until the complete batch.
-                staged=[];transfers=[]
-                for row,item,values in zip(rows[start:start+self.batch_size],items,logits):
-                    k=len(row['options']);values=values[:k].float()
-                    temperature=self.temperatures.get(row['task_type'],1.)
-                    probabilities=(values/temperature).softmax(-1)
-                    staged.append((row,item,k,temperature))
-                    transfers.extend((values,probabilities))
-                host_values=torch.cat(transfers).tolist()
-                offset=0
-                for row,item,k,temperature in staged:
-                    values=host_values[offset:offset+k]
-                    probabilities=host_values[offset+k:offset+2*k]
-                    offset+=2*k
-                    answer=typed_answer(row,probabilities)
-                    prediction=max(range(k),key=probabilities.__getitem__)
-                    if row['task_type']=='noul':
-                        chosen='true' if answer['noul']>=.5 else 'false'
-                        prediction=[o['key'] for o in row['options']].index(chosen)
-                    rec={'id':row['id'],'status':'ok','prediction':prediction,
-                         'probabilities':probabilities,'logits':values,'temperature':temperature,
-                         'native_contract':True,'truncated':False,'input_tokens':len(item['ids']),
-                         'prompt_sha256':item['prompt_sha256'],'answer':answer}
-                    if row['task_type']=='noul':rec['native_noul']=answer['noul']
-                    if row['task_type']=='score':rec['native_score']=answer['score']
-                    records.append(rec)
-        return records
-
-    def decide(self, state, questions):
-        if not isinstance(questions,dict) or not questions:
-            raise ValueError('questions must be a nonempty mapping')
-        if not all(isinstance(name,str) for name in questions):raise ValueError('Question names must be strings')
-        rows=[question_row(state,name,q) for name,q in questions.items()]
-        result=self.predict_rows(rows)
-        return {'model':self.model_name,'answers':{r['id']:r['answer'] for r in result},
-                'usage':{'input_tokens':sum(r['input_tokens'] for r in result),'scored_questions':len(result)}}
-
-
-"""Experimental request-local exact-segment tokenization.
-
-Original encode/segments functions remain authoritative. Batch tokenize exact
-whole segments, never split a BPE prefix at a new boundary. No cross-request
-cache, GPU change, prompt change or change to the eight-row inference groups.
-"""
-
-
-class SegmentLookup:
-    def __init__(self, tokenizer, cache):
-        self.tokenizer, self.cache = tokenizer, cache
-
-    def encode(self, text, **kwargs):
-        if kwargs == {'add_special_tokens': False} and text in self.cache:
-            # Original encode extends its prefix list in place.
-            return list(self.cache[text])
-        return self.tokenizer.encode(text, **kwargs)
-
-
-def encode_request(rows, tokenizer, module, max_length=16384,
-                   max_cached_characters=8_000_000, segment_batch_size=64):
-    if max_cached_characters < 0 or segment_batch_size < 1:
-        raise ValueError('Invalid tokenizer resource bound')
-    unique = {}
-    characters = 0
-    for row in rows:
-        prefix, options, suffix = module.segments(row)
-        for segment in (prefix, *options, suffix):
-            if segment not in unique:
-                unique[segment] = None
-                characters += len(segment)
-                if characters > max_cached_characters:
-                    # Preserve the original behavior under the resource cap.
-                    return [module.encode(r, tokenizer, max_length) for r in rows]
-    strings = list(unique)
-    for start in range(0, len(strings), segment_batch_size):
-        batch = strings[start:start + segment_batch_size]
-        result = tokenizer(batch, add_special_tokens=False, padding=False,
-                           truncation=False, return_attention_mask=False,
-                           return_token_type_ids=False)['input_ids']
-        if len(result) != len(batch):
-            raise ValueError('Batch tokenizer output count differs')
-        for segment, ids in zip(batch, result):
-            unique[segment] = tuple(ids)
-    lookup = SegmentLookup(tokenizer, unique)
-    return [module.encode(row, lookup, max_length) for row in rows]

code/decision_model.py

@@ -1,173 +0,0 @@
-"""Dynamic candidate readout over a causal Qwen3.5 text backbone.
-
-Candidate endpoints retain their contextual vectors. A final global-query
-vector can incorporate all options before a shared bilinear + MLP scorer
-scores every candidate. This is a research architecture, not a Jev claim.
-"""
-import hashlib
-import json
-import math
-from pathlib import Path
-
-import torch
-from torch import nn
-import torch.nn.functional as F
-from safetensors.torch import load_file, save_file
-from transformers import AutoTokenizer, Qwen3_5ForConditionalGeneration
-from transformers.models.qwen3_5.modeling_qwen3_5 import Qwen3_5TextModel
-
-PROMPT_VERSION = "structured-segmented-candidate-endpoints-global-query-v2"
-MAX_OPTIONS = 255
-
-
-def canonical(value):
-    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
-
-
-def payload(value):
-    return value if isinstance(value, str) else canonical(value)
-
-
-def segments(row):
-    opts = row["options"]
-    if not 2 <= len(opts) <= MAX_OPTIONS:
-        raise ValueError(f"{row['id']}: expected 2..255 options")
-    if not all(isinstance(o["key"], str) for o in opts):
-        raise ValueError("Option keys must be strings")
-    if len({o["key"] for o in opts}) != len(opts):
-        raise ValueError("Duplicate option keys")
-    prefix = f"Context:\n{payload(row['state'])}\n\nTask type: {row.get('task_type', 'choice')}\nQuestion:\n{payload(row['instructions'])}\nOptions:"
-    # Tokenize each part separately. This deliberately fixes boundaries and
-    # avoids guessing endpoint indices from merged BPE character offsets.
-    options = ["\n<option>\n" + canonical({"key": o["key"], "description": o.get("description")}) + "\n</option>" for o in opts]
-    suffix = "\n\nSelect the single option best supported by the context and instructions.\nDecision:"
-    return prefix, options, suffix
-
-
-def render(row):
-    prefix, opts, suffix = segments(row)
-    return prefix + "".join(opts) + suffix
-
-
-def encode(row, tokenizer, max_length=16384):
-    prefix, opts, suffix = segments(row)
-    ids = tokenizer.encode(prefix, add_special_tokens=False)
-    candidate_positions = []
-    for option in opts:
-        part = tokenizer.encode(option, add_special_tokens=False)
-        if not part:
-            raise ValueError("Empty tokenized candidate")
-        ids.extend(part)
-        candidate_positions.append(len(ids) - 1)
-    ids.extend(tokenizer.encode(suffix, add_special_tokens=False))
-    if len(ids) > max_length:
-        raise ValueError(f"{row['id']}: {len(ids)} tokens exceeds max_length={max_length}; no truncation allowed")
-    label = row.get("label", -1)
-    if label != -1 and not 0 <= label < len(opts):
-        raise ValueError("Invalid label")
-    prompt = prefix + "".join(opts) + suffix
-    return {"id": row["id"], "ids": ids, "label": label, "nopts": len(opts), "family": row.get("family", "unspecified"), "candidate_positions": candidate_positions, "query_position": len(ids) - 1, "target_probs": row.get("target_probs"), "prompt_sha256": hashlib.sha256(prompt.encode()).hexdigest(), "token_ids_sha256": hashlib.sha256(canonical(ids).encode()).hexdigest(), "segmented_tokenization": True}
-
-
-def collate(items, pad_id):
-    length = ((max(len(x["ids"]) for x in items) + 31) // 32) * 32
-    nopts = max(x["nopts"] for x in items)
-    ids = torch.full((len(items), length), pad_id, dtype=torch.long)
-    mask = torch.zeros_like(ids)
-    positions = torch.zeros((len(items), nopts), dtype=torch.long)
-    candidate_mask = torch.zeros((len(items), nopts), dtype=torch.bool)
-    for i, item in enumerate(items):
-        if len(item["candidate_positions"]) != item["nopts"]:
-            raise ValueError("Candidate count does not match endpoint count")
-        if not all(0 <= p < item["query_position"] < len(item["ids"]) for p in item["candidate_positions"]):
-            raise ValueError("Candidate endpoints must precede global query")
-        if len(set(item["candidate_positions"])) != item["nopts"]:
-            raise ValueError("Duplicate candidate endpoint")
-        ids[i, :len(item["ids"])] = torch.tensor(item["ids"])
-        mask[i, :len(item["ids"])] = 1
-        positions[i, :item["nopts"]] = torch.tensor(item["candidate_positions"])
-        candidate_mask[i, :item["nopts"]] = True
-    return {"input_ids": ids, "attention_mask": mask, "candidate_positions": positions, "candidate_mask": candidate_mask, "query_positions": torch.tensor([x["query_position"] for x in items]), "labels": torch.tensor([x["label"] for x in items]), "nopts": torch.tensor([x["nopts"] for x in items]), "ids": [x["id"] for x in items], "families": [x["family"] for x in items]}
-
-
-class CandidateHead(nn.Module):
-    def __init__(self, hidden_size, head_dim=256):
-        super().__init__()
-        self.head_dim = head_dim
-        self.candidate_norm = nn.LayerNorm(hidden_size)
-        self.query_norm = nn.LayerNorm(hidden_size)
-        self.key = nn.Linear(hidden_size, head_dim, bias=False)
-        self.query = nn.Linear(hidden_size, head_dim, bias=False)
-        self.candidate_mlp = nn.Linear(hidden_size, head_dim, bias=True)
-        self.query_mlp = nn.Linear(hidden_size, head_dim, bias=False)
-        self.scalar = nn.Linear(head_dim, 1, bias=False)
-        nn.init.normal_(self.scalar.weight, mean=0., std=0.01)
-
-    def forward(self, candidates, query):
-        # Keep the small shared head in FP32 even when the backbone uses BF16.
-        # The v1 letter head exhibited BF16 ties sensitive to batch padding.
-        with torch.autocast(device_type=candidates.device.type, enabled=False):
-            c = self.candidate_norm(candidates.float())
-            q = self.query_norm(query.float())
-            bilinear = (self.key(c) * self.query(q)[:, None, :]).sum(-1) / math.sqrt(self.head_dim)
-            interaction = self.scalar(F.gelu(self.candidate_mlp(c) + self.query_mlp(q)[:, None, :])).squeeze(-1)
-            return bilinear + interaction
-
-
-class DecisionModel(nn.Module):
-    def __init__(self, backbone, head, metadata):
-        super().__init__()
-        self.backbone, self.head, self.metadata = backbone, head, metadata
-
-    @classmethod
-    def from_base(cls, path, revision="local", dtype=torch.bfloat16, attention="sdpa", head_dim=256):
-        tokenizer = AutoTokenizer.from_pretrained(path, local_files_only=True)
-        full, info = Qwen3_5ForConditionalGeneration.from_pretrained(path, dtype=dtype, local_files_only=True, attn_implementation=attention, output_loading_info=True)
-        if any(info.get(k) for k in ("missing_keys", "mismatched_keys", "error_msgs")):
-            raise RuntimeError(f"Incomplete base loading: {info}")
-        backbone = full.model.language_model
-        backbone.config.use_cache = False
-        head = CandidateHead(backbone.config.hidden_size, head_dim)
-        metadata = {"base_revision": revision, "text_parameter_count": sum(p.numel() for p in backbone.parameters()), "prompt_version": PROMPT_VERSION, "attention": attention, "head_dim": head_dim, "max_options": MAX_OPTIONS, "architecture": "contextual-candidate-endpoint-plus-global-query-shared-bilinear-mlp", "head_initialization": "random-shared-content-scorer", "head_precision": "float32-outside-autocast"}
-        return cls(backbone, head, metadata), tokenizer
-
-    @classmethod
-    def from_decision_checkpoint(cls, path, dtype=torch.bfloat16, attention="sdpa", head_dim=256):
-        """Warm-start the backbone of a trained v1 model; initialize a new head."""
-        path = Path(path)
-        metadata = json.loads((path / "decision_config.json").read_text())
-        backbone = Qwen3_5TextModel.from_pretrained(path / "backbone", dtype=dtype, local_files_only=True, attn_implementation=attention)
-        backbone.config.use_cache = False
-        head = CandidateHead(backbone.config.hidden_size, head_dim)
-        metadata.update({"prompt_version": PROMPT_VERSION, "head_dim": head_dim, "max_options": MAX_OPTIONS, "architecture": "contextual-candidate-endpoint-plus-global-query-shared-bilinear-mlp", "head_initialization": "random-shared-content-scorer", "warm_start": "trained-v1-text-backbone", "head_precision": "float32-outside-autocast"})
-        return cls(backbone, head, metadata), AutoTokenizer.from_pretrained(path, local_files_only=True)
-
-    @classmethod
-    def from_checkpoint(cls, path, dtype=torch.bfloat16, attention="sdpa"):
-        path = Path(path)
-        metadata = json.loads((path / "decision_config.json").read_text())
-        if metadata["prompt_version"] != PROMPT_VERSION:
-            raise ValueError("Not a pointer-v2 checkpoint; use from_decision_checkpoint for warm start")
-        backbone = Qwen3_5TextModel.from_pretrained(path / "backbone", dtype=dtype, local_files_only=True, attn_implementation=attention)
-        head = CandidateHead(backbone.config.hidden_size, metadata["head_dim"])
-        head.load_state_dict(load_file(path / "decision_head.safetensors"))
-        return cls(backbone, head, metadata), AutoTokenizer.from_pretrained(path, local_files_only=True)
-
-    def forward(self, input_ids, attention_mask, candidate_positions, candidate_mask, query_positions, **unused):
-        hidden = self.backbone(input_ids=input_ids, attention_mask=attention_mask, use_cache=False).last_hidden_state
-        batches = torch.arange(hidden.shape[0], device=hidden.device)
-        candidates = hidden[batches[:, None], candidate_positions]
-        query = hidden[batches, query_positions]
-        scores = self.head(candidates, query).float()
-        return scores.masked_fill(~candidate_mask, -float("inf"))
-
-    def save(self, path, tokenizer):
-        path = Path(path); path.mkdir(parents=True, exist_ok=True)
-        self.backbone.save_pretrained(path / "backbone", safe_serialization=True, max_shard_size="4GB")
-        save_file({n: v.detach().cpu().contiguous() for n, v in self.head.state_dict().items()}, str(path / "decision_head.safetensors"))
-        tokenizer.save_pretrained(path)
-        (path / "decision_config.json").write_text(json.dumps(self.metadata, indent=2) + "\n")
-
-
-def classification_loss(logits, labels):
-    return F.cross_entropy(logits, labels)

code/predict.py

@@ -1,43 +0,0 @@
-"""Portable one-GPU JSONL inference for frozen dynamic-option checkpoints."""
-import argparse
-import hashlib
-import json
-from pathlib import Path
-import time
-import torch
-from decision_model import DecisionModel, encode, collate
-
-p = argparse.ArgumentParser()
-p.add_argument("--model", required=True)
-p.add_argument("--base", action="store_true")
-p.add_argument("--revision", default="local-checkpoint")
-p.add_argument("--input", required=True)
-p.add_argument("--output", required=True)
-p.add_argument("--batch-size", type=int, default=8)
-p.add_argument("--max-length", type=int, default=4096)
-p.add_argument("--temperature", type=float, default=1.0)
-a = p.parse_args()
-assert a.temperature > 0
-torch.cuda.set_device(0)
-model, tokenizer = DecisionModel.from_base(a.model, a.revision) if a.base else DecisionModel.from_checkpoint(a.model)
-model = model.cuda().eval()
-rows = [json.loads(line) for line in Path(a.input).read_text().splitlines() if line.strip()]
-encoded = [encode(row, tokenizer, a.max_length) for row in rows]
-assert len({row["id"] for row in rows}) == len(rows)
-output = Path(a.output); output.parent.mkdir(parents=True, exist_ok=True)
-if output.exists(): raise RuntimeError("Refusing to overwrite predictions")
-with torch.inference_mode(), output.open("w") as f:
-    for start in range(0, len(encoded), a.batch_size):
-        examples = encoded[start:start + a.batch_size]
-        batch = {key: value.cuda() if torch.is_tensor(value) else value for key, value in collate(examples, tokenizer.pad_token_id if tokenizer.pad_token_id is not None else tokenizer.eos_token_id).items()}
-        torch.cuda.synchronize(); tick = time.perf_counter()
-        with torch.autocast("cuda", dtype=torch.bfloat16): logits = model(**batch)
-        torch.cuda.synchronize(); elapsed = time.perf_counter() - tick
-        probabilities = (logits / a.temperature).softmax(-1).cpu().tolist(); scores = logits.cpu().tolist()
-        for row, example, prob, score in zip(rows[start:start + a.batch_size], examples, probabilities, scores):
-            k = example["nopts"]; pred = max(range(k), key=lambda i: prob[i])
-            rec = {"id": row["id"], "family": row.get("family"), "label": row.get("label"), "prediction": pred, "prediction_key": row["options"][pred]["key"], "probabilities": prob[:k], "logits": score[:k], "temperature": a.temperature, "input_tokens": len(example["ids"]), "prompt_sha256": example["prompt_sha256"], "batch_elapsed_seconds": elapsed, "batch_size": len(examples)}
-            if "score_values" in row: rec["expected_score"] = sum(value * probability for value, probability in zip(row["score_values"], prob[:k]))
-            f.write(json.dumps(rec, ensure_ascii=False) + "\n")
-        f.flush(); print(json.dumps({"completed": min(start + a.batch_size, len(rows)), "total": len(rows)}), flush=True)
-Path(str(output) + ".metadata.json").write_text(json.dumps({"model": a.model, "revision": a.revision, "temperature": a.temperature, "input_sha256": hashlib.sha256(Path(a.input).read_bytes()).hexdigest(), "predictions_sha256": hashlib.sha256(output.read_bytes()).hexdigest(), "rows": len(rows), "model_metadata": model.metadata}, indent=2))

code/profile_guard.py

@@ -1,82 +0,0 @@
-"""Fail-closed official FLA strict-config setup for one isolated process.
-
-No model/prompt/head changes. The guard prevents FLA STRICT's ordinary missing
-key fallback and records actual configured calls. This is a diagnostic module,
-not an installed change to the published wrapper or dependency environment.
-"""
-import hashlib,importlib,json,os,sys
-from pathlib import Path
-
-def sha(p):return hashlib.sha256(Path(p).read_bytes()).hexdigest()
-def serialized(key):return json.dumps(key,separators=(',',':'),sort_keys=True)
-def config_fields(config):
- if isinstance(config,dict):return {k:config.get(k) for k in ['kwargs','num_warps','num_stages','num_ctas','maxnreg','ir_override']}
- return {k:getattr(config,k,None) for k in ['kwargs','num_warps','num_stages','num_ctas','maxnreg','ir_override']}
-def validate_profile(path,expected_sha):
- path=Path(path).resolve()
- if sha(path)!=expected_sha:raise ValueError('Profile hash changed')
- profile=json.loads(path.read_text())
- if profile['format']!='decision-fla-l2norm-profile-v1' or profile.get('model_family')!='Qwen/Qwen3.5-4B' or profile['cache_mode']!='strict':raise ValueError('Profile format/mode unsupported')
- if len(profile['files'])!=1 or profile['files'][0]['file']!='l2norm_fwd_kernel.json':raise ValueError('Unexpected profile file set')
- f=path.parent/'l2norm_fwd_kernel.json'
- if sha(f)!=profile['files'][0]['sha256']:raise ValueError('Explicit kernel config changed')
- data=json.loads(f.read_text());entries={}
- if data.get('default_config') is not None:raise ValueError('Implicit fallback defaults forbidden')
- for h,item in data['autotune_entries'].items():
-  key=item['autotune_key'];encoded=serialized(key)
-  if hashlib.md5(encoded.encode()).hexdigest()!=h or encoded in entries:raise ValueError('Invalid/duplicate key')
-  if len(key)!=5 or key[0]!=128 or type(key[1]) is not int or not 1<=key[1]<=64 or key[2:]!=['torch.bfloat16','torch.bfloat16','torch.float32']:raise ValueError('Unsupported numerical key')
-  c=item['config']
-  if c['kwargs'].keys()!={'BT'} or c['kwargs']['BT'] not in [8,16,32,64] or c['num_warps'] not in [1,2,4,8,16] or c['num_stages']!=3 or c['num_ctas']!=1 or any(c.get(x) is not None for x in ['maxnreg','pre_hook','ir_override']):raise ValueError('Unexpected launch configuration')
-  entries[encoded]=c
- if {json.loads(k)[1] for k in entries}!=set(range(1,65)):raise ValueError('Incomplete legal NB coverage')
- return path,profile,entries
-
-def attach_guard(kernel,cache_module,entries,telemetry):
- original=kernel.run
- def guarded(*args,**kwargs):
-  if cache_module.FLA_CACHE_MODE is not cache_module.FlaCacheMode.STRICT:raise RuntimeError('FLA strict mode changed')
-  key=cache_module.AutotuneKey.build(kernel.arg_names,kernel.keys,args,kwargs);encoded=serialized(list(key.autotune_key))
-  if encoded not in entries:raise RuntimeError('Uncontracted FLA l2norm key: '+encoded)
-  expected=entries[encoded];loaded=cache_module.load_cached_config(kernel.kernel_name,key)
-  if config_fields(loaded)!=config_fields(expected):raise RuntimeError('FLA exact config lookup mismatch')
-  if key.autotune_key in kernel.cache and config_fields(kernel.cache[key.autotune_key])!=config_fields(expected):raise RuntimeError('A conflicting in-process kernel cache exists')
-  # Explicit official configuration load guarantees that the following original
-  # run finds this exact cache entry and cannot perform timing-based autotune.
-  kernel.maybe_load_cached_config(key)
-  if key.autotune_key not in kernel.cache or config_fields(kernel.cache[key.autotune_key])!=config_fields(expected):raise RuntimeError('Official strict config did not load')
-  result=original(*args,**kwargs)
-  if config_fields(kernel.cache[key.autotune_key])!=config_fields(expected):raise RuntimeError('Kernel config changed during call')
-  telemetry['calls']+=1;telemetry['keys'][encoded]=telemetry['keys'].get(encoded,0)+1
-  return result
- kernel.run=guarded
- return original
-
-def install(profile_path,expected_sha):
- path,profile,entries=validate_profile(profile_path,expected_sha)
- if any(n=='fla' or n.startswith('fla.') for n in sys.modules):raise RuntimeError('Install profile before importing FLA; use a fresh isolated process')
- for name,wanted in {'FLA_CACHE_MODE':'strict','FLA_CONFIG_DIR':str(path.parent)}.items():
-  actual=os.environ.get(name)
-  if actual is not None and actual!=wanted:raise RuntimeError('Conflicting '+name)
-  os.environ[name]=wanted
- import torch,triton,fla
- actual={'torch':str(torch.__version__),'hip':torch.version.hip,'triton':triton.__version__,'fla':fla.__version__}
- for name,value in actual.items():
-  if value!=profile['runtime'][name]:raise RuntimeError('Runtime mismatch: '+name)
- if not torch.cuda.is_available():raise RuntimeError('Profile is only qualified for the specified ROCm GPU')
- arch=torch.cuda.get_device_properties(0).gcnArchName.split(':')[0]
- if arch!=profile['runtime']['gpu_arch']:raise RuntimeError('Unsupported GPU architecture '+arch)
- module=importlib.import_module('fla.modules.l2norm');cache_module=importlib.import_module('fla.ops.utils.cache');root=Path(fla.__file__).parent
- for name,value in profile['fla_source_sha256'].items():
-  if sha(root/name)!=value:raise RuntimeError('Pinned FLA source changed: '+name)
- kernel=module.l2norm_fwd_kernel
- if kernel.kernel_name!='l2norm_fwd_kernel' or kernel.keys!=['D','NB'] or kernel.cache:raise RuntimeError('Kernel identity or fresh-cache precondition failed')
- telemetry={'profile_sha256':expected_sha,'status':'installed','calls':0,'keys':{},'strict_guard':True,'unknown_keys':'raise','autotune_fallback_permitted':False,'runtime':actual,'gpu_arch':arch,'process_scope':'one explicitly profiled Nox model; other model loading in this process is not supported'}
- attach_guard(kernel,cache_module,entries,telemetry)
- # The validated inference path only uses the vectorized D128 forward kernel.
- # Other dimensions/backward must not silently enter a different autotuner.
- for name in ['l2norm_fwd_kernel1','l2norm_bwd_kernel','l2norm_bwd_kernel1']:
-  other=getattr(module,name)
-  def reject(*args,_name=name,**kwargs):raise RuntimeError('Uncontracted normalization kernel: '+_name)
-  other.run=reject
- return telemetry

code/runtime_profile.py

@@ -1,36 +0,0 @@
-"""Bundle-local automatic launch-profile binding, before importing FLA.
-
-One profile is active per Python process. Repeated loading of the same verified
-profile is allowed; mixing with an unprofiled/different-profile model is not.
-"""
-import hashlib,importlib.util,json,os,sys,types
-from pathlib import Path
-STATE='_decision_process_normalization_profile_v1'
-def sha(p):return hashlib.sha256(Path(p).read_bytes()).hexdigest()
-def safe(root,relative):
- p=Path(relative)
- if p.is_absolute() or '..' in p.parts:raise ValueError('Unsafe runtime-profile path')
- return root/p
-
-def ensure_profile(bundle):
- bundle=Path(bundle).resolve();runtime=json.loads((bundle/'runtime.json').read_text());spec=runtime.get('normalization_profile');active=sys.modules.get(STATE)
- if spec is None:
-  if active is not None:raise RuntimeError('Load unprofiled and profiled Decision models in separate processes')
-  return None
- if spec.get('kind')!='decision-fla-l2norm-profile-v1' or spec.get('validated_arch')!='gfx942':raise ValueError('Unknown normalization profile contract')
- profile=safe(bundle,spec['profile_file']);guard=safe(bundle,spec['guard_file'])
- if sha(profile)!=spec['profile_sha256'] or sha(guard)!=spec['guard_sha256']:raise ValueError('Bound runtime profile bytes changed')
- if json.loads((bundle/'decision_config.json').read_text()).get('base_model')!='Qwen/Qwen3.5-4B':raise ValueError('This bundle profile is bound to the validated Nox family only')
- if active is not None:
-  if active.profile_sha256!=spec['profile_sha256'] or active.guard_sha256!=spec['guard_sha256']:raise RuntimeError('Different Decision normalization profile is already active; use a separate process')
-  active.guard.validate_profile(profile,spec['profile_sha256'])
-  if os.environ.get('FLA_CACHE_MODE')!='strict' or os.environ.get('FLA_CONFIG_DIR')!=active.profile_dir:raise RuntimeError('Active FLA profile environment changed')
-  return {'profile_sha256':active.profile_sha256,'guard_sha256':active.guard_sha256,'validated_arch':'gfx942','automatic_bundle_binding':True,'scope':'single profile per process'}
- module_spec=importlib.util.spec_from_file_location('decision_profile_guard_'+spec['guard_sha256'][:16],guard);module=importlib.util.module_from_spec(module_spec);module_spec.loader.exec_module(module)
- telemetry=module.install(profile,spec['profile_sha256'])
- state=types.ModuleType(STATE);state.profile_sha256=spec['profile_sha256'];state.guard_sha256=spec['guard_sha256'];state.profile_dir=str(profile.parent);state.guard=module;state.telemetry=telemetry;sys.modules[STATE]=state
- return {'profile_sha256':state.profile_sha256,'guard_sha256':state.guard_sha256,'validated_arch':'gfx942','automatic_bundle_binding':True,'scope':'single profile per process'}
-
-def active_telemetry():
- state=sys.modules.get(STATE)
- return None if state is None else dict(state.telemetry)