Publish BTL-3 Compact package metadata

RELEASE_MANIFEST.json

@@ -0,0 +1,55 @@
+{
+  "schema_version": 1,
+  "release": "BTL-3 Compact",
+  "checkpoint": "RL-0013",
+  "architecture": "Qwen3.6-27B",
+  "model": {
+    "path": "model/BTL-3-Compact-AVQ2.gguf",
+    "bytes": 8392369600,
+    "sha256": "2ddf9527620a17a2a6739d184a7096c45712092e6589128792ec6254e94dc30c"
+  },
+  "runtimes": {
+    "supported": [
+      {
+        "name": "BTL-3-Compact-macos-arm64",
+        "path": "runtimes/supported/BTL-3-Compact-macos-arm64",
+        "bundle": "BTL-3 Compact macOS arm64",
+        "status": "verified native runtime"
+      }
+    ],
+    "preview": [
+      {
+        "name": "BTL-3-Compact-linux-arm64-cuda",
+        "path": "runtimes/preview/BTL-3-Compact-linux-arm64-cuda",
+        "bundle": "BTL-3 Compact Linux arm64 CUDA (DGX Spark)",
+        "status": "cross-compiled; NVIDIA runtime conformance pending"
+      }
+    ]
+  },
+  "integrations": [
+    "integrations/btl3-native",
+    "integrations/ollama"
+  ],
+  "documentation": [
+    "docs/launch-btl3-compact.md",
+    "docs/launch-btl3-cuda.md",
+    "docs/patched-ollama-and-lmstudio.md",
+    "docs/btl-3-compact-gguf-exporter.md"
+  ],
+  "evidence": [
+    "evidence/BTL-3-Compact-AVQ2.report.json",
+    "evidence/native-load-report.json",
+    "evidence/rtx-pro-6000-speed-2026-07-19.md",
+    "evidence/compact-validation.md"
+  ],
+  "tools": [
+    "tools/install_consumer_bundle.py"
+  ],
+  "licenses": [
+    "licenses/LICENSE",
+    "licenses/LICENSE.runtime",
+    "licenses/THIRD_PARTY_NOTICES.md"
+  ],
+  "stock_ollama_compatible": false,
+  "stock_lm_studio_engine_compatible": false
+}

SHA256SUMS

@@ -0,0 +1,67 @@
+60abfe4b90cb4be69481bbe4df2619ed0732f9222c65b9368ec881a099cc6835  README.md
+87e8ab7ed85be38e270830b157061a99af89fb85f51eb12c411e6dcecf5d88e8  RELEASE_MANIFEST.json
+7c3d8064baf55779579b48c58fa083e0bda2a639c857b4bde56bab4008d28002  docs/btl-3-compact-gguf-exporter.md
+d1f83f8a4652b7d07417067e964af864aaebf559bb9b0c76a54a0c357c3ffe86  docs/launch-btl3-compact.md
+ad9f659ec619d9ba3ce07ea864d994f312947d8e7c47abf52b1df659f557811b  docs/launch-btl3-cuda.md
+47611c1f38ce2151446883eff93f3cf0f87e3ce41714efdc9324d5c344a377b5  docs/patched-ollama-and-lmstudio.md
+9425bf13a02b906a7f0af92f94cb3970a8c4b30190d6920908c3235111a4aade  evidence/BTL-3-Compact-AVQ2.report.json
+c7441c024c90d293b1e95a8eb97d5e3ce6d007d218f6e53aab443a0e9c96d71b  evidence/compact-validation.md
+46140e71a8d13348dea6735c039aab8201d9bbbaaff438362b50c4f4f384e02c  evidence/native-load-report.json
+ba9f674a698aa8344596eff3ee698eaf67727222181a0463bc393b3467dddde4  evidence/rtx-pro-6000-speed-2026-07-19.md
+63016e04a641e0eb1741aff3591fcda65cb57c2bdd9d96d4bfa7c7d65a6456b5  integrations/btl3-native/README.md
+78cb0785678d836893fe0ddce58b4c7ff34beec050158ff25f479abc02d562a1  integrations/btl3-native/manifest.json
+0dda87a718d77f5d3d4d47017b37b1261c29349f6d9cede2b639309fda5a348d  integrations/btl3-native/model.yaml
+3b2125b24cffabc49b490ca8824656309670f02f0d1a4f7aea2699cf6d47668a  integrations/btl3-native/package-lock.json
+f47708fb76e59e85c44a0b61928793d53290880d5e6b93e40926c21f1e223811  integrations/btl3-native/package.json
+47c2254ff3cae7b23631dc01a84deefa25940befa8852d08ac2cc1bbef53abd5  integrations/btl3-native/run-local
+6e2a1a2c5838436c7762ee6e0d879737acbc4dac6dd9d7a3a0f03ac4d7bfe72d  integrations/btl3-native/src/config.ts
+51a8605efddaa8fafd708be26e0ac5cd6b12002b948b2a8f4c4c27fe452f33d7  integrations/btl3-native/src/generator.ts
+2840145e096cdea78b8323ba29258b1dd80c8ee7ab66e72a4550fe77a5010a76  integrations/btl3-native/src/index.ts
+6ec5c47c5991089837db57630255e05bb9eda81c63592f962a6a5387d716a2c0  integrations/btl3-native/src/nativeRunner.ts
+d74511d134d59f432bc5108a3a0449c29e7a75346511cceda10575fb8ac084e7  integrations/btl3-native/tsconfig.json
+6492d9473f6f6c7c6126cb11259324e2081fdc2c3dfbcad5fa22534d3680de32  integrations/ollama/Modelfile
+0d542e0c8804e39aa7f37eb00da5a762149dc682d7829451287e11b938e94594  licenses/LICENSE
+ef85e198bda0c18a42650ea1a576bffdc3f8749d2f8dcec739b9be34efeebb2d  licenses/LICENSE.runtime
+87cfc2262dbf499daff47db1339293198fba61431f623fd7226004d6714d58c8  licenses/THIRD_PARTY_NOTICES.md
+2ddf9527620a17a2a6739d184a7096c45712092e6589128792ec6254e94dc30c  model/BTL-3-Compact-AVQ2.gguf
+94f29bbed6a22c35b992c5c6ebf0e7c92f13b836b90f36f461c9cf2f0f1d010d  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/LICENSE.llama.cpp
+043658e4900b04a80fb9d4247c4fe8b04f5adc3706325996dc176b202f9baa24  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/bin/btl3-server
+328388c97746e3781f0fe8520ec73aa4bb8ad55978c2a62385964fff33e711d0  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/bundle-manifest.json
+7761d260387b95fa13b7ec101453abca45ef972d3e6ccc8bcf54251e1ac0470b  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/lib/libcublas.so.13
+3839e12c3b69ed8eb732e5d5f8e749403a582a9d706f779017c785152d9e62f9  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/lib/libcublasLt.so.13
+7bdba2b5b08cbdc85203c41cc94598adedb1bcfea7cb574ca693ac73599e4e63  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/lib/libcudart.so.13
+b18971c1a35490194c8aa1666a57494e6324064155017add217f0b20ade657ba  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/lib/libggml-base.so.0
+b18971c1a35490194c8aa1666a57494e6324064155017add217f0b20ade657ba  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/lib/libggml-base.so.0.13.1
+b61975da167b511286b5df2d6cc384d3ba9eb78d559927d784352d420a4d59db  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/lib/libggml-cpu.so
+9edb3b2a88fe59fe6d33d9e6a70f8bede4df68b3acfc5e00a63c53e34163985c  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/lib/libggml-cuda.so
+3ab1d08c26865f5ff7ed753818cd84bc1fa9438e633eae7e3a53b633794973f5  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/lib/libggml.so.0
+3ab1d08c26865f5ff7ed753818cd84bc1fa9438e633eae7e3a53b633794973f5  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/lib/libggml.so.0.13.1
+cde7a5d92f37a641b8962fd2a4a516edfadb19a53b426ab392d10995053df7c0  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/lib/libllama-cli-impl.so
+a154d3ee1da598eb55ff0ecfbdcd6898fa449a1dbac7c2afcf22263eac7abae6  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/lib/libllama-common.so.0
+a154d3ee1da598eb55ff0ecfbdcd6898fa449a1dbac7c2afcf22263eac7abae6  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/lib/libllama-common.so.0.0.0
+44c74d0f766c9f0fa1bf0482eabf12927b9a5615e18c348c8cd19e3c2c952f25  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/lib/libllama-server-impl.so
+78addbbc0eb03da6208eab469e8e17a989e47f3e3c99674aa3203fd658694021  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/lib/libllama.so.0
+78addbbc0eb03da6208eab469e8e17a989e47f3e3c99674aa3203fd658694021  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/lib/libllama.so.0.0.0
+60a791c271d779f4f11321a13dd380424ca20909f530b035ea3d568ab2b87178  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/lib/libmtmd.so.0
+60a791c271d779f4f11321a13dd380424ca20909f530b035ea3d568ab2b87178  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/lib/libmtmd.so.0.0.0
+5e1c37e59fb2cd37acd8df0fe87a5e1f7a74a496af4ae278012757d84a1b1939  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/libexec/llama-cli
+b67f9d10eaa85a500180ddecf6ecdf0e9c100b0bdf4c10e32b0bf657ca50e494  runtimes/preview/BTL-3-Compact-linux-arm64-cuda/libexec/llama-server
+7d5450cb2d142651b8afa315b5f238efc805dad827d91ba367d8516bc9d49e7a  runtimes/supported/BTL-3-Compact-macos-arm64/LICENSE.OpenSSL
+94f29bbed6a22c35b992c5c6ebf0e7c92f13b836b90f36f461c9cf2f0f1d010d  runtimes/supported/BTL-3-Compact-macos-arm64/LICENSE.llama.cpp
+de4350f194d6f393bd3ea1065b024d7f92fea0a8f2e435f6557dc0c6696b3a74  runtimes/supported/BTL-3-Compact-macos-arm64/bin/btl3-ollama-bridge
+f14fe48ab3d5f0662f7ffe524cd6db8bc4d9bb2d892e54147c1e290cd2532d75  runtimes/supported/BTL-3-Compact-macos-arm64/bin/btl3-server
+3ac935decfa3c67faaa210dee3b07417611cc1abcf13c5fcf5850fac3cbd399e  runtimes/supported/BTL-3-Compact-macos-arm64/bundle-manifest.json
+1f6ea0bde7b3d4ea462b047e12905c8b554b111d2808deb33fc3add67b4d0895  runtimes/supported/BTL-3-Compact-macos-arm64/lib/libcrypto.3.dylib
+a5edff95c1a5f9c6fd3072ea65cb8b75e44fb92bbb1b35901ec43fe62cbc6eff  runtimes/supported/BTL-3-Compact-macos-arm64/lib/libggml-base.0.13.1.dylib
+14c8604076154609c9767a936953f7c2e419099a509e129629467329b5d21aad  runtimes/supported/BTL-3-Compact-macos-arm64/lib/libggml-blas.0.13.1.dylib
+9c4a1850b1c55891fb0c9f050c3ba42951b724cff9da8e9ba666fc79dfbd2014  runtimes/supported/BTL-3-Compact-macos-arm64/lib/libggml-cpu.0.13.1.dylib
+60827547a100f266ba2003d71ff875e69bd228c6ba0882c478eb70591236971f  runtimes/supported/BTL-3-Compact-macos-arm64/lib/libggml-metal.0.13.1.dylib
+0cee0d7d52b6146f0806931e3dd298b4ad7d14ca7dee09877550710856031d72  runtimes/supported/BTL-3-Compact-macos-arm64/lib/libggml.0.13.1.dylib
+62ad74a419305415bb82949c4e2aab62011544905af956aa35a5b6de37212cd0  runtimes/supported/BTL-3-Compact-macos-arm64/lib/libllama-common.0.0.9596.dylib
+5fa01307a6369735e27caeba88f7c918f48bb3618db77049733b62a7cca072c2  runtimes/supported/BTL-3-Compact-macos-arm64/lib/libllama-server-impl.dylib
+803311ec14455f2d0c48a79501d10134ec7d7a91c135363ca066be0b77ba19e0  runtimes/supported/BTL-3-Compact-macos-arm64/lib/libllama.0.0.9596.dylib
+1a50c4f282eaaa080918262324f0095eb189857eb05d3604931c52e6039ea818  runtimes/supported/BTL-3-Compact-macos-arm64/lib/libmtmd.0.0.9596.dylib
+7bc4c3a34a7f6b90eb3715de8ccb76bf0262882b9c3fb5dc2bdb13a30b0fe0bf  runtimes/supported/BTL-3-Compact-macos-arm64/lib/libssl.3.dylib
+822a7679463a66d994b14f1d6fcab80f08fae0c3839d83d08fb8778b78f685f8  runtimes/supported/BTL-3-Compact-macos-arm64/libexec/llama-server
+8ee92d4b719fe2cb94cfe673beb55b51c2c4f6248b98449224462aa47346b068  runtimes/supported/BTL-3-Compact-macos-arm64/share/btl3/ollama_bridge.py
+4c0c84652be9749c3aa521a9b75a2b4511e0d949f755b41eca960929717e1fc0  tools/install_consumer_bundle.py

