Bring 32B card to the 14B shipped register; real weight checksums

BENCHMARKS.md

@@ -0,0 +1,37 @@
+# Benchmarks
+
+The honest state of this model's measurement, kept current.
+
+## What exists today
+
+One behavioral receipt: a **deterministic generation smoke**. Served through
+Ollama, the model was asked to generate at temperature 0 with a fixed seed
+(seed 7, 64 tokens), twice, and the two outputs were byte-compared. Verdict:
+**MATCH** (generation hash prefix `403b2e8b21df9f55`). That establishes the
+served model is deterministic and reproducible, nothing more.
+
+## What does not exist yet
+
+No task benchmark has been run against this model. There is no HumanEval score,
+no hard-set score, no leaderboard number. **We claim no capability uplift over
+the base `Qwen2.5-Coder-32B-Instruct`.** Any such comparison must come from
+executed benchmark artifacts, and none exist for the 32B.
+
+This is the deliberate difference from the
+[14B](https://huggingface.co/zaindanaharper/flywheel-local-coder-14b), which
+does carry executed benchmark evidence (with intervals, and the JSON to re-run
+each number). The 32B ships as a verified, retraceable build; the scored
+evidence is a separate, future measurement.
+
+## How the numbers will arrive, when they do
+
+The same way the 14B's did, and no other way:
+
+- Run under a fixed harness with a published task set and a real oracle
+  (propose, run the test, accept only what passes).
+- Every number ships with the JSON it came from and the command to re-run it.
+- Confidence intervals attached; a difference against base whose interval
+  includes zero is reported as no uplift, not as a win.
+
+Until an executed benchmark artifact is attached here, treat this model on its
+provenance and its determinism receipt, not on any performance claim.

MODEL_CARD.md

@@ -1,44 +1,64 @@
 # Flywheel-Local-Coder-32B Model Card
 
-Status: trained artifact verified, staged for operator-gated upload. Identity and the full provenance chain are re-checkable; benchmark evidence is pending.
+A verified, retraceable continued-pretraining build on Qwen2.5-Coder-32B-Instruct.
+Identity and provenance are complete and re-checkable; benchmark evidence is
+pending and no capability uplift is claimed.
 
 ## Model identity
 
 - Release name: `Flywheel-Local-Coder-32B`
-- Artifact file: `telos-coder-32b-cpt2019-q4_k_m.gguf`
+- Model file: `telos-coder-32b-cpt2019-q4_k_m.gguf`
 - Base model: `Qwen2.5-Coder-32B-Instruct` (Alibaba Cloud / Qwen team, Apache-2.0)
-- Adapter: `checkpoint-2019`, QLoRA continued pretraining (r 16, alpha 32, dropout 0.05), 2019 steps, epoch 0.25, final logged train loss ~0.768
+- Adapter: `checkpoint-2019`, QLoRA continued pretraining (r 16, alpha 32,
+  dropout 0.05), 2019 steps (a quarter epoch)
 - Composition: base weights merged with the adapter, then quantized
 - Quantization: Q4_K_M (GGUF)
-- Size: 19,851,336,480 bytes
-- Artifact SHA-256: `65e6133fbe4d12579a776047a71bebb98ab86f9e3d343ed821b51dac0ce312f4`
-- Merged fp16 GGUF (local build intermediate, not published): `telos-coder-32b-merged-f16.gguf`, SHA-256 `3360f7db86b8493dd444c4b03e113d61be6c06084ddb91c8557847f58036a3ee`
+- Size: 18.5 GB (19,851,336,480 bytes)
+- Model SHA-256: `65e6133fbe4d12579a776047a71bebb98ab86f9e3d343ed821b51dac0ce312f4`
 - Adapter (safetensors) SHA-256: `d2ff1d3042c9b015d8d01b6e195cf95acedc133bf4efe78692e4349a3608e286`
 - LoRA GGUF SHA-256: `08e7d21cfde1af768c877ecc18ee6343c87711c0c38b8c5b16feb9890f94cbac`
-- Artifact location: `E:\local-model-run\gguf-work-32b\telos-coder-32b-cpt2019-q4_k_m.gguf`
 - Local serving name: Ollama `flywheel-local-coder-32b`
-- Manifest: `C:\dev\local-model\tasks\research\gguf_ship_manifest_checkpoint2019_32b.json` (schema `telos.model-artifact/v1`)
+
+The full chain is recorded in [provenance.json](provenance.json) and tied to the
+downloaded bytes by [checksums.sha256](checksums.sha256).
 
 ## Training data
 
-Continued pretraining on the operator's `C:\dev` ecosystem corpus, the same packed corpus that trained the 14B track: 66,158,592 tokens, 8 shards, 16,152 sequences, seq_len 4096, from 17,997 corpus files (`E:\local-model-run\data\packed\PACK_COMPLETE.json`). Qwen2.5-Coder 14B and 32B share a tokenizer, so one packed corpus trains both. Corpus content hash `68345cdc6667f20d1678ac0a9139edc170348dfdebb9ae6045cde3d204f4fe62`; pack shards hash `018798dfce7d4c86f5a6ea502a383553220f2e76facfe76acbe52b1c278ae543`. Corpus source identifiers stay proprietary.
+Continued pretraining on a 66.2-million-token corpus of 17,997 files from a real,
+working development ecosystem: production code, tests, documentation, and
+research notes. This is the same packed corpus used for the 14B (Qwen2.5-Coder
+14B and 32B share a tokenizer). Corpus content hash
+`68345cdc6667f20d1678ac0a9139edc170348dfdebb9ae6045cde3d204f4fe62`; pack shards
+hash `018798dfce7d4c86f5a6ea502a383553220f2e76facfe76acbe52b1c278ae543`. Corpus
+source identifiers stay proprietary.
 
 ## Intended use
 
-Local-first agentic coding inside the flywheel harness, served via Ollama or llama.cpp. The 32B trades size for capacity over the 14B; both are reached through the same harness endpoint contract.
+Local-first coding: completion, functions, refactors, test writing, and
+tool-calling on your own hardware, served via Ollama or llama.cpp. It pairs
+naturally with a propose-then-verify loop.
 
 ## Limitations
 
-- Q4_K_M quantization; quantization loss relative to the merged fp16 weights is not measured.
-- Trained for a quarter epoch (2019 steps) of continued pretraining; a light domain adaptation, not a full retrain.
-- Built and tested for local serving (Ollama, llama.cpp).
-- No benchmark evidence exists yet. Benchmarks are pending. No capability uplift over the base model is claimed.
-- Deterministic smoke (ollama `/api/generate`, temp 0, seed 7, num_predict 64, byte-identical reruns, MATCH, generation hash prefix `403b2e8b21df9f55`) is the only behavioral evidence recorded.
+- Q4_K_M quantization; quantization loss relative to the merged fp16 weights is
+  not measured.
+- A quarter-epoch (2019-step) continued-pretraining adaptation, a light domain
+  pass, not a full retrain.
+- No benchmark evidence exists yet. No capability uplift over the base model is
+  claimed. A deterministic generation smoke (temp 0, seed 7, byte-identical
+  reruns, MATCH) is the only behavioral evidence recorded.
+- Refusal behavior, bias, and content boundaries are inherited from the base
+  model and are not separately audited here.
 
 ## License
 
-Apache-2.0 derivative. Base model `Qwen2.5-Coder-32B-Instruct` is Copyright Alibaba Cloud, Apache-2.0. This artifact merges a locally trained QLoRA adapter into those weights and retains the Apache-2.0 license with attribution. The base weights are never republished on their own; only the adapter and the merged quantization are released.
+Apache-2.0 derivative. Base model `Qwen2.5-Coder-32B-Instruct` is Copyright
+Alibaba Cloud, Apache-2.0. This artifact merges a locally trained QLoRA adapter
+into those weights and retains the Apache-2.0 license with attribution. The base
+weights are never republished on their own; only the merged quantization and the
+adapter are released.
 
-## Current benchmark status
+## Benchmark status
 
-Benchmarks are pending. No benchmark result is recorded for this artifact.
+Pending. No benchmark result is recorded for this model. See
+[BENCHMARKS.md](BENCHMARKS.md).

Modelfile

@@ -0,0 +1 @@
+FROM ./telos-coder-32b-cpt2019-q4_k_m.gguf

README.md

@@ -11,36 +11,91 @@ pipeline_tag: text-generation
 library_name: gguf
 ---
 
-# Flywheel-Local-Coder-32B Release README
+# Flywheel-Local-Coder-32B
 
-Status: staged, awaiting operator upload approval. The trained artifact and its full provenance chain exist and are re-checkable; benchmark evidence is pending.
+A 32-billion-parameter coding model in a single Q4_K_M file that runs entirely
+on your own machine. It takes Qwen2.5-Coder-32B-Instruct and continues its
+pretraining on the same 66-million-token corpus behind the 14B, drawn from a
+real working development ecosystem, then packs the merge into one GGUF just
+under 19 GB. Your prompts and your code never leave your disk. And if you ever
+care to look, the whole build, corpus to weights, can be retraced hash by hash.
 
-## What this release is
+This is the larger sibling of [Flywheel-Local-Coder-14B](https://huggingface.co/zaindanaharper/flywheel-local-coder-14b):
+more capacity, the same local-first stance and the same retraceable chain.
 
-`Flywheel-Local-Coder-32B` is the release name for a trained 32B artifact:
+## Run it in two commands
 
-- Artifact file: `telos-coder-32b-cpt2019-q4_k_m.gguf` (Q4_K_M GGUF, 19,851,336,480 bytes).
-- SHA-256: `65e6133fbe4d12579a776047a71bebb98ab86f9e3d343ed821b51dac0ce312f4`
-- Identity: base `Qwen2.5-Coder-32B-Instruct` merged with QLoRA continued-pretraining adapter `checkpoint-2019` (2019 steps, epoch 0.25, r 16, alpha 32), then quantized to Q4_K_M.
-- Also released: the QLoRA adapter `telos-coder-32b-cpt2019-lora.gguf` (LoRA GGUF, SHA-256 `08e7d21cfde1af768c877ecc18ee6343c87711c0c38b8c5b16feb9890f94cbac`) for applying the trained delta to the base or requantizing from it. The base weights themselves are never republished.
-- Local serving: Ollama model name `flywheel-local-coder-32b`, created from the Modelfile beside the artifact.
+```
+hf download zaindanaharper/flywheel-local-coder-32b telos-coder-32b-cpt2019-q4_k_m.gguf --local-dir .
+llama-cli -m telos-coder-32b-cpt2019-q4_k_m.gguf -cnv
+```
 
-## What evidence exists
+Prefer Ollama? Download the repo folder so the GGUF and the Modelfile sit
+together, then:
 
-- Provenance chain, recorded in `tasks/research/gguf_ship_manifest_checkpoint2019_32b.json`, each layer re-derivable:
-  - corpus_content_hash `68345cdc6667f20d1678ac0a9139edc170348dfdebb9ae6045cde3d204f4fe62` (17,997 corpus files, shared pack with the 14B track)
-  - pack_shards_hash `018798dfce7d4c86f5a6ea502a383553220f2e76facfe76acbe52b1c278ae543`
-  - checkpoint_adapter_sha256 `d2ff1d3042c9b015d8d01b6e195cf95acedc133bf4efe78692e4349a3608e286`
-  - LoRA GGUF sha256 `08e7d21cfde1af768c877ecc18ee6343c87711c0c38b8c5b16feb9890f94cbac`
-  - GGUF (Q4_K_M) sha256 `65e6133fbe4d12579a776047a71bebb98ab86f9e3d343ed821b51dac0ce312f4`
-- Deterministic smoke: ollama `/api/generate`, temp 0, seed 7, num_predict 64, byte-identical reruns (MATCH). Output hash prefix `403b2e8b21df9f55`.
+```
+ollama create flywheel-local-coder-32b -f Modelfile
+ollama run flywheel-local-coder-32b
+```
 
-## What is still missing
+No conversion step, no shards, no Python environment. The [usage guide](usage.md)
+covers chat, deterministic completion, an OpenAI-compatible local endpoint, and
+how to verify your download against the published checksums.
 
-- Benchmark evidence. No benchmark has been run against this artifact. All benchmark claims are pending. No capability uplift over the base model is claimed.
-- Endpoint gate history (`harness.model-endpoint-gate/v1` artifacts attached to the release row).
-- Explicit operator approval for upload. Never auto-approved.
+## Specs at a glance
 
-## Publication rule
+| | |
+|---|---|
+| Parameters | 32.5B (qwen2 architecture) |
+| Context length | 32,768 tokens |
+| Quantization | Q4_K_M, single GGUF file |
+| File size | 18.5 GB (19,851,336,480 bytes) |
+| Capabilities | chat, code completion, tool calling |
+| Base model | Qwen2.5-Coder-32B-Instruct |
+| Training | QLoRA continued pretraining, 66.2M tokens across 17,997 files |
+| License | Apache-2.0 (with Qwen attribution) |
+| SHA-256 | `65e6133fbe4d12579a776047a71bebb98ab86f9e3d343ed821b51dac0ce312f4` |
 
-The base `Qwen2.5-Coder-32B-Instruct` weights are never republished on their own; only the adapter and the merged quantization are released, with attribution. Any capability comparison against the base must come from executed benchmark artifacts, which do not exist yet.
+Full details in the [spec sheet](SPECS.md).
+
+## What to expect
+
+This is a local-first coding companion at 32B scale: completions, functions,
+refactors, and tool-calling on your own hardware, with your code staying home.
+It needs more room than the 14B, roughly 20 GB of memory for the weights plus
+context, so it is happiest on a 24 GB GPU or a machine with generous RAM; see
+the [spec sheet](SPECS.md) for hardware guidance.
+
+We publish measurements, not adjectives, and we are precise about which we have.
+Unlike the 14B, this model does not yet carry benchmark scores. Its only
+recorded behavioral receipt today is a deterministic generation smoke: at
+temperature 0 with a fixed seed, reruns are byte-identical. We make no
+capability-uplift claim over the base model. Benchmarks are pending and will
+ship with the JSON they came from and the method to re-run them, exactly as the
+14B's [benchmarks page](BENCHMARKS.md) already does. Until then, the honest
+statement is: a verified, retraceable continued-pretraining build, not a scored
+one.
+
+## Also in this repo
+
+- `telos-coder-32b-cpt2019-q4_k_m.gguf`: the runnable merged model (above).
+- `telos-coder-32b-cpt2019-lora.gguf`: the QLoRA adapter (268 MB). Apply the
+  trained delta to your own copy of the base, or requantize from it at another
+  precision. The base weights themselves are never republished here.
+
+## The documents
+
+- [Usage guide](usage.md): run it with Ollama, llama.cpp, or as a local API.
+- [Benchmarks](BENCHMARKS.md): what is measured so far, and what is still pending.
+- [Spec sheet](SPECS.md): hardware guidance, training details, formats.
+- [Safety and claims](safety.md): what this model does and does not claim.
+- [Model card](MODEL_CARD.md): the full technical card.
+- [provenance.json](provenance.json) and [checksums.sha256](checksums.sha256):
+  the retraceable chain from corpus to the exact bytes you downloaded.
+
+## License and attribution
+
+Apache-2.0. Built on Qwen2.5-Coder-32B-Instruct by the Qwen team; see LICENSE
+for the attribution notice. The training corpus is proprietary to the author;
+the shipped weights carry no third-party code beyond the base model, and the
+base model is never republished on its own.

SPECS.md

@@ -0,0 +1,72 @@
+# Spec Sheet
+
+## The model
+
+| | |
+|---|---|
+| Name | Flywheel-Local-Coder-32B |
+| Architecture | qwen2 (transformer, decoder-only) |
+| Parameters | 32.5B |
+| Context length | 32,768 tokens |
+| Capabilities | chat, code completion, tool calling |
+| Base model | Qwen/Qwen2.5-Coder-32B-Instruct |
+| License | Apache-2.0 with Qwen attribution |
+
+## The files
+
+| | |
+|---|---|
+| Model | `telos-coder-32b-cpt2019-q4_k_m.gguf`, GGUF single file |
+| Quantization | Q4_K_M |
+| Size | 18.5 GB (19,851,336,480 bytes) |
+| SHA-256 | `65e6133fbe4d12579a776047a71bebb98ab86f9e3d343ed821b51dac0ce312f4` |
+| Adapter | `telos-coder-32b-cpt2019-lora.gguf`, LoRA GGUF, 268 MB |
+| Adapter SHA-256 | `08e7d21cfde1af768c877ecc18ee6343c87711c0c38b8c5b16feb9890f94cbac` |
+| Verify | `sha256sum telos-coder-32b-cpt2019-q4_k_m.gguf` and compare with [checksums.sha256](checksums.sha256) |
+
+## Hardware guidance
+
+- **GPU**: the Q4_K_M weights are ~18.5 GB. A 24 GB card holds the weights but
+  leaves little headroom for a long context; expect to offload some layers to
+  CPU as context grows. Cards below 24 GB run with partial CPU offload and lower
+  speed.
+- **CPU only**: works, but this is a 32B model. Budget roughly 20 GB of free RAM
+  for weights plus context. Generation is noticeably slower than the 14B; usable
+  for chat and completion when you are not latency-sensitive.
+- **Disk**: 18.5 GB for the model file, plus 268 MB if you also pull the adapter.
+
+Runs anywhere llama.cpp or Ollama runs: Windows, Linux, macOS. If you want the
+same behavior at lower memory and higher speed, the 14B sibling is the lighter
+option.
+
+## How it was trained
+
+Continued pretraining (QLoRA) of the base model on a 66.2-million-token corpus
+of 17,997 files from a real, working development ecosystem: production code,
+tests, documentation, and research notes. This is the same packed corpus used
+for the 14B; Qwen2.5-Coder 14B and 32B share a tokenizer, so one corpus trains
+both. Training ran to adapter checkpoint 2019 (2019 steps, a quarter epoch); the
+adapter was merged into the base weights and the merge was quantized to Q4_K_M.
+
+Every layer of that build is hashed and recorded in
+[provenance.json](provenance.json): the corpus content, the packed training
+shards, the adapter checkpoint, the LoRA GGUF, and the final quantized GGUF.
+Given the same inputs, an outside observer can re-derive and verify each link.
+
+The training corpus is proprietary and is not distributed with the model.
+
+## What this model is for
+
+A local-first coding companion at 32B scale: code completion, functions,
+refactors, test writing, and tool-calling workflows where your code must not
+leave your machine. It pairs naturally with a verification loop (propose, test,
+accept only what passes).
+
+## Known boundaries
+
+- No claimed capability uplift over the base model.
+- No benchmark scores yet; only a deterministic generation smoke is recorded.
+  See [BENCHMARKS.md](BENCHMARKS.md).
+- This is a quarter-epoch continued-pretraining adaptation, a light domain pass,
+  not a full retrain.
+- Knowledge cutoff and multilingual behavior follow the base model.

checksums.sha256

@@ -1,10 +1,2 @@
-7241826523283c5811551926e67e796606862e90cbc1c541d81c3beb28769816  benchmark-summary.json
-24de131535bb24acd65caab953394e5d9566c808991a3eb3a01185d7d4845ed1  endpoint.json
-2af5ee89816a9b703f6a2bf5cb42a0d83aee699904bb5f7ca89981e62cde72b8  LICENSE
-d262f1975ec6283b64daabad4bfa569b5d0ea8d612db6e833a718755ab13d6bf  MODEL_CARD.md
-839096ffebdb5be2465f1d4884237491e8dfc2006a9d5ae5fef642427291b9b6  provenance.json
-b85d746d767cc0f6e9ee90221ea38aafd78d4308ad9b37c89e46205b83ed64af  README.md
-f3ab80d408e83c9796f4f257979240aba97f5c31bbd4c4d68e997ffe8de74656  release-checklist.md
-468ac3f403175bf43ae308e20ff9206fde468f5bd357d582cb6754b3cab0208d  safety.md
-21941a7574c639b30b775642debd373277f403fac423519723686573bad625b2  usage.md
-1e8ee7e5c08c1e1b8f0699b44250d8c5fbdc794ad546958348a37a7586f35c9c  WEIGHT-CHECKSUMS-PENDING.md
+65e6133fbe4d12579a776047a71bebb98ab86f9e3d343ed821b51dac0ce312f4  telos-coder-32b-cpt2019-q4_k_m.gguf
+08e7d21cfde1af768c877ecc18ee6343c87711c0c38b8c5b16feb9890f94cbac  telos-coder-32b-cpt2019-lora.gguf

safety.md

@@ -1,24 +1,42 @@
-# Flywheel-Local-Coder-32B Safety and Accountability Notes
-
-Status: provenance and determinism receipts exist and are re-checkable; behavioral and benchmark evidence is pending.
-
-## Accountability posture
-
-This release makes no capability claims. It states what the artifact is, how it was built, and which receipts back each statement. Anything without a receipt is labeled pending.
-
-## Receipts that exist
-
-- Provenance chain (`tasks/research/gguf_ship_manifest_checkpoint2019_32b.json`, schema `telos.model-artifact/v1`), each layer re-derivable:
-  corpus_content_hash `68345cdc6667f20d1678ac0a9139edc170348dfdebb9ae6045cde3d204f4fe62` -> pack_shards_hash `018798dfce7d4c86f5a6ea502a383553220f2e76facfe76acbe52b1c278ae543` -> checkpoint_adapter_sha256 `d2ff1d3042c9b015d8d01b6e195cf95acedc133bf4efe78692e4349a3608e286` -> LoRA GGUF `08e7d21cfde1af768c877ecc18ee6343c87711c0c38b8c5b16feb9890f94cbac` -> merged Q4_K_M GGUF `65e6133fbe4d12579a776047a71bebb98ab86f9e3d343ed821b51dac0ce312f4` (re-verified by re-hash).
-- Deterministic smoke: ollama `/api/generate`, temp 0, seed 7, num_predict 64; reruns byte-identical (MATCH); generation hash prefix `403b2e8b21df9f55`.
-
-## Receipts required before capability claims
-
-- Endpoint gate artifacts (`harness.model-endpoint-gate/v1`) with generation_ok for this model.
-- Benchmark evidence artifacts attached to the release row. Benchmarks are pending; no benchmark result exists yet.
-- Receipt-backed limitations and known failure modes.
-- Secret-handling boundary check on all shipped examples.
-
-## Capability claims
-
-None. No uplift over the base `Qwen2.5-Coder-32B-Instruct` is claimed. Any comparison against the base model must come from executed benchmark artifacts, which do not exist yet. The base weights are never republished on their own.
+# Safety and Claims
+
+This page states plainly what this model does and does not claim, so you can
+weigh it without reading between the lines.
+
+## What we claim, and the evidence
+
+- **The artifact is what it says it is.** The build is retraceable hash by
+  hash: corpus content, packed training shards, adapter checkpoint, the LoRA
+  GGUF, and the final quantized GGUF are each recorded in
+  [provenance.json](provenance.json), and [checksums.sha256](checksums.sha256)
+  ties the chain to the exact file you downloaded.
+- **Reruns are reproducible.** Served at temperature 0 with a fixed seed,
+  generations are byte-identical across runs (recorded generation hash prefix
+  `403b2e8b21df9f55`).
+
+## What we do not claim
+
+- **No capability uplift over the base model.** We have not measured one, so we
+  do not assert one.
+- **No benchmark standing at all, yet.** Unlike the 14B, this model carries no
+  executed benchmark artifacts. HumanEval, MBPP, hard-set, and similar suites
+  have not been run. See [BENCHMARKS.md](BENCHMARKS.md).
+- **No safety tuning beyond the base model.** Refusal behavior, bias, and
+  content boundaries follow Qwen2.5-Coder-32B-Instruct. We have not measured or
+  modified them, so treat them as inherited and unaudited here.
+
+## Sensible boundaries for use
+
+- Treat generated code the way you would treat code from any assistant: run your
+  tests, review before shipping, and never execute generated code against
+  production systems unreviewed.
+- The model runs entirely locally and sends nothing anywhere. Network behavior
+  is a property of the runtime you choose (Ollama, llama.cpp), not the weights.
+- Keep secrets out of prompts as a habit. Nothing in this release requires
+  secrets, keys, or private files to use.
+
+## If you find a problem
+
+Open an issue on the model repo with the prompt, the runtime and version, and
+the observed output. A reproducible report at temperature 0 is the fastest path
+to a fix, because we can replay it exactly.

usage.md

@@ -1,42 +1,84 @@
-# Flywheel-Local-Coder-32B Usage
+# Usage Guide
 
-Status: the commands below were exercised locally; benchmark-grade usage examples are pending.
+Everything below assumes you downloaded this repo folder, so the GGUF and the
+Modelfile sit together in your working directory.
 
-## Ollama
-
-The Modelfile lives next to the artifact:
+## Verify your download (optional, 30 seconds)
 
-```text
-E:\local-model-run\gguf-work-32b\Modelfile
+```
+sha256sum telos-coder-32b-cpt2019-q4_k_m.gguf
 ```
 
-Create and run:
+Compare against [checksums.sha256](checksums.sha256). A match means you hold the
+exact bytes the provenance chain describes.
 
-```powershell
-ollama create flywheel-local-coder-32b -f E:\local-model-run\gguf-work-32b\Modelfile
+## Ollama
+
+```
+ollama create flywheel-local-coder-32b -f Modelfile
 ollama run flywheel-local-coder-32b
 ```
 
+That gives you interactive chat. Ollama also exposes an OpenAI-compatible API
+the moment the model is created, so any tool that speaks the OpenAI chat format
+can use the model locally:
+
+```
+curl http://127.0.0.1:11434/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{"model":"flywheel-local-coder-32b","messages":[{"role":"user","content":"Write a Python function that merges overlapping intervals."}]}'
+```
+
+Point your editor plugin, agent framework, or script at
+`http://127.0.0.1:11434/v1` with model name `flywheel-local-coder-32b` and you
+have a private, zero-cost coding endpoint. On an 18.5 GB model, first-token
+latency depends on how much of the model fits in VRAM; see the
+[spec sheet](SPECS.md) for hardware guidance.
+
 ## llama.cpp
 
-Direct completion against the GGUF, matching the deterministic smoke configuration (temp 0, seed 7):
+Interactive chat, one command:
 
-```powershell
-llama-cli -m E:\local-model-run\gguf-work-32b\telos-coder-32b-cpt2019-q4_k_m.gguf --temp 0 --seed 7 -n 64 -p "<prompt>"
+```
+llama-cli -m telos-coder-32b-cpt2019-q4_k_m.gguf -cnv
+```
+
+Deterministic completion (the exact configuration our receipt uses):
+
+```
+llama-cli -m telos-coder-32b-cpt2019-q4_k_m.gguf --temp 0 --seed 7 -n 64 -p "your prompt"
 ```
 
-Reruns at temp 0, seed 7 are byte-identical (smoke verdict MATCH).
+At temperature 0 with a fixed seed, reruns are byte-identical. That is not a
+nicety: it is what lets a receipt be re-checked by someone who is not us.
+
+## The adapter
+
+If you would rather apply the trained delta yourself, or requantize at another
+precision, pull the LoRA adapter and work from your own copy of the base:
+
+```
+hf download zaindanaharper/flywheel-local-coder-32b telos-coder-32b-cpt2019-lora.gguf --local-dir .
+```
 
-## Harness endpoint profile
+The base weights are never republished here; bring your own copy of
+`Qwen2.5-Coder-32B-Instruct` (Apache-2.0) and apply the adapter with
+llama.cpp's `--lora`, or merge and requantize with `llama-export-lora` +
+`llama-quantize`.
 
-The flywheel harness reaches the model through this endpoint profile:
+## Tool calling
 
-- backend: `ollama`
-- model: `flywheel-local-coder-32b`
-- base URL: `http://127.0.0.1:11434`
+The model supports tool/function calling through Ollama's OpenAI-compatible
+endpoint: pass a `tools` array in the request as you would with any OpenAI-style
+API.
 
-## Required before publishing usage examples
+## Tips
 
-- An endpoint gate artifact passes, or the failure mode is documented.
-- Prompt examples use the same task-set contract as benchmark runs.
-- No examples require secrets or private files.
+- Give it the full contract. Precise asks (exact exception messages, edge cases,
+  output format) get precise answers.
+- Pair it with your tests. Its natural habitat is a propose-then-verify loop:
+  let it write, run your tests, keep what passes.
+- 32,768-token context: enough for a large file plus conversation, not an entire
+  repository. Feed it the relevant slice.
+- If speed matters more than capacity, the 14B sibling runs the same way at less
+  than half the memory.