bankml 0.3.6 on PR #1: penalties, byte-identical pins, a bankml node's own chat and judge models, and the VPS install guide

- serve --to bankml takes repeat_penalty / repeat_last_n / presence_penalty /
frequency_penalty when `bankml version` is 0.3.6+ (bankml's O2) and refuses them,
with the reason, before; --bankml-system, --bankml-param KEY=VALUE and
--bankml-stop layer a persona and its sampling over the pin. Measured on gen39:
the bare pin answers ",,,,"; the layered tag answers in words.
- The merged directory is converted through a link named after the tag: llama.cpp
names a model after its directory, so `merged/` gave general.name "Merged" and a
different sha256. Through the link gen39 converts to 6b64c748…, the pin mindX
serves (verified against bankml 0.3.6 with the Hub's gen39 weights).
- BankmlBackend sends sampling fields from options= / MINDXTRAIN_BANKML_OPTIONS,
only when set.
- MINDXTRAIN_CHAT_MODEL / MINDXTRAIN_JUDGE_MODEL / MINDXTRAIN_CHAT_OPTIONS: the
panel and the judges named llama3.2, which a bankml node does not serve.
classroom(use_judge=True) with no model uses the default judge instead of skipping.
- docs/install.md: bankml 0.3.6 and this lane on the mindX VPS, in copy-paste
steps with a check after each and a rollback; steps 3–4 replayed locally.

852 passed, 3 skipped (PR #1's 842 + 10); ruff clean on the changed files; mypy clean.

Co-Authored-By: Professor Codephreak <codephreak@pythai.net>

docs/CHANGELOG.md

@@ -8,6 +8,19 @@ project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Added
 
+- **bankml 0.3.6 penalties.** `serve --to bankml` takes `repeat_penalty`, `repeat_last_n`,
+  `presence_penalty` and `frequency_penalty` in the Modelfile when `bankml version` is 0.3.6 or
+  later (bankml's O2), and refuses them with the reason before; `--bankml-system`,
+  `--bankml-param KEY=VALUE` and `--bankml-stop` layer a persona and its sampling over the pin.
+  The backend sends sampling fields from `options=` / `MINDXTRAIN_BANKML_OPTIONS`, only when set.
+- **Byte-identical conversion.** The merged directory is converted through a link named after the
+  tag, so llama.cpp's `general.name` is the tag's and gen39 converts to `6b64c748…`, the GGUF mindX
+  pins (through `merged/` it was "Merged" and a different sha256).
+- **`MINDXTRAIN_CHAT_MODEL`, `MINDXTRAIN_JUDGE_MODEL`, `MINDXTRAIN_CHAT_OPTIONS`.** The panel and
+  the judges named `llama3.2` when given no model; a bankml node serves none. Read at call time.
+  `classroom(use_judge=True)` without a model now uses the default judge instead of skipping it.
+- **`docs/install.md`**: deploying bankml 0.3.6 and mindXtrain's bankml lane to the mindX VPS.
+
 - **bankml, the verified CPU engine** ([github.com/cryptoAGI/bankml](https://github.com/cryptoAGI/bankml),
   [`docs/bankml.md`](bankml.md)), reached over HTTP and its CLI only — nothing vendored.
   - `operator/backends/bankml.py`: `@register_backend("bankml")`, `MINDXTRAIN_BANKML_BASE_URL`

docs/NAV.md

@@ -13,6 +13,7 @@ reading paths first, then jump straight to the section you need.
 - **Running the demo / operating a real run?** → [HANDOFF.md](HANDOFF.md) → [CLI](cli.md) → [YAML schema](yaml_schema.md).
 - **Contributing code?** → [Development workflow](development.md) → [Architecture](architecture.md) → [Actualization status](actualization_status.md).
 - **Driving the UI?** → [Coach UI](coach.md) → [dcoach](dcoach.md) → [Governance](governance.md).
+- **Deploying to the mindX VPS?** → [install.md](install.md) (bankml 0.3.6 + the bankml lane, step by step) → [bankml](bankml.md).
 - **Researching the space?** → [Decentralized training deep-dive](decentralized-training-deep-dive-2026.md) → [LLM training-stack landscape](mindxtrain-llm-training-landscape-2026.md) → [Autoresearch strategy](mindXtrain_autoresearch_strategy.md).
 
 ---
@@ -132,6 +133,7 @@ The interactive `/coach/` operator UI: create-script, live-training diagnostics,
 - [What bankml runs, and what it refuses](bankml.md#what-bankml-runs-and-what-it-refuses)
 - [Operator backend](bankml.md#operator-backend--mindxtrain_backendbankml) · [`serve --to bankml`](bankml.md#serving-a-trained-run--mindxtrain-serve---to-bankml) · [The Modelfile subset](bankml.md#the-modelfile-subset-bankml_sanitize)
 - [`imprint-bankml` (not comparable with the canonical gate)](bankml.md#a-second-imprint-instrument--mindxtrain-imprint-bankml)
+- [The chat and judge models on a bankml node](bankml.md#the-chat-and-judge-models-on-a-bankml-node) · [Install on the mindX VPS](install.md)
 
 ### [Governance](governance.md)
 classroom (graduation) / boardroom (any-N consensus) / dojo (prime-N dispute settlement), model-backed deliberation.

docs/bankml.md

@@ -17,8 +17,8 @@ mindXtrain reaches bankml **only over HTTP and as a CLI subprocess**. No bankml
 | | bankml |
 |---|---|
 | **Architectures** | Qwen3 (`Q1_0`, `Q2_0_g64`: the Bonsai family) and Llama in F16 (SmolLM2-135M, mindX's `mindx-genN`) |
-| **Sampling it reproduces** | `temperature`, `top_k`, `top_p`, `min_p`, `seed`, JSON mode; `num_ctx`, `num_predict`, `stop` |
-| **Refused with HTTP 400 and a reason** | repeat / presence / frequency penalties (non-neutral), `mirostat`, `typical_p`, `tools`, images, a replacement `template`, unknown architectures, `Q8_0` / `Q4_K` / `BF16` |
+| **Sampling it reproduces** | `temperature`, `top_k`, `top_p`, `min_p`, `seed`, JSON mode; `num_ctx`, `num_predict`, `stop`; from **0.3.6** also `repeat_penalty`, `repeat_last_n`, `presence_penalty`, `frequency_penalty`, token for token as llama-server b11192 applies them |
+| **Refused with HTTP 400 and a reason** | penalties on bankml before 0.3.6, `mirostat`, `typical_p`, `tools`, images, a replacement `template`, unknown architectures, `Q8_0` / `Q4_K` / `BF16` |
 | **Receipt** (`bankml_receipt`) | `bankml` version, `engine`, `model_sha256`, `guard`, `prompt_tokens`, `completion_tokens`, `ttft_ms`, `wall_ms`, `response_sha256`, `request_sha256`, `signed: false` |
 
 A refusal is the product, not a defect: bankml answers only what its verified forward pass does.
@@ -35,6 +35,9 @@ MINDXTRAIN_BACKEND=bankml uv run uvicorn mindxtrain.operator.app:app --port 8080
 ```
 
 - `MINDXTRAIN_BANKML_BASE_URL` (default `http://127.0.0.1:18093/v1`).
+- `MINDXTRAIN_BANKML_OPTIONS`: a JSON object of sampling fields to send on every request (or
+  `BankmlBackend(options=...)`), e.g. `{"repeat_penalty": 1.3}` for a small generation on 0.3.6+.
+  Nothing extra is sent unless it is set.
 - `POST /v1/chat/completions` returns `ChatResponse.receipt`; the backend also keeps `last_receipt`.
   Streamed answers parse bankml's final `data: {"bankml_receipt": …}` event.
 - HTTP 400 → `BankmlRefusal(reason)` → the operator answers 400 with bankml's reason. Other non-2xx
@@ -52,9 +55,15 @@ MINDXTRAIN_BACKEND=bankml uv run uvicorn mindxtrain.operator.app:app --port 8080
 
 ```bash
 uv run mindxtrain serve run.yaml --to bankml [--tag mindx-gen80] [--checkpoint DIR] \
-    [--bankml-bin PATH] [--bankml-convert] [--register-as-fallback]
+    [--bankml-bin PATH] [--bankml-convert] [--register-as-fallback] \
+    [--bankml-system "You are mindX, generation 80."] \
+    [--bankml-param repeat_penalty=1.3 --bankml-param num_ctx=2048 --bankml-stop '<|im_end|>']
 ```
 
+A SmolLM2 / mindx-genN generation wants all of the bracketed last line on bankml 0.3.6+: measured
+on gen39, the bare pin answers runs of `,` with or without a per-request penalty, and the layered
+tag answers in words.
+
 1. **Refuses up front** (exit 2): `quantize.enabled` with a scheme other than `none` (bankml serves
    the merged weights as GGUF F16; it does not reproduce FP8, MXFP4, GPTQ, Q8_0 or Q4_K), and base
    families bankml cannot convert (Qwen, Mistral, Phi, Gemma, GLM, DeepSeek, Instella).
@@ -67,6 +76,10 @@ uv run mindxtrain serve run.yaml --to bankml [--tag mindx-gen80] [--checkpoint D
 4. Re-checks the merged `config.json`: only `LlamaForCausalLM` converts.
 5. Writes a Modelfile through `bankml_sanitize` and runs `bankml create <tag> -f Modelfile`, which
    converts the merged safetensors to GGUF F16 byte-identically to llama.cpp b11192 and pins it.
+   The directory is passed through a link named after the tag (`<work>/<tag>/<tag>`): llama.cpp
+   names a model after the directory it reads, so `merged/` would give `general.name` "Merged"
+   and a different sha256. Through the link gen39 converts to `6b64c748…`, the pin mindX serves.
+   Penalties in the Modelfile are taken on bankml 0.3.6+ and refused, with the reason, before.
    `--bankml-convert` runs `bankml convert` (GGUF + `FORK.json`) first and writes `FROM <gguf>`.
 6. Records the model sha256 bankml prints for the base it verified, and the derived model's digest.
 7. `--register-as-fallback` PATCHes mindX's fallback model to `{provider: "bankml", model: <tag>}`
@@ -81,7 +94,8 @@ uv run mindxtrain serve run.yaml --to bankml [--tag mindx-gen80] [--checkpoint D
 | `PARAMETER` temperature, top_k, top_p, min_p, seed, num_ctx, num_predict; `stop` | taken |
 | `ADAPTER` | **refused** — merge first (`push_to_bankml` does) |
 | `TEMPLATE` | **refused** unless equal to the base's own chat template |
-| penalties, `repeat_last_n`, mirostat*, `typical_p` | **refused** — not reproduced |
+| penalties, `repeat_last_n` | taken on bankml **0.3.6+**; **refused** before (checked against `bankml version`) |
+| mirostat*, `typical_p` | **refused** — not reproduced |
 | `num_gpu`, `num_thread`, `num_batch`, `num_keep`, `draft_num_predict` | **refused** — a resource option is not part of a model |
 
 Each refusal is returned with its reason; nothing is dropped silently. Python API:
@@ -125,9 +139,30 @@ repeating; pass the persona's `--system` as the coach does.
 - `hf.extension.publish_generation(..., repeat_penalty=None)` publishes a Modelfile without the
   penalty line, which bankml can load. The default stays 1.3.
 
+## The chat and judge models on a bankml node
+
+The governance panel and the LLM judges used to name `llama3.2` when no model was given; bankml
+serves no such model. Both now read the environment at call time:
+
+| variable | for | example on the VPS |
+|---|---|---|
+| `MINDXTRAIN_CHAT_MODEL` | boardroom members and dojo judges with no `model` | `bonsai-8b-q1_0` |
+| `MINDXTRAIN_JUDGE_MODEL` | `CorrectnessEvaluator`, `PairwiseEvaluator`, `GuidelineEvaluator`, classroom (falls back to the chat model) | `bonsai-8b-q1_0` |
+| `MINDXTRAIN_CHAT_OPTIONS` | extra fields on every `chat_once` body | `{"repeat_penalty": 1.3}` |
+
+`classroom(use_judge=True)` with no model now uses that judge instead of silently skipping it.
+
+Speeds (bankml's `docs/PERFORMANCE.md`, a Ryzen 3 3200U at 3 threads): mindx-genN / SmolLM2-135M
+F16 ~38 tokens/s (the fastest; serving and voice probes, too weak to judge); Bonsai-1.7B Q1_0 ~8.5
+(the fastest that judges); Bonsai-8B Q1_0 and Ternary-Bonsai-8B Q2_0_g64 ~2.4 (teacher and judge).
+The VPS runs bankml on one thread: expect about a third of that.
+
+Deploying all of this to the mindX VPS, step by step: [install.md](install.md).
+
 ## Tests
 
-`tests/test_bankml_backend.py`, `tests/test_bankml_push.py`, `tests/test_imprint_bankml.py` — no
+`tests/test_bankml_backend.py`, `tests/test_bankml_push.py`, `tests/test_imprint_bankml.py`,
+`tests/test_bankml_extras.py` — no
 network and no binary: `httpx.MockTransport`, monkeypatched `subprocess.run` / `shutil.which`.
 `tests/conftest.py` pins the bankml auto-detect probe to "absent" so a developer box running bankml
 cannot change what the other auto-detect tests resolve to.

docs/install.md

@@ -0,0 +1,247 @@
+# Install on the mindX VPS: bankml 0.3.6 and mindXtrain's bankml lane
+
+This guide upgrades the mindX node (mindx.pythai.net, `168.231.126.58`) in eight steps:
+
+1. bankml 0.3.5 → 0.3.6 (repetition penalties, token-identical to llama-server)
+2. gen39 re-layered so it answers in words
+3. mindXtrain → the Hub's `main` (the bankml serve target, backend and judges)
+4. mindX pointed at bankml for mindXtrain's chat, judges and teacher
+
+Every block is meant to be copied whole and pasted into a root shell on the VPS. Each step ends
+with a check; do not go on until it passes. [Roll back](#rollback) undoes any step.
+
+**What you need:** root SSH to the VPS, about 15 minutes, and 1 GB free on `/`. Restarting
+`bankml` makes mindX's default model unavailable for a few seconds; restarting `mindx` takes
+3–4 minutes before `/health` answers again.
+
+---
+
+## 0. Log in and look before you touch
+
+```bash
+ssh root@168.231.126.58
+```
+
+```bash
+df -h / | tail -1
+systemctl is-active bankml mindx
+curl -s 127.0.0.1:18093/bankml | head -c 200; echo
+/home/mindx/bankml-0.3.5/bankml --version
+```
+
+You should see both services `active`, a `"verdict": "play"` from bankml, and `bankml 0.3.5`.
+
+Check that no training run is going (a mindX restart in step 7 would end it):
+
+```bash
+pgrep -af 'mindxtrain (train|ascend)' || echo "no training running"
+```
+
+## 1. Back up what you will change
+
+```bash
+TS=$(date -u +%Y%m%dT%H%M%SZ); mkdir -p /root/deploy_backup_bankml036_$TS
+cp /etc/systemd/system/bankml.service /home/mindx/mindX/.env /root/deploy_backup_bankml036_$TS/
+echo "/root/deploy_backup_bankml036_$TS" | tee /root/LAST_BANKML036_BACKUP
+ls -la /root/deploy_backup_bankml036_$TS
+```
+
+## 2. Build bankml 0.3.6
+
+bankml has no dependencies to fetch; it builds with the `mindx` user's cargo in a few minutes on
+the VPS's two cores. Build from the `v0.3.6` tag once it is published; until then, from `main`.
+
+```bash
+sudo -u mindx bash -lc 'cd /home/mindx && rm -rf bankml-src-0.3.6 && git clone --depth 1 --branch v0.3.6 https://github.com/cryptoAGI/bankml bankml-src-0.3.6 || git clone --depth 1 https://github.com/cryptoAGI/bankml bankml-src-0.3.6'
+```
+
+```bash
+sudo -u mindx bash -lc 'cd /home/mindx/bankml-src-0.3.6 && nice -n 19 cargo build --release 2>&1 | tail -3'
+```
+
+```bash
+sudo -u mindx mkdir -p /home/mindx/bankml-0.3.6
+sudo -u mindx cp /home/mindx/bankml-src-0.3.6/target/release/bankml /home/mindx/bankml-0.3.6/bankml
+/home/mindx/bankml-0.3.6/bankml --version
+```
+
+**Check:** it prints `bankml 0.3.6` (or later). If it prints 0.3.5, the tag is not out yet and
+`main` has not moved past it either: stop here, nothing has changed on the running node.
+
+## 3. Point the service at 0.3.6 and restart bankml
+
+```bash
+sed -i 's#/home/mindx/bankml-0\.3\.5/bankml#/home/mindx/bankml-0.3.6/bankml#' /etc/systemd/system/bankml.service
+grep ExecStart /etc/systemd/system/bankml.service
+```
+
+```bash
+systemctl daemon-reload && systemctl restart bankml && sleep 5 && systemctl is-active bankml
+```
+
+```bash
+curl -s 127.0.0.1:18093/bankml | grep -o '"bankml": *"[^"]*"'
+```
+
+**Check:** `"bankml": "0.3.6"`. Now prove the penalties are honoured (0.3.5 answered HTTP 400 to
+this request):
+
+```bash
+curl -s -o /dev/null -w '%{http_code}\n' 127.0.0.1:18093/v1/chat/completions -H 'Content-Type: application/json' -d '{"model":"mindx-gen39-f16","messages":[{"role":"user","content":"Who are you?"}],"max_tokens":16,"repeat_penalty":1.3}'
+```
+
+**Check:** `200`.
+
+## 4. Layer gen39 so it answers in words
+
+A 135M generation on its own repeats itself (`,,,,`). A layer over the pinned GGUF adds its
+persona, its stop string and a 1.3 repeat penalty; the weights are not copied.
+
+```bash
+cat > /home/mindx/models/Modelfile.mindx-gen39 <<'MF'
+FROM mindx-gen39-f16
+SYSTEM """You are mindX, generation 39."""
+PARAMETER stop "<|im_end|>"
+PARAMETER num_ctx 2048
+PARAMETER repeat_penalty 1.3
+MF
+chown mindx:mindx /home/mindx/models/Modelfile.mindx-gen39
+```
+
+```bash
+sudo -u mindx /home/mindx/bankml-0.3.6/bankml create mindx-gen39 -f /home/mindx/models/Modelfile.mindx-gen39 --registry /home/mindx/models/registry
+```
+
+```bash
+curl -s 127.0.0.1:18093/v1/chat/completions -H 'Content-Type: application/json' -d '{"model":"mindx-gen39","messages":[{"role":"user","content":"Who are you?"}],"max_tokens":48}' | python3 -c 'import json,sys; print(json.load(sys.stdin)["choices"][0]["message"]["content"])'
+```
+
+**Check:** an answer in words, not a run of commas. (`mindx-gen39-f16` is still the bare pin;
+`mindx-gen39` is now the layer. One thread on the VPS: give it 10–30 seconds.)
+
+## 5. Bring mindXtrain to the Hub's `main`
+
+mindXtrain moved from GitHub (archived) to `huggingface.co/PYTHAI/mindXtrain`. The checkout on
+the VPS still tracks GitHub at v1.0.2 and has a local `uv.lock` edit, which is set aside first.
+
+```bash
+cd /home/mindx/mindXtrain
+sudo -u mindx git stash push -m "pre-bankml uv.lock" -- uv.lock || true
+sudo -u mindx git remote add hf https://huggingface.co/PYTHAI/mindXtrain 2>/dev/null || true
+sudo -u mindx GIT_LFS_SKIP_SMUDGE=1 git fetch hf main
+sudo -u mindx git checkout -B main hf/main
+sudo -u mindx git log --oneline -1
+```
+
+Install it into the existing virtualenv. `--inexact` keeps the extras already installed there
+(torch, peft, trl), which a plain `uv sync` would remove:
+
+```bash
+cd /home/mindx/mindXtrain && sudo -u mindx /home/mindx/.local/bin/uv sync --inexact --extra ml 2>&1 | tail -2
+```
+
+```bash
+cd /home/mindx/mindXtrain && sudo -u mindx .venv/bin/mindxtrain serve --help | grep -c 'bankml'
+```
+
+**Check:** a number above 0 (the `--to bankml` options are there).
+
+## 6. Tell mindX's mindXtrain to use bankml
+
+mindX starts mindXtrain with its own environment (`/home/mindx/mindX/.env`). Append the bankml
+lane (Bonsai-8B is the model on the VPS that is good enough to judge and teach; gen39 is too
+small for that):
+
+```bash
+cat >> /home/mindx/mindX/.env <<'ENV'
+
+# mindXtrain on bankml (docs/install.md in PYTHAI/mindXtrain)
+MINDXTRAIN_BANKML_BASE_URL=http://127.0.0.1:18093/v1
+MINDXTRAIN_CHAT_MODEL=bonsai-8b-q1_0
+MINDXTRAIN_JUDGE_MODEL=bonsai-8b-q1_0
+MINDXTRAIN_TEACHER_BASE_URL=http://127.0.0.1:18093/v1
+MINDXTRAIN_TEACHER_MODEL=bonsai-8b-q1_0
+ENV
+grep -n 'MINDXTRAIN_' /home/mindx/mindX/.env
+```
+
+`MINDXTRAIN_BACKEND=bankml` is deliberately not set: with it, the panel would use bankml even
+where an `MINDXTRAIN_OPENAI_BASE_URL` is configured. Add it only if bankml should be the only
+chat endpoint.
+
+## 7. Restart mindX and confirm
+
+Look at what is inside mindX's cgroup first; a restart ends everything listed there:
+
+```bash
+for p in $(cat /sys/fs/cgroup/system.slice/mindx.service/cgroup.procs); do ps -o pid=,args= -p $p; done | cut -c1-120
+```
+
+```bash
+systemctl restart mindx && echo "restarted at $(date -u +%T); /health answers in 3-4 minutes"
+```
+
+```bash
+until curl -s -o /dev/null -w '%{http_code}' 127.0.0.1:8000/health | grep -q 200; do sleep 15; done; echo "mindX is up"
+```
+
+```bash
+tr '\0' '\n' < /proc/$(systemctl show -p MainPID --value mindx)/environ | grep MINDXTRAIN_
+```
+
+**Check:** the five `MINDXTRAIN_` lines from step 6.
+
+## 8. Serving the next generation
+
+When a run finishes, put it on bankml (merge, pin byte-identically, layer) in one command. Use
+the run's config and tag:
+
+```bash
+cd /home/mindx/mindXtrain && sudo -u mindx BANKML_FORKS=/home/mindx/models/registry .venv/bin/mindxtrain serve /path/to/run.yaml --to bankml --tag mindx-gen82 --bankml-bin /home/mindx/bankml-0.3.6/bankml --bankml-system "You are mindX, generation 82." --bankml-param repeat_penalty=1.3 --bankml-param num_ctx=2048 --bankml-stop '<|im_end|>'
+```
+
+It prints the model's sha256; `curl -s 127.0.0.1:18093/api/tags` then lists `mindx-gen82`.
+
+---
+
+## Rollback
+
+Each line undoes one step; run only the ones you need.
+
+```bash
+B=$(cat /root/LAST_BANKML036_BACKUP); echo "restoring from $B"
+```
+
+bankml back to 0.3.5 (steps 2–3):
+
+```bash
+cp $B/bankml.service /etc/systemd/system/bankml.service && systemctl daemon-reload && systemctl restart bankml && /home/mindx/bankml-0.3.5/bankml --version
+```
+
+gen39's layer (step 4), so `mindx-gen39` is the bare pin's alias again:
+
+```bash
+rm -f /home/mindx/models/registry/mindx-gen39.MODEL.json
+```
+
+mindX's environment (step 6), then restart mindX as in step 7:
+
+```bash
+cp $B/.env /home/mindx/mindX/.env && chown mindx:mindx /home/mindx/mindX/.env
+```
+
+mindXtrain back to the GitHub checkout (step 5):
+
+```bash
+cd /home/mindx/mindXtrain && sudo -u mindx git checkout -B main github/main && sudo -u mindx git stash pop || true
+```
+
+## Troubleshooting
+
+| you see | it means | do |
+|---|---|---|
+| `cargo: command not found` | the build ran outside `mindx`'s login shell | keep the `sudo -u mindx bash -lc '…'` form |
+| step 3 answers `400` | bankml is still 0.3.5 | `grep ExecStart /etc/systemd/system/bankml.service`, then `systemctl daemon-reload && systemctl restart bankml` |
+| `bankml create … refuse` | the Modelfile asks for something bankml does not reproduce | the message names it; penalties need 0.3.6 |
+| `git fetch hf` fails | the Hub was unreachable | `curl -sI https://huggingface.co/PYTHAI/mindXtrain`, then retry |
+| `/health` never turns 200 | mindX did not start | `journalctl -u mindx -n 50 --no-pager` |

mindxtrain/cli/main.py

@@ -394,6 +394,25 @@ def _serve_openai_server(
         )
 
 
+def _parse_params(items: list[str]) -> dict[str, float | int | str]:
+    """['repeat_penalty=1.3', 'num_ctx=2048'] → {'repeat_penalty': 1.3, 'num_ctx': 2048}."""
+    out: dict[str, float | int | str] = {}
+    for item in items:
+        key, sep, raw = item.partition("=")
+        if not sep or not key.strip():
+            msg = f"{item!r} is not KEY=VALUE"
+            raise ValueError(msg)
+        val: float | int | str = raw.strip()
+        for cast in (int, float):
+            try:
+                val = cast(raw)
+                break
+            except ValueError:
+                continue
+        out[key.strip()] = val
+    return out
+
+
 def _serve_bankml(
     cfg: XTrainConfig,
     checkpoint: Path | None,
@@ -403,6 +422,9 @@ def _serve_bankml(
     convert: bool,
     register_as_fallback: bool,
     mindx_base_url: str | None,
+    system: str | None = None,
+    params: list[str] | None = None,
+    stop: list[str] | None = None,
 ) -> None:
     """`serve --to bankml`: refuse what bankml cannot serve, else merge + `bankml create`.
 
@@ -432,6 +454,11 @@ def _serve_bankml(
         console.print(f"[red]checkpoint not found:[/red] {ckpt}")
         raise typer.Exit(code=1)
     is_adapter = (ckpt / "adapter_config.json").exists() or not (ckpt / "config.json").exists()
+    try:
+        parsed = _parse_params(params or [])
+    except ValueError as exc:
+        console.print(f"[red]--bankml-param:[/red] {exc}")
+        raise typer.Exit(code=2) from exc
     result = push_to_bankml(
         base_model,
         tag or run_name,
@@ -439,6 +466,9 @@ def _serve_bankml(
         merged_dir=None if is_adapter else ckpt,
         bankml_bin=bankml_bin,
         convert=convert,
+        system=system,
+        params=parsed,
+        stop=list(stop or []),
         register_with_mindx=register_as_fallback,
         mindx_base_url=mindx_base_url,
         sink=lambda line: console.print(line, markup=False, highlight=False),
@@ -530,6 +560,19 @@ def serve(
         None, "--bankml-bin",
         help="Override the bankml binary path for `--to bankml` (defaults to PATH lookup).",
     ),
+    bankml_system: str = typer.Option(
+        None, "--bankml-system",
+        help="With `--to bankml`: the SYSTEM prompt layered over the pinned base (the persona).",
+    ),
+    bankml_param: list[str] = typer.Option(
+        None, "--bankml-param",
+        help="With `--to bankml`: a Modelfile PARAMETER as KEY=VALUE, repeatable. A SmolLM2 / "
+             "mindx-genN generation wants `repeat_penalty=1.3` (bankml 0.3.6+) and `num_ctx=2048`.",
+    ),
+    bankml_stop: list[str] = typer.Option(
+        None, "--bankml-stop",
+        help="With `--to bankml`: a stop string, repeatable (SmolLM2: '<|im_end|>').",
+    ),
     bankml_convert: bool = typer.Option(
         False, "--bankml-convert",
         help="With `--to bankml`: run `bankml convert` (GGUF F16 + FORK.json pin) before "
@@ -579,6 +622,7 @@ def serve(
         _serve_bankml(
             cfg, checkpoint, tag=tag, bankml_bin=bankml_bin, convert=bankml_convert,
             register_as_fallback=register_as_fallback, mindx_base_url=mindx_base_url,
+            system=bankml_system, params=bankml_param, stop=bankml_stop,
         )
         return
 

mindxtrain/deploy/bankml_push.py

@@ -14,13 +14,20 @@ from the one described):
 - **Taken:** `FROM` (the merged safetensors directory, which `bankml create` converts to GGUF F16
   byte-identically to llama.cpp b11192, or a GGUF `bankml convert` already pinned), `SYSTEM`,
   `MESSAGE`, `LICENSE`, `REQUIRES`, `PARAMETER` temperature / top_k / top_p / min_p / seed /
-  num_ctx / num_predict, and `stop`.
+  num_ctx / num_predict, and `stop`; from bankml 0.3.6 (its O2) also the penalties —
+  repeat_penalty, repeat_last_n, presence_penalty, frequency_penalty — which it applies token
+  for token as llama-server b11192 does. A small generation (SmolLM2 / mindx-genN) needs
+  `repeat_penalty` to answer in words rather than runs of `,`.
 - **Refused:** `ADAPTER` (merge first — this module does it for you given `adapter_dir`), a
-  `TEMPLATE` other than the base's own, the penalties (repeat / presence / frequency,
-  repeat_last_n), mirostat*, typical_p, resource options (num_gpu, num_thread, num_batch,
+  `TEMPLATE` other than the base's own, the penalties on a bankml older than 0.3.6,
+  mirostat*, typical_p, resource options (num_gpu, num_thread, num_batch,
   num_keep, draft_num_predict), and any architecture other than Llama (SmolLM2 = mindx-genN):
   bankml converts Llama safetensors only; Qwen3 it serves only as a pinned Q1_0/Q2_0_g64 GGUF.
 
+The merged directory is converted through a link named after the tag: llama.cpp's converter
+names a model after the directory it reads (`merged` → general.name "Merged"), and only the
+tag's name gives the GGUF byte-identical to the one mindX pins (gen39 → 6b64c748…).
+
 `bankml create` / `bankml convert` arrive in bankml 0.3.5. An older binary is detected from
 `bankml --help` (the verbs it lists) and reported as `status="bankml_too_old"`, never raised.
 
@@ -49,6 +56,7 @@ BANKML_PARAMS: frozenset[str] = frozenset(
 )
 
 _PENALTY = frozenset({"repeat_penalty", "presence_penalty", "frequency_penalty", "repeat_last_n"})
+PENALTIES_SINCE = (0, 3, 6)  # bankml O2: penalties token-identical to llama-server b11192
 _MIROSTAT = frozenset({"mirostat", "mirostat_tau", "mirostat_eta"})
 _RESOURCE = frozenset({"num_gpu", "num_thread", "num_batch", "num_keep", "draft_num_predict"})
 
@@ -63,10 +71,21 @@ PushStatus = Literal[
 ]
 
 
+def version_tuple(version: str) -> tuple[int, ...]:
+    """'0.3.6' → (0, 3, 6); '' or unparseable → () (treated as older than any release)."""
+    m = re.match(r"(\d+)\.(\d+)\.(\d+)", version or "")
+    return tuple(int(g) for g in m.groups()) if m else ()
+
+
+def penalties_supported(version: str) -> bool:
+    return version_tuple(version) >= PENALTIES_SINCE
+
+
 def _param_refusal(name: str) -> str:
     if name in _PENALTY:
-        return (f"PARAMETER {name}: penalties are not reproduced by bankml's verified sampler "
-                "(llama.cpp's top-k, top-p, min-p and temperature are); leave it out")
+        return (f"PARAMETER {name}: penalties are reproduced from bankml "
+                f"{'.'.join(map(str, PENALTIES_SINCE))} (O2); this bankml predates it — upgrade, "
+                "or leave it out")
     if name in _MIROSTAT:
         return f"PARAMETER {name}: mirostat is not reproduced by bankml; leave it out"
     if name == "typical_p":
@@ -142,12 +161,15 @@ class BankmlSanitizeResult:
         return not self.refusals
 
 
-def bankml_sanitize(spec: ModelfileSpec, *, base_template: str | None = None) -> BankmlSanitizeResult:
+def bankml_sanitize(
+    spec: ModelfileSpec, *, base_template: str | None = None, penalties: bool = False,
+) -> BankmlSanitizeResult:
     """Check a ModelfileSpec against the subset `bankml create` reproduces.
 
     Refuses (and names) every instruction bankml would not honour; it never drops one, because a
     silently dropped PARAMETER serves a model that answers differently from the spec. A
     `TEMPLATE` passes only when it equals `base_template` (the base GGUF's own chat template).
+    `penalties=True` admits the penalties (bankml 0.3.6+; see `penalties_supported`).
     """
     refusals: list[str] = []
     if spec.adapter:
@@ -157,8 +179,9 @@ def bankml_sanitize(spec: ModelfileSpec, *, base_template: str | None = None) ->
         refusals.append("TEMPLATE: bankml renders the base model's own chat template "
                         "(byte-identical to llama.cpp); a different template is not reproduced — "
                         "leave TEMPLATE out")
+    allowed = BANKML_PARAMS | _PENALTY if penalties else BANKML_PARAMS
     for name in sorted(spec.parameters):
-        if name not in BANKML_PARAMS:
+        if name not in allowed:
             refusals.append(_param_refusal(name))
     for label, value in (("SYSTEM", spec.system), ("TEMPLATE", spec.template),
                          ("LICENSE", spec.license)):
@@ -296,7 +319,7 @@ def push_to_bankml(
     # 1. the subset — checked before anything expensive runs
     spec = ModelfileSpec(from_model="<merged>", system=system or "", parameters=dict(params or {}),
                          stop=list(stop or []))
-    checked = bankml_sanitize(spec)
+    checked = bankml_sanitize(spec, penalties=True)  # penalties are gated on the version below
     if not checked.ok:
         for r in checked.refusals:
             emit(f"[push-bankml] refuse: {r}")
@@ -315,6 +338,13 @@ def push_to_bankml(
         return done("bankml_too_old", bankml_version=caps.version, reason=(
             f"bankml {caps.version or '(unknown version)'} has no `{'`/`'.join(missing)}` verb "
             f"(they arrive in bankml 0.3.5); upgrade from {BANKML_URL}"))
+    asked = sorted(_PENALTY & set(spec.parameters))
+    if asked and not penalties_supported(caps.version):
+        refusals = tuple(_param_refusal(n) for n in asked)
+        for r in refusals:
+            emit(f"[push-bankml] refuse: {r}")
+        return done("refused", bankml_version=caps.version, refusals=refusals,
+                    reason=f"bankml {caps.version or '(unknown version)'} does not reproduce penalties")
     emit(f"[push-bankml] bankml {caps.version} at {caps.binary}")
 
     work = Path(work_dir) if work_dir else (
@@ -349,8 +379,9 @@ def push_to_bankml(
     gguf: Path | None = None
     model_sha = ""
     try:
-        # 4. optional explicit conversion
-        source = str(merged.resolve())
+        # 4. optional explicit conversion — through a link named after the tag, so the GGUF's
+        #    general.name (and so its bytes and sha256) is the one mindX pins
+        source = str(_named_source(merged, work / name, name))
         if convert:
             registry.mkdir(parents=True, exist_ok=True)
             gguf = registry / f"{name}-base-F16.gguf"
@@ -419,6 +450,21 @@ def push_to_bankml(
                 mindx_fallback_swap=swap)
 
 
+def _named_source(merged: Path, at: Path, name: str) -> Path:
+    """A link `at/<name>` → `merged`, unless `merged` is already called `name`."""
+    target = merged.resolve()
+    if target.name == name:
+        return target
+    at.mkdir(parents=True, exist_ok=True)
+    link = at / name
+    if link.is_symlink():
+        link.unlink()
+    elif link.exists():
+        return link  # a real directory by that name: the caller put it there
+    link.symlink_to(target, target_is_directory=True)
+    return link
+
+
 def _last_line(text: str) -> str:
     rows = [r.strip() for r in text.strip().splitlines() if r.strip()]
     return rows[-1] if rows else ""
@@ -427,6 +473,7 @@ def _last_line(text: str) -> str:
 __all__ = [
     "BANKML_CONVERT_ARCHS",
     "BANKML_PARAMS",
+    "PENALTIES_SINCE",
     "BankmlCapabilities",
     "BankmlPushResult",
     "BankmlSanitizeResult",
@@ -435,5 +482,7 @@ __all__ = [
     "bankml_sanitize",
     "base_family_refusal",
     "check_merged_arch",
+    "penalties_supported",
     "push_to_bankml",
+    "version_tuple",
 ]

mindxtrain/eval/llama_evals.py

@@ -24,6 +24,16 @@ _CHOICE_RE = re.compile(r"\b(A|B|TIE)\b", re.IGNORECASE)
 _DEFAULT_JUDGE = "llama3.2"
 
 
+def default_judge_model() -> str:
+    """`MINDXTRAIN_JUDGE_MODEL`, else the panel's chat model, else llama3.2 — read at call
+    time so a bankml node judges with a model it actually serves."""
+    import os
+
+    from mindxtrain.governance.panel import default_chat_model
+
+    return os.environ.get("MINDXTRAIN_JUDGE_MODEL") or default_chat_model()
+
+
 class EvalScore(BaseModel):
     """A single evaluation result, score normalized to [0, 1]."""
 
@@ -79,8 +89,8 @@ class SemanticSimilarityEvaluator:
 class CorrectnessEvaluator:
     """LLM-as-judge: is RESPONSE correct/faithful vs REFERENCE for the QUERY?"""
 
-    def __init__(self, model: str = _DEFAULT_JUDGE, base_url: str | None = None, threshold: float = 0.6) -> None:
-        self.model, self.base_url, self.threshold = model, base_url, threshold
+    def __init__(self, model: str | None = None, base_url: str | None = None, threshold: float = 0.6) -> None:
+        self.model, self.base_url, self.threshold = model or default_judge_model(), base_url, threshold
 
     def evaluate(self, query: str, response: str, reference: str) -> EvalScore:
         system = (
@@ -97,8 +107,8 @@ class CorrectnessEvaluator:
 class PairwiseEvaluator:
     """Which of two responses better matches the persona/reference? B (after) vs A (before)."""
 
-    def __init__(self, model: str = _DEFAULT_JUDGE, base_url: str | None = None) -> None:
-        self.model, self.base_url = model, base_url
+    def __init__(self, model: str | None = None, base_url: str | None = None) -> None:
+        self.model, self.base_url = model or default_judge_model(), base_url
 
     def evaluate(self, query: str, response_a: str, response_b: str, *, reference: str = "") -> EvalScore:
         ref = f" The target voice/reference is: {reference}." if reference else ""
@@ -131,8 +141,8 @@ class PairwiseEvaluator:
 class GuidelineEvaluator:
     """LLM-as-judge: does RESPONSE comply with the GUIDELINES/rubric?"""
 
-    def __init__(self, model: str = _DEFAULT_JUDGE, base_url: str | None = None, threshold: float = 0.6) -> None:
-        self.model, self.base_url, self.threshold = model, base_url, threshold
+    def __init__(self, model: str | None = None, base_url: str | None = None, threshold: float = 0.6) -> None:
+        self.model, self.base_url, self.threshold = model or default_judge_model(), base_url, threshold
 
     def evaluate(self, response: str, guidelines: str) -> EvalScore:
         system = (

mindxtrain/governance/classroom.py

@@ -100,7 +100,7 @@ def evaluate_classroom(
 
     # Pairwise: judge each inquiry (before vs after) toward the persona, else use the
     # imprint delta sign as the signal.
-    if use_judge and model:
+    if use_judge:  # no model named → MINDXTRAIN_JUDGE_MODEL / MINDXTRAIN_CHAT_MODEL / llama3.2
         from mindxtrain.eval.llama_evals import PairwiseEvaluator
 
         ev = PairwiseEvaluator(model=model, base_url=base_url)

mindxtrain/governance/panel.py

@@ -12,6 +12,7 @@ or is recorded as a reject (dojo, which forbids abstention). Pure stdlib + httpx
 
 from __future__ import annotations
 
+import json
 import os
 import re
 from collections.abc import Callable
@@ -33,6 +34,31 @@ ROLE_STANCE: dict[Role, str] = {
 }
 
 _DEFAULT_MODEL = "llama3.2"
+
+
+def default_chat_model() -> str:
+    """The model a member or judge uses when none is named: `MINDXTRAIN_CHAT_MODEL`, else
+    llama3.2. Read at call time, so a node pointed at bankml (which serves no llama3.2)
+    names its own model without a code change."""
+    return os.environ.get("MINDXTRAIN_CHAT_MODEL") or _DEFAULT_MODEL
+
+
+def chat_options() -> dict[str, object]:
+    """Extra sampling fields for every chat body, from `MINDXTRAIN_CHAT_OPTIONS` (a JSON
+    object), e.g. `{"repeat_penalty": 1.3}` for a small generation on bankml 0.3.6+. Empty
+    when unset: a server that refuses fields it does not know is never sent any."""
+    raw = os.environ.get("MINDXTRAIN_CHAT_OPTIONS")
+    if not raw:
+        return {}
+    try:
+        val = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        msg = f"MINDXTRAIN_CHAT_OPTIONS is not JSON: {exc}"
+        raise ValueError(msg) from exc
+    if not isinstance(val, dict):
+        msg = "MINDXTRAIN_CHAT_OPTIONS must be a JSON object"
+        raise ValueError(msg)
+    return val
 _VERDICT_RE = re.compile(r"verdict\s*[:\-]?\s*(approve|reject|abstain)", re.IGNORECASE)
 
 
@@ -71,8 +97,12 @@ def chat_once(
     temperature: float = 0.0,
     max_tokens: int = 256,
     timeout_s: float = 60.0,
+    options: dict[str, object] | None = None,
 ) -> str:
-    """One non-streaming OpenAI-compatible chat completion; returns the content."""
+    """One non-streaming OpenAI-compatible chat completion; returns the content.
+
+    `options` (else `MINDXTRAIN_CHAT_OPTIONS`) adds sampling fields beyond OpenAI's — bankml
+    0.3.6+ honours `repeat_penalty`, `repeat_last_n`, `presence_penalty`, `frequency_penalty`."""
     base = resolve_chat_base_url(base_url)
     key = api_key or os.environ.get("MINDXTRAIN_OPENAI_API_KEY", "")
     headers = {"Content-Type": "application/json"}
@@ -82,6 +112,7 @@ def chat_once(
         resp = client.post(
             f"{base}/chat/completions",
             json={
+                **(chat_options() if options is None else options),
                 "model": model,
                 "messages": messages,
                 "temperature": temperature,
@@ -132,7 +163,7 @@ def deliberate(
     *,
     base_url: str | None = None,
     allow_abstain: bool = True,
-    default_model: str = _DEFAULT_MODEL,
+    default_model: str | None = None,
     **chat_kw: object,
 ) -> Deliberation:
     """Query `member`'s model from its role stance and parse a vote + rationale."""
@@ -143,7 +174,7 @@ def deliberate(
         f"motion. {stance} Give a one-sentence rationale, then on the final line write "
         f"exactly 'VERDICT: <{verdicts}>'."
     )
-    model = member.model or default_model
+    model = member.model or default_model or default_chat_model()
     # Reasoning ("thinking") models spend tokens before the verdict — give enough
     # room and time by default so the `VERDICT:` line is actually reached (concurrent
     # members also queue inside a single-GPU backend). Callers can override.
@@ -168,7 +199,7 @@ def deliberate(
 
 
 def model_ballot(
-    *, base_url: str | None = None, default_model: str = _DEFAULT_MODEL, **chat_kw: object,
+    *, base_url: str | None = None, default_model: str | None = None, **chat_kw: object,
 ) -> Callable[[Member, str], Vote]:
     """A boardroom ballot backed by real models (members may abstain)."""
 
@@ -182,7 +213,7 @@ def model_ballot(
 
 
 def model_judge_ballot(
-    *, base_url: str | None = None, default_model: str = _DEFAULT_MODEL, **chat_kw: object,
+    *, base_url: str | None = None, default_model: str | None = None, **chat_kw: object,
 ) -> Callable[[Member, str], JudgeVote]:
     """A dojo ballot backed by real models (judges must approve/reject)."""
 
@@ -200,6 +231,8 @@ __all__ = [
     "ROLE_STANCE",
     "Deliberation",
     "chat_once",
+    "chat_options",
+    "default_chat_model",
     "deliberate",
     "model_ballot",
     "model_judge_ballot",

mindxtrain/operator/backends/bankml.py

@@ -13,12 +13,19 @@ What this backend adds over `openai_compat`:
   in `ChatResponse.receipt`; streamed it arrives as one extra `data: {"bankml_receipt": ...}`
   event before `data: [DONE]`. Either way the latest receipt is also kept on `last_receipt`.
 - **Refusals are typed, never retried.** bankml answers HTTP 400 with a plain-text reason when a
-  request asks for something its verified forward pass does not reproduce (repeat / presence /
-  frequency penalties, mirostat, typical_p, tools, an unknown architecture, Q8_0 / Q4_K / BF16).
+  request asks for something its verified forward pass does not reproduce (penalties before
+  0.3.6, mirostat, typical_p, tools, an unknown architecture, Q8_0 / Q4_K / BF16).
   That becomes `BankmlRefusal(reason)`. The request is never re-sent with altered parameters:
   a changed request would be a different, unreceipted question.
 
-Env: `MINDXTRAIN_BANKML_BASE_URL` (default `http://127.0.0.1:18093/v1`).
+- **Sampling options, only when set.** bankml 0.3.6 reproduces `repeat_penalty`,
+  `repeat_last_n`, `presence_penalty` and `frequency_penalty` as llama-server b11192 does; a
+  small generation (mindx-genN) needs `repeat_penalty` to answer in words. They are sent from
+  `options=` or `MINDXTRAIN_BANKML_OPTIONS`, never by default, so an older bankml is never sent
+  a field it refuses.
+
+Env: `MINDXTRAIN_BANKML_BASE_URL` (default `http://127.0.0.1:18093/v1`),
+`MINDXTRAIN_BANKML_OPTIONS` (a JSON object, e.g. `{"repeat_penalty": 1.3}`).
 """
 
 from __future__ import annotations
@@ -91,6 +98,17 @@ def raise_for_bankml(resp: httpx.Response) -> None:
         raise BankmlError(refusal_reason(resp), resp.status_code)
 
 
+def _env_options() -> dict[str, object]:
+    raw = os.environ.get("MINDXTRAIN_BANKML_OPTIONS")
+    if not raw:
+        return {}
+    val = json.loads(raw)
+    if not isinstance(val, dict):
+        msg = "MINDXTRAIN_BANKML_OPTIONS must be a JSON object"
+        raise ValueError(msg)
+    return val
+
+
 @register_backend("bankml")
 class BankmlBackend(OpenAICompatBackend):
     """OpenAI-compatible client for `bankml serve --native`, keeping receipts and refusals."""
@@ -103,12 +121,16 @@ class BankmlBackend(OpenAICompatBackend):
         timeout_s: float = 300.0,
         *,
         seed: int | None = None,
+        options: dict[str, object] | None = None,
         transport: httpx.AsyncBaseTransport | None = None,
     ) -> None:
         super().__init__(base_url=base_url or bankml_base_url(), api_key=None, timeout_s=timeout_s)
         # `api_key or env` in the parent would pick up an OpenAI key; bankml is loopback, keyless.
         self.api_key = ""
         self.seed = seed
+        # Sampling fields beyond OpenAI's that bankml honours (repeat_penalty & co. from 0.3.6),
+        # sent only when set: from MINDXTRAIN_BANKML_OPTIONS (a JSON object), then `options`.
+        self.options: dict[str, object] = {**_env_options(), **(options or {})}
         self._transport = transport
         self.last_receipt: dict[str, Any] | None = None
 
@@ -116,7 +138,7 @@ class BankmlBackend(OpenAICompatBackend):
         return httpx.AsyncClient(timeout=self.timeout_s, transport=self._transport)
 
     def _payload(self, request: ChatRequest, *, stream: bool) -> dict[str, object]:
-        payload = super()._payload(request, stream=stream)
+        payload = {**self.options, **super()._payload(request, stream=stream)}
         if self.seed is not None:
             payload["seed"] = self.seed
         return payload

tests/test_bankml_extras.py

@@ -0,0 +1,114 @@
+"""bankml 0.3.6 on top of PR #1: sampling options, the chat/judge models a bankml node names,
+and the serve flags that layer a persona and its parameters."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+
+import httpx
+import pytest
+
+from mindxtrain.models.registry import ChatMessage, ChatRequest
+from mindxtrain.operator.backends.bankml import BankmlBackend
+
+_ENV = ("MINDXTRAIN_CHAT_MODEL", "MINDXTRAIN_JUDGE_MODEL", "MINDXTRAIN_CHAT_OPTIONS",
+        "MINDXTRAIN_BANKML_OPTIONS")
+
+
+@pytest.fixture(autouse=True)
+def _clean_env(monkeypatch: pytest.MonkeyPatch) -> None:
+    for k in _ENV:
+        monkeypatch.delenv(k, raising=False)
+
+
+def _backend(seen: list[dict[str, object]], **kw: object) -> BankmlBackend:
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen.append(json.loads(request.content))
+        return httpx.Response(200, json={
+            "model": "mindx-gen39", "choices": [{"message": {"content": "I am mindX."}, "finish_reason": "stop"}],
+            "usage": {"prompt_tokens": 9, "completion_tokens": 4},
+            "bankml_receipt": {"model_sha256": "6b64c748"},
+        })
+
+    return BankmlBackend(transport=httpx.MockTransport(handler), **kw)  # type: ignore[arg-type]
+
+
+def _ask(b: BankmlBackend) -> None:
+    asyncio.run(b.chat(ChatRequest(model="mindx-gen39", messages=[ChatMessage(role="user", content="hi")],
+                                   max_tokens=16)))
+
+
+def test_backend_sends_options_only_when_set(monkeypatch: pytest.MonkeyPatch) -> None:
+    seen: list[dict[str, object]] = []
+    _ask(_backend(seen))
+    assert not {"repeat_penalty", "repeat_last_n"} & set(seen[0])
+    monkeypatch.setenv("MINDXTRAIN_BANKML_OPTIONS", '{"repeat_penalty": 1.3, "repeat_last_n": 64}')
+    _ask(_backend(seen, options={"repeat_last_n": 32}))
+    assert seen[1]["repeat_penalty"] == 1.3 and seen[1]["repeat_last_n"] == 32   # ctor over env
+    assert seen[1]["model"] == "mindx-gen39" and seen[1]["max_tokens"] == 16      # request wins
+
+
+def test_backend_options_must_be_an_object(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("MINDXTRAIN_BANKML_OPTIONS", "[1.3]")
+    with pytest.raises(ValueError, match="JSON object"):
+        BankmlBackend()
+
+
+def test_chat_and_judge_models_follow_env(monkeypatch: pytest.MonkeyPatch) -> None:
+    from mindxtrain.eval.llama_evals import (
+        CorrectnessEvaluator,
+        PairwiseEvaluator,
+        default_judge_model,
+    )
+    from mindxtrain.governance.panel import default_chat_model
+
+    assert default_chat_model() == "llama3.2" and default_judge_model() == "llama3.2"
+    monkeypatch.setenv("MINDXTRAIN_CHAT_MODEL", "bonsai-8b-q1_0")
+    assert default_judge_model() == "bonsai-8b-q1_0"                    # judges follow the chat model
+    monkeypatch.setenv("MINDXTRAIN_JUDGE_MODEL", "bonsai-1.7b")
+    assert CorrectnessEvaluator().model == "bonsai-1.7b"
+    assert PairwiseEvaluator(model="explicit").model == "explicit"
+
+
+def test_chat_once_options(monkeypatch: pytest.MonkeyPatch) -> None:
+    from mindxtrain.governance import panel
+
+    bodies: list[dict[str, object]] = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        bodies.append(json.loads(request.content))
+        return httpx.Response(200, json={"choices": [{"message": {"content": "VERDICT: APPROVE"}}]})
+
+    real = httpx.Client
+    monkeypatch.setattr(httpx, "Client", lambda **k: real(transport=httpx.MockTransport(handler), **k))
+    url = "http://127.0.0.1:18093/v1"
+    panel.chat_once("m", [{"role": "user", "content": "x"}], base_url=url)
+    monkeypatch.setenv("MINDXTRAIN_CHAT_OPTIONS", '{"repeat_penalty": 1.3}')
+    panel.chat_once("m", [{"role": "user", "content": "x"}], base_url=url)
+    panel.chat_once("m", [{"role": "user", "content": "x"}], base_url=url, options={})
+    assert "repeat_penalty" not in bodies[0] and bodies[1]["repeat_penalty"] == 1.3
+    assert "repeat_penalty" not in bodies[2]                             # explicit {} wins
+    monkeypatch.setenv("MINDXTRAIN_CHAT_OPTIONS", "nope")
+    with pytest.raises(ValueError, match="not JSON"):
+        panel.chat_options()
+
+
+def test_deliberate_uses_the_env_chat_model(monkeypatch: pytest.MonkeyPatch) -> None:
+    from mindxtrain.governance import panel
+    from mindxtrain.governance.boardroom import Member
+
+    asked: list[str] = []
+    monkeypatch.setattr(panel, "chat_once", lambda model, *a, **k: asked.append(model) or "VERDICT: APPROVE")
+    monkeypatch.setenv("MINDXTRAIN_CHAT_MODEL", "bonsai-8b-q1_0")
+    d = panel.deliberate(Member(id="m1", role="critic"), "ship it")
+    assert asked == ["bonsai-8b-q1_0"] and d.vote == "approve"
+
+
+def test_serve_param_parsing() -> None:
+    from mindxtrain.cli.main import _parse_params
+
+    assert _parse_params(["repeat_penalty=1.3", "num_ctx=2048", "seed=0"]) == {
+        "repeat_penalty": 1.3, "num_ctx": 2048, "seed": 0}
+    with pytest.raises(ValueError):
+        _parse_params(["repeat_penalty"])

tests/test_bankml_push.py

@@ -30,8 +30,10 @@ USAGE_034 = "usage: bankml usage [PID …]\n       bankml serve FILE --fork FORK
 class FakeBankml:
     """Records argv; answers `version`, `--help`, `convert`, `create`, `sha256` like bankml."""
 
-    def __init__(self, usage: str = USAGE_035, create_rc: int = 0, create_err: str = "") -> None:
+    def __init__(self, usage: str = USAGE_035, create_rc: int = 0, create_err: str = "",
+                 version: str = "0.3.5") -> None:
         self.calls: list[list[str]] = []
+        self.version = version
         self.usage = usage
         self.create_rc = create_rc
         self.create_err = create_err
@@ -41,7 +43,7 @@ class FakeBankml:
         self.calls.append(list(cmd))
         verb = cmd[1]
         if verb == "version":
-            return subprocess.CompletedProcess(cmd, 0, "bankml 0.3.5\n", "")
+            return subprocess.CompletedProcess(cmd, 0, f"bankml {self.version}\n", "")
         if verb == "--help":
             return subprocess.CompletedProcess(cmd, 1, "", self.usage)
         if verb == "convert":
@@ -172,7 +174,9 @@ def test_push_from_merged_dir(fake: FakeBankml, tmp_path: Path) -> None:
     assert res.model_sha256 == SHA and res.digest == DIGEST
     create = next(c for c in fake.calls if c[1] == "create")
     assert create[2] == "mindx-gen99" and "--registry" in create
-    assert fake.modelfile_text.startswith(f"FROM {merged.resolve()}")
+    # converted through a link named after the tag: the GGUF's general.name is "Mindx Gen99"
+    link = tmp_path / "work" / "mindx-gen99" / "mindx-gen99"
+    assert fake.modelfile_text.startswith(f"FROM {link}\n") and link.resolve() == merged.resolve()
     assert 'SYSTEM """You are mindX."""' in fake.modelfile_text
     assert "repeat_penalty" not in fake.modelfile_text
 
@@ -188,12 +192,44 @@ def test_push_with_convert_first(fake: FakeBankml, tmp_path: Path) -> None:
 
 def test_refused_params_never_reach_bankml(fake: FakeBankml, tmp_path: Path) -> None:
     res = BP.push_to_bankml("b", "t", merged_dir=_merged(tmp_path),
-                            params={"repeat_penalty": 1.3, "temperature": 0.7})
+                            params={"mirostat": 2, "temperature": 0.7})
     assert res.status == "refused"
-    assert any("repeat_penalty" in r for r in res.refusals)
+    assert any("mirostat" in r for r in res.refusals)
     assert fake.calls == []  # refused before even probing the binary
 
 
+def test_penalties_refused_before_0_3_6(fake: FakeBankml, tmp_path: Path) -> None:
+    res = BP.push_to_bankml("b", "t", merged_dir=_merged(tmp_path),
+                            params={"repeat_penalty": 1.3, "temperature": 0.7})
+    assert res.status == "refused" and res.bankml_version == "0.3.5"
+    assert any("repeat_penalty" in r and "0.3.6" in r for r in res.refusals)
+    assert not any(c[1] in ("create", "convert") for c in fake.calls)
+
+
+def test_penalties_taken_from_0_3_6(fake: FakeBankml, tmp_path: Path) -> None:
+    fake.version = "0.3.6"
+    res = BP.push_to_bankml("b", "mindx-gen99", merged_dir=_merged(tmp_path), work_dir=tmp_path / "w",
+                            params={"repeat_penalty": 1.3, "num_ctx": 2048}, stop=["<|im_end|>"])
+    assert res.ok, res
+    assert "PARAMETER repeat_penalty 1.3" in fake.modelfile_text
+
+
+def test_version_gate() -> None:
+    assert BP.penalties_supported("0.3.6") and BP.penalties_supported("0.4.0")
+    assert not BP.penalties_supported("0.3.5") and not BP.penalties_supported("")
+    assert BP.bankml_sanitize(ModelfileSpec(from_model="x", parameters={"repeat_penalty": 1.3})).refusals
+    assert BP.bankml_sanitize(ModelfileSpec(from_model="x", parameters={"repeat_penalty": 1.3}),
+                              penalties=True).ok
+
+
+def test_merged_dir_already_named_after_the_tag_is_used_as_is(fake: FakeBankml, tmp_path: Path) -> None:
+    merged = tmp_path / "mindx-gen99"
+    merged.mkdir()
+    (merged / "config.json").write_text(json.dumps({"architectures": ["LlamaForCausalLM"]}))
+    res = BP.push_to_bankml("b", "mindx-gen99", merged_dir=merged, work_dir=tmp_path / "w")
+    assert res.ok and fake.modelfile_text.startswith(f"FROM {merged.resolve()}\n")
+
+
 def test_non_llama_merged_dir_refused(fake: FakeBankml, tmp_path: Path) -> None:
     res = BP.push_to_bankml("b", "t", merged_dir=_merged(tmp_path, "Qwen3ForCausalLM"))
     assert res.status == "refused" and "Llama-architecture" in res.reason