docs/btl-3-compact-gguf-exporter.md

@@ -0,0 +1,69 @@
+# BTL-3 Compact GGUF exporter
+
+## Scope
+
+The exporter turns the frozen BTL-3 Compact package into the tensor contract
+consumed by the custom Qwen3.6 llama.cpp backend. It never reconstructs a dense
+decoder. Safetensors are mmap-backed and materialized one tensor at a time.
+Every one of the 158 source files is size- and SHA-256-checked against the
+frozen package manifest before planning or writing.
+
+It exports:
+
+- standard Qwen3.6 small-state tensors with official converter semantics;
+- AVQ2 codes, affines, and exact Torch-seeded sign vectors;
+- affine-INT4 codes, scales, and zero points;
+- the two final INT4 demotions in place of their superseded BF16 islands;
+- frozen BF16 islands;
+- the rank-8 behavior LoRA;
+- AVQ2 embedding and output tensors, rescued embedding rows, and head residual.
+
+## Verified planning result
+
+The full dry-run plans 2,416 tensors and 8,381,262,032 tensor bytes. The
+170,510,920-byte reduction from the source package is expected: the package
+retains two superseded BF16 island files for provenance, while the export emits
+only their final INT4 demotions.
+
+The exporter reports no unsupported representations and no native-runtime
+contract gaps.
+
+## Numerical conformance
+
+Three representative layers were exported so every decoder representation was
+materialized:
+
+| Layer | Coverage | Tensors | Bytes | Payloads verified |
+|---:|---|---:|---:|---:|
+| 13 | AVQ2, BF16 island, final INT4 demotion | 28 | 322,295,104 | 28/28 |
+| 40 | AVQ2, small state, behavior LoRA | 44 | 98,427,808 | 44/44 |
+| 47 | AVQ2, standard affine INT4, behavior LoRA | 35 | 122,932,064 | 35/35 |
+
+Every tensor passed:
+
+- canonical-name equality;
+- source-shape equality;
+- exact GGUF storage-type equality;
+- exact raw payload-byte equality after required Qwen transformations;
+- exact regeneration of seeded signs.
+
+The layer-40 artifact SHA-256 is
+`e621b4cdb1e3f25cdde514427b14cd6d27bacbe72ad5850468311c693d4d79f7`.
+
+This one-layer artifact is not a runnable model. A full export was deliberately
+not started at this gate.
+
+## Commands
+
+```bash
+.venv/bin/python tools/export_btl3_compact_gguf.py \
+  --source /path/to/BTL-3/compact \
+  --dry-run \
+  --report artifacts/btl3-compact-gguf-dry-run.json
+
+.venv/bin/python tools/export_btl3_compact_gguf.py \
+  --source /path/to/BTL-3/compact \
+  --conformance-layer 40 \
+  --output artifacts/conformance/btl-3-compact-layer40.gguf \
+  --report artifacts/conformance/btl-3-compact-layer40.report.json
+```

docs/launch-btl3-compact.md

@@ -0,0 +1,153 @@
+# Launch BTL-3 Compact locally
+
+This repository ships a relocatable macOS arm64 server bundle for the exact
+BTL-3 Compact AVQ2 artifact:
+
+- model: `BTL-3-Compact-AVQ2.gguf`
+- bytes: `8,392,369,600`
+- SHA-256:
+  `2ddf9527620a17a2a6739d184a7096c45712092e6589128792ec6254e94dc30c`
+- runtime: llama.cpp build 9596, commit `9fcaed763`
+
+The model is external to the 28 MB runtime bundle. The launcher finds the model
+in `artifacts/release`, in the bundle's `model` directory, or at `BTL3_MODEL`.
+
+## Build and verify the bundle
+
+Run this on an Apple Silicon Mac with Homebrew OpenSSL 3 installed:
+
+```bash
+rm -rf artifacts/runtime/BTL-3-Compact-macos-arm64
+.venv/bin/python tools/build_macos_arm64_bundle.py
+```
+
+The builder copies the native dependency closure, rewrites absolute install
+names and rpaths, ad-hoc signs the result, includes dependency licenses, and
+writes `bundle-manifest.json`.
+
+## OpenAI-compatible API
+
+Start the server:
+
+```bash
+BTL3_CTX_SIZE=4096 \
+  artifacts/runtime/BTL-3-Compact-macos-arm64/bin/btl3-server
+```
+
+Check it:
+
+```bash
+curl -s http://127.0.0.1:8080/health
+curl -s http://127.0.0.1:8080/v1/models
+```
+
+Call chat completions with any OpenAI-compatible client:
+
+```bash
+curl http://127.0.0.1:8080/v1/chat/completions \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "model": "BTL-3",
+    "messages": [{"role": "user", "content": "Write a retrying fetch helper."}],
+    "stream": true
+  }'
+```
+
+Useful configuration:
+
+| Variable | Default | Meaning |
+|---|---:|---|
+| `BTL3_HOST` | `127.0.0.1` | Listen address |
+| `BTL3_PORT` | `8080` | OpenAI API port |
+| `BTL3_CTX_SIZE` | `32768` | Allocated context |
+| `BTL3_PARALLEL` | `1` | Concurrent slots |
+| `BTL3_GPU_LAYERS` | `99` | Layers requested on Metal |
+| `BTL3_API_KEY` | unset | Optional local bearer key |
+| `BTL3_MODEL_ALIASES` | `BTL-3` | Comma-separated transport aliases |
+
+On a 16 GB Mac, begin at 2K–4K context. A larger context raises KV-cache and
+working-memory requirements. The model's declared context length is not a
+promise that a particular device can allocate it.
+
+## LM Studio
+
+LM Studio's official
+[`openai-compat-endpoint`](https://www.lmstudio.ai/lmstudio/openai-compat-endpoint)
+generator can target the local API. Its current model picker uses a fixed set
+of model IDs, so expose one of those IDs as a **transport alias**:
+
+```bash
+BTL3_API_KEY=btl3-local \
+BTL3_MODEL_ALIASES='BTL-3,gpt-4.1-2025-04-14' \
+BTL3_CTX_SIZE=4096 \
+  artifacts/runtime/BTL-3-Compact-macos-arm64/bin/btl3-server
+```
+
+Then:
+
+1. Install the official plugin from its LM Studio Hub page.
+2. Set **Override Base URL** to `http://127.0.0.1:8080/v1`.
+3. Set its API key to `btl3-local`.
+4. Select `gpt-4.1-2025-04-14`.
+
+That name is only protocol routing. The served model remains BTL-3; the
+integration does not claim it is an OpenAI model.
+
+## Ollama CLI
+
+Stock Ollama does not load BTL-3's custom AVQ2 GGUF. Do not use
+`ollama create`. The supplied bridge lets the unmodified Ollama CLI speak to
+the native BTL-3 server through Ollama's local HTTP protocol.
+
+In terminal one:
+
+```bash
+BTL3_CTX_SIZE=4096 \
+  artifacts/runtime/BTL-3-Compact-macos-arm64/bin/btl3-server
+```
+
+In terminal two:
+
+```bash
+BTL3_CTX_SIZE=4096 \
+  artifacts/runtime/BTL-3-Compact-macos-arm64/bin/btl3-ollama-bridge
+```
+
+Then use the installed Ollama CLI:
+
+```bash
+OLLAMA_HOST=http://127.0.0.1:11435 ollama list
+OLLAMA_HOST=http://127.0.0.1:11435 ollama show btl3-compact:latest
+OLLAMA_HOST=http://127.0.0.1:11435 ollama run btl3-compact:latest
+```
+
+The bridge implements `/api/chat`, `/api/generate`, `/api/tags`, `/api/show`,
+`/api/ps`, and `/api/version`. It maps streaming to Ollama NDJSON and preserves
+reasoning, tool calls, structured output, cancellation, token counts, and the
+common sampling options. Unsupported Ollama management endpoints return 501
+instead of pretending to work.
+
+## Validation status
+
+The packaged executable has passed native model load, graph reservation,
+`/health`, and `/v1/models` checks on Apple M2. Protocol tests pass using the
+real installed Ollama CLI and a deterministic OpenAI-compatible upstream.
+
+The native Metal runtime accelerates AVQ2, affine INT4, the vocabulary head,
+and rescued and ordinary embedding rows without reconstructing dense weights.
+On a base Apple M2 with 16 GB unified memory, a clean full-model smoke measured
+2.30 prompt tokens/second and 2.48 generated tokens/second at a 128-token
+allocated context. Treat those as one-device smoke results, not universal
+throughput claims. Context size, prompt length, thermal state, and Apple chip
+generation will change performance.
+
+The exact GGUF has passed full-model native CUDA execution on an RTX PRO 6000
+Blackwell Server Edition. Three repetitions measured 84.70 prompt
+tokens/second and 43.16 generated tokens/second with full GPU offload. This
+does not establish RTX 4090, RTX 5090, DGX Spark, or Windows compatibility;
+each target still requires its own packaged-runtime gate. Do not reuse the old
+Python/Triton H100 number as a native-runtime claim.
+
+The native server may display roughly 7.7B `n_params`; that value counts packed
+stored elements, not the logical 27B architecture. Product metadata exposed by
+the bridge reports the logical model class.

docs/launch-btl3-cuda.md

@@ -0,0 +1,161 @@
+# BTL-3 consumer NVIDIA build and packaging
+
+This repository contains reproducible native CUDA build and package definitions
+for three consumer targets:
+
+| Target | Intended hardware | Requested CUDA architectures |
+|---|---|---|
+| `linux-x86_64` | RTX 4090 and RTX 5090 | `89-real;120-real` |
+| `windows-x86_64` | RTX 4090 and RTX 5090 | `89-real;120-real` |
+| `linux-arm64` | NVIDIA DGX Spark | `121-real` |
+
+The definitions pin CUDA Toolkit 13.0.2. NVIDIA lists compute capability 8.9
+for RTX 4090, 12.0 for RTX 5090, and 12.1 for DGX Spark. NVIDIA's DGX Spark
+porting guide specifically recommends `CMAKE_CUDA_ARCHITECTURES="121-real"`.
+The current llama.cpp fork deliberately rewrites requested plain Blackwell
+architectures to architecture-specific code: `120-real` becomes `120a-real`
+and `121-real` becomes `121a-real`. This enables Blackwell-specific
+instructions and is not forward-compatible with later architectures.
+
+Sources:
+
+- <https://developer.nvidia.com/cuda/gpus>
+- <https://docs.nvidia.com/dgx/dgx-spark-porting-guide/porting/compilation.html>
+- <https://docs.nvidia.com/dgx/dgx-spark/system-overview.html>
+- <https://docs.nvidia.com/dgx/dgx-spark/release-notes.html>
+
+## Current support boundary
+
+Native AVQ2, affine INT4, vocabulary projection, and embedding kernels have
+passed exact-GGUF full-model execution on one Linux x86_64 RTX PRO 6000
+Blackwell Server Edition (`sm_120a`). Three native benchmark repetitions
+measured 84.70 prompt tokens/second and 43.16 generated tokens/second.
+
+That measurement validates the implementation on that device. It does not
+automatically validate a separately built archive, RTX 4090, RTX 5090,
+Windows, or DGX Spark. The complete Linux arm64 runner cross-compiles under
+CUDA 13.0.2 for DGX Spark `sm_121a`, but remains a preview until target-device
+execution. Do not advertise unmeasured targets as supported.
+
+## Linux x86_64 and DGX Spark builds
+
+The Docker definition uses NVIDIA's multi-architecture
+`nvidia/cuda:13.0.2-devel-ubuntu24.04` image. Its published manifest contains
+both `linux/amd64` and `linux/arm64`. The Dockerfile pins manifest-list digest
+`sha256:5dc1bca23d05bd37b011be68ec470c03b403a5da07ec3a86e41af9470e9d0cc6`
+so the tag cannot silently change the toolchain.
+
+Build an RTX Linux bundle:
+
+```bash
+packaging/cuda/build-linux.sh \
+  linux-x86_64 artifacts/runtime/BTL-3-Compact-linux-x86_64-cuda
+```
+
+Build natively on DGX Spark:
+
+```bash
+packaging/cuda/build-linux.sh \
+  linux-arm64 artifacts/runtime/BTL-3-Compact-linux-arm64-cuda
+```
+
+Cross-building arm64 through Docker Buildx is useful as a compile/package
+check, but it does not replace execution on DGX Spark.
+
+## Windows x64 build
+
+Run this in PowerShell with Visual Studio C++ tools, CMake, Python, and CUDA
+Toolkit 13.0.x installed:
+
+```powershell
+.\packaging\cuda\build-windows.ps1 `
+  -Output artifacts\runtime\BTL-3-Compact-windows-x86_64-cuda
+```
+
+The package contains `llama-server.exe`, `llama-cli.exe`, the produced llama
+and GGML DLLs, and the required redistributable CUDA runtime DLLs. The NVIDIA
+display driver remains a system prerequisite.
+
+## Bundle contents
+
+The model is deliberately external to every runtime bundle:
+
+- `libexec/llama-server[.exe]`
+- `libexec/llama-cli[.exe]`
+- `lib/` runtime dependency closure
+- `bin/btl3-server[.ps1]`
+- `bundle-manifest.json`
+- `model/` empty destination for the model
+
+The manifest records checksums for packaged files and the expected external
+model:
+
+- filename: `BTL-3-Compact-AVQ2.gguf`
+- bytes: `8,392,369,600`
+- SHA-256:
+  `2ddf9527620a17a2a6739d184a7096c45712092e6589128792ec6254e94dc30c`
+
+## Safe context defaults
+
+The launcher detects the first NVIDIA GPU's total memory. DGX Spark falls back
+to system memory because CPU and GPU share its 128 GB unified pool.
+
+| Detected memory | Default context |
+|---:|---:|
+| below 20,000 MiB | 16,384 |
+| 20,000–27,999 MiB | 32,768 |
+| 28,000–47,999 MiB | 65,536 |
+| 48,000–95,999 MiB | 98,304 |
+| at least 96,000 MiB | 131,072 |
+
+These defaults reserve memory for the 8.39 GB model, runtime workspace, and
+other processes. Override them with `BTL3_CTX_SIZE`. Override faulty hardware
+detection with `BTL3_GPU_MEMORY_MIB`. On DGX Spark, the launcher enables
+`GGML_CUDA_ENABLE_UNIFIED_MEMORY=1`; lower context if the system is under
+memory pressure.
+
+Place the GGUF in the bundle's `model` directory or set `BTL3_MODEL`, then run:
+
+```bash
+BTL3_PRINT_COMMAND=1 ./bin/btl3-server
+./bin/btl3-server
+```
+
+For a verified per-user installation used automatically by the LM Studio
+plugin, install the downloaded runtime and GGUF in one command:
+
+```bash
+python3 tools/install_consumer_bundle.py \
+  --runtime artifacts/runtime/BTL-3-Compact-linux-x86_64-cuda \
+  --model artifacts/release/BTL-3-Compact-AVQ2.gguf
+```
+
+The installer checks every runtime hash plus the complete 8.39 GB model hash
+before atomically installing. Its defaults are `~/.local/share/btl3` on Linux
+and `%LOCALAPPDATA%\BTL3` on Windows.
+
+On Windows:
+
+```powershell
+$env:BTL3_PRINT_COMMAND = "1"
+.\bin\btl3-server.ps1
+```
+
+The print mode validates model discovery, memory detection, and chosen context
+without starting the server.
+
+## Required NVIDIA conformance
+
+Before changing the support label:
+
+1. Build both Linux architectures and Windows x64 from clean environments.
+2. Run `test-btl3-avq-cuda`, `test-btl3-int4-cuda`, and
+   `test-btl3-vocab-cuda` on RTX 4090, RTX 5090, and DGX Spark.
+3. Record numerical parity and packed-probe placement for all four custom
+   operation families.
+4. Load the exact external GGUF and execute prompt plus decode.
+5. Run transport, reasoning, tool-call, cancellation, and behavior gates.
+6. Record throughput, peak memory, driver, CUDA runtime, and artifact hashes.
+
+No throughput or compatibility number should be inferred from a successful
+cross-compile.

docs/patched-ollama-and-lmstudio.md

@@ -0,0 +1,234 @@
+# BTL-3 consumer integrations
+
+This document separates three products that must not be conflated:
+
+| Surface | How BTL-3 executes | Current status |
+|---|---|---|
+| Stock Ollama | Stock runner | Does not execute AVQ2 |
+| **BTL-3 Patched Ollama** | Ollama directly spawns BTL's native `llama-server` | Packaging scaffold complete; target packages pending |
+| LM Studio | Official generator plugin calls BTL's native local endpoint | Plugin type-checks; macOS native endpoint verified |
+
+No HTTP translation bridge sits between patched Ollama and the runner.
+
+## Why the runner replacement is small
+
+At official Ollama commit
+[`573386c35eac76124ffce571f4b0fefa0a7fe13c`](https://github.com/ollama/ollama/commit/573386c35eac76124ffce571f4b0fefa0a7fe13c),
+`llm.NewLlamaServer` delegates every GGUF model to a `llama-server`
+subprocess. Ollama locates that executable under `lib/ollama`, starts it on an
+ephemeral loopback port, and speaks its native `/health`, `/completion`,
+`/v1/chat/completions`, tokenization, and embedding endpoints. The relevant
+upstream files are
+[`llm/server.go`](https://github.com/ollama/ollama/blob/573386c35eac76124ffce571f4b0fefa0a7fe13c/llm/server.go),
+[`llm/llama_server.go`](https://github.com/ollama/ollama/blob/573386c35eac76124ffce571f4b0fefa0a7fe13c/llm/llama_server.go),
+and
+[`llm/llama_binary.go`](https://github.com/ollama/ollama/blob/573386c35eac76124ffce571f4b0fefa0a7fe13c/llm/llama_binary.go).
+
+BTL's native runner already exposes that contract. The patched distribution
+replaces Ollama's runtime payload, not its public API, scheduler, CLI, model
+store, or UI.
+
+## Build the CUDA runner payload
+
+Build on the target machine so CMake selects the target GPU:
+
+```bash
+cmake -S native/llama.cpp -B native/llama.cpp/build-btl3-cuda \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DCMAKE_CUDA_ARCHITECTURES=native \
+  -DBUILD_SHARED_LIBS=ON \
+  -DGGML_BACKEND_DL=ON \
+  -DGGML_CUDA=ON \
+  -DLLAMA_CURL=OFF
+cmake --build native/llama.cpp/build-btl3-cuda \
+  --target llama-server --parallel
+```
+
+Stage the executable and its shared libraries. Use `cuda_v13` with CUDA 13 and
+`cuda_v12` with CUDA 12:
+
+```bash
+payload=/tmp/btl3-runner
+cuda_dir=cuda_v13
+rm -rf "$payload"
+mkdir -p "$payload/$cuda_dir"
+cp native/llama.cpp/build-btl3-cuda/bin/llama-server "$payload/"
+cp native/llama.cpp/build-btl3-cuda/bin/libggml*.so* "$payload/"
+cp native/llama.cpp/build-btl3-cuda/bin/libllama*.so* "$payload/"
+mv "$payload"/libggml-cuda.so* "$payload/$cuda_dir/"
+"$payload/llama-server" --help
+```
+
+Do not package until `--help` exposes `--model`, `--host`, `--port`,
+`--no-webui`, `--offline`, and `-np`. The packager enforces that contract.
+
+### Hardware targets
+
+- RTX 4090: build `linux-amd64-cuda12` or `cuda13` on that machine.
+- RTX 5090: build on the 5090 so `native` includes its Blackwell target.
+- Windows RTX 4090/5090: build `windows-amd64-cuda13` on Windows x64.
+- DGX Spark: build `linux-arm64-cuda13` on Spark. Current DGX Spark software is
+  ARM64 and ships CUDA 13; do not reuse an x86_64 payload. See NVIDIA's
+  [hardware overview](https://docs.nvidia.com/dgx/dgx-spark/hardware.html) and
+  [current release notes](https://docs.nvidia.com/dgx/dgx-spark/release-notes.html).
+
+## Build BTL-3 Patched Ollama
+
+Build Ollama from the pinned source commit using its official Linux build, or
+unpack a distribution built from that exact commit into `OLLAMA_DIST`. Then:
+
+```bash
+.venv/bin/python tools/build_patched_ollama.py \
+  --ollama-dist "$OLLAMA_DIST" \
+  --runner-payload /tmp/btl3-runner \
+  --platform linux-amd64-cuda13 \
+  --output dist/btl3-patched-ollama-linux-amd64-cuda13
+```
+
+The output contains:
+
+```text
+bin/ollama
+bin/btl3-ollama
+lib/ollama/llama-server
+lib/ollama/cuda_v13/libggml-cuda.so
+share/btl3/patched-ollama-manifest.json
+```
+
+`btl3-ollama --btl3-info` prints the patched label. All other arguments are
+passed to the packaged Ollama binary.
+
+Create the local model only with the patched distribution:
+
+```bash
+cp artifacts/release/BTL-3-Compact-AVQ2.gguf integrations/ollama/
+dist/btl3-patched-ollama-linux-amd64-cuda13/bin/btl3-ollama serve
+# in another terminal
+dist/btl3-patched-ollama-linux-amd64-cuda13/bin/btl3-ollama \
+  create btl3-compact -f integrations/ollama/Modelfile
+dist/btl3-patched-ollama-linux-amd64-cuda13/bin/btl3-ollama \
+  run btl3-compact
+```
+
+The GGUF stores BTL's packed representation in ordinary I8/F32/BF16 tensors
+with custom names, so no new GGUF tensor-type enum is required. Actual model
+creation and generation remain release gates on each CUDA target.
+
+### Windows x64 CUDA 13
+
+The pinned Ollama source has the same direct subprocess architecture on
+Windows. Its
+[`llama_binary.go`](https://github.com/ollama/ollama/blob/573386c35eac76124ffce571f4b0fefa0a7fe13c/llm/llama_binary.go)
+adds `.exe` and searches beside a top-level `ollama.exe` at
+`lib\ollama\llama-server.exe`; the pinned
+[`build_windows.ps1`](https://github.com/ollama/ollama/blob/573386c35eac76124ffce571f4b0fefa0a7fe13c/scripts/build_windows.ps1)
+installs CUDA payloads under that same directory.
+
+Build the native runner from an x64 Visual Studio developer shell with CUDA 13:
+
+```powershell
+cmake -S native/llama.cpp -B native/llama.cpp/build-btl3-win-cuda13 `
+  -A x64 `
+  -DBUILD_SHARED_LIBS=ON `
+  -DGGML_BACKEND_DL=ON `
+  -DGGML_CUDA=ON `
+  -DLLAMA_CURL=OFF
+cmake --build native/llama.cpp/build-btl3-win-cuda13 `
+  --config Release --target llama-server --parallel
+
+$Bin = "native/llama.cpp/build-btl3-win-cuda13/bin/Release"
+$Payload = "$env:TEMP/btl3-runner-win"
+Remove-Item -Recurse -Force $Payload -ErrorAction SilentlyContinue
+New-Item -ItemType Directory "$Payload/cuda_v13" | Out-Null
+Copy-Item "$Bin/llama-server.exe" $Payload
+Copy-Item "$Bin/*.dll" $Payload
+Move-Item "$Payload/ggml-cuda.dll" "$Payload/cuda_v13/"
+powershell -ExecutionPolicy Bypass -File tools/probe_windows_runner.ps1 `
+  -Runner "$Payload/llama-server.exe" `
+  -Output "$Payload/runner-cli-contract.json"
+```
+
+The target-side probe executes the exact runner and binds its required Ollama
+CLI flags to its SHA-256. Cross-platform packaging refuses a missing, stale,
+or wrong-platform contract. It also checks that `ollama.exe`,
+`llama-server.exe`, and every staged DLL are PE x64.
+
+Package an official pinned Windows x64 distribution:
+
+```powershell
+python tools/build_patched_ollama.py `
+  --ollama-dist "$env:TEMP/ollama-windows-amd64" `
+  --runner-payload "$env:TEMP/btl3-runner-win" `
+  --platform windows-amd64-cuda13 `
+  --output dist/btl3-patched-ollama-windows-amd64-cuda13
+
+dist\btl3-patched-ollama-windows-amd64-cuda13\btl3-ollama.cmd --btl3-info
+dist\btl3-patched-ollama-windows-amd64-cuda13\btl3-ollama.cmd serve
+```
+
+The Windows output uses top-level `ollama.exe` and `btl3-ollama.cmd`, with the
+runner at `lib\ollama\llama-server.exe` and CUDA backend at
+`lib\ollama\cuda_v13\ggml-cuda.dll`. This path is source-verified and
+package-tested, but still requires generation conformance on real Windows
+CUDA hardware before release.
+
+## Required Ollama release gates
+
+For each 4090, 5090, and DGX Spark artifact:
+
+1. Verify runner and CUDA library architecture with `file`/`ldd` on Linux, or
+   `dumpbin /headers` and `/dependents` on Windows.
+2. Run `btl3-ollama --btl3-info` and verify the manifest hashes.
+3. Create the model in a temporary `OLLAMA_MODELS` directory.
+4. Confirm Ollama itself spawns the packaged runner PID.
+5. Exercise streaming chat, cancellation, reasoning, single and parallel tool
+   calls, JSON schema output, context reuse, and unload/reload.
+6. Reverify the exact model SHA-256:
+   `2ddf9527620a17a2a6739d184a7096c45712092e6589128792ec6254e94dc30c`.
+
+Until those checks pass on a real CUDA executable, the output is a packaging
+candidate—not an Ollama-compatible release.
+
+## LM Studio generator
+
+LM Studio's official plugin API treats generators as replacement token
+sources. The BTL plugin therefore calls the native runner's OpenAI-compatible
+endpoint; it does not ask LM Studio's stock engine to interpret AVQ2. Official
+generator and tool-call APIs are documented in LM Studio's
+[generator introduction](https://lmstudio.ai/docs/typescript/plugins/generator)
+and
+[tool-calling guide](https://lmstudio.ai/docs/typescript/plugins/generator/tool-calling-generators).
+
+Install the BTL native runner and model into the platform-default BTL-3 data
+directory (or configure their paths in the plugin), then:
+
+```bash
+cd integrations/lmstudio/btl3-native
+./run-local
+```
+
+The script installs the locked dependencies and runs the official `lms dev`
+workflow. The model appears in LM Studio's model picker as the generator
+plugin. Its default endpoint is `http://127.0.0.1:8080/v1`. When that endpoint
+is offline, the Node plugin starts the installed native runner directly with
+the configured model; no separately launched compatibility server is required.
+
+The plugin preserves:
+
+- streamed content;
+- reasoning fragments through `reasoningType: "reasoning"`;
+- cancellation through `ctl.abortSignal`;
+- full chat history and tool results;
+- parallel tool-call IDs, names, and JSON argument fragments;
+- explicit propagation of cancellation, connection, and API failures.
+
+Content and reasoning stream live. LM Studio's generator event lifecycle
+represents one active tool call at a time and its argument-fragment callback
+does not include a call ID. To preserve BTL-3's parallel calls correctly, the
+plugin buffers tool fragments by upstream call index and emits each complete
+lifecycle sequentially when the server stream ends. It does not misattribute
+interleaved arguments merely to make the tool UI look live.
+
+The included `model.yaml` is catalog metadata, not a claim that the stock LM
+Studio GGUF engine supports AVQ2. It uses the explicit compatibility label
+`btl3-avq2-native`.

evidence/BTL-3-Compact-AVQ2.report.json

@@ -0,0 +1,45 @@
+{
+  "schema_version": 1,
+  "model": "BTL-3 Compact",
+  "mode": "full",
+  "source_manifest_sha256": "a2b763323eed76d8f78fe5cbdf5a2349323b2c3d87dddc037714569946961116",
+  "source_weight_bytes": 8551772952,
+  "tensor_count": 2416,
+  "projected_tensor_bytes": 8381262032,
+  "components": {
+    "small-state": {
+      "tensors": 449,
+      "bytes": 57767936
+    },
+    "avq2": {
+      "tensors": 1615,
+      "bytes": 5498130320
+    },
+    "affine-int4": {
+      "tensors": 189,
+      "bytes": 875438080
+    },
+    "bf16-island": {
+      "tensors": 12,
+      "bytes": 1205862400
+    },
+    "affine-int4-demotion": {
+      "tensors": 6,
+      "bytes": 43909120
+    },
+    "behavior-lora": {
+      "tensors": 132,
+      "bytes": 32440320
+    },
+    "vocabulary": {
+      "tensors": 13,
+      "bytes": 667713856
+    }
+  },
+  "exporter_unsupported": [],
+  "native_runtime_gaps": [],
+  "output_bytes": 8392369600,
+  "output_sha256": "2ddf9527620a17a2a6739d184a7096c45712092e6589128792ec6254e94dc30c",
+  "verified_tensor_count": 2416,
+  "verified_payload_count": 2416
+}

evidence/compact-validation.md

@@ -0,0 +1,122 @@
+# BTL-3 Compact native release validation
+
+Date: 2026-07-19
+
+## Candidate
+
+- Public model: **BTL-3 Compact**.
+- Model lineage: Qwen3.6-27B plus BTL RL0013 and the frozen behavior repair.
+- Scope: text-only coding, tool use and agent behavior.
+- Representation: full 64-layer AVQ2/UniSVQ decoder, two measured INT4
+  demotions, selected BF16 islands, packed vocabulary matrices, rank-32 head
+  correction and a small behavior adapter.
+- Source payload bytes before GGUF packing: 8,572,070,080.
+- Source weight bytes: 8,551,772,952.
+- Portable GGUF bytes: 8,392,369,600.
+- Portable GGUF SHA-256:
+  `2ddf9527620a17a2a6739d184a7096c45712092e6589128792ec6254e94dc30c`.
+
+The package is complete enough to instantiate and generate without downloading
+or loading the BF16 Qwen checkpoint.
+
+## Native runtime proof
+
+The standalone loader meta-initializes the Qwen3.6 text architecture and
+installs only the package's small state, packed decoder tensors, packed
+embedding, packed head, rank-32 output correction and behavior LoRA.
+
+The H100 smoke test observed:
+
+- no surviving dense compatible decoder matrices;
+- exact AVQ2 CUDA-kernel parity with the unpacked reference;
+- INT4 maximum absolute kernel error of `3.0517578125e-05`;
+- standalone model peak CUDA allocation of 8,552,500,736 bytes;
+- successful autoregressive generation.
+
+The source payload was subsequently exported into the portable GGUF without
+reconstructing dense weights. The exporter byte-verified all 2,416 payloads
+and reported no unsupported tensors or native runtime gaps. The exact GGUF
+then passed native llama.cpp generation on Apple Metal and NVIDIA CUDA.
+MLX, WebGPU, phone execution, and stock-engine compatibility remain unverified.
+
+## Fresh sealed gate
+
+Benchmark ID: `btl-fresh-tool-gate-2026-07-19-v1`
+
+Cases SHA-256:
+`d656a7862e16e64ed3a359ba1de10f7eafefad77f6cf5a8264d60287e1890a45`
+
+The gate was authored after compression and behavior-repair choices were
+frozen. It contains 100 scored turns:
+
+- 20 single calls;
+- 20 parallel calls;
+- 20 sequential calls;
+- 20 parallel-multiple calls;
+- 20 abstention decisions.
+
+All tool families are first-party and use a new `lumenharbor_*` namespace.
+Mechanical QA found no schema errors, duplicate IDs, parse errors or exact tool
+name overlap with repository training/evaluation data.
+
+This is a private synthetic contract-retention gate. It is not a public coding
+benchmark and must not be presented as a frontier benchmark score.
+
+## Full-precision teacher
+
+The frozen RL0013 teacher scored:
+
+| Category | Correct | Total |
+|---|---:|---:|
+| Single | 20 | 20 |
+| Parallel | 20 | 20 |
+| Sequential | 20 | 20 |
+| Parallel-multiple | 10 | 20 |
+| Abstention | 20 | 20 |
+| Overall | 90 | 100 |
+
+The release metric is conditional retention on these 90 teacher-correct turns,
+reported separately for every category and overall. Absolute student accuracy
+is also retained in the raw result.
+
+## Standalone result
+
+The standalone package scored:
+
+| Category | Student correct | Total | Teacher-correct retained | Retention |
+|---|---:|---:|---:|---:|
+| Single | 20 | 20 | 20 / 20 | 100% |
+| Parallel | 20 | 20 | 20 / 20 | 100% |
+| Sequential | 20 | 20 | 20 / 20 | 100% |
+| Parallel-multiple | 3 | 20 | 3 / 10 | 30% |
+| Abstention | 20 | 20 | 20 / 20 | 100% |
+| **Overall** | **83** | **100** | **83 / 90** | **92.2%** |
+
+All generations stopped. The measured malformed rate was 7%, entirely within
+the difficult parallel-multiple family.
+
+The seven teacher-correct/student-wrong parallel-multiple cases were not parser
+false negatives. The package emitted a fluent abstention instead of making the
+three requested independent calls. This is a real over-abstention failure under
+novel multi-call schemas.
+
+### Decision
+
+The package passes a 90% **overall** conditional-retention rule. It fails a 90%
+**per-category** rule because parallel-multiple retention is 30%.
+
+Do not alter compression based on this sealed result. Any behavior repair aimed
+at these cases creates a new candidate and requires a newly authored, untouched
+release gate.
+
+## Release boundary
+
+This result validates that the exact text-only source payload is physically
+standalone and retains more than 90% overall on the fresh CUDA gate. The GGUF
+export preserved those payload bytes exactly. It does not support a claim of
+uniformly preserved behavior or phone deployment.
+
+The release includes a distributable macOS native runtime and exact-artifact
+throughput measurements on Apple M2 and RTX PRO 6000. Other GPU packages,
+stock Ollama/LM Studio execution, mobile runtimes, and a public compact-specific
+coding benchmark remain separate gates.

evidence/native-load-report.json

@@ -0,0 +1,23 @@
+{
+  "schema_version": 1,
+  "model": "BTL-3 Compact",
+  "artifact": "BTL-3-Compact-AVQ2.gguf",
+  "artifact_bytes": 8392369600,
+  "artifact_sha256": "2ddf9527620a17a2a6739d184a7096c45712092e6589128792ec6254e94dc30c",
+  "tensor_count": 2416,
+  "verified_payload_count": 2416,
+  "runner_commit": "9fcaed763",
+  "platform": "macOS arm64",
+  "device": "Apple M2",
+  "context_tokens": 128,
+  "cpu_only": false,
+  "backend": "Apple Metal",
+  "model_load": "pass",
+  "graph_reservation": "pass",
+  "generation": "pass",
+  "prompt_tokens": 15,
+  "prompt_tokens_per_second": 2.297,
+  "generated_tokens": 4,
+  "generated_tokens_per_second": 2.483,
+  "generation_note": "Single Apple M2 full-model smoke; not a universal throughput claim"
+}

evidence/rtx-pro-6000-speed-2026-07-19.md

@@ -0,0 +1,59 @@
+# BTL-3 Compact — RTX PRO 6000 speed
+
+Measured on 2026-07-19 using the native patched `llama.cpp` CUDA runtime and
+the frozen `BTL-3-Compact-AVQ2.gguf` release artifact.
+
+## Artifact
+
+- File bytes: `8,392,369,600`
+- GPU offload: all layers (`-ngl 99`)
+- KV types: FP16
+- CUDA architecture: `sm_120a`
+- GPU: NVIDIA RTX PRO 6000 Blackwell Server Edition
+- GPU memory: 97,887 MiB reported by `nvidia-smi`
+
+## Command
+
+```text
+llama-bench \
+  -m /vol/release/compact/BTL-3-Compact-AVQ2.gguf \
+  -ngl 99 \
+  -p 512 \
+  -n 128 \
+  -r 3 \
+  -o json
+```
+
+## Results
+
+| Workload | Throughput | Standard deviation |
+|---|---:|---:|
+| 512-token prompt processing | 84.70 tok/s | 0.37 tok/s |
+| 128-token generation | 43.16 tok/s | 0.29 tok/s |
+
+Generation samples: `42.83`, `43.35`, and `43.30` tok/s.
+
+Prompt-processing samples: `84.28`, `84.91`, and `84.91` tok/s.
+
+The measured benchmark body, including model load, completed in 41.03 seconds.
+
+## Consumer-GPU projections
+
+These are projections, not measurements. Single-stream decode is scaled
+primarily from memory bandwidth, then widened to account for architecture,
+clock, power, kernel occupancy, and driver differences.
+
+| GPU | Estimated generation | Estimated prompt processing | Fit |
+|---|---:|---:|---|
+| RTX 5090 32GB | 39–44 tok/s | 75–88 tok/s | Yes |
+| RTX 4090 24GB | 22–28 tok/s | 45–60 tok/s | Yes |
+| RTX 4050 Laptop 6GB | No credible full-GPU estimate | No credible full-GPU estimate | No |
+
+The RTX PRO 6000 and RTX 5090 both advertise 1,792 GB/s memory bandwidth and
+share the Blackwell generation, so near-parity is the reasonable batch-one
+decode hypothesis. The RTX 4090 advertises 1,008 GB/s, or 56.25% of that
+bandwidth. A literal RTX 4050 Laptop has only 6GB of VRAM, below the 8.39GB
+weight file before KV cache and runtime allocations; it therefore requires
+CPU offload and should be described as a low-single-digit, system-dependent
+fallback rather than a supported full-GPU target.
+

integrations/btl3-native/README.md

@@ -0,0 +1,29 @@
+# BTL-3 Native for LM Studio
+
+This generator exposes the native BTL-3 OpenAI-compatible server inside LM
+Studio. It does not ask LM Studio's stock GGUF engine to load AVQ2.
+
+## Local development install
+
+1. Install the BTL-3 runtime and model in its platform-default location, or set
+   `BTL3_RUNNER_PATH` and `BTL3_MODEL_PATH`.
+2. Install the LM Studio CLI with `npx lmstudio install-cli` if needed.
+3. In this directory run `npm ci`, then `lms dev`.
+4. Select **badtheorylabs/btl3-native** in LM Studio's model picker. The plugin
+   starts the native runner automatically when the local endpoint is offline.
+
+The default endpoint is `http://127.0.0.1:8080/v1`. Change it in the plugin's
+global settings when the native runner is elsewhere. Automatic startup can be
+disabled when an independently managed server is preferred. The generator preserves
+streamed content, reasoning fragments, cancellation, and parallel tool calls.
+LM Studio's generator lifecycle has no per-fragment call ID, so parallel
+tool-call fragments are buffered by call index and emitted sequentially after
+the upstream stream finishes. This preserves the calls without misattributing
+interleaved JSON fragments.
+
+`model.yaml` is catalog metadata for the native-generator product. Its custom
+`btl3-avq2-native` compatibility type deliberately avoids claiming that LM
+Studio's stock GGUF engine can execute this model.
+
+This plugin has not been published. `lms push` is intentionally outside this
+repository's local validation workflow.

integrations/btl3-native/manifest.json

@@ -0,0 +1,7 @@
+{
+  "type": "plugin",
+  "runner": "node",
+  "owner": "badtheorylabs",
+  "name": "btl3-native",
+  "revision": 1
+}

integrations/btl3-native/model.yaml

@@ -0,0 +1,17 @@
+# Catalog metadata only. The btl3-native generator owns execution.
+model: badtheorylabs/btl-3-compact
+base: badtheorylabs/btl-3-compact-avq2-native
+metadataOverrides:
+  domain: llm
+  architectures:
+    - qwen3.5
+  compatibilityTypes:
+    - btl3-avq2-native
+  paramsStrings:
+    - 27B
+  minMemoryUsageBytes: 10000000000
+  contextLengths:
+    - 262144
+  vision: false
+  reasoning: true
+  trainedForToolUse: true

integrations/btl3-native/package-lock.json

@@ -0,0 +1,221 @@
+{
+  "name": "btl3-native-lmstudio",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "btl3-native-lmstudio",
+      "version": "0.1.0",
+      "dependencies": {
+        "@lmstudio/sdk": "1.5.0",
+        "openai": "6.48.0"
+      },
+      "devDependencies": {
+        "@types/node": "24.0.0",
+        "typescript": "5.9.3"
+      }
+    },
+    "node_modules/@lmstudio/lms-isomorphic": {
+      "version": "0.4.6",
+      "resolved": "https://registry.npmjs.org/@lmstudio/lms-isomorphic/-/lms-isomorphic-0.4.6.tgz",
+      "integrity": "sha512-v0LIjXKnDe3Ff3XZO5eQjlVxTjleUHXaom14MV7QU9bvwaoo3l5p71+xJ3mmSaqZq370CQ6pTKCn1Bb7Jf+VwQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "ws": "^8.16.0"
+      }
+    },
+    "node_modules/@lmstudio/sdk": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/@lmstudio/sdk/-/sdk-1.5.0.tgz",
+      "integrity": "sha512-fdY12x4hb14PEjYijh7YeCqT1ZDY5Ok6VR4l4+E/dI+F6NW8oB+P83Sxed5vqE4XgTzbgyPuSR2ZbMNxxF+6jA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@lmstudio/lms-isomorphic": "^0.4.6",
+        "chalk": "^4.1.2",
+        "jsonschema": "^1.5.0",
+        "zod": "^3.22.4",
+        "zod-to-json-schema": "^3.22.5"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "24.0.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.0.0.tgz",
+      "integrity": "sha512-yZQa2zm87aRVcqDyH5+4Hv9KYgSdgwX1rFnGvpbzMaC7YAljmhBET93TPiTd3ObwTL+gSpIzPKg5BqVxdCvxKg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.8.0"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "license": "MIT"
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/jsonschema": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/jsonschema/-/jsonschema-1.5.0.tgz",
+      "integrity": "sha512-K+A9hhqbn0f3pJX17Q/7H6yQfD/5OXgdrR5UE12gMXCiN9D5Xq2o5mddV2QEcX/bjla99ASsAAQUyMCCRWAEhw==",
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/openai": {
+      "version": "6.48.0",
+      "resolved": "https://registry.npmjs.org/openai/-/openai-6.48.0.tgz",
+      "integrity": "sha512-KhVp+FyV50QrXNextvL9hIU5l6ox5HYuKQjGVk7lIqprgJol90+dQXWONV6S1lRWsKA1bXjrow8RsUT14M1hNA==",
+      "license": "Apache-2.0",
+      "peerDependencies": {
+        "@aws-sdk/credential-provider-node": ">=3.972.0 <4",
+        "@smithy/hash-node": ">=4.3.0 <5",
+        "@smithy/signature-v4": ">=5.4.0 <6",
+        "ws": "^8.18.0",
+        "zod": "^3.25 || ^4.0"
+      },
+      "peerDependenciesMeta": {
+        "@aws-sdk/credential-provider-node": {
+          "optional": true
+        },
+        "@smithy/hash-node": {
+          "optional": true
+        },
+        "@smithy/signature-v4": {
+          "optional": true
+        },
+        "ws": {
+          "optional": true
+        },
+        "zod": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "7.8.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.8.0.tgz",
+      "integrity": "sha512-9UJ2xGDvQ43tYyVMpuHlsgApydB8ZKfVYTsLDhXkFL/6gfkp+U8xTGdh8pMJv1SpZna0zxG1DwsKZsreLbXBxw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/ws": {
+      "version": "8.21.1",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.1.tgz",
+      "integrity": "sha512-+0NTnW77fFN/DjQi6k/Sq/Yvk4Sgajw7urW8V+asjXnRgDs9gyGkdb7EzgfhA4goXsRIZKE28fzIXBHEzhuiWw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/zod-to-json-schema": {
+      "version": "3.25.2",
+      "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.25.2.tgz",
+      "integrity": "sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA==",
+      "license": "ISC",
+      "peerDependencies": {
+        "zod": "^3.25.28 || ^4"
+      }
+    }
+  }
+}

integrations/btl3-native/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "btl3-native-lmstudio",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "build": "tsc --noEmit",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@lmstudio/sdk": "1.5.0",
+    "openai": "6.48.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.0.0",
+    "typescript": "5.9.3"
+  }
+}

integrations/btl3-native/run-local

@@ -0,0 +1,11 @@
+#!/bin/sh
+set -eu
+
+root=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+if ! command -v lms >/dev/null 2>&1; then
+    echo "LM Studio CLI not found. Install it with: npx lmstudio install-cli" >&2
+    exit 2
+fi
+cd "$root"
+npm ci --ignore-scripts
+exec lms dev

integrations/btl3-native/src/config.ts

@@ -0,0 +1,53 @@
+import { createConfigSchematics } from "@lmstudio/sdk";
+
+export const globalConfigSchematics = createConfigSchematics()
+  .field(
+    "baseUrl",
+    "string",
+    {
+      displayName: "BTL-3 server URL",
+      subtitle: "OpenAI-compatible endpoint exposed by the native BTL-3 runner.",
+      placeholder: "http://127.0.0.1:8080/v1",
+    },
+    "http://127.0.0.1:8080/v1",
+  )
+  .field(
+    "apiKey",
+    "string",
+    {
+      displayName: "Local API key",
+      subtitle: "Must match BTL3_API_KEY when authentication is enabled.",
+      isProtected: true,
+    },
+    "btl3-local",
+  )
+  .field(
+    "autoStart",
+    "boolean",
+    {
+      displayName: "Start the native runner automatically",
+      subtitle: "Launch BTL-3 locally when the configured endpoint is offline.",
+    },
+    true,
+  )
+  .field(
+    "runnerPath",
+    "string",
+    {
+      displayName: "Native runner path",
+      subtitle: "Optional. Defaults to BTL3_RUNNER_PATH or the installed BTL-3 runtime.",
+      placeholder: "/home/user/.local/share/btl3/libexec/llama-server",
+    },
+    "",
+  )
+  .field(
+    "modelPath",
+    "string",
+    {
+      displayName: "BTL-3 model path",
+      subtitle: "Optional. Defaults to BTL3_MODEL_PATH or the installed compact GGUF.",
+      placeholder: "/home/user/.local/share/btl3/model/BTL-3-Compact-AVQ2.gguf",
+    },
+    "",
+  )
+  .build();

integrations/btl3-native/src/generator.ts

@@ -0,0 +1,185 @@
+import {
+  type Chat,
+  type GeneratorController,
+  type InferParsedConfig,
+  type PluginContext,
+} from "@lmstudio/sdk";
+import OpenAI from "openai";
+import type {
+  ChatCompletionChunk,
+  ChatCompletionMessageParam,
+  ChatCompletionMessageToolCall,
+  ChatCompletionTool,
+} from "openai/resources/chat/completions";
+import { globalConfigSchematics } from "./config";
+import { ensureNativeRunner } from "./nativeRunner";
+
+type Config = InferParsedConfig<typeof globalConfigSchematics>;
+type ToolState = {
+  id: string;
+  name: string;
+  argumentFragments: string[];
+};
+
+function messages(history: Chat): ChatCompletionMessageParam[] {
+  const result: ChatCompletionMessageParam[] = [];
+  for (const message of history) {
+    switch (message.getRole()) {
+      case "system":
+        result.push({ role: "system", content: message.getText() });
+        break;
+      case "user":
+        result.push({ role: "user", content: message.getText() });
+        break;
+      case "assistant": {
+        const toolCalls: ChatCompletionMessageToolCall[] = message
+          .getToolCallRequests()
+          .map(call => ({
+            id: call.id ?? "",
+            type: "function",
+            function: {
+              name: call.name,
+              arguments: JSON.stringify(call.arguments ?? {}),
+            },
+          }));
+        result.push({
+          role: "assistant",
+          content: message.getText(),
+          ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+        });
+        break;
+      }
+      case "tool":
+        for (const toolResult of message.getToolCallResults()) {
+          result.push({
+            role: "tool",
+            tool_call_id: toolResult.toolCallId ?? "",
+            content: toolResult.content,
+          });
+        }
+        break;
+    }
+  }
+  return result;
+}
+
+function tools(ctl: GeneratorController): ChatCompletionTool[] | undefined {
+  const result = ctl.getToolDefinitions().map<ChatCompletionTool>(tool => ({
+    type: "function",
+    function: {
+      name: tool.function.name,
+      description: tool.function.description,
+      parameters: tool.function.parameters ?? {},
+    },
+  }));
+  return result.length > 0 ? result : undefined;
+}
+
+function asError(error: unknown): Error {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+function finishTool(ctl: GeneratorController, state: ToolState): void {
+  ctl.toolCallGenerationStarted({ toolCallId: state.id });
+  if (state.name) {
+    ctl.toolCallGenerationNameReceived(state.name);
+  }
+  for (const fragment of state.argumentFragments) {
+    ctl.toolCallGenerationArgumentFragmentGenerated(fragment);
+  }
+  try {
+    const parsed = JSON.parse(
+      state.argumentFragments.join("") || "{}",
+    ) as Record<string, unknown>;
+    ctl.toolCallGenerationEnded({
+      type: "function",
+      id: state.id,
+      name: state.name,
+      arguments: parsed,
+    });
+  } catch (error) {
+    ctl.toolCallGenerationFailed(asError(error));
+  }
+}
+
+function bufferToolDelta(
+  pending: Map<number, ToolState>,
+  call: ChatCompletionChunk.Choice.Delta.ToolCall,
+): void {
+  const state = pending.get(call.index) ?? {
+      id: call.id ?? `call_${call.index}`,
+      name: "",
+      argumentFragments: [],
+  };
+  if (call.id) state.id = call.id;
+  if (call.function?.name) {
+    state.name += call.function.name;
+  }
+  if (call.function?.arguments) {
+    state.argumentFragments.push(call.function.arguments);
+  }
+  pending.set(call.index, state);
+}
+
+async function generate(
+  ctl: GeneratorController,
+  history: Chat,
+  config: Config,
+): Promise<void> {
+  if (config.get("autoStart")) {
+    await ensureNativeRunner({
+      baseUrl: config.get("baseUrl"),
+      runnerPath: config.get("runnerPath"),
+      modelPath: config.get("modelPath"),
+    });
+  }
+  const client = new OpenAI({
+    apiKey: config.get("apiKey") || "btl3-local",
+    baseURL: config.get("baseUrl"),
+  });
+  const toolDefinitions = tools(ctl);
+  const pending = new Map<number, ToolState>();
+  try {
+    ctl.abortSignal.throwIfAborted();
+    const stream = await client.chat.completions.create(
+      {
+        model: "BTL-3",
+        messages: messages(history),
+        tools: toolDefinitions,
+        ...(toolDefinitions ? { parallel_tool_calls: true } : {}),
+        stream: true,
+      },
+      { signal: ctl.abortSignal },
+    );
+    for await (const chunk of stream) {
+      ctl.abortSignal.throwIfAborted();
+      const delta = chunk.choices[0]?.delta;
+      if (!delta) continue;
+      const reasoning = (
+        delta as typeof delta & { reasoning_content?: string }
+      ).reasoning_content;
+      if (reasoning) {
+        ctl.fragmentGenerated(reasoning, { reasoningType: "reasoning" });
+      }
+      if (delta.content) {
+        ctl.fragmentGenerated(delta.content);
+      }
+      for (const call of delta.tool_calls ?? []) {
+        bufferToolDelta(pending, call);
+      }
+    }
+    for (const [, state] of [...pending].sort(([a], [b]) => a - b)) {
+      finishTool(ctl, state);
+    }
+  } catch (error) {
+    throw asError(error);
+  }
+}
+
+export async function main(context: PluginContext): Promise<void> {
+  context.withGlobalConfigSchematics(globalConfigSchematics);
+  context.withGenerator(async (ctl, history) => {
+    const config = ctl.getGlobalPluginConfig(globalConfigSchematics);
+    await generate(ctl, history, config);
+  });
+}

integrations/btl3-native/src/index.ts

@@ -0,0 +1 @@
+export { main } from "./generator";

integrations/btl3-native/src/nativeRunner.ts

@@ -0,0 +1,120 @@
+import { spawn, type ChildProcess } from "node:child_process";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+type RunnerOptions = {
+  baseUrl: string;
+  runnerPath: string;
+  modelPath: string;
+};
+
+let child: ChildProcess | undefined;
+let startup: Promise<void> | undefined;
+let stderrTail = "";
+let childError: Error | undefined;
+
+function installedPaths(): { runner: string; model: string } {
+  if (process.platform === "win32") {
+    const root = process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local");
+    return {
+      runner: join(root, "BTL3", "libexec", "llama-server.exe"),
+      model: join(root, "BTL3", "model", "BTL-3-Compact-AVQ2.gguf"),
+    };
+  }
+  const root = process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
+  return {
+    runner: join(root, "btl3", "libexec", "llama-server"),
+    model: join(root, "btl3", "model", "BTL-3-Compact-AVQ2.gguf"),
+  };
+}
+
+function endpoint(baseUrl: string, path: string): URL {
+  const url = new URL(baseUrl);
+  url.pathname = path;
+  url.search = "";
+  return url;
+}
+
+async function healthy(baseUrl: string): Promise<boolean> {
+  try {
+    const response = await fetch(endpoint(baseUrl, "/health"), {
+      signal: AbortSignal.timeout(1_500),
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+function runnerArguments(baseUrl: string, modelPath: string): string[] {
+  const url = new URL(baseUrl);
+  const port = url.port || "8080";
+  return [
+    "--model", modelPath,
+    "--host", url.hostname,
+    "--port", port,
+    "--no-webui",
+    "--offline",
+    "-np", "1",
+  ];
+}
+
+async function waitUntilReady(baseUrl: string): Promise<void> {
+  const deadline = Date.now() + 60_000;
+  while (Date.now() < deadline) {
+    if (await healthy(baseUrl)) return;
+    if (childError) {
+      throw new Error(`BTL-3 runner failed to start: ${childError.message}`);
+    }
+    if (child?.exitCode !== null && child?.exitCode !== undefined) {
+      throw new Error(`BTL-3 runner exited (${child.exitCode}): ${stderrTail}`);
+    }
+    await new Promise(resolve => setTimeout(resolve, 250));
+  }
+  throw new Error(`BTL-3 runner did not become ready: ${stderrTail}`);
+}
+
+async function start(options: RunnerOptions): Promise<void> {
+  if (await healthy(options.baseUrl)) return;
+  const defaults = installedPaths();
+  const runner = options.runnerPath || process.env.BTL3_RUNNER_PATH || defaults.runner;
+  const model = options.modelPath || process.env.BTL3_MODEL_PATH || defaults.model;
+  const root = dirname(dirname(runner));
+  const libraryPath = join(root, "lib");
+  const env = { ...process.env };
+  if (process.platform === "win32") {
+    env.PATH = `${libraryPath};${env.PATH ?? ""}`;
+    env.GGML_BACKEND_PATH = join(libraryPath, "ggml-cuda.dll");
+  } else {
+    env.LD_LIBRARY_PATH =
+      `${libraryPath}${env.LD_LIBRARY_PATH ? `:${env.LD_LIBRARY_PATH}` : ""}`;
+    env.GGML_BACKEND_PATH = join(libraryPath, "libggml-cuda.so");
+  }
+  stderrTail = "";
+  childError = undefined;
+  child = spawn(runner, runnerArguments(options.baseUrl, model), {
+    windowsHide: true,
+    stdio: ["ignore", "ignore", "pipe"],
+    env,
+  });
+  child.stderr?.on("data", data => {
+    stderrTail = (stderrTail + String(data)).slice(-4_096);
+  });
+  child.once("error", error => {
+    childError = error;
+    stderrTail = (stderrTail + error.message).slice(-4_096);
+  });
+  await waitUntilReady(options.baseUrl);
+}
+
+export async function ensureNativeRunner(options: RunnerOptions): Promise<void> {
+  if (await healthy(options.baseUrl)) return;
+  startup ??= start(options).finally(() => {
+    startup = undefined;
+  });
+  await startup;
+}
+
+process.once("exit", () => {
+  child?.kill();
+});

integrations/btl3-native/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "module": "CommonJS",
+    "target": "ES2021",
+    "declaration": true,
+    "noImplicitOverride": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*.ts"]
+}

integrations/ollama/Modelfile

@@ -0,0 +1,5 @@
+# Requires the explicitly labeled BTL-3 Patched Ollama distribution.
+FROM ./BTL-3-Compact-AVQ2.gguf
+PARAMETER num_ctx 32768
+PARAMETER temperature 0.6
+PARAMETER top_p 0.95

licenses/LICENSE

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

licenses/LICENSE.runtime

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

licenses/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,30 @@
+# Third-party notices
+
+## Qwen3.6-27B
+
+BTL-3 is a post-trained adapter for `Qwen/Qwen3.6-27B`, pinned to revision
+`6a9e13bd6fc8f0983b9b99948120bc37f49c13e9`. The base model is distributed
+under Apache License 2.0. Users of the full-quality adapter must obtain the base
+model separately and comply with its model card and license.
+
+## Runtime dependencies
+
+BTL-3 Compact's native runtime is derived from llama.cpp and links platform
+libraries including Apple Accelerate/Metal or NVIDIA CUDA. The macOS bundle
+includes its llama.cpp and OpenSSL notices; CUDA preview bundles include the
+llama.cpp notice and NVIDIA redistributable runtime libraries. Those projects
+retain their own copyrights and licenses and are not relicensed by Bad Theory
+Labs.
+
+## Benchmark artifacts
+
+The evidence folder includes outputs and aggregate results from HumanEval and
+BigCodeBench. It does not redistribute private evaluation cases, training
+corpora, provider credentials, or paid-service configuration.
+
+## Names and marks
+
+Qwen, Hugging Face, PyTorch, Transformers, PEFT, vLLM, HumanEval,
+BigCodeBench, LiveCodeBench, and BFCL are names of their respective projects
+or owners. Their inclusion describes compatibility or evaluation and does not
+imply endorsement.

tools/install_consumer_bundle.py

@@ -0,0 +1,148 @@
+"""Install a verified BTL-3 consumer runtime and its external model."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import platform
+import shutil
+import tempfile
+
+
+MODEL_NAME = "BTL-3-Compact-AVQ2.gguf"
+MODEL_BYTES = 8_392_369_600
+MODEL_SHA256 = "2ddf9527620a17a2a6739d184a7096c45712092e6589128792ec6254e94dc30c"
+
+
+class InstallError(ValueError):
+    pass
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(4 * 1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def default_prefix() -> Path:
+    if os.name == "nt":
+        root = os.environ.get("LOCALAPPDATA")
+        if not root:
+            raise InstallError("LOCALAPPDATA is unavailable; pass --prefix")
+        return Path(root) / "BTL3"
+    root = os.environ.get("XDG_DATA_HOME")
+    return Path(root) / "btl3" if root else Path.home() / ".local/share/btl3"
+
+
+def read_manifest(runtime: Path) -> dict:
+    path = runtime / "bundle-manifest.json"
+    try:
+        manifest = json.loads(path.read_text())
+    except (OSError, json.JSONDecodeError) as error:
+        raise InstallError(f"invalid runtime manifest: {error}") from error
+    external = manifest.get("external_model", {})
+    expected = {
+        "filename": MODEL_NAME,
+        "bytes": MODEL_BYTES,
+        "sha256": MODEL_SHA256,
+    }
+    if any(external.get(key) != value for key, value in expected.items()):
+        raise InstallError("runtime expects a different BTL-3 model")
+    return manifest
+
+
+def verify_runtime(runtime: Path, manifest: dict) -> None:
+    for name, expected in manifest.get("files", {}).items():
+        path = runtime / name
+        if "symlink" in expected:
+            if not path.is_symlink() or os.readlink(path) != expected["symlink"]:
+                raise InstallError(f"runtime symlink mismatch: {name}")
+            continue
+        if not path.is_file():
+            raise InstallError(f"runtime file is missing: {name}")
+        if path.stat().st_size != expected["bytes"]:
+            raise InstallError(f"runtime file size mismatch: {name}")
+        if sha256(path) != expected["sha256"]:
+            raise InstallError(f"runtime file checksum mismatch: {name}")
+
+
+def verify_model(model: Path) -> None:
+    if not model.is_file():
+        raise InstallError(f"model is missing: {model}")
+    if model.stat().st_size != MODEL_BYTES:
+        raise InstallError(f"model size mismatch: {model.stat().st_size}")
+    if sha256(model) != MODEL_SHA256:
+        raise InstallError("model SHA-256 mismatch")
+
+
+def install(runtime: Path, model: Path, prefix: Path, replace: bool) -> Path:
+    runtime, model, prefix = runtime.resolve(), model.resolve(), prefix.resolve()
+    manifest = read_manifest(runtime)
+    verify_runtime(runtime, manifest)
+    verify_model(model)
+    if prefix.exists() and not replace:
+        raise InstallError(f"install already exists (use --replace): {prefix}")
+    prefix.parent.mkdir(parents=True, exist_ok=True)
+    staging = Path(tempfile.mkdtemp(prefix=f".{prefix.name}-", dir=prefix.parent))
+    try:
+        shutil.copytree(runtime, staging, dirs_exist_ok=True, symlinks=True)
+        destination = staging / "model" / MODEL_NAME
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(model, destination)
+        receipt = {
+            "schema_version": 1,
+            "installed_by": "BTL-3 consumer installer",
+            "platform": platform.platform(),
+            "runtime_target": manifest.get("target") or manifest.get("platform"),
+            "model": {
+                "path": f"model/{MODEL_NAME}",
+                "bytes": MODEL_BYTES,
+                "sha256": MODEL_SHA256,
+            },
+        }
+        (staging / "install-receipt.json").write_text(
+            json.dumps(receipt, indent=2) + "\n"
+        )
+        if prefix.exists():
+            backup = prefix.with_name(f".{prefix.name}.previous")
+            shutil.rmtree(backup, ignore_errors=True)
+            prefix.rename(backup)
+            try:
+                staging.rename(prefix)
+            except Exception:
+                backup.rename(prefix)
+                raise
+            shutil.rmtree(backup)
+        else:
+            staging.rename(prefix)
+    except Exception:
+        shutil.rmtree(staging, ignore_errors=True)
+        raise
+    return prefix
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--runtime", type=Path, required=True)
+    parser.add_argument("--model", type=Path, required=True)
+    parser.add_argument("--prefix", type=Path, default=None)
+    parser.add_argument("--replace", action="store_true")
+    args = parser.parse_args()
+    try:
+        print(install(
+            args.runtime,
+            args.model,
+            args.prefix or default_prefix(),
+            args.replace,
+        ))
+    except InstallError as error:
+        parser.error(str(error))
+
+
+if __name__ == "__main__":
+    main()