diff --git a/.gitignore b/.gitignore
index 0a0228b..4a2d623 100644
--- a/.gitignore
+++ b/.gitignore
@@ -27,6 +27,26 @@ build/
 *.log
 transcripts/
 outputs/
+config/machine.toml
+docs/downstream/
+docs/**/artifacts/
+
+# Local telemetry / runtime artifacts
+telemetry/
+**/telemetry/
+models/**/config/logs/
+*.jsonl
+*session*.json
+*session*.jsonl
+
+# Machine-local config files
+config.local.toml
+config.local.json
+*.local.toml
+*.local.json
+machine.toml
+machine.json
+models/**/config/config.json
 
 # Model files (keep weights out of git if they ever land here)
 *.safetensors
@@ -43,10 +63,17 @@ models/**
 !models/**/notes/**
 !models/**/config/**
 !models/**/templates/**
+# Re-ignore machine/runtime artifacts inside otherwise allowed config trees
+models/**/config/config.json
+models/**/config/logs/**
+models/**/config/telemetry/**
+models/**/config/**/*.jsonl
+models/**/config/**/*session*.json
+models/**/config/**/*session*.jsonl
 # Never commit prompts (may contain secrets)
 models/**/prompts/**
 !models/**/prompts/README.md
 
 
 alex.jinja
-*character/
\ No newline at end of file
+*character/
diff --git a/AGENTS.md b/AGENTS.md
index 4548ee2..9029921 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,31 +1,136 @@
 # AGENTS
 
 ## Purpose
-This repository hosts lightweight local model runners for multiple backends:
-- Hugging Face causal language models (`transformers` + `torch`)
-- GGUF models (`llama-cpp-python`)
-- Ollama API models (streaming wrapper)
+This repo is a local model lab for:
+- local model research
+- runtime tuning and backend comparison
+- agent and application experimentation
+- model-specific notes/config/template management
+
+It spans both:
+- inference/runtime engineering
+- AI application and agent development testing
+
+Treat it as a practical research workspace, not just a terminal chat app.
+
+Primary goals:
+- run lots of local models consistently across multiple backends
+- make runtime behavior visible enough to learn from and compare
+- keep model-specific knowledge in-repo next to the configs/templates that matter
+- make backend experimentation fast, local, and repeatable
+
+## Priority Order
+When making engineering tradeoffs, prefer:
+1. runtime truth and observability
+2. comparable behavior across backends
+3. local-first experimentation speed
+4. enjoyable interaction surfaces
+
+If a UX summary conflicts with backend truth, fix the summary instead of hiding the truth.
 
 ## Scope
-- Keep the project small and practical.
-- Prioritize simple CLI flows for loading models and chatting.
-- Prefer local-first execution with PyTorch + Transformers.
+- Keep the project practical and easy to navigate.
+- Favor local-first execution; avoid unnecessary services.
+- Preserve backend diversity instead of forcing one engine to define the whole repo.
+- Prefer standardized reporting where possible, but do not flatten away backend-specific facts that matter for tuning.
+- Notes-first workflow: document behavior before changing code when possible.
+
+## Repo Operating Model
+This repo uses two complementary document types:
+
+- **Decision records**
+  - capture contracts, invariants, and repo-wide rules discovered or established over time
+  - define what future work must preserve unless the decision itself is intentionally revised
+  - should be treated as contributor-facing truth, not as optional historical commentary
+  - live under `docs/decisions/`
+
+- **Specs**
+  - describe a concrete implementation pass
+  - turn a direction into executable engineering work
+  - should follow existing decision records instead of silently redefining them
+  - live under `docs/specs/`
+
+Contributor rule of thumb:
+- check decision records when you need to know what must remain true
+- check specs when you need to know what to build next
+- if a coding pass reveals a new invariant or repo-wide contract, write it down as a decision instead of leaving it implicit in the codebase
+
+Do not treat chat history as the source of truth when a decision or spec should exist in-repo.
+
+## Shallow Map
+Use this as the repo’s first-pass navigation graph. Start narrow and only drill deeper when the task requires it.
+
+- `README.md`
+  - front door: repo identity, current state, direction, major entry points
+- `docs/decisions/`
+  - contracts and invariants that future work is expected to preserve
+- `docs/specs/`
+  - implementation passes and scoped engineering instructions
+- `docs/observability_dashboard`
+  - current north-star document for the lab/observability direction
+- `docs/entrypoints.md`
+  - practical command/entrypoint map
+- `tui.py`
+  - top-level CLI/parser and current main control surface
+- `tui_app/app.py`
+  - TUI behavior, slash commands, transcript rendering, `/show` surfaces
+- `tui_app/backends/`
+  - backend-specific runtime implementations
+- `tui_app/transports/`
+  - shared protocol/client logic, especially OpenAI-compatible transport behavior
+- `models/<model>/<backend>/`
+  - model-first working area for notes, config, templates, prompts
+
+When orienting to a task:
+- start with the smallest canonical document or module that explains the behavior
+- prefer the model/backend-specific folder before searching the whole repo
+- prefer decisions/specs over reverse-engineering behavior from scattered code when documentation exists
+
+## Current UX Posture
+- The Textual TUI is a valid current control surface.
+- The TUI is not the final observability or optimization product.
+- Work that improves browser/dashboard-oriented observability is aligned with repo direction.
+- Terminal UX should remain useful, but new designs should not assume the TUI is the only long-term interface.
 
 ## Current Entry Points
-- `runner.py`: minimal interactive text generation runner.
-- `chat.py`: template-aware chat loop with conversation history.
-- `alex.py`: GGUF chat runner via `llama-cpp-python`.
-- `ollama_chat.py`: Ollama API wrapper with optional reasoning filtering.
+- **Unified TUI (current interaction surface):**
+  - `tui.py`: multi-backend Textual TUI
+  - `tui_app/`: internal package used by `tui.py` (don’t run directly)
+
+- **Managed backend control:**
+  - `vllm-up`, `vllm-down`, related repo helpers for managed vLLM bring-up
+
+- **Simple non-TUI CLIs (good for isolation/debug):**
+  - `chat.py`: HF/Transformers chat loop
+  - `runner.py`: minimal HF prompt -> completion loop
+  - `alex.py`: GGUF chat loop
+  - `ollama_chat.py`: Ollama streaming CLI
 
 ## Conventions
-- Default to straightforward Python scripts over heavy framework structure.
-- Keep dependencies minimal and rely on the existing `.venv`.
-- Favor clear failure messages when CUDA/model loading is unavailable.
-- Keep backend-specific logic separated instead of overloading one script.
+- Prefer straightforward Python and small modules; avoid heavy frameworks unless they materially improve the lab.
+- Keep backend-specific logic under `tui_app/backends/` and shared protocol logic under `tui_app/transports/` when applicable.
+- Preserve consistent event behavior across backends:
+  - `TurnStart`, `ThinkDelta`, `AnswerDelta`, `Meta`, `Error`, `Finish`
+  - thinking routing via `ThinkRouter` and `assume_think`
+  - `/show` surfaces for effective/requested state when available
+  - `/show logs` via a per-session ring buffer
+- Prefer runtime facts over intent-only displays.
+- Distinguish clearly between:
+  - requested/configured values
+  - effective/runtime values
+  - unknown/unavailable values
+- Standardize the UX shape where possible, but do not invent precision the backend cannot actually provide.
+- Favor clear failure messages when CUDA/model loading/runtime support is unavailable.
+- When backend behavior is discovered during debugging, prefer capturing it in notes, a decision record, or a spec instead of relying on memory.
 
 ## Usage
-Run:
+Recommended:
+```bash
+python tui.py <model> [backend_hint]
+python tui.py --config <model_name> --backend <hf|gguf|ollama|exl2|openai|vllm> [--profile <name>]
+```
 
+Legacy/simple:
 ```bash
 python runner.py <hf_model_or_local_path>
 python chat.py <hf_model_or_local_path>
@@ -33,4 +138,27 @@ python alex.py <path_to_model.gguf>
 python ollama_chat.py <ollama_model_name>
 ```
 
-Type prompts at `>` and type `exit` or `quit` to end.
+## Repo Layout (model-first)
+- Model assets live under `models/<model>/<backend>/`:
+  - `notes/` for repo-local notes and upstream model cards
+  - `config/default.toml` and `config/profiles/*.toml`
+  - `templates/` for template overrides
+  - `prompts/` for prompt/system assets
+
+Use:
+```bash
+python scripts/model add <model> <backend> [--id <backend_id>]
+```
+to scaffold new folders.
+
+## Direction
+The repo is moving toward a stronger local observability story:
+- better backend/runtime truth surfaces
+- better comparison across engines
+- browser/dashboard-oriented metrics and visualization
+- a more complete local model lab feel
+
+The observability direction already has a home in:
+- `docs/observability_dashboard`
+
+Keep that direction in mind when making UX or architecture decisions.
diff --git a/README.md b/README.md
index 82b8a08..500461b 100644
--- a/README.md
+++ b/README.md
@@ -1,80 +1,181 @@
 # model-runner
 
-Lightweight local model runner scripts for:
-- Hugging Face text/chat models (`transformers` + `torch`)
-- GGUF models via `llama-cpp-python`
-- Ollama models via HTTP API with optional reasoning-filtered output
-- EXL2 models via ExLlamaV2 (unified TUI backend)
+`model-runner` is a local model lab: a practical workspace for running local models, comparing backends, tuning inference, and testing agent/application behavior without leaving a local-first environment.
 
-## User Guide
+This repo spans two overlapping jobs:
+- runtime and backend engineering
+- AI application, agent, and prompt experimentation
 
-### 1) Setup
+It is intentionally broad. It contains useful tooling, model-specific notes/configs/templates, backend adapters, and a growing observability direction for understanding what models are actually doing at runtime.
 
-Use the existing virtual env in this repo:
+## What This Repo Is
 
+This project is for local model research and tinkering:
+- run the same model across multiple backends
+- compare runtime behavior instead of guessing
+- keep model-specific notes, configs, templates, and prompts in-repo
+- test tool use, thinking behavior, context management, and backend quirks
+- build toward a real local observability and optimization workflow
+
+Supported runtime paths today include:
+- Hugging Face / `transformers` + `torch`
+- GGUF via `llama-cpp-python`
+- Ollama via HTTP
+- EXL2 via ExLlamaV2
+- OpenAI-compatible servers
+- managed vLLM
+
+## Current State
+
+This repo is already useful, but uneven.
+
+What exists now:
+- a multi-backend Textual TUI for local interaction and debugging
+- simple CLI entrypoints for isolated backend checks
+- model-first config/notes/templates layout under `models/`
+- a lot of backend standardization work around prompts, knobs, history, logging, token accounting, and tool calls
+
+What is still rough:
+- the TUI is a workable control surface, but not a polished observability product
+- backend comparison is possible, but not yet clean or visual enough for serious runtime learning
+- some runtime truths are still too hard to surface quickly
+
+If you want to just chat with models, the current tooling works.
+If you want to learn how backends really behave, optimize them, and compare them with confidence, the repo still needs a stronger observability layer.
+
+## Layout Philosophy
+
+This repo remains model-first for authored metadata, but machine assets now live outside the repo.
+
+- repo `models/` = config, notes, prompts, templates, compressor recipes
+- `~/models` = actual weights and quantized artifacts
+- `~/data/model-runner` = durable input datasets
+- `~/runs/model-runner` = telemetry, transcripts, logs, outputs, state
+
+Runtime artifacts should use logical run paths, not repo-path mirroring:
+
+- `~/runs/model-runner/logs/<backend>/<model>/<slot>/`
+- `~/runs/model-runner/state/<backend>/<model>/<slot>/`
+- `~/runs/model-runner/outputs/`
+- `~/runs/model-runner/telemetry/`
+- `~/runs/model-runner/transcripts/`
+
+See:
+- [docs/reference/local-layout.md](/home/poop/code/dev/model-runner/docs/reference/local-layout.md)
+
+## Direction
+
+The direction is a **local model lab**, not “just a TUI.”
+
+That means:
+- keep local-first model execution
+- preserve backend diversity instead of collapsing everything into one engine
+- make runtime behavior visible and measurable
+- make tuning and comparison enjoyable, not forensic
+- move toward a browser-based observability and control surface for metrics, backend state, cache growth, memory behavior, and experiment comparison
+
+The existing observability direction is captured in:
+- [docs/observability_dashboard](/home/poop/ml/model-runner/docs/observability_dashboard)
+
+The current TUI should be thought of as:
+- a current interaction surface
+- a useful backend bring-up tool
+- not the final home for optimization, inspection, and comparison UX
+
+## Entry Points
+
+### Current control surface: unified TUI
+
+Use `tui.py` when you want a terminal UI for chat, streaming, thinking display, slash-command inspection, or fast backend switching.
+
+Recommended environment setup:
 ```bash
-source .venv/bin/activate
-pip install -r requirements.txt
+uv sync --python 3.12
 ```
 
-Optional (recommended): install a console entrypoint for the unified TUI:
+Optional backend groups:
 ```bash
-pip install -e .
+uv pip install --python .venv/bin/python exllamav2
+uv pip install --python .venv/bin/python llama-cpp-python
 ```
 
-Optional GGUF support:
+Why the setup is serving-first:
+- the main repo environment is anchored on `vllm>=0.18`
+- the current Fedora target environment is a manual `uv` venv built around Python `3.12`, `vllm 0.18.0`, `torch 2.10.0+cu130`, `transformers 5.3.0`, and `huggingface_hub 1.7.2`
+- managed repo launchers prepend the repo-local Torch and NVIDIA runtime libraries automatically so `./vllm-up` works without shell-level `LD_LIBRARY_PATH` setup
+- released `llmcompressor` builds are currently incompatible with `vllm 0.18.x`, so compression is not part of the main sync
 
+Examples:
 ```bash
-pip install llama-cpp-python
+.venv/bin/python tui.py Nanbeige4.1-3B
+.venv/bin/python tui.py --config Qwen3.5-9B --backend vllm
+.venv/bin/python -m vllm.entrypoints.cli.main serve --help
 ```
 
-Optional EXL2 support:
+### Backend bring-up: managed vLLM helpers
 
-- See `docs/exl2_setup.md`
+Use the helper commands when you want repo-configured managed vLLM without entering the TUI:
 
-### 2) Scripts and What They Do
+```bash
+./vllm-up --config Qwen3.5-9B
+./vllm-up --config Qwen3.5-9B --bg
+./vllm-down --config Qwen3.5-9B
+```
 
-- `runner.py`
-  - Simple prompt loop for text generation.
-  - Optional token streaming with `--stream`.
-  - Supports `-8bit` / `-4bit` (bitsandbytes) on CUDA.
-  - Best for non-chat generation tests.
+### Isolation/debug CLIs
 
-- `chat.py`
-  - Chat loop with conversation history.
-  - Uses tokenizer native chat template by default.
-  - Optional `--prompt-mode plain` for minimal role-formatted prompting (no chat template).
-  - Decodes assistant-only new tokens.
-  - Optional token streaming with `--stream`.
-  - Supports precision selection via `--dtype`.
-  - Default `--max-new-tokens` is `2048`.
-  - Supports `-8bit` / `-4bit` (CUDA only).
+Use these when you want simpler, backend-specific loops:
 
+- `runner.py`
+  - minimal HF prompt -> completion
+- `chat.py`
+  - template-aware HF chat loop
+- `alex.py`
+  - GGUF chat via `llama-cpp-python`
+- `ollama_chat.py`
+  - Ollama streaming chat loop
 - `tui_chat.py`
-  - Legacy Textual TUI for HF chat.
-  - Kept as migration reference.
+  - older HF-only Textual TUI kept as reference/debug aid
 
-- `tui.py`
-  - Unified Textual TUI entrypoint for HF, GGUF, Ollama, and EXL2.
-  - Auto-detects backend from `model_id` or accepts `--backend`.
-  - Bottom grey input band with scrollable transcript above.
-  - Collapsible streaming thinking section per assistant turn.
-  - Hides `<think>` markers while routing inner content to a grey “thinking” panel.
-  - Optional `--assume-think` / `--no-assume-think` for models that emit only end-think markers.
+More detail lives in:
+- [docs/entrypoints.md](/home/poop/ml/model-runner/docs/entrypoints.md)
 
-- `alex.py`
-  - GGUF chat runner via `llama-cpp-python`.
-  - Accepts Windows or WSL paths.
-  - Best for direct `.gguf` testing without Ollama.
+## Model-First Workspace
 
-- `ollama_chat.py`
-  - Lightweight wrapper around Ollama `/api/chat`.
-  - Streams output and can hide reasoning blocks.
-  - Auto-detects Ollama host (`OLLAMA_HOST`, localhost, WSL gateway).
+The repo is organized around models first, then backends:
+
+- `models/<model>/<backend>/notes/`
+- `models/<model>/<backend>/config/`
+- `models/<model>/<backend>/templates/`
+- `models/<model>/<backend>/prompts/`
+
+That structure exists so research stays grounded:
+- notes next to configs
+- templates next to the model they affect
+- backend variants for the same model stay comparable
+
+To scaffold a new model folder:
+```bash
+python scripts/model add <model_name> <hf|gguf|ollama|exl2> [--id <backend_id>]
+```
 
-### 3) Common Commands
+## Setup
+
+Use the repo `uv` environment:
 
-Unified TUI (recommended):
+```bash
+uv sync --python 3.11
+```
+
+Optional backend extras:
+- GGUF: `uv sync --python 3.11 --group gguf`
+- EXL2: see [docs/exl2_setup.md](/home/poop/ml/model-runner/docs/exl2_setup.md)
+- EXL2 install: `uv sync --python 3.11 --group exl2`
+- Compression is currently out-of-band until a released `llmcompressor` version coexists with `vllm 0.18.x`
+
+## Common Commands
+
+Unified TUI:
 ```bash
 tui Nanbeige4.1-3B
 tui /mnt/d/models/your-model.gguf
@@ -82,15 +183,13 @@ tui ollama:your-ollama-model
 tui --backend exl2 /path/to/exl2_model_dir
 ```
 
-Hugging Face text run:
-
+HF text run:
 ```bash
 python runner.py Nanbeige4.1-3B
 python runner.py /home/poop/ml/models/Nanbeige4.1-3B -8bit
 ```
 
-Hugging Face chat run:
-
+HF chat run:
 ```bash
 python chat.py Nanbeige4.1-3B
 python chat.py Nanbeige4.1-3B --prompt-mode plain
@@ -98,126 +197,82 @@ python chat.py Nanbeige4.1-3B --dtype bfloat16
 python chat.py Nanbeige4.1-3B -4bit --dtype float16 --system "You are concise."
 ```
 
-Config-driven run (recommended):
-
+Config-driven run:
 ```bash
 python chat.py --config Nanbeige4.1-3B
 python chat.py --config models/Nanbeige4.1-3B/hf/config --max-new-tokens 1024
 python chat.py --config Nanbeige4.1-3B --stream
-python -m pip install -e .
-tui Nanbeige4.1-3B
-python tui.py Nanbeige4.1-3B
-python tui.py /mnt/d/models/your-model.gguf
-python tui.py /mnt/d/models/your-model.gguf --assume-think
-python tui.py ollama:your-ollama-model
-python tui.py ollama:your-ollama-model --backend ollama --ollama-think false
-python tui_chat.py --config Nanbeige4.1-3B
-python tui_chat.py --config Nanbeige4.1-3B --prompt-mode plain
 python runner.py --config Nanbeige4.1-3B
-```
-
-Template config:
-
-```bash
-mkdir -p models/MyModel/hf/config
-cp models/_TEMPLATE/hf/config/config.json models/MyModel/hf/config/config.json
+python tui.py --config Nanbeige4.1-3B --backend hf
 ```
 
 GGUF run:
-
 ```bash
 python alex.py "/mnt/d/models/your-model.gguf"
 ```
 
-Ollama API run:
-
+Ollama run:
 ```bash
 python ollama_chat.py "your-ollama-model" --think false
 python ollama_chat.py "your-ollama-model" --think false --strict-think-strip
 ```
 
-### 4) Path Notes
-
-- Bare names like `Nanbeige4.1-3B` auto-resolve to `~/ml/models/<name>` if present.
-- Windows paths are accepted by `chat.py`, `runner.py`, and `alex.py` and mapped to WSL style when possible.
-- In WSL, Windows drives are typically mounted under `/mnt/<drive-letter>/...`.
-
-### 5) Troubleshooting
-
-- `... is not a local folder and is not a valid model identifier`
-  - Use full local path or place model under `~/ml/models/<name>`.
-
-- Tokenizer conversion errors
-  - Ensure: `sentencepiece`, `tiktoken`, `protobuf` are installed.
-
-- PersonaPlex model fails in `runner.py`/`chat.py`
-  - Expected: PersonaPlex is speech-to-speech, not a text `AutoModelForCausalLM` checkpoint.
-
-- Ollama connection refused from WSL
-  - `ollama_chat.py` auto-detects host each run.
-  - If needed: `python ollama_chat.py "<model>" --host "http://<windows-ip>:11434"`.
-
 ## Configs
 
-- Config files live under `models/<model>/<backend>/config/`.
-- Current starter profile: `models/Nanbeige4.1-3B/hf/config/config.json`.
-- HF template profile: `models/_TEMPLATE/hf/config/config.json`.
+- Config files live under `models/<model>/<backend>/config/`
 - `--config` lookup supports:
   - direct file path
-  - path without `.json`
-  - directory containing `config.json` (e.g. `models/<model>/hf/config`)
-  - short name resolved under `models/<name>/<backend>/config/config.json` (e.g. `Nanbeige4.1-3B`)
+  - path without extension
+  - directory containing config
+  - short name resolved under `models/<name>/<backend>/config/`
 
 Precedence:
-
 1. CLI flags
 2. Config values
 3. Script defaults
 
-Selected HF knobs now exposed in CLI/config:
-
-- sampling: `temperature`, `top_p`, `top_k`, `typical_p`, `min_p`
-- output mode: `stream`
-- routing mode: `assume_think` (TUI)
-- length/termination: `max_new_tokens`, `max_time`, `stop_strings`
-- repetition/structure: `repetition_penalty`, `no_repeat_ngram_size`
-- decoding mode: `num_beams`
-- prompt control: `system`, `system_file`, `user_prefix`, `prompt_prefix`
-- template control (chat): `chat_template` (`default`, `search`, or template file path)
-- chat memory control: `max_context_tokens` (chat only)
-
-## Contributor Guide
-
-### Repo Structure
-
-- `runner.py`: baseline text generation flow.
-- `chat.py`: template-aware chat flow.
-- `tui.py` + `tui_app/`: unified Textual TUI + backend adapters.
-- `alex.py`: GGUF (`llama-cpp-python`) chat backend.
-- `ollama_chat.py`: Ollama HTTP streaming backend + filtering.
-- `models/`: model-first workspace for per-model config/notes/templates/prompts.
-- `docs/`: decisions/specs/audits for repo evolution.
-- `requirements.txt`: current `.venv` package lock-style snapshot.
-- `models/_shared/`: shared templates and prompt assets (organized by backend).
-
-### Design Constraints
-
-- Keep scripts simple and local-first.
-- Prefer explicit, readable CLI behavior over framework complexity.
-- Do not mix speech-model pipelines into text runners.
-- Keep error messages direct and actionable.
-
-### Development Workflow
-
-1. Edit one script at a time.
-2. Run syntax checks:
-   - `python -m py_compile runner.py chat.py tui.py tui_chat.py alex.py ollama_chat.py`
-3. Validate script help output:
-   - `python <script>.py --help`
-4. Smoke-test with one known model per backend.
-
-### Extension Ideas
-
-- Add `Modelfile` parser support in `ollama_chat.py` for template/prefix parity.
-- Add optional transcript logging (`--log-file`).
-- Add streaming token timing metrics for latency debugging.
+## Troubleshooting
+
+- `... is not a local folder and is not a valid model identifier`
+  - Use a full local path or place the model under `~/ml/models/<name>`
+
+- Tokenizer conversion errors
+  - Ensure `sentencepiece`, `tiktoken`, and `protobuf` are installed
+
+- PersonaPlex model fails in `runner.py`/`chat.py`
+  - Expected: it is a speech-to-speech checkpoint, not a text causal LM
+
+- Ollama connection refused from WSL
+  - `ollama_chat.py` auto-detects host each run
+  - If needed: `python ollama_chat.py "<model>" --host "http://<windows-ip>:11434"`
+
+## Contributor Notes
+
+This repo is not trying to be a minimal polished app. It is trying to become a useful local model research environment.
+
+From a contributor perspective, the repo operates on two different kinds of documents:
+- **Decision records** capture contracts and invariants the repo has discovered or chosen.
+  - They explain what must stay true across refactors, standardization passes, and new backend work.
+  - Treat them as the repo's operating agreements, not as disposable notes.
+- **Specs** describe concrete implementation passes.
+  - They are instructions for how to execute a change or feature once the direction is understood.
+  - They may evolve, but they should not silently violate existing decision records.
+
+In practice:
+- consult decision records first when you need to understand what behavior is supposed to remain invariant
+- use specs to drive the implementation work for a specific pass
+- if implementation reveals a new invariant, ambiguity, or repo-wide rule, capture that in a decision record instead of leaving it trapped in code or chat history
+
+When making changes:
+- prefer backend truth over inferred summaries
+- preserve local-first workflows
+- keep models comparable across backends where practical
+- document model/runtime quirks in-repo
+- treat observability as a first-class feature, not a nice-to-have
+- distinguish clearly between:
+  - requested/configured behavior
+  - effective/runtime behavior
+  - unknown/unavailable runtime truth
+- avoid hiding backend-specific realities behind fake uniformity; standardize the surface, not the facts
+
+The current TUI is still worth improving, but new work should not assume terminal UX is the final destination for runtime debugging and optimization.
diff --git a/backend-down-bg b/backend-down-bg
new file mode 100755
index 0000000..aeed050
--- /dev/null
+++ b/backend-down-bg
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec "$ROOT/scripts/backend_ctl.py" "backend-down-bg" "$@"
diff --git a/backend-up-bg b/backend-up-bg
new file mode 100755
index 0000000..e118fc3
--- /dev/null
+++ b/backend-up-bg
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec "$ROOT/scripts/backend_ctl.py" "backend-up-bg" "$@"
diff --git a/bin/backend-down-bg b/bin/backend-down-bg
new file mode 100755
index 0000000..e900b86
--- /dev/null
+++ b/bin/backend-down-bg
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+exec "$ROOT/backend-down-bg" "$@"
diff --git a/bin/backend-up-bg b/bin/backend-up-bg
new file mode 100755
index 0000000..3830f0a
--- /dev/null
+++ b/bin/backend-up-bg
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+exec "$ROOT/backend-up-bg" "$@"
diff --git a/bin/expand b/bin/expand
new file mode 100755
index 0000000..a76c6a1
--- /dev/null
+++ b/bin/expand
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+exec "$ROOT/expand" "$@"
diff --git a/bin/model b/bin/model
new file mode 100755
index 0000000..12cf038
--- /dev/null
+++ b/bin/model
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+exec "$ROOT/scripts/model" "$@"
diff --git a/bin/tui b/bin/tui
new file mode 100755
index 0000000..91e5744
--- /dev/null
+++ b/bin/tui
@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+set -euo pipefail
+SELF="$(readlink -f "${BASH_SOURCE[0]}")"
+ROOT="$(cd "$(dirname "$SELF")/.." && pwd)"
+PY="$ROOT/.venv/bin/python"
+if [[ ! -x "$PY" ]]; then
+  PY="${PYTHON:-python3}"
+fi
+
+export PATH="$ROOT/.venv/bin:$PATH"
+
+SITE_PACKAGES="$ROOT/.venv/lib/python3.12/site-packages"
+LIB_DIRS=()
+for candidate in \
+  "$SITE_PACKAGES/torch/lib" \
+  "$SITE_PACKAGES/nvidia/cuda_runtime/lib" \
+  "$SITE_PACKAGES/nvidia/cu13/lib" \
+  "$SITE_PACKAGES/nvidia/cudnn/lib" \
+  "$SITE_PACKAGES/nvidia/cusparselt/lib" \
+  "$SITE_PACKAGES/nvidia/nccl/lib" \
+  "$SITE_PACKAGES/nvidia/nvshmem/lib"
+do
+  if [[ -d "$candidate" ]]; then
+    LIB_DIRS+=("$candidate")
+  fi
+done
+
+if [[ ${#LIB_DIRS[@]} -gt 0 ]]; then
+  LIB_PATH="$(IFS=:; echo "${LIB_DIRS[*]}")"
+  if [[ -n "${LD_LIBRARY_PATH:-}" ]]; then
+    export LD_LIBRARY_PATH="$LIB_PATH:$LD_LIBRARY_PATH"
+  else
+    export LD_LIBRARY_PATH="$LIB_PATH"
+  fi
+fi
+
+if [[ -d /usr/local/cuda ]]; then
+  export CUDA_HOME=/usr/local/cuda
+  export CUDA_PATH=/usr/local/cuda
+  export CUDACXX=/usr/local/cuda/bin/nvcc
+  export NVCC_CCBIN=/usr/bin/g++-14
+  export PATH=/usr/local/cuda/bin:$PATH
+fi
+
+exec "$PY" "$ROOT/tui.py" "$@"
diff --git a/bin/vllm-down b/bin/vllm-down
new file mode 100755
index 0000000..9b8ea26
--- /dev/null
+++ b/bin/vllm-down
@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+SCRIPT_PATH="$(readlink -f "${BASH_SOURCE[0]}")"
+ROOT="$(cd "$(dirname "$SCRIPT_PATH")/.." && pwd)"
+exec "$ROOT/scripts/backend_ctl.py" "vllm-down" "$@"
diff --git a/bin/vllm-up b/bin/vllm-up
new file mode 100755
index 0000000..43f0a71
--- /dev/null
+++ b/bin/vllm-up
@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+SCRIPT_PATH="$(readlink -f "${BASH_SOURCE[0]}")"
+ROOT="$(cd "$(dirname "$SCRIPT_PATH")/.." && pwd)"
+exec "$ROOT/scripts/backend_ctl.py" "vllm-up" "$@"
diff --git a/bin/vllm-up-bg b/bin/vllm-up-bg
new file mode 100755
index 0000000..5e33006
--- /dev/null
+++ b/bin/vllm-up-bg
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+exec "$ROOT/vllm-up-bg" "$@"
diff --git a/config/machine.example.toml b/config/machine.example.toml
new file mode 100644
index 0000000..eef87c4
--- /dev/null
+++ b/config/machine.example.toml
@@ -0,0 +1,13 @@
+[machine]
+run_root = "/home/poop/runs/model-runner"
+# Local path containing model folders/files (not committed in machine.toml).
+model_root = "/home/poop/models/local"
+gguf_model_root = "/home/poop/models/local/gguf"
+exl2_model_root = "/home/poop/models/local/exl2"
+
+# Optional per-machine endpoint defaults.
+ollama_host = "http://127.0.0.1:11434"
+
+# Optional placeholders for future backends.
+hf_cache_dir = "/home/poop/models/hf"
+openai_base_url = "http://127.0.0.1:8000/v1"
diff --git a/config_utils.py b/config_utils.py
index 3277ace..5a177c2 100644
--- a/config_utils.py
+++ b/config_utils.py
@@ -1,10 +1,448 @@
+from __future__ import annotations
+
 import json
 import os
 import re
+import tomllib
+from pathlib import Path
 
 
 def _repo_root() -> str:
-    return os.path.dirname(os.path.abspath(__file__))
+    module_dir = os.path.dirname(os.path.abspath(__file__))
+    cwd = os.path.abspath(os.getcwd())
+    if (
+        os.path.isdir(os.path.join(cwd, "models"))
+        and os.path.isdir(os.path.join(cwd, "docs"))
+        and os.path.isfile(os.path.join(cwd, "tui.py"))
+    ):
+        return cwd
+    return module_dir
+
+
+def _load_raw_config(path: str) -> dict:
+    with open(path, "rb") as fh:
+        if path.endswith(".toml"):
+            data = tomllib.load(fh)
+        else:
+            data = json.loads(fh.read().decode("utf-8"))
+    if not isinstance(data, dict):
+        raise ValueError(f"Config must be an object at top level: {path}")
+    return data
+
+
+def _flatten_toml_config(data: dict, *, backend: str) -> dict:
+    out: dict = {}
+
+    model = data.get("model")
+    if isinstance(model, dict):
+        if "id" in model:
+            out["model_id"] = model.get("id")
+        if "display_name" in model:
+            out["display_name"] = model.get("display_name")
+
+    for section in ("gen", "prompt", "ui", "tools", "telemetry"):
+        sec = data.get(section)
+        if isinstance(sec, dict):
+            for key, value in sec.items():
+                mapped = key
+                if section == "tools":
+                    mapped = f"tools_{key}"
+                elif section == "telemetry":
+                    mapped = f"telemetry_{key}"
+                out[mapped] = value
+
+    backend_root = data.get("backend")
+    if isinstance(backend_root, dict):
+        bsec = backend_root.get(backend)
+        if isinstance(bsec, dict):
+            for key, value in bsec.items():
+                mapped = key
+                if backend == "ollama":
+                    if key == "host":
+                        mapped = "ollama_host"
+                    elif key == "timeout":
+                        mapped = "ollama_timeout"
+                    elif key == "think_mode":
+                        mapped = "ollama_think"
+                elif backend == "hf" and key == "attn_implementation":
+                    mapped = "hf_attn_implementation"
+                elif backend == "hf" and key == "log_file":
+                    mapped = "hf_log_file"
+                elif backend == "hf" and key == "device_map":
+                    mapped = "hf_device_map"
+                elif backend == "hf" and key == "max_memory":
+                    mapped = "hf_max_memory"
+                elif backend == "hf" and key == "text_only":
+                    mapped = "hf_text_only"
+                elif backend == "hf" and key == "low_cpu_mem_usage":
+                    mapped = "hf_low_cpu_mem_usage"
+                elif backend == "gguf" and key == "log_file":
+                    mapped = "gguf_log_file"
+                elif backend == "exl2" and key == "log_file":
+                    mapped = "exl2_log_file"
+                elif backend == "openai":
+                    if key == "base_url":
+                        mapped = "openai_base_url"
+                    elif key == "api_key":
+                        mapped = "openai_api_key"
+                    elif key == "timeout_s":
+                        mapped = "openai_timeout_s"
+                    elif key == "log_file":
+                        mapped = "openai_log_file"
+                elif backend == "ollama" and key == "log_file":
+                    mapped = "ollama_log_file"
+                elif backend == "vllm":
+                    if key == "host":
+                        mapped = "vllm_host"
+                    elif key == "port":
+                        mapped = "vllm_port"
+                    elif key == "mode":
+                        mapped = "vllm_mode"
+                    elif key == "cmd":
+                        mapped = "vllm_cmd"
+                    elif key == "extra_args":
+                        mapped = "vllm_extra_args"
+                    elif key == "served_model_name":
+                        mapped = "vllm_served_model_name"
+                    elif key == "tensor_parallel_size":
+                        mapped = "vllm_tensor_parallel_size"
+                    elif key == "gpu_memory_utilization":
+                        mapped = "vllm_gpu_memory_utilization"
+                    elif key == "max_model_len":
+                        mapped = "vllm_max_model_len"
+                    elif key == "base_url":
+                        mapped = "vllm_base_url"
+                    elif key == "api_key":
+                        mapped = "vllm_api_key"
+                    elif key == "timeout_s":
+                        mapped = "vllm_timeout_s"
+                    elif key == "generation_config":
+                        mapped = "vllm_generation_config"
+                    elif key == "attention_backend":
+                        mapped = "vllm_attention_backend"
+                    elif key == "dtype":
+                        mapped = "vllm_dtype"
+                    elif key == "enable_auto_tool_choice":
+                        mapped = "vllm_enable_auto_tool_choice"
+                    elif key == "tool_call_parser":
+                        mapped = "vllm_tool_call_parser"
+                    elif key == "log_file":
+                        mapped = "vllm_log_file"
+                out[mapped] = value
+
+    return out
+
+
+def _read_config_as_flat(path: str, *, backend: str) -> dict:
+    data = _load_raw_config(path)
+    if path.endswith(".toml"):
+        return _flatten_toml_config(data, backend=backend)
+    return data
+
+
+def _merge_dicts(base: dict, override: dict) -> dict:
+    merged = dict(base)
+    for key, value in override.items():
+        if isinstance(value, dict) and isinstance(merged.get(key), dict):
+            merged[key] = _merge_dicts(merged[key], value)
+        else:
+            merged[key] = value
+    return merged
+
+
+def _merge_layers_with_origins(layers: list[tuple[str, dict]]) -> tuple[dict, dict]:
+    merged: dict = {}
+    origins: dict = {}
+    for source, data in layers:
+        for key, value in data.items():
+            merged[key] = value
+            origins[key] = source
+    return merged, origins
+
+
+def _is_local_stem(model_id: str) -> bool:
+    value = (model_id or "").strip()
+    if not value:
+        return False
+    lowered = value.lower()
+    if lowered.startswith(("ollama:", "exl2:")):
+        return False
+    if value.startswith((".", "~")):
+        return False
+    if "/" in value or "\\" in value:
+        return False
+    if ":" in value:
+        return False
+    return True
+
+
+def _kebab_model_name(value: str) -> str:
+    text = (value or "").strip().lower()
+    text = re.sub(r"[^a-z0-9]+", "-", text)
+    text = re.sub(r"-{2,}", "-", text)
+    return text.strip("-")
+
+
+def _slug_path_part(value: str, fallback: str) -> str:
+    text = (value or "").strip().lower()
+    text = re.sub(r"[^a-z0-9._-]+", "-", text)
+    text = re.sub(r"-{2,}", "-", text)
+    text = text.strip("-._")
+    return text or fallback
+
+
+def _existing_local_model_path(model_root: str, model_ref: str) -> str:
+    root = Path(os.path.expanduser(model_root))
+    if not root.is_dir():
+        return ""
+
+    candidates = [model_ref]
+    kebab = _kebab_model_name(model_ref)
+    if kebab and kebab not in candidates:
+        candidates.append(kebab)
+
+    for name in candidates:
+        path = root / name
+        if path.exists():
+            return str(path)
+
+    target_names = {name.casefold() for name in candidates if name}
+    if not target_names:
+        return ""
+    for child in root.iterdir():
+        if child.name.casefold() in target_names:
+            return str(child)
+    return ""
+
+
+def _latest_hf_snapshot_dir(hf_cache_dir: str, stem: str) -> str:
+    cache_root = Path(os.path.expanduser(hf_cache_dir))
+    if not cache_root.is_dir() or not stem:
+        return ""
+
+    # Accept either HF_HOME-style roots (.../models/hf) or direct hub cache roots
+    # (.../models/hf/hub).
+    if (cache_root / "hub").is_dir():
+        cache_root = cache_root / "hub"
+
+    repo_candidates: list[Path] = []
+    if stem.startswith("models--"):
+        repo_candidates.append(cache_root / stem)
+    elif "/" in stem:
+        owner, name = stem.split("/", 1)
+        repo_candidates.append(cache_root / f"models--{owner}--{name}")
+    repo_candidates.extend(sorted(cache_root.glob(f"models--*--{stem}")))
+
+    seen: set[str] = set()
+    best_path = ""
+    best_mtime = -1.0
+    for repo_dir in repo_candidates:
+        repo_key = str(repo_dir)
+        if repo_key in seen:
+            continue
+        seen.add(repo_key)
+        snapshots_dir = repo_dir / "snapshots"
+        if not snapshots_dir.is_dir():
+            continue
+        for snap_dir in snapshots_dir.iterdir():
+            if not snap_dir.is_dir():
+                continue
+            try:
+                mtime = snap_dir.stat().st_mtime
+            except OSError:
+                continue
+            if mtime > best_mtime:
+                best_mtime = mtime
+                best_path = str(snap_dir.resolve())
+    return best_path
+
+
+def _resolve_machine_model_ref(value: str, *, machine: dict) -> str:
+    model_ref = (value or "").strip()
+    if not _is_local_stem(model_ref):
+        return value
+
+    model_root = machine.get("model_root")
+    if isinstance(model_root, str) and model_root.strip():
+        local_path = _existing_local_model_path(model_root, model_ref)
+        if local_path:
+            return local_path
+
+    hf_cache_dir = machine.get("hf_cache_dir")
+    if isinstance(hf_cache_dir, str) and hf_cache_dir.strip():
+        snapshot_dir = _latest_hf_snapshot_dir(hf_cache_dir.strip(), model_ref)
+        if snapshot_dir:
+            return snapshot_dir
+
+    if isinstance(model_root, str) and model_root.strip():
+        return os.path.join(os.path.expanduser(model_root), model_ref)
+    return value
+
+
+def _apply_machine_overrides(data: dict, *, backend: str, machine_path: str) -> dict:
+    if not os.path.isfile(machine_path):
+        return dict(data)
+    raw = _load_raw_config(machine_path)
+    machine = raw.get("machine")
+    if not isinstance(machine, dict):
+        return dict(data)
+
+    out = dict(data)
+    model_root = machine.get("model_root")
+    gguf_model_root = machine.get("gguf_model_root")
+    exl2_model_root = machine.get("exl2_model_root")
+    exl2_repo_path = machine.get("exl2_repo_path")
+
+    def _clean_str(value: object) -> str:
+        return value.strip() if isinstance(value, str) else ""
+
+    def _pathish_is_relative(value: str) -> bool:
+        if not value:
+            return False
+        expanded = os.path.expanduser(value)
+        if os.path.isabs(expanded):
+            return False
+        if re.match(r"^[A-Za-z]:[\\/]", value):
+            return False
+        return True
+
+    # EXL2 has its own root (`exl2_model_root`) and should keep `model_id`
+    # as the local stem while `model_path` points at the backend-specific base
+    # directory. Running it through the generic model_root resolver points it
+    # at the wrong tree (`~/models/local/...` instead of `~/models/local/exl2/...`).
+    if backend != "exl2" and isinstance(out.get("model_id"), str):
+        out["model_id"] = _resolve_machine_model_ref(out["model_id"], machine=machine)
+
+    if backend == "gguf":
+        gguf_root = _clean_str(gguf_model_root) or _clean_str(model_root)
+        raw_model_path = _clean_str(out.get("model_path"))
+        if gguf_root and _pathish_is_relative(raw_model_path):
+            out["model_path"] = os.path.join(os.path.expanduser(gguf_root), raw_model_path)
+
+    if backend == "exl2":
+        exl2_root = _clean_str(exl2_model_root) or _clean_str(model_root)
+        raw_model_path = _clean_str(out.get("model_path"))
+        raw_model_id = _clean_str(out.get("model_id"))
+        if exl2_root and not raw_model_path and _is_local_stem(raw_model_id):
+            out["model_path"] = os.path.expanduser(exl2_root)
+        elif exl2_root and _pathish_is_relative(raw_model_path):
+            out["model_path"] = os.path.join(os.path.expanduser(exl2_root), raw_model_path)
+
+        raw_repo_path = _clean_str(out.get("exl2_repo_path"))
+        if _clean_str(exl2_repo_path) and not raw_repo_path:
+            out["exl2_repo_path"] = _clean_str(exl2_repo_path)
+        elif _clean_str(exl2_repo_path) and _pathish_is_relative(raw_repo_path):
+            out["exl2_repo_path"] = os.path.join(os.path.expanduser(_clean_str(exl2_repo_path)), raw_repo_path)
+
+    if backend == "ollama":
+        ollama_host = machine.get("ollama_host")
+        if isinstance(ollama_host, str) and ollama_host.strip():
+            out["ollama_host"] = ollama_host.strip()
+    hf_cache_dir = machine.get("hf_cache_dir")
+    if isinstance(hf_cache_dir, str) and hf_cache_dir.strip():
+        if not out.get("hf_cache_dir"):
+            out["hf_cache_dir"] = hf_cache_dir.strip()
+    openai_base_url = machine.get("openai_base_url")
+    if isinstance(openai_base_url, str) and openai_base_url.strip():
+        if not out.get("openai_base_url"):
+            out["openai_base_url"] = openai_base_url.strip()
+        if backend == "vllm" and not out.get("vllm_base_url"):
+            out["vllm_base_url"] = openai_base_url.strip()
+    return out
+
+
+def _machine_override_updates(data: dict, *, backend: str, machine_path: str) -> dict:
+    updated = _apply_machine_overrides(data, backend=backend, machine_path=machine_path)
+    out: dict = {}
+    for key, value in updated.items():
+        if data.get(key) != value:
+            out[key] = value
+    return out
+
+
+def apply_machine_model_root(model_id: str) -> str:
+    value = (model_id or "").strip()
+    if not value:
+        return value
+    machine_path = os.path.join(_repo_root(), "config", "machine.toml")
+    if not os.path.isfile(machine_path):
+        return model_id
+    raw = _load_raw_config(machine_path)
+    machine = raw.get("machine")
+    if not isinstance(machine, dict):
+        return model_id
+    return _resolve_machine_model_ref(value, machine=machine)
+
+
+def get_machine_value(key: str, default: str = "") -> str:
+    machine_path = os.path.join(_repo_root(), "config", "machine.toml")
+    if not os.path.isfile(machine_path):
+        return default
+    raw = _load_raw_config(machine_path)
+    machine = raw.get("machine")
+    if not isinstance(machine, dict):
+        return default
+    value = machine.get(key)
+    if isinstance(value, str) and value.strip():
+        return value.strip()
+    return default
+
+
+def get_machine_run_root(default: str = "~/runs/model-runner") -> str:
+    value = get_machine_value("run_root", default=default)
+    return os.path.abspath(os.path.expanduser(value))
+
+
+def get_runtime_scope(
+    *,
+    config_path: str | None = None,
+    backend: str = "",
+    model_ref: str = "",
+    profile: str = "",
+) -> dict[str, str]:
+    repo_root = _repo_root()
+    run_root = get_machine_run_root()
+    model_name = ""
+    backend_name = (backend or "").strip().lower()
+
+    cfg_path = os.path.abspath(os.path.expanduser(config_path)) if config_path else ""
+    if cfg_path:
+        repo_models_root = os.path.join(repo_root, "models") + os.sep
+        if cfg_path.startswith(repo_models_root):
+            rel = os.path.relpath(cfg_path, os.path.join(repo_root, "models"))
+            parts = rel.split(os.sep)
+            if len(parts) >= 2:
+                model_name = parts[0].strip()
+                if not backend_name:
+                    backend_name = parts[1].strip().lower()
+
+    if not model_name and model_ref:
+        candidates = _model_name_candidates(model_ref)
+        if candidates:
+            model_name = candidates[0].strip()
+
+    model_name = model_name or "adhoc"
+    backend_name = backend_name or "misc"
+    slot_name = (profile or "").strip() or "default"
+
+    model_slug = _slug_path_part(model_name, "adhoc")
+    backend_slug = _slug_path_part(backend_name, "misc")
+    slot_slug = _slug_path_part(slot_name, "default")
+
+    return {
+        "run_root": run_root,
+        "backend": backend_slug,
+        "model": model_slug,
+        "slot": slot_slug,
+    }
+
+
+def _resolve_profile_path(base_path: str, profile: str) -> str:
+    if not profile:
+        return ""
+    base_dir = os.path.dirname(base_path)
+    name = profile if profile.endswith(".toml") else f"{profile}.toml"
+    return os.path.join(base_dir, "profiles", name)
 
 
 def resolve_config_path(config_arg: str, backend: str = "hf") -> str | None:
@@ -13,34 +451,40 @@ def resolve_config_path(config_arg: str, backend: str = "hf") -> str | None:
 
     raw = os.path.expanduser(config_arg.strip())
     root = _repo_root()
+    has_ext = raw.endswith(".json") or raw.endswith(".toml")
 
-    candidates = []
-    candidates.append(raw)
-    if not raw.endswith(".json"):
+    candidates = [raw]
+    if not has_ext:
+        candidates.append(f"{raw}.toml")
         candidates.append(f"{raw}.json")
 
-    # Relative to repo root
+    # Relative to repo root.
     candidates.append(os.path.join(root, raw))
-    if not raw.endswith(".json"):
+    if not has_ext:
+        candidates.append(os.path.join(root, f"{raw}.toml"))
         candidates.append(os.path.join(root, f"{raw}.json"))
 
     basename = os.path.basename(raw)
-    stem = basename[:-5] if basename.endswith(".json") else basename
+    stem = basename
+    for suffix in (".json", ".toml"):
+        if stem.endswith(suffix):
+            stem = stem[: -len(suffix)]
     if stem == "template":
         stem = "_TEMPLATE"
 
-    # Model-first layout (preferred), e.g. models/Nanbeige4.1-3B/hf/config/config.json
+    # Model-first layout (preferred).
+    candidates.append(os.path.join(root, "models", stem, backend, "config", "default.toml"))
     candidates.append(os.path.join(root, "models", stem, backend, "config", "config.json"))
     candidates.append(os.path.join(root, "models", stem, backend, "config"))
     candidates.append(os.path.join(root, "models", stem, backend))
     candidates.append(os.path.join(root, "models", stem))
 
-    # Backend-scoped fallbacks (legacy), e.g. config/hf/Nanbeige4.1-3B.json
+    # Backend-scoped legacy fallbacks.
     candidates.append(os.path.join(root, "config", backend, basename))
-    if not basename.endswith(".json"):
-        candidates.append(os.path.join(root, "config", backend, f"{basename}.json"))
-
-    # Backend-scoped folder layout (legacy), e.g. config/hf/Nanbeige4.1-3B/config.json
+    if not has_ext:
+        candidates.append(os.path.join(root, "config", backend, f"{stem}.toml"))
+        candidates.append(os.path.join(root, "config", backend, f"{stem}.json"))
+    candidates.append(os.path.join(root, "config", backend, stem, "default.toml"))
     candidates.append(os.path.join(root, "config", backend, stem, "config.json"))
     candidates.append(os.path.join(root, "config", backend, stem))
 
@@ -55,28 +499,81 @@ def resolve_config_path(config_arg: str, backend: str = "hf") -> str | None:
             return normalized
 
         if os.path.isdir(normalized):
-            inside = os.path.join(normalized, "config.json")
-            if os.path.isfile(inside):
-                return inside
+            inside_toml = os.path.join(normalized, "default.toml")
+            if os.path.isfile(inside_toml):
+                return inside_toml
+            inside_json = os.path.join(normalized, "config.json")
+            if os.path.isfile(inside_json):
+                return inside_json
+
+    # Allow the OpenAI-compatible attach path to reuse an existing managed-vLLM
+    # model config when there is no dedicated openai config folder.
+    if backend == "openai":
+        vllm_backend = "vllm"
+        vllm_candidates = []
+        vllm_candidates.append(os.path.join(root, "models", stem, vllm_backend, "config", "default.toml"))
+        vllm_candidates.append(os.path.join(root, "models", stem, vllm_backend, "config", "config.json"))
+        vllm_candidates.append(os.path.join(root, "models", stem, vllm_backend, "config"))
+        vllm_candidates.append(os.path.join(root, "models", stem, vllm_backend))
+        for path in vllm_candidates:
+            normalized = os.path.abspath(path)
+            if os.path.isfile(normalized):
+                return normalized
+            if os.path.isdir(normalized):
+                inside_toml = os.path.join(normalized, "default.toml")
+                if os.path.isfile(inside_toml):
+                    return inside_toml
+                inside_json = os.path.join(normalized, "config.json")
+                if os.path.isfile(inside_json):
+                    return inside_json
 
     return None
 
 
 def load_json_config(config_arg: str, backend: str = "hf") -> tuple[dict, str]:
+    # Legacy entrypoint name retained for compatibility with existing callers.
     resolved = resolve_config_path(config_arg, backend=backend)
     if not resolved:
         raise FileNotFoundError(
             f"Config file not found for '{config_arg}'. "
-            f"Tried direct paths, models/<name>/{backend}/config/config.json, and legacy config/{backend}/... paths."
+            f"Tried direct paths, models/<name>/{backend}/config/default.toml|config.json, "
+            f"and legacy config/{backend}/... paths."
         )
 
-    with open(resolved, "r", encoding="utf-8") as fh:
-        data = json.load(fh)
+    data = _read_config_as_flat(resolved, backend=backend)
+    return data, resolved
 
-    if not isinstance(data, dict):
-        raise ValueError("Config JSON must be an object at the top level.")
 
-    return data, resolved
+def load_config_layers(
+    config_arg: str,
+    *,
+    backend: str = "hf",
+    profile: str = "",
+    include_machine: bool = True,
+) -> tuple[dict, dict]:
+    base_data, base_path = load_json_config(config_arg, backend=backend)
+    layers: list[tuple[str, dict]] = [(base_path, dict(base_data))]
+    loaded = [base_path]
+
+    profile_path = ""
+    if profile:
+        profile_path = _resolve_profile_path(base_path, profile)
+        if not os.path.isfile(profile_path):
+            raise FileNotFoundError(f"Profile not found: {profile_path}")
+        profile_data = _read_config_as_flat(profile_path, backend=backend)
+        layers.append((profile_path, dict(profile_data)))
+        loaded.append(profile_path)
+
+    machine_path = os.path.join(_repo_root(), "config", "machine.toml")
+    if include_machine and os.path.isfile(machine_path):
+        pre_merge, _ = _merge_layers_with_origins(layers)
+        machine_updates = _machine_override_updates(pre_merge, backend=backend, machine_path=machine_path)
+        if machine_updates:
+            layers.append((machine_path, machine_updates))
+            loaded.append(machine_path)
+
+    merged, origins = _merge_layers_with_origins(layers)
+    return merged, {"base": base_path, "profile": profile_path or None, "loaded": loaded, "origins": origins}
 
 
 def _normalize_model_ref(model_ref: str) -> str:
@@ -121,7 +618,6 @@ def add_name(raw_name: str) -> None:
     else:
         add_name(os.path.basename(value.rstrip("/\\")))
 
-    # For HF IDs like org/model, use final segment.
     if "/" in value and not os.path.exists(value) and not value.startswith("ollama:"):
         add_name(value.rsplit("/", 1)[-1])
 
@@ -136,13 +632,57 @@ def add_name(raw_name: str) -> None:
     return deduped
 
 
-def load_default_json_config_for_model(model_ref: str, backend: str = "hf") -> tuple[dict, str] | tuple[None, None]:
+def load_default_json_config_for_model(
+    model_ref: str,
+    backend: str = "hf",
+    profile: str = "",
+) -> tuple[dict, str] | tuple[None, None]:
     for candidate in _model_name_candidates(model_ref):
         resolved = resolve_config_path(candidate, backend=backend)
         if not resolved:
             continue
-        with open(resolved, "r", encoding="utf-8") as fh:
-            data = json.load(fh)
+        data = _read_config_as_flat(resolved, backend=backend)
+        if profile:
+            profile_path = _resolve_profile_path(resolved, profile)
+            if os.path.isfile(profile_path):
+                data = _merge_dicts(data, _read_config_as_flat(profile_path, backend=backend))
+        machine_path = os.path.join(_repo_root(), "config", "machine.toml")
+        if os.path.isfile(machine_path):
+            data = _apply_machine_overrides(data, backend=backend, machine_path=machine_path)
         if isinstance(data, dict):
             return data, resolved
     return None, None
+
+
+def load_default_config_layers_for_model(
+    model_ref: str,
+    *,
+    backend: str = "hf",
+    profile: str = "",
+    include_machine: bool = True,
+) -> tuple[dict, dict] | tuple[None, None]:
+    for candidate in _model_name_candidates(model_ref):
+        resolved = resolve_config_path(candidate, backend=backend)
+        if not resolved:
+            continue
+
+        layers: list[tuple[str, dict]] = [(resolved, _read_config_as_flat(resolved, backend=backend))]
+        loaded = [resolved]
+        profile_path = ""
+        if profile:
+            profile_path = _resolve_profile_path(resolved, profile)
+            if os.path.isfile(profile_path):
+                layers.append((profile_path, _read_config_as_flat(profile_path, backend=backend)))
+                loaded.append(profile_path)
+
+        machine_path = os.path.join(_repo_root(), "config", "machine.toml")
+        if include_machine and os.path.isfile(machine_path):
+            pre_merge, _ = _merge_layers_with_origins(layers)
+            machine_updates = _machine_override_updates(pre_merge, backend=backend, machine_path=machine_path)
+            if machine_updates:
+                layers.append((machine_path, machine_updates))
+                loaded.append(machine_path)
+
+        merged, origins = _merge_layers_with_origins(layers)
+        return merged, {"base": resolved, "profile": profile_path or None, "loaded": loaded, "origins": origins}
+    return None, None
diff --git a/docs/audits/0003-standardization.md b/docs/audits/0003-standardization.md
new file mode 100644
index 0000000..50cd11e
--- /dev/null
+++ b/docs/audits/0003-standardization.md
@@ -0,0 +1,222 @@
+# Backend Standardization Audit (TUI)
+
+Date: 2026-03-08
+
+This audit focuses on the unified Textual TUI path (`tui.py` + `tui_app/`) and compares how each backend behaves today, where we have de-facto standards, and where we should tighten things so adding new backends/models doesn’t re-introduce inconsistency.
+
+Backends in scope:
+- HF (`tui_app/backends/hf.py`)
+- GGUF (`tui_app/backends/gguf.py`)
+- EXL2 (`tui_app/backends/exl2.py`)
+- Ollama (`tui_app/backends/ollama.py`)
+- OpenAI-compatible (external attach) (`tui_app/backends/openai.py` + `tui_app/transports/openai_http.py`)
+- vLLM managed server (`tui_app/backends/vllm.py` + `tui_app/transports/openai_http.py`)
+
+## Current Standard (What’s Already Consistent)
+
+### 1. One event contract for the UI
+All TUI backends stream into a shared event model:
+- `TurnStart`
+- `ThinkDelta`
+- `AnswerDelta`
+- `Meta` (ad-hoc key/value metadata)
+- `Error`
+- `Finish` (with a `TurnRecord`)
+
+The minimum “backend session” surface area is standardized via a protocol:
+- `backend_name`
+- `resolved_model_id`
+- `generate_turn(turn_id, messages, emit)`
+- `get_recent_logs(n=80)` (exists on the protocol even if some backends return `[]`)
+
+Files:
+- `tui_app/backends/base.py`
+- `tui_app/events.py`
+
+### 2. One think-splitting primitive
+Think vs answer routing is centralized in `ThinkRouter` and used across backends.
+
+What’s standardized:
+- Split on marker strings (`<think>`, `</think>`, plus a few alternates)
+- `assume_think` support
+- Streaming-safe buffer logic for markers split across chunks
+
+File:
+- `tui_app/think_router.py`
+
+### 3. Model-first config and folder layout
+This repo has converged on:
+- `models/<model>/<backend>/config/default.toml`
+- `models/<model>/<backend>/config/profiles/<name>.toml` overlays (`--profile <name>`)
+- `config/machine.toml` machine-local overrides
+- `models/<model>/<backend>/{notes,templates,prompts}/`
+
+Config resolution and TOML flattening is centralized:
+- `config_utils.py` (`resolve_config_path`, `load_config_layers`, TOML section flattening)
+
+### 4. “Managed server” reuse
+vLLM uses the same OpenAI-compatible HTTP transport as external attach:
+- vLLM = “engine that happens to speak OpenAI”
+- OpenAI backend = “external server that speaks OpenAI”
+
+Transport:
+- `tui_app/transports/openai_http.py`
+
+## Where We’re Not Standardized (And What To Do)
+
+### A. Token accounting and performance metrics (biggest gap)
+
+What we have now:
+- HF: can count think tokens using the token-ID streamer (`TokenCountingTextIteratorStreamer`), and emits `Meta(think_tokens_inc=...)`.
+- GGUF: can near-exactly count emitted think tokens via `llama_cpp.Llama.tokenize`, emits `Meta(think_tokens_inc=...)`.
+- EXL2: has token IDs for chunks and emits `Meta(prompt_tokens=...)`; does not standardize “completion_tokens/total_tokens” in `Meta`.
+- Ollama: if `message.thinking` exists, it routes it directly to thinking; otherwise it uses `ThinkRouter` on content; think token count is a whitespace approximation.
+- OpenAI/vLLM: think token count is a whitespace approximation; no usage parsing; no prompt/completion token counts.
+- `/show last`: prints lengths in *characters* for `raw/think/answer`, not tokens (useful for “is anything happening”, not useful for tok/s).
+
+Impact:
+- Tok/s is currently either missing or approximate depending on backend.
+- Debugging max context and “thinking ate my budget” becomes guesswork.
+- We keep rediscovering “tokens are the unit” but the UI is not instrumented to report them consistently.
+
+Standardization target:
+- Every backend should ideally provide:
+  - `Meta(prompt_tokens=...)` (int, if knowable)
+  - `Meta(completion_tokens=...)` (int, if knowable)
+  - `Meta(total_tokens=...)` (int, if knowable)
+  - `Meta(tokens_per_s=...)` (float, if completion_tokens is knowable)
+- When not knowable, explicitly report:
+  - `Meta(token_counts="unavailable")` or a structured `Meta(token_counts={...})`
+
+Concrete standardization opportunities:
+1. vLLM/OpenAI transport: parse server-provided usage when enabled and attach to TurnRecord + `/show`.
+2. EXL2: emit completion token count and total token count in addition to prompt tokens.
+3. Ollama: use Ollama’s own eval counts if available in the response (preferred), fallback to approximation otherwise.
+4. `/show last`: display both `chars` and `tokens` when available; don’t pretend chars are tokens.
+
+Decision missing today:
+- “Source of truth for token counts”: backend-native usage > backend token IDs > retokenization fallback.
+
+### B. Logging and log tails
+
+What we have now:
+- HF/GGUF/EXL2/Ollama/OpenAI use `FileLogger` (file-backed ring buffer).
+- vLLM managed uses an in-memory deque for stdout/stderr tail; optional tee to file.
+
+Impact:
+- `/show logs` parity is hard until all sessions expose the same “recent logs” behavior.
+
+Standardization target:
+- Every backend should expose a recent-log ring buffer (even if it’s filled from file logger).
+- Backends that spawn a process should also capture stdout/stderr into that same ring buffer.
+
+### C. “Knob mapping” semantics (sent vs deferred vs ignored)
+
+What we have now:
+- HF has native knobs (transformers generate kwargs).
+- GGUF has llama.cpp knobs (not all match HF).
+- EXL2 has ExLlamaV2 knobs (its own set).
+- Ollama only sends options when user explicitly sets them.
+- OpenAI transport emits `Meta(ignored_knobs=[...])` for some fields, but doesn’t present a full “sent/deferred/ignored” report.
+
+Impact:
+- Users don’t know which knobs actually changed model behavior on that backend.
+- Profiles accumulate “placebo knobs” unless we explicitly report what was sent and what was ignored.
+
+Standardization target:
+- For every turn, record and optionally show:
+  - `sent`: values actually delivered to the engine/server
+  - `deferred`: values left to backend defaults (unset)
+  - `ignored`: values user set but backend does not support
+
+This should be a TurnRecord-level field (or well-defined `Meta`) so the UI can show it without backend-specific formatting.
+
+### D. Template and history standardization
+
+What we have now:
+- HF: uses tokenizer/processor `apply_chat_template`, supports overrides via `--chat-template`.
+- EXL2: uses Jinja templates and can read tokenizer_config.json.
+- GGUF: uses a chat template spec; fallback to a plain “System/User/Assistant” prompt.
+- Ollama/OpenAI/vLLM: template lives server-side; we only send messages.
+
+Impact:
+- “Sanitizing history” (e.g., removing `<think>...</think>` before re-sending) is only meaningful when we control templating locally. It’s not universally applicable.
+
+Standardization target (best-effort repo-wide control):
+- Aim for repo-controlled chat templates and history shaping whenever feasible:
+  - `local_template`: we render prompts/templates (HF, GGUF, EXL2) and can fully sanitize history.
+  - `managed_server_template`: we launch the server and can pass template settings at launch (vLLM managed).
+  - `server_owned_template`: template is effectively baked into the model/server (Ollama `/api/chat`, arbitrary external OpenAI-compatible servers).
+- Only apply history sanitization rules in backends where the repo controls the template (`local_template` and `managed_server_template`).
+- Still keep think routing consistent in the UI regardless of template control level.
+- Note: attempting “template control” for Ollama-style services is not worth it for this repo; the effective control mechanism is rebuilding the model/server outside this codebase.
+
+### E. Error and timeout semantics
+
+What we have now:
+- OpenAI transport uses a total timeout.
+- vLLM readiness probe has its own cap.
+- Other backends vary (ollama host probing, hf generation errors, gguf context overflow retries, exl2 context restarts).
+
+Standardization target:
+- Declare a common error shape in `TurnRecord` (or meta) when available:
+  - `stage`
+  - `backend`
+  - `retryable` (if known)
+- Add consistent timeout semantics to config: total vs connect vs read (even if only “total” is supported for v1).
+
+## Where Standardization Is Not Possible (Or Not Worth It Yet)
+
+### 1. Server-driven “thinking” fields
+Ollama can stream `message.thinking` separately for supported models; OpenAI-like servers may use `reasoning_content` deltas. Local backends don’t have this.
+
+We can standardize the *UI experience* (thinking panel + toggle), but we should not force a single transport contract across all sources of thinking.
+
+### 2. Full knob parity
+Sampling and engine knobs differ across transformers/llama.cpp/exllamav2/vLLM/Ollama.
+
+We can standardize:
+- naming in config (`[gen]` is stable)
+- reporting (sent/deferred/ignored)
+
+But we cannot standardize “every knob exists everywhere” without turning the repo into an abstraction tax.
+
+## Recommended Standardization Roadmap (Minimal, High-Leverage)
+
+1. Token counts and tok/s
+- vLLM: parse usage tokens when enabled.
+- EXL2: emit completion and total tokens.
+- GGUF: add prompt/completion/total (it can tokenize).
+- HF: add prompt token count (we already compute prompt length internally).
+
+2. Best-effort chat template and history control
+- Standardize a `chat_template`-style knob across backends that can honor it:
+  - HF/GGUF/EXL2: template is repo-owned and applied locally.
+  - vLLM managed: template is repo-owned and passed at server launch.
+  - Ollama: explicitly excluded (server-owned template via Modelfile/build).
+- Add/standardize template docs and a consistent “history sanitization” policy for repo-owned templates.
+
+3. Per-turn “sent/deferred/ignored” reporting
+- Make this a standard TurnRecord field (or a structured Meta key).
+- Make `/show gen` default output depend on this instead of ad-hoc printing.
+
+4. Standard log tail
+- Ensure every session’s `get_recent_logs()` returns something meaningful.
+- Pipe managed server logs into that same surface.
+- Adopt the TUI log buffer contract in `docs/audits/0004_tui_logging.md` (session-owned ring buffer, optional file sink, UTC timestamps, redaction).
+
+5. Capabilities declaration
+- Add a backend capability dict exposed via `describe()` or `capabilities()`:
+  - `supports_images`
+  - `template_control_level`
+  - `supports_usage_tokens`
+  - `supports_tool_calls` (transport-level)
+
+## Notes For Model Onboarding
+
+The biggest “repo drift” risk isn’t adding more models; it’s adding more backends without:
+- explicit capability reporting
+- explicit knob mapping (“this setting actually did something”)
+- explicit token accounting
+
+If those three are standardized, new backends/models become predictable to reason about and compare.
diff --git a/docs/audits/0004_tui_logging.md b/docs/audits/0004_tui_logging.md
new file mode 100644
index 0000000..a65bbc9
--- /dev/null
+++ b/docs/audits/0004_tui_logging.md
@@ -0,0 +1,89 @@
+# 0004 TUI Logging
+
+Date: 2026-03-08
+
+## Purpose
+Reference for standardizing backend logging surfaced in the TUI (`/show logs`) so diagnostics are consistent across backends.
+
+This is a supporting audit for backend standardization in `docs/audits/0003-standardization.md`.
+
+## Current State
+
+### Shared TUI surface
+- All backends now expose `get_recent_logs(n)` so `/show logs` works everywhere.
+- For non-vLLM backends, log lines are produced by app-level logging calls (not raw engine stdout/stderr).
+
+### vLLM (managed)
+- Captures child-process `stdout` and `stderr` into an in-memory deque.
+- Optional tee-to-file supported.
+- This gives highest-fidelity diagnostics in-TUI today.
+
+### HF / GGUF / EXL2 / Ollama / OpenAI
+- Use `FileLogger` ring buffer (in-memory, optional file sink).
+- Captures structured app-level lifecycle/events/errors we emit.
+- Does **not** automatically capture raw library/framework stderr/stdout internals.
+
+## Target Standard
+Adopt one backend log buffer contract with source tagging and worker/session ownership:
+- `append_log(source, level, message, context?)`
+- `get_recent_logs(n, filter?)`
+- Optional `get_log_file_path()`
+
+Recommended `source` values:
+- `app` (our runner/session code)
+- `engine_stdout`
+- `engine_stderr`
+- `transport`
+
+This keeps one retrieval path in TUI while allowing backend-specific capture methods.
+
+Hard requirements:
+- Ownership: log buffers are per worker/session, never global.
+- Timestamp: UTC, ISO 8601 with milliseconds: `YYYY-MM-DDTHH:MM:SS.sssZ` (avoid local timezone ambiguity).
+- Safety: never log secrets; redact auth headers/api keys; omit or summarize data URLs (images).
+
+## Standard Runtime Modes
+
+### 1) Always-on in-memory (fast path)
+- Ring buffer per backend worker/session.
+- Keep small fixed size (recommended: 200-500 lines).
+- Store compact structured lines only:
+  - `timestamp source level message` (timestamp is UTC `...Z`)
+- No file writes by default.
+- `/show logs` reads this buffer.
+
+### 2) Optional file sink (debug mode)
+- Off by default.
+- Enable per backend/model only when needed.
+- Default file level should be `warn/error` unless debugging requires more.
+- Minimal retention:
+  - single rotation
+  - small cap (recommended: 1-2 MB + 1 backup)
+
+Default posture:
+- in-memory on
+- file off
+- enable file only for stubborn failures (especially pre-init crashes).
+
+## Worker-First Parity Plan
+To match vLLM-level diagnostics across backends, prefer managed backend workers where possible:
+- capture worker `stdout/stderr`
+- feed captured lines into the same in-memory buffer API
+- optionally mirror selected lines to debug file sink
+
+For in-process backends that cannot be isolated immediately:
+- keep structured app-stage logs
+- add stage coverage (init/build request/generate/retry/failure)
+- treat worker isolation as the long-term parity target
+
+## Performance Guidance
+- Avoid verbose logging in hot token loops.
+- Log stage transitions and failures, not every token/chunk.
+- Downsample repetitive backend spam before appending to buffer.
+- Use non-blocking append; drop oldest entries when full.
+- Logging must never block generation.
+
+## Practical Conclusion
+- Near-term: keep `/show logs` consistent with compact in-memory buffers everywhere.
+- Debug/deep-failure path: turn on minimal file sink as needed.
+- Long-term parity: move backends toward worker-managed execution so TUI can surface raw engine startup/runtime logs uniformly.
diff --git a/docs/audits/README.md b/docs/audits/README.md
index d7586b3..ee9e56b 100644
--- a/docs/audits/README.md
+++ b/docs/audits/README.md
@@ -4,3 +4,5 @@ Short, practical audits of current behavior (e.g., output parsing, streaming beh
 
 - `docs/audits/0001-hide-think.md`: Audit of `chat.py` hide-think behavior and common failure modes.
 - `docs/audits/0002-exllamav2-examples-chat-findings.md`: Findings from upstream ExLlamaV2 `examples/chat.py` and prompt formats.
+- `docs/audits/0003-standardization.md`: Audit of backend consistency in the unified TUI and a standardization roadmap.
+- `docs/audits/0004_tui_logging.md`: Standard for backend/session logging surfaced in the TUI.
diff --git a/docs/dashboard_repo_architecture.md b/docs/dashboard_repo_architecture.md
new file mode 100644
index 0000000..082d1c4
--- /dev/null
+++ b/docs/dashboard_repo_architecture.md
@@ -0,0 +1,135 @@
+# Dashboard Repo Architecture Note
+
+Date: 2026-03-15
+
+Status: Scratchpad
+
+Downstream repo name:
+- `lab-llm`
+
+Purpose:
+- keep repo-facing notes about the downstream dashboard architecture
+- document the current expected boundary from `model-runner`
+- avoid turning this repo into the dashboard implementation home
+
+This file is intentionally downstream-facing and non-authoritative for the dashboard repo.
+It exists so this repo can remember what the downstream architecture expects today.
+
+## Current boundary assumptions
+The `lab-llm` dashboard repo is expected to consume `model-runner` through external interfaces only:
+- JSON/app telemetry events
+- optional Prometheus-compatible metrics
+
+It should not import internal modules from this repo as a primary integration path.
+It should also own frontend-facing REST/SSE rather than expecting `model-runner` to provide them.
+
+## Current architectural shape
+The dashboard repo is expected to have three layers.
+
+### 1. Ingestion layer
+Consumes telemetry from `model-runner`.
+
+Inputs:
+- fixture JSONL during early UI development
+- live-appended JSONL from `model-runner`
+- optional Prometheus scrape data
+- optional GPU/system exporter metrics
+
+Later, a more direct ingestion channel may be added if it clearly earns the extra complexity.
+
+Responsibilities:
+- normalize external input into dashboard-owned read models
+- maintain live session state
+- persist recent history as needed
+
+### 2. Dashboard service layer
+Serves dashboard-facing queries and live updates.
+
+Likely responsibilities:
+- session list/detail APIs
+- experiment compare APIs
+- live subscription fanout
+- retention/downsampling policy
+- local persistence management
+
+### 3. Web UI layer
+Provides the browser experience.
+
+Likely areas:
+- overview
+- sessions
+- compare
+- inspect
+- logs
+- future chat area in the same shell
+
+## Current entity expectations
+The dashboard repo should expect these concepts from `model-runner`:
+- session
+- experiment
+- load report
+- turn summary
+- runtime sample
+- log event
+- error event
+
+## Current app/API expectations
+The dashboard repo should assume:
+- events are append-only
+- payloads are versioned
+- unknown fields may appear over time
+- some metrics are unavailable on some backends
+
+The dashboard should therefore:
+- treat missing fields as capability gaps, not hard failures
+- clearly distinguish unavailable vs zero
+- prefer canonical fields over backend-specific extensions
+
+## Current Prometheus posture
+Prometheus is expected to be useful for:
+- quick charts
+- standard metric collection
+- reuse of existing exporter tooling
+
+Prometheus is not expected to be sufficient for:
+- turn-level inspection
+- knob truth
+- logs
+- request inspect views
+- chat/session semantics
+
+The dashboard repo should therefore treat Prometheus as supplemental, not primary.
+
+## Current integration order
+Shortest path for the downstream repo:
+- develop against fixture JSONL
+- switch to live-appended JSONL from `model-runner`
+- add a more direct ingestion channel later only if it materially improves the system
+
+## Current UI posture
+The downstream UI should be:
+- observability-first initially
+- ready to share a shell with future browser chat
+- explicit about live vs completed state
+- explicit about unknown/unavailable metrics
+
+## Diagnostic expectation
+The downstream dashboard should help distinguish model/config issues from fused-kernel/runtime issues.
+
+In particular, for cases like Qwen3.5 where:
+- conservative paths such as HF `sdpa` behave correctly
+- faster fused paths such as HF `flash_attention_2` or vLLM/FlashInfer may loop or fail
+
+the dashboard should make it possible to compare and inspect:
+- attention backend in use
+- prefill behavior versus decode behavior
+- cache-on versus cache-off runs when available
+- throughput versus correctness regressions
+- runtime errors and termination mode
+
+The goal is not only “what is faster,” but “which kernel path changes model behavior.”
+
+## Open notes
+- If the dashboard repo needs long-retention storage, that should be solved there, not here.
+- If the dashboard repo wants richer compare workflows or annotations, that should be solved there, not here.
+- If the telemetry schema changes, this note should only summarize the downstream impact, not restate the full schema.
diff --git a/docs/debugging/outputs b/docs/debugging/outputs
new file mode 100644
index 0000000..3bf1338
--- /dev/null
+++ b/docs/debugging/outputs
@@ -0,0 +1,65 @@
+//before quiting tui
+❯ ps -u $USER -o pid,rss,cmd --sort=-rss | head -n 30
+    PID   RSS CMD
+ 632865 2032336 python3 tui.py --config Qwen3.5-9B
+1207977 1100788 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/extensions/ms-python.vscode-pylance-2026.1.1/dist/server.bundle.js --cancellationReceive=file:9abaff3392ff3b7d0255f815af0a51be90feed36e9 --node-ipc --clientProcessId=1205523
+1205523 936960 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node --dns-result-order=ipv4first /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/out/bootstrap-fork --type=extensionHost --transformURIs --useHostProxy=true
+4031917 815560 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node --dns-result-order=ipv4first /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/out/bootstrap-fork --type=extensionHost --transformURIs --useHostProxy=true
+1205710 743500 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node --dns-result-order=ipv4first /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/out/bootstrap-fork --type=extensionHost --transformURIs --useHostProxy=true
+    319 520820 openclaw-gateway
+1208248 480720 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/extensions/ms-python.vscode-pylance-2026.1.1/dist/server.bundle.js --cancellationReceive=file:5c6b81c4f1598668fbbebcf0a42858584bf44784a5 --node-ipc --clientProcessId=1205710
+4032989 417928 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/extensions/ms-python.vscode-pylance-2026.1.1/dist/server.bundle.js --cancellationReceive=file:30c970133d7a9420a9a5edccc495c0d4450165bb11 --node-ipc --clientProcessId=4031917
+1205025 191508 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/out/server-main.js --host=127.0.0.1 --port=0 --connection-token=444663059-3733162418-2790522967-1206847818 --use-host-proxy --without-browser-env-var --disable-websocket-compression --accept-server-license-terms --telemetry-level=all
+3023773 127320 /home/poop/.npm-global/lib/node_modules/@openai/codex/node_modules/@openai/codex-linux-x64/vendor/x86_64-unknown-linux-musl/codex/codex resume 019cba69-d4ce-7e83-bb5d-d72d89ad4fda
+2459677 124636 /home/poop/.npm-global/lib/node_modules/@openai/codex/node_modules/@openai/codex-linux-x64/vendor/x86_64-unknown-linux-musl/codex/codex resume
+3937525 101992 /home/poop/.npm-global/lib/node_modules/@openai/codex/node_modules/@openai/codex-linux-x64/vendor/x86_64-unknown-linux-musl/codex/codex resume 019bfb81-465d-7723-b6f5-de6e3885b5e4
+2453239 85548 /home/poop/.npm-global/lib/node_modules/@openai/codex/node_modules/@openai/codex-linux-x64/vendor/x86_64-unknown-linux-musl/codex/codex resume
+3955783 84272 python -m flow_lens.main --config config/app_btc.toml
+1205537 83708 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/out/bootstrap-fork --type=ptyHost --logsPath /home/poop/.vscode-server/data/logs/20260304T121938
+3807210 67124 /home/poop/.npm-global/lib/node_modules/@openai/codex/node_modules/@openai/codex-linux-x64/vendor/x86_64-unknown-linux-musl/codex/codex --config features.streaming=false --config model=gpt-5.2 --config model_reasoning_effort=high
+1206473 65780 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/extensions/markdown-language-features/dist/serverWorkerMain --node-ipc --clientProcessId=1205523
+ 517637 63732 python3 -m flow_lens.main --config config/app_btc.toml --dist-dia
+1211452 57184 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/extensions/markdown-language-features/dist/serverWorkerMain --node-ipc --clientProcessId=1205710
+4031883 56388 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node -e const net = require('net'); process.stdin.pause(); const client = net.createConnection({ host: '127.0.0.1', port: 39225 }, () => { client.pipe(process.stdout); process.stdin.pipe(client); }); client.on('close', function (hadError) { console.error(hadError ? 'Remote close with error' : 'Remote close'); process.exit(hadError ? 1 : 0); }); client.on('error', function (err) { process.stderr.write(err && (err.stack || err.message) || String(err)); });
+4032230 53932 /home/poop/.vscode-server/extensions/openai.chatgpt-26.304.20706-linux-x64/bin/linux-x86_64/codex app-server --analytics-default-enabled
+4031902 52076 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/out/bootstrap-fork --type=fileWatcher
+1205353 50128 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node -e const net = require('net'); process.stdin.pause(); const client = net.createConnection({ host: '127.0.0.1', port: 39225 }, () => { client.pipe(process.stdout); process.stdin.pipe(client); }); client.on('close', function (hadError) { console.error(hadError ? 'Remote close with error' : 'Remote close'); process.exit(hadError ? 1 : 0); }); client.on('error', function (err) { process.stderr.write(err && (err.stack || err.message) || String(err)); });
+1247470 49312 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/extensions/json-language-features/server/dist/node/jsonServerMain --node-ipc --clientProcessId=1205523
+1205538 48948 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node -e const net = require('net'); process.stdin.pause(); const client = net.createConnection({ host: '127.0.0.1', port: 39225 }, () => { client.pipe(process.stdout); process.stdin.pipe(client); }); client.on('close', function (hadError) { console.error(hadError ? 'Remote close with error' : 'Remote close'); process.exit(hadError ? 1 : 0); }); client.on('error', function (err) { process.stderr.write(err && (err.stack || err.message) || String(err)); });
+1205316 48908 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node -e const net = require('net'); process.stdin.pause(); const client = net.createConnection({ host: '127.0.0.1', port: 39225 }, () => { client.pipe(process.stdout); process.stdin.pipe(client); }); client.on('close', function (hadError) { console.error(hadError ? 'Remote close with error' : 'Remote close'); process.exit(hadError ? 1 : 0); }); client.on('error', function (err) { process.stderr.write(err && (err.stack || err.message) || String(err)); });
+4034212 48668 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/extensions/markdown-language-features/dist/serverWorkerMain --node-ipc --clientProcessId=4031917
+1205565 48644 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/out/bootstrap-fork --type=fileWatcher
+1207360 48356 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/extensions/json-language-features/server/dist/node/jsonServerMain --node-ipc --clientProcessId=1205710
+
+// after quiting tui
+❯ ps -u $USER -o pid,rss,cmd --sort=-rss | head -n 30
+    PID   RSS CMD
+1207977 1100788 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/extensions/ms-python.vscode-pylance-2026.1.1/dist/server.bundle.js --cancellationReceive=file:9abaff3392ff3b7d0255f815af0a51be90feed36e9 --node-ipc --clientProcessId=1205523
+1205523 936960 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node --dns-result-order=ipv4first /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/out/bootstrap-fork --type=extensionHost --transformURIs --useHostProxy=true
+4031917 815560 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node --dns-result-order=ipv4first /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/out/bootstrap-fork --type=extensionHost --transformURIs --useHostProxy=true
+1205710 761660 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node --dns-result-order=ipv4first /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/out/bootstrap-fork --type=extensionHost --transformURIs --useHostProxy=true
+    319 534132 openclaw-gateway
+1208248 480720 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/extensions/ms-python.vscode-pylance-2026.1.1/dist/server.bundle.js --cancellationReceive=file:5c6b81c4f1598668fbbebcf0a42858584bf44784a5 --node-ipc --clientProcessId=1205710
+4032989 417928 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/extensions/ms-python.vscode-pylance-2026.1.1/dist/server.bundle.js --cancellationReceive=file:30c970133d7a9420a9a5edccc495c0d4450165bb11 --node-ipc --clientProcessId=4031917
+ 640218 229664 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node --max-old-space-size=3072 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/extensions/node_modules/typescript/lib/tsserver.js --useInferredProjectPerProjectRoot --enableTelemetry --cancellationPipeName /tmp/vscode-typescript1000/6da1a90c8d11372c0502/tscancellation-06c444cbc8880a65a2a5.tmp* --globalPlugins @vscode/copilot-typescript-server-plugin --pluginProbeLocations /home/poop/.vscode-server/extensions/github.copilot-chat-0.38.0 --locale en --noGetErrOnBackgroundUpdate --canUseWatchEvents --validateDefaultNpmLocation --useNodeIpc
+1205025 191764 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/out/server-main.js --host=127.0.0.1 --port=0 --connection-token=444663059-3733162418-2790522967-1206847818 --use-host-proxy --without-browser-env-var --disable-websocket-compression --accept-server-license-terms --telemetry-level=all
+ 640217 146484 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node --max-old-space-size=3072 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/extensions/node_modules/typescript/lib/tsserver.js --serverMode partialSemantic --useInferredProjectPerProjectRoot --disableAutomaticTypingAcquisition --cancellationPipeName /tmp/vscode-typescript1000/6da1a90c8d11372c0502/tscancellation-de1adfc057d8d60c12ca.tmp* --globalPlugins @vscode/copilot-typescript-server-plugin --pluginProbeLocations /home/poop/.vscode-server/extensions/github.copilot-chat-0.38.0 --locale en --noGetErrOnBackgroundUpdate --canUseWatchEvents --validateDefaultNpmLocation --useNodeIpc
+3023773 127320 /home/poop/.npm-global/lib/node_modules/@openai/codex/node_modules/@openai/codex-linux-x64/vendor/x86_64-unknown-linux-musl/codex/codex resume 019cba69-d4ce-7e83-bb5d-d72d89ad4fda
+2459677 125448 /home/poop/.npm-global/lib/node_modules/@openai/codex/node_modules/@openai/codex-linux-x64/vendor/x86_64-unknown-linux-musl/codex/codex resume
+3937525 101992 /home/poop/.npm-global/lib/node_modules/@openai/codex/node_modules/@openai/codex-linux-x64/vendor/x86_64-unknown-linux-musl/codex/codex resume 019bfb81-465d-7723-b6f5-de6e3885b5e4
+ 640231 97672 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/extensions/node_modules/typescript/lib/typingsInstaller.js --globalTypingsCacheLocation /home/poop/.cache/typescript/5.9 --enableTelemetry --typesMapLocation /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/extensions/node_modules/typescript/lib/typesMap.json --validateDefaultNpmLocation
+2453239 85548 /home/poop/.npm-global/lib/node_modules/@openai/codex/node_modules/@openai/codex-linux-x64/vendor/x86_64-unknown-linux-musl/codex/codex resume
+3955783 84272 python -m flow_lens.main --config config/app_btc.toml
+1205537 83708 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/out/bootstrap-fork --type=ptyHost --logsPath /home/poop/.vscode-server/data/logs/20260304T121938
+3807210 67124 /home/poop/.npm-global/lib/node_modules/@openai/codex/node_modules/@openai/codex-linux-x64/vendor/x86_64-unknown-linux-musl/codex/codex --config features.streaming=false --config model=gpt-5.2 --config model_reasoning_effort=high
+1206473 65780 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/extensions/markdown-language-features/dist/serverWorkerMain --node-ipc --clientProcessId=1205523
+ 517637 63732 python3 -m flow_lens.main --config config/app_btc.toml --dist-dia
+1205717 59596 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/out/bootstrap-fork --type=fileWatcher
+1211452 57184 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/extensions/markdown-language-features/dist/serverWorkerMain --node-ipc --clientProcessId=1205710
+4031883 56388 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node -e const net = require('net'); process.stdin.pause(); const client = net.createConnection({ host: '127.0.0.1', port: 39225 }, () => { client.pipe(process.stdout); process.stdin.pipe(client); }); client.on('close', function (hadError) { console.error(hadError ? 'Remote close with error' : 'Remote close'); process.exit(hadError ? 1 : 0); }); client.on('error', function (err) { process.stderr.write(err && (err.stack || err.message) || String(err)); });
+4032230 53844 /home/poop/.vscode-server/extensions/openai.chatgpt-26.304.20706-linux-x64/bin/linux-x86_64/codex app-server --analytics-default-enabled
+4031902 52076 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/out/bootstrap-fork --type=fileWatcher
+1205353 50128 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node -e const net = require('net'); process.stdin.pause(); const client = net.createConnection({ host: '127.0.0.1', port: 39225 }, () => { client.pipe(process.stdout); process.stdin.pipe(client); }); client.on('close', function (hadError) { console.error(hadError ? 'Remote close with error' : 'Remote close'); process.exit(hadError ? 1 : 0); }); client.on('error', function (err) { process.stderr.write(err && (err.stack || err.message) || String(err)); });
+1247470 49312 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/extensions/json-language-features/server/dist/node/jsonServerMain --node-ipc --clientProcessId=1205523
+1205538 48948 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node -e const net = require('net'); process.stdin.pause(); const client = net.createConnection({ host: '127.0.0.1', port: 39225 }, () => { client.pipe(process.stdout); process.stdin.pipe(client); }); client.on('close', function (hadError) { console.error(hadError ? 'Remote close with error' : 'Remote close'); process.exit(hadError ? 1 : 0); }); client.on('error', function (err) { process.stderr.write(err && (err.stack || err.message) || String(err)); });
+1205316 48908 /home/poop/.vscode-server/bin/0870c2a0c7c0564e7631bfed2675573a94ba4455/node -e const net = require('net'); process.stdin.pause(); const client = net.createConnection({ host: '127.0.0.1', port: 39225 }, () => { client.pipe(process.stdout); process.stdin.pipe(client); }); client.on('close', function (hadError) { console.error(hadError ? 'Remote close with error' : 'Remote close'); process.exit(hadError ? 1 : 0); }); client.on('error', function (err) { process.stderr.write(err && (err.stack || err.message) || String(err)); });
\ No newline at end of file
diff --git a/docs/debugging/temp b/docs/debugging/temp
new file mode 100644
index 0000000..31f70b2
--- /dev/null
+++ b/docs/debugging/temp
@@ -0,0 +1,31 @@
+: 0.0 tokens/s, Running: 0 reqs, Waiting: 0 reqs, GPU KV cache usage: 0.0%, Prefix cache hit rate: 0.0%
+(APIServer pid=970883) DEBUG 03-08 14:07:14 [v1/metrics/loggers.py:259] Engine 000: Avg prompt throughput: 0.0 tokens/s, Avg generation throughput: 0.0 tokens/s, Running: 0 reqs, Waiting: 0 reqs, GPU KV cache usage: 0.0%, Prefix cache hit rate: 0.0%
+(APIServer pid=970883) DEBUG 03-08 14:07:21 [entrypoints/logger.py:53] Request chatcmpl-98df3c3a77798b6d details: prompt: '<|im_start|>user\nhello<|im_end|>\n<|im_start|>assistant\n<think>\n', prompt_token_ids: [248045, 846, 198, 14556, 248046, 198, 248045, 74455, 198, 248068, 198], prompt_embeds shape: None.
+(APIServer pid=970883) INFO 03-08 14:07:21 [entrypoints/logger.py:63] Received request chatcmpl-98df3c3a77798b6d: params: SamplingParams(n=1, presence_penalty=0.0, frequency_penalty=0.0, repetition_penalty=1.0, temperature=0.7, top_p=1.0, top_k=0, min_p=0.0, seed=None, stop=[], stop_token_ids=[], bad_words=[], include_stop_str_in_output=False, ignore_eos=False, max_tokens=2048, min_tokens=0, logprobs=None, prompt_logprobs=None, skip_special_tokens=True, spaces_between_special_tokens=True, structured_outputs=None, extra_args=None), lora_request: None.
+(APIServer pid=970883) INFO:     127.0.0.1:53256 - "POST /v1/chat/completions HTTP/1.1" 200 OK
+(APIServer pid=970883) DEBUG 03-08 14:07:21 [v1/sample/logits_processor/__init__.py:63] No logitsprocs plugins installed (group vllm.logits_processors).
+(APIServer pid=970883) INFO 03-08 14:07:21 [v1/engine/async_llm.py:421] Added request chatcmpl-98df3c3a77798b6d-b1dae366.
+(EngineCore_DP0 pid=971139) DEBUG 03-08 14:07:21 [v1/engine/core.py:1154] EngineCore loop active.
+(EngineCore_DP0 pid=971139) DEBUG 03-08 14:07:21 [v1/worker/gpu_model_runner.py:3482] Running batch with cudagraph_mode: NONE, batch_descriptor: BatchDescriptor(num_tokens=11, num_reqs=None, uniform=False, has_lora=False, num_active_loras=0), should_ubatch: False, num_tokens_across_dp: None
+(EngineCore_DP0 pid=971139) DEBUG 03-08 14:07:21 [v1/worker/gpu_model_runner.py:3503] ubatch_slices: None, ubatch_slices_padded: None
+(EngineCore_DP0 pid=971139) /home/poop/ml/model-runner/.venv/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:1181: UserWarning: Input tensor shape suggests potential format mismatch: seq_len (11) < num_heads (16). This may indicate the inputs were passed in head-first format [B, H, T, ...] Please verify your input tensor format matches the expected shape [B, T, H, ...].
+(EngineCore_DP0 pid=971139)   return fn(*args, **kwargs)
+(EngineCore_DP0 pid=971139) /home/poop/ml/model-runner/.venv/lib/python3.11/site-packages/vllm/model_executor/layers/fla/ops/utils.py:113: UserWarning: Input tensor shape suggests potential format mismatch: seq_len (11) < num_heads (32). This may indicate the inputs were passed in head-first format [B, H, T, ...] when head_first=False was specified. Please verify your input tensor format matches the expected shape [B, T, H, ...].
+(EngineCore_DP0 pid=971139)   return fn(*contiguous_args, **contiguous_kwargs)
+(APIServer pid=970883) DEBUG 03-08 14:07:24 [v1/metrics/loggers.py:259] Engine 000: Avg prompt throughput: 0.0 tokens/s, Avg generation throughput: 0.0 tokens/s, Running: 0 reqs, Waiting: 0 reqs, GPU KV cache usage: 0.0%, Prefix cache hit rate: 0.0%
+(APIServer pid=970883) DEBUG 03-08 14:07:34 [v1/metrics/loggers.py:259] Engine 000: Avg prompt throughput: 0.0 tokens/s, Avg generation throughput: 0.0 tokens/s, Running: 0 reqs, Waiting: 0 reqs, GPU KV cache usage: 0.0%, Prefix cache hit rate: 0.0%
+(APIServer pid=970883) DEBUG 03-08 14:07:44 [v1/metrics/loggers.py:259] Engine 000: Avg prompt throughput: 0.0 tokens/s, Avg generation throughput: 0.0 tokens/s, Running: 0 reqs, Waiting: 0 reqs, GPU KV cache usage: 0.0%, Prefix cache hit rate: 0.0%
+(APIServer pid=970883) INFO 03-08 14:07:51 [v1/engine/async_llm.py:725] Aborted request(s) chatcmpl-98df3c3a77798b6d-b1dae366.
+(APIServer pid=970883) INFO 03-08 14:07:51 [v1/engine/async_llm.py:599] Request chatcmpl-98df3c3a77798b6d aborted.
+(APIServer pid=970883) DEBUG 03-08 14:07:54 [v1/metrics/loggers.py:259] Engine 000: Avg prompt throughput: 0.0 tokens/s, Avg generation throughput: 0.0 tokens/s, Running: 0 reqs, Waiting: 0 reqs, GPU KV cache usage: 0.0%, Prefix cache hit rate: 0.0%
+(EngineCore_DP0 pid=971139) /home/poop/ml/model-runner/.venv/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:1181: UserWarning: Input tensor shape suggests potential format mismatch: seq_len (11) < num_heads (16). This may indicate the inputs were passed in head-first format [B, H, T, ...] Please verify your input tensor format matches the expected shape [B, T, H, ...].
+(EngineCore_DP0 pid=971139)   return fn(*args, **kwargs)
+(EngineCore_DP0 pid=971139) /home/poop/ml/model-runner/.venv/lib/python3.11/site-packages/vllm/model_executor/layers/fla/ops/utils.py:113: UserWarning: Input tensor shape suggests potential format mismatch: seq_len (11) < num_heads (32). This may indicate the inputs were passed in head-first format [B, H, T, ...] when head_first=False was specified. Please verify your input tensor format matches the expected shape [B, T, H, ...].
+(EngineCore_DP0 pid=971139)   return fn(*contiguous_args, **contiguous_kwargs)
+(EngineCore_DP0 pid=971139) /home/poop/ml/model-runner/.venv/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:1181: UserWarning: Input tensor shape suggests potential format mismatch: seq_len (11) < num_heads (16). This may indicate the inputs were passed in head-first format [B, H, T, ...] Please verify your input tensor format matches the expected shape [B, T, H, ...].
+(EngineCore_DP0 pid=971139)   return fn(*args, **kwargs)
+(EngineCore_DP0 pid=971139) /home/poop/ml/model-runner/.venv/lib/python3.11/site-packages/vllm/model_executor/layers/fla/ops/utils.py:113: UserWarning: Input tensor shape suggests potential format mismatch: seq_len (11) < num_heads (32). This may indicate the inputs were passed in head-first format [B, H, T, ...] when head_first=False was specified. Please verify your input tensor format matches the expected shape [B, T, H, ...].
+(EngineCore_DP0 pid=971139)   return fn(*contiguous_args, **contiguous_kwargs)
+(EngineCore_DP0 pid=971139) DEBUG 03-08 14:07:57 [v1/engine/core.py:1142] EngineCore waiting for work.
+(APIServer pid=970883) DEBUG 03-08 14:08:04 [v1/metrics/loggers.py:259] Engine 000: Avg prompt throughput: 0.0 tokens/s, Avg generation throughput: 0.0 tokens/s, Running: 0 reqs, Waiting: 0 reqs, GPU KV cache usage: 0.0%, Prefix cache hit rate: 0.0%
+(APIServer pid=970883) DEBUG 03-08 14:08:14 [v1/metrics/loggers.py:259] Engine 000: Avg prompt throughput: 0.0 tokens/s, Avg generation throughput: 0.0 tokens/s, Running: 0 reqs, Waiting: 0 reqs, GPU KV cache usage: 0.0%, Prefix cache hit rate: 0.0%
\ No newline at end of file
diff --git a/docs/decisions/0010-reviews-branch-mirror.md b/docs/decisions/0010-reviews-branch-mirror.md
new file mode 100644
index 0000000..7aaac89
--- /dev/null
+++ b/docs/decisions/0010-reviews-branch-mirror.md
@@ -0,0 +1,22 @@
+# 0010 - Mirror PR review output into a `reviews` branch
+
+Date: 2026-03-04
+
+## Context
+- PR review bots (e.g. `codex-connector`) produce useful findings on GitHub.
+- Local Codex sessions in this repo may not reliably access GitHub APIs, and copy/pasting review output into local sessions is tedious.
+
+## Decision
+- Add a CI workflow that mirrors bot review output into a dedicated git branch named `reviews`.
+- `reviews` is an orphan branch that contains only generated artifacts under `docs/reviews/`.
+- CI is the only writer to `reviews`.
+- Do not publish mirror artifacts for PRs from forks.
+
+## Consequences
+- Pros:
+  - Local/offline tooling can fetch and read review bundles via `git show`, no checkout required.
+  - Review history is versioned and searchable.
+- Cons:
+  - The `reviews` branch is generated content and should not be edited manually.
+  - Fork PRs will not publish review bundles without a separate `pull_request_target` design (intentionally deferred).
+
diff --git a/docs/decisions/0011-toml-config-and-machine-overrides.md b/docs/decisions/0011-toml-config-and-machine-overrides.md
new file mode 100644
index 0000000..8dd803b
--- /dev/null
+++ b/docs/decisions/0011-toml-config-and-machine-overrides.md
@@ -0,0 +1,34 @@
+# 0011 - Adopt TOML configs with profiles and machine-local overrides
+
+Date: 2026-03-07
+
+## Context
+Config in this repo has grown to include:
+- generation knobs
+- backend/engine knobs
+- TUI/UI knobs
+
+Flat JSON is machine-friendly but has become hard to read and hard to distinguish “model vs backend vs UI” settings. We also want local-only settings (paths, hosts, API keys) that should not be committed, and multiple runnable “profiles” per model (fast/agent/longctx).
+
+Python 3.11 includes `tomllib`, so TOML provides comments + sections without adding dependencies.
+
+## Decision
+- Primary config format becomes **TOML** with sections by concern:
+  - `[model]`, `[gen]`, `[prompt]`, `[ui]`, and `[backend.<name>]`
+- Support **profiles** per model/backend under:
+  - `models/<model>/<backend>/config/profiles/<name>.toml`
+- Support an optional **machine-local override** file:
+  - `config/machine.toml` (gitignored), with a committed `config/machine.example.toml`
+
+Backward compatibility:
+- Continue supporting existing JSON configs for a transition period.
+- Prefer `default.toml` if present; otherwise fall back to `config.json`.
+
+This extends (and partially supersedes) decision `0005` by preserving the idea of per-model config profiles while switching the primary format to TOML.
+
+## Consequences
+- Configs are easier to navigate and comment.
+- Model settings and backend settings become visually separated.
+- Adding new backends (e.g. vLLM/OpenAI-compatible servers) doesn’t bloat existing configs.
+- Some implementation work is required: a loader/merger and updated scaffolding templates.
+
diff --git a/docs/decisions/0012-store-upstream-model-cards.md b/docs/decisions/0012-store-upstream-model-cards.md
new file mode 100644
index 0000000..25ebf6d
--- /dev/null
+++ b/docs/decisions/0012-store-upstream-model-cards.md
@@ -0,0 +1,28 @@
+# 0012 - Store upstream model cards as `notes/model_card.md`
+
+Date: 2026-03-07
+
+## Context
+Upstream model cards (typically `README.md` in the model folder / HF repo) are useful references for:
+- architecture + context length claims
+- recommended runtimes (Transformers vs vLLM vs SGLang)
+- modality support (vision/audio)
+- special prompting/tooling formats
+
+But keeping them as `README.md` inside this repo conflicts with our convention that `notes/README.md` is the “repo-local” notes file for how to run the model here.
+
+## Decision
+When we copy/import an upstream model card into this repo, store it as:
+- `models/<model>/<backend>/notes/model_card.md`
+
+Keep our repo-local notes at:
+- `models/<model>/<backend>/notes/README.md`
+
+Automation:
+- `scripts/model add` may copy a local model folder’s `README.md` into `notes/model_card.md` for HF models.
+
+## Consequences
+- Notes remain consistent and easy to find.
+- Upstream model documentation is preserved without clobbering local notes.
+- Onboarding new HF models becomes more repeatable.
+
diff --git a/docs/decisions/0013-openai-backend-naming-and-targets.md b/docs/decisions/0013-openai-backend-naming-and-targets.md
new file mode 100644
index 0000000..4edb3d9
--- /dev/null
+++ b/docs/decisions/0013-openai-backend-naming-and-targets.md
@@ -0,0 +1,30 @@
+#!/usr/bin/env markdown
+# Decision: Keep `openai` backend name; add “targets” for multiple servers
+
+Date: 2026-03-08
+
+## Context
+We want “vLLM integration”, but the repo’s backend naming convention is by **client protocol / adapter contract**, not by server engine.
+
+We also want to support multiple OpenAI-compatible servers (vLLM local, LM Studio, OpenRouter, etc.) without duplicating endpoint/auth settings across every model config.
+
+## Decision
+1) Keep the backend name `openai`.
+   - Meaning: “OpenAI-compatible HTTP API adapter”.
+   - vLLM is treated as one of several possible servers behind that adapter.
+
+2) Introduce named **targets** for the `openai` backend.
+   - Purpose: store server endpoint/auth/timeout in one place.
+   - Location: `config/targets/openai/<target>.toml`
+
+3) Maintain model-first configs as “client intent”.
+   - Model/prompt/gen/ui remain under `models/<model>/openai/config/default.toml`.
+
+## Consequences
+- Users can switch servers without touching per-model config:
+  - `--target vllm-local` vs `--target openrouter`
+- We avoid “vllm backend” proliferation while still making vLLM the primary recommended server engine.
+
+## Follow-ups
+- Spec: `docs/specs/0012-openai-targets-and-server-config-separation.md`
+
diff --git a/docs/decisions/0014-status-and-show-command-ux.md b/docs/decisions/0014-status-and-show-command-ux.md
new file mode 100644
index 0000000..4baaefc
--- /dev/null
+++ b/docs/decisions/0014-status-and-show-command-ux.md
@@ -0,0 +1,29 @@
+#!/usr/bin/env markdown
+# Decision: Add `/status` and make `/show` the primary inspector (with hidden aliases)
+
+Date: 2026-03-08
+
+## Context
+Slash commands grew organically. We need:
+- a concise “what’s going on?” view for normal use
+- a consistent deep-inspection surface for debugging
+- fewer primary commands in help, without breaking old muscle memory
+
+## Decision
+- Add `/status` as the default concise runtime summary.
+- Keep `/show` as the primary deep inspection command (topics + `--verbose`).
+- Keep existing shortcut commands as hidden aliases mapping to `/show <topic>` for backward compatibility.
+- Add `/show logs` (and optionally `/show request`) to enable managed-mode debugging without leaving the TUI.
+- Standardize backend log introspection with a shared in-memory tail contract:
+  - backend sessions expose `get_recent_logs(n=80) -> list[str]`
+  - `/show logs` reads this method across backends
+  - file logging remains optional and separate from in-memory tails
+
+## Consequences
+- Help output becomes cleaner and more navigable.
+- Debugging managed vLLM becomes feasible without rerunning in “external attach” mode.
+- Debugging is more consistent across backends, even when file logging was not enabled.
+- We can later add session save/restore without multiplying commands.
+
+## Spec
+- `docs/specs/0014-tui-status-and-show-inspect.md`
diff --git a/docs/decisions/0015-token-accounting-and-metrics.md b/docs/decisions/0015-token-accounting-and-metrics.md
new file mode 100644
index 0000000..ccc002d
--- /dev/null
+++ b/docs/decisions/0015-token-accounting-and-metrics.md
@@ -0,0 +1,39 @@
+# 0015 - Token Accounting And Metrics
+
+Date: 2026-03-08
+
+## Context
+This repo supports multiple backends (HF, GGUF/llama.cpp, EXL2, Ollama, OpenAI-compatible servers, vLLM managed server).
+
+We need consistent and reliable performance/behavior metrics in the TUI:
+- prompt token counts
+- completion token counts
+- total tokens
+- tokens/sec
+
+Today, some backends can report exact tokens (token IDs or backend usage), while others only have streamed text.
+
+## Decision
+Token counts should come from the most reliable source available, in this order:
+
+1. Backend-native usage counters (preferred)
+- Server-provided `usage` fields (OpenAI-compatible servers/vLLM when enabled)
+- Engine-provided token IDs (EXL2)
+
+2. Backend tokenization API
+- llama.cpp tokenization (`llama_cpp.Llama.tokenize`) for GGUF
+
+3. Retokenization fallback (last resort)
+- Only when a tokenizer is already loaded as part of normal operation
+- Avoid loading heavyweight tokenizers solely for metrics
+
+UI/display rules:
+- `/show` must prefer token metrics when available.
+- If token metrics are unavailable, show “unavailable” explicitly (don’t substitute characters and imply they are tokens).
+- Character counts may still be shown as a secondary diagnostic signal.
+
+## Consequences
+- Adding a new backend requires deciding how token counts will be obtained and documented.
+- OpenAI-compatible transports should parse and store usage when the server can provide it.
+- Backends that cannot provide reliable token counts should clearly report that limitation in notes and `/show`.
+
diff --git a/docs/decisions/0016-observability-boundary-and-external-dashboard.md b/docs/decisions/0016-observability-boundary-and-external-dashboard.md
new file mode 100644
index 0000000..1ef53a1
--- /dev/null
+++ b/docs/decisions/0016-observability-boundary-and-external-dashboard.md
@@ -0,0 +1,52 @@
+# 0016 - Keep telemetry in this repo and build the dashboard separately
+
+Date: 2026-03-15
+
+## Context
+This repo is a local model lab for backend experimentation, runtime tuning, and model/application research.
+
+It already spans:
+- multiple inference backends
+- model-first config and notes
+- terminal interaction surfaces
+- backend standardization work
+
+Observability is aligned with the repo's purpose, but a full browser dashboard introduces a second product with distinct concerns:
+- frontend architecture
+- dashboard persistence and compare workflows
+- visualization UX
+- external adoption by users who may not want the full runner repo
+
+Keeping all of that in this repo would increase clutter and weaken separation between:
+- runner/backend experimentation
+- dashboard product development
+
+## Decision
+This repo will own the observability production side:
+- canonical telemetry schema
+- backend telemetry adapters
+- session and turn event emission
+- optional export endpoints such as Prometheus-compatible metrics
+- documentation for external observability consumers
+
+This repo will not own the long-term browser dashboard product.
+
+The dashboard should live in a separate repo and consume this repo through stable external interfaces rather than importing internal runner modules directly.
+
+We will support two external boundaries:
+
+1. Metrics boundary
+- Prometheus-compatible numeric metrics export
+
+2. App boundary
+- richer JSON/event interfaces for sessions, turns, logs, inspect data, and experiment metadata
+
+Prometheus support is optional but recommended as an export format.
+It is not the canonical internal model.
+
+## Consequences
+- Observability work in this repo should focus on schema, emission, and export.
+- Browser dashboard implementation should not be added to this repo as the default path.
+- Prometheus metrics must be derived from the repo-owned telemetry model, not used as the primary source of truth.
+- A downstream dashboard can be useful both to this repo and to other experimenters with different runners if the boundary stays clean.
+- Future implementation specs in this repo should describe telemetry contracts and export behavior, while dashboard UI specs belong in the dashboard repo.
diff --git a/docs/decisions/0017-canonical-telemetry-schema-and-dual-export.md b/docs/decisions/0017-canonical-telemetry-schema-and-dual-export.md
new file mode 100644
index 0000000..a7bdaeb
--- /dev/null
+++ b/docs/decisions/0017-canonical-telemetry-schema-and-dual-export.md
@@ -0,0 +1,61 @@
+# 0017 - Canonical telemetry schema with dual export surfaces
+
+Date: 2026-03-15
+
+## Context
+Decision `0016` establishes that this repo owns telemetry production and export, while the browser dashboard lives in a separate repo.
+
+That leaves two related questions:
+- what is the canonical telemetry model in this repo?
+- how should external consumers read it?
+
+We need:
+- one stable internal schema across backends
+- one export path for numeric metric tooling
+- one richer export path for session- and turn-aware consumers
+
+If we let Prometheus define the model, we lose important semantics like:
+- per-turn request truth
+- logs
+- inspect payloads
+- experiment/session structure
+
+If we only expose a custom app API, we lose easy compatibility with Grafana and standard exporter workflows.
+
+## Decision
+This repo will use a canonical telemetry schema as the source of truth.
+
+That schema will cover:
+- sessions
+- load reports
+- turn summaries
+- runtime samples
+- logs
+- errors
+
+This repo will support two export surfaces derived from that schema:
+
+1. App export surface
+- JSON-shaped events for rich downstream consumers
+- MVP delivery in this repo is in-process publication with an optional JSONL sink
+- Network-facing app APIs are deferred to downstream consumers unless a later decision changes that
+
+2. Metrics export surface
+- Prometheus-compatible numeric metrics for scrape-based tooling
+
+Prometheus is an export format, not the canonical model.
+Prometheus support is expected to be disabled by default and enabled explicitly when needed.
+
+The telemetry model should be:
+- backend-agnostic by default
+- extensible for backend-specific facts
+- additive and versioned
+- tolerant of unknown/unavailable fields without fabricating values
+
+## Consequences
+- Telemetry work in this repo should start from canonical event/entity design, not from metric label design.
+- Any Prometheus metric added here should be traceable back to a canonical schema field.
+- Rich downstream consumers such as the future dashboard repo should prefer the app export surface.
+- The dashboard repo should ingest telemetry and expose its own REST/SSE surfaces instead of relying on `model-runner` to host them.
+- Backend adapters must explicitly represent unavailable facts instead of inferring them.
+- Future schema evolution should prefer additive changes and explicit versioning.
diff --git a/docs/decisions/README.md b/docs/decisions/README.md
index 59dc79c..d538dbe 100644
--- a/docs/decisions/README.md
+++ b/docs/decisions/README.md
@@ -15,6 +15,14 @@ This folder stores short decision records (ADRs) for choices made while evolving
 | 0007 | Adopt model-first `models/` workspace | Organize notes/config/templates/prompts under `models/<model>/<backend>/...`. |
 | 0008 | TUI follow mode is intent-driven | Follow state changes only from explicit user scroll intent, not passive scroll-delta inference. |
 | 0009 | TUI slash commands are local-only and registry-driven | Provide in-TUI introspection without sending commands to the model. |
+| 0010 | Mirror PR review output into a `reviews` branch | CI writes bot review bundles to an orphan `reviews` branch for local/offline reading. |
+| 0011 | Adopt TOML configs with profiles and machine-local overrides | Switch primary config to TOML sections; add profiles and local-only machine overrides. |
+| 0012 | Store upstream model cards as `notes/model_card.md` | Keep upstream HF README content separate from repo-local notes. |
+| 0013 | Keep `openai` backend name; add “targets” for multiple servers | Name backends by protocol contract; add `config/targets/openai/` for endpoints/auth. |
+| 0014 | Add `/status`; make `/show` the primary inspector | Provide concise status + verbose inspection; keep old shortcuts as hidden aliases. |
+| 0015 | Token accounting and metrics | Prefer backend-native usage/token IDs; fall back to backend tokenization; avoid char-as-token substitutions. |
+| 0016 | Keep telemetry in this repo and build the dashboard separately | Scope this repo to telemetry/schema/export and keep the browser dashboard in a separate repo. |
+| 0017 | Canonical telemetry schema with dual export surfaces | Use a repo-owned telemetry model and derive both JSON app exports and Prometheus metrics from it. |
 
 ## Format
 
diff --git a/docs/decisions/offline-quant-artifacts.md b/docs/decisions/offline-quant-artifacts.md
new file mode 100644
index 0000000..2d49872
--- /dev/null
+++ b/docs/decisions/offline-quant-artifacts.md
@@ -0,0 +1,16 @@
+# Offline Quant Artifacts
+
+## Decision
+Quantization artifacts are produced offline from this repo but stored outside the repo with the rest of the machine-local model weights.
+
+## Why
+- quantized artifacts are large and machine-local
+- quantization is a prep workflow, not a runtime backend
+- model-specific config still belongs in this repo next to notes and runtime config
+
+## Rules
+- keep compressor config under `models/<model>/vllm/compressor/`
+- write artifacts under `~/ml/models/quants/<model>/<scheme>/...`
+- preserve run history under `runs/`
+- expose a stable `current` symlink for serving tools
+- keep a manifest next to each saved artifact
diff --git a/docs/entrypoints.md b/docs/entrypoints.md
index 358b240..3dfd3cc 100644
--- a/docs/entrypoints.md
+++ b/docs/entrypoints.md
@@ -6,9 +6,9 @@ This repo intentionally has a few small “front door” scripts. Pick the one t
 
 Use `tui.py` when you want a terminal UI (scrollback, collapsible thinking, streaming) and/or you want to switch between backends with one command.
 
-Optional: install a console entrypoint so you can run `tui ...` instead of `python tui.py ...`:
+Recommended environment setup:
 ```bash
-pip install -e .
+uv sync --python 3.11
 ```
 
 What it supports:
@@ -19,28 +19,54 @@ What it supports:
 
 Examples:
 ```bash
-# HF (local folder under ~/ml/models/ or an HF id)
-tui Nanbeige4.1-3B
-python tui.py Nanbeige4.1-3B
-python tui.py --config Nanbeige4.1-3B
+# HF (local folder under ~/models/local/ or an HF id)
+uv run tui Nanbeige4.1-3B
+uv run python tui.py Nanbeige4.1-3B
+uv run python tui.py --config Nanbeige4.1-3B
 
 # GGUF (auto-detected by .gguf extension)
-tui /mnt/d/models/your-model.gguf
-python tui.py /mnt/d/models/your-model.gguf
+uv run tui ~/models/local/gguf/your-model.gguf
+uv run python tui.py ~/models/local/gguf/your-model.gguf
 
 # Ollama (explicit by scheme prefix)
-tui ollama:your-ollama-model
-python tui.py ollama:your-ollama-model
-python tui.py ollama:your-ollama-model --ollama-think false
+uv run tui ollama:your-ollama-model
+uv run python tui.py ollama:your-ollama-model
+uv run python tui.py ollama:your-ollama-model --ollama-think false
 
 # EXL2 (directory path is ambiguous with HF; use --backend)
-tui --backend exl2 /path/to/exl2_model_dir
-python tui.py --backend exl2 /path/to/exl2_model_dir
+uv run tui --backend exl2 /path/to/exl2_model_dir
+uv run python tui.py --backend exl2 /path/to/exl2_model_dir
 ```
 
 Notes:
 - EXL2 setup can be finicky under WSL; see `docs/exl2_setup.md`.
 
+## Managed vLLM backend control
+
+Use the root helper commands when you want to run managed vLLM from repo config without entering the TUI.
+
+Examples:
+```bash
+# Foreground managed vLLM only
+./vllm-up --config Qwen3.5-9B
+
+# Detached managed vLLM only
+./vllm-up --config Qwen3.5-9B --bg
+
+# Stop detached managed vLLM for that config slot
+./vllm-down --config Qwen3.5-9B
+```
+
+Notes:
+- `./vllm-up` is a thin wrapper over `python tui.py --backend vllm --backend-only ...`
+- `--bg` adds `--detach-backend`
+- detached managed vLLM is reattachable from the TUI via the same config
+- from inside the TUI:
+  - `Ctrl+Q` or `/exit` leaves managed vLLM running
+  - `/quit` shuts managed vLLM down
+- this Fedora machine should use the single repo `.venv` built manually with `uv venv .venv --python 3.12`
+- the managed launcher injects repo-local Torch and NVIDIA library directories automatically, so `./vllm-up` is the preferred path for Fedora serving checks
+
 Notes:
 - `tui_app/` is an internal package used by `tui.py` (don’t run `tui_app/app.py` directly).
 - Backend detection is deterministic:
@@ -48,7 +74,7 @@ Notes:
   - `*.gguf` → GGUF
   - existing directory → HF
   - otherwise → HF
-- When running under WSL, Windows paths like `D:\models\foo.gguf` are normalized to `/mnt/d/models/foo.gguf`.
+- This Fedora machine expects local assets under `~/models`, not WSL `/mnt/d/...` paths.
 
 ## HF CLI chat (template-aware)
 
@@ -56,8 +82,8 @@ Use `chat.py` when you want a simple terminal chat loop (no TUI) and you’re wo
 
 Examples:
 ```bash
-python chat.py Nanbeige4.1-3B
-python chat.py --config Nanbeige4.1-3B
+uv run python chat.py Nanbeige4.1-3B
+uv run python chat.py --config Nanbeige4.1-3B
 
 # Force plain prompting (no chat template)
 python chat.py Nanbeige4.1-3B --prompt-mode plain
@@ -74,10 +100,10 @@ Use `runner.py` when you want the most minimal “type prompt → get completion
 
 Examples:
 ```bash
-python runner.py Nanbeige4.1-3B
-python runner.py --config Nanbeige4.1-3B
-python runner.py Nanbeige4.1-3B -8bit
-python runner.py Nanbeige4.1-3B -4bit
+uv run python runner.py Nanbeige4.1-3B
+uv run python runner.py --config Nanbeige4.1-3B
+uv run python runner.py Nanbeige4.1-3B -8bit
+uv run python runner.py Nanbeige4.1-3B -4bit
 ```
 
 ## Backend-specific standalone scripts (non-TUI)
@@ -86,12 +112,12 @@ These are useful for isolating backend issues or doing quick checks without the
 
 - `alex.py` (GGUF / llama.cpp chat CLI)
   ```bash
-  python alex.py /path/to/model.gguf
+  uv run python alex.py /path/to/model.gguf
   ```
 
 - `ollama_chat.py` (Ollama streaming CLI)
   ```bash
-  python ollama_chat.py your-ollama-model
+  uv run python ollama_chat.py your-ollama-model
   ```
 
 ## Legacy / experimental
diff --git a/docs/environments/machine_spec.json b/docs/environments/machine_spec.json
new file mode 100644
index 0000000..275f7b0
--- /dev/null
+++ b/docs/environments/machine_spec.json
@@ -0,0 +1,528 @@
+[
+  {
+    "type": "Title",
+    "result": {
+      "userId": 1000,
+      "userName": "poop",
+      "fullUserName": ",,,",
+      "hostName": "DESKTOP-MDLU7UA",
+      "homeDir": "/home/poop/",
+      "exePath": "/usr/bin/fastfetch",
+      "userShell": "/bin/bash",
+      "pid": 14295,
+      "cwd": "/home/poop/projects/agentmux/"
+    }
+  },
+  {
+    "type": "Separator",
+    "error": "Unsupported for JSON format"
+  },
+  {
+    "type": "OS",
+    "result": {
+      "buildID": "",
+      "codename": "jammy",
+      "id": "ubuntu",
+      "idLike": "debian",
+      "name": "Ubuntu",
+      "prettyName": "Ubuntu 22.04.2 LTS (Jammy Jellyfish)",
+      "variant": "",
+      "variantID": "",
+      "version": "22.04.2 LTS (Jammy Jellyfish)",
+      "versionID": "22.04"
+    }
+  },
+  {
+    "type": "Host",
+    "result": {
+      "family": "WSL",
+      "name": "Windows Subsystem for Linux - Ubuntu",
+      "version": "2.6.3.0",
+      "sku": "",
+      "vendor": "Microsoft Corporation",
+      "serial": "",
+      "uuid": ""
+    }
+  },
+  {
+    "type": "Kernel",
+    "result": {
+      "architecture": "x86_64",
+      "name": "Linux",
+      "release": "6.6.87.2-microsoft-standard-WSL2",
+      "version": "#1 SMP PREEMPT_DYNAMIC Thu Jun  5 18:30:46 UTC 2025",
+      "pageSize": 4096
+    }
+  },
+  {
+    "type": "Uptime",
+    "result": {
+      "uptime": 1009529960,
+      "bootTime": "2026-03-07T15:58:18.475-0700"
+    }
+  },
+  {
+    "type": "Packages",
+    "result": {
+      "all": 1246,
+      "amSystem": 0,
+      "amUser": 0,
+      "apk": 0,
+      "brew": 59,
+      "brewCask": 0,
+      "choco": 0,
+      "dpkg": 1181,
+      "emerge": 0,
+      "eopkg": 0,
+      "flatpakSystem": 0,
+      "flatpakUser": 0,
+      "guixSystem": 0,
+      "guixUser": 0,
+      "guixHome": 0,
+      "hpkgSystem": 0,
+      "hpkgUser": 0,
+      "kiss": 0,
+      "linglong": 0,
+      "macports": 0,
+      "mport": 0,
+      "moss": 0,
+      "nixDefault": 0,
+      "nixSystem": 0,
+      "nixUser": 0,
+      "opkg": 0,
+      "pacman": 0,
+      "pacstall": 0,
+      "paludis": 0,
+      "pisi": 0,
+      "pkg": 0,
+      "pkgtool": 0,
+      "pkgsrc": 0,
+      "rpm": 0,
+      "scoopUser": 0,
+      "scoopGlobal": 0,
+      "snap": 6,
+      "soar": 0,
+      "sorcery": 0,
+      "winget": 0,
+      "xbps": 0,
+      "pacmanBranch": ""
+    }
+  },
+  {
+    "type": "Shell",
+    "result": {
+      "exe": "bash",
+      "exeName": "bash",
+      "exePath": "/usr/bin/bash",
+      "pid": 89137,
+      "ppid": 89133,
+      "processName": "bash",
+      "prettyName": "bash",
+      "version": "5.1.16",
+      "tty": 66
+    }
+  },
+  {
+    "type": "Display",
+    "result": [
+      {
+        "id": 206920770674,
+        "name": "rdp-0",
+        "primary": false,
+        "output": {
+          "width": 3840,
+          "height": 2160,
+          "refreshRate": 60.0,
+          "drrStatus": null
+        },
+        "scaled": {
+          "width": 3840,
+          "height": 2160
+        },
+        "preferred": {
+          "width": 3840,
+          "height": 2160,
+          "refreshRate": 60.0
+        },
+        "physical": {
+          "width": 0,
+          "height": 0
+        },
+        "rotation": 0,
+        "bitDepth": 0,
+        "hdrStatus": null,
+        "type": "Unknown",
+        "manufactureDate": null,
+        "serial": null,
+        "platformApi": "wayland-global"
+      }
+    ]
+  },
+  {
+    "type": "DE",
+    "error": "No DE found"
+  },
+  {
+    "type": "WM",
+    "result": {
+      "processName": "WSLg",
+      "prettyName": "WSLg",
+      "protocolName": "Wayland",
+      "pluginName": "",
+      "version": "1.0.71"
+    }
+  },
+  {
+    "type": "WMTheme",
+    "error": "Unknown WM: WSLg"
+  },
+  {
+    "type": "Theme",
+    "result": {
+      "theme1": "",
+      "theme2": "Yaru [GTK3]"
+    }
+  },
+  {
+    "type": "Icons",
+    "result": {
+      "icons1": "",
+      "icons2": "Yaru [GTK3]"
+    }
+  },
+  {
+    "type": "Font",
+    "error": "No fonts found"
+  },
+  {
+    "type": "Cursor",
+    "error": "WSLg uses native windows cursor"
+  },
+  {
+    "type": "Terminal",
+    "result": {
+      "processName": "Windows Terminal",
+      "exe": "Windows Terminal",
+      "exeName": "Windows Terminal",
+      "exePath": "",
+      "pid": 0,
+      "ppid": 0,
+      "prettyName": "Windows Terminal",
+      "version": "",
+      "tty": ""
+    }
+  },
+  {
+    "type": "TerminalFont",
+    "error": "Unknown terminal: Windows Terminal"
+  },
+  {
+    "type": "CPU",
+    "result": {
+      "cpu": "13th Gen Intel(R) Core(TM) i9-13900K",
+      "vendor": "GenuineIntel",
+      "packages": 1,
+      "cores": {
+        "physical": 16,
+        "logical": 32,
+        "online": 32
+      },
+      "frequency": {
+        "base": 2995,
+        "max": 0
+      },
+      "coreTypes": [],
+      "temperature": null,
+      "march": "x86_64-v3",
+      "numaNodes": 1
+    }
+  },
+  {
+    "type": "GPU",
+    "result": [
+      {
+        "index": null,
+        "coreCount": null,
+        "coreUsage": null,
+        "memory": {
+          "dedicated": {
+            "total": 25310527488,
+            "used": null
+          },
+          "shared": {
+            "total": 34196840448,
+            "used": null
+          },
+          "type": null
+        },
+        "driver": "32.0.15.9174",
+        "name": "NVIDIA GeForce RTX 4090",
+        "temperature": null,
+        "type": "Discrete",
+        "vendor": "NVIDIA",
+        "platformApi": "DXCore",
+        "frequency": null,
+        "deviceId": 9223372043527772130
+      },
+      {
+        "index": null,
+        "coreCount": null,
+        "coreUsage": null,
+        "memory": {
+          "dedicated": {
+            "total": 134217728,
+            "used": null
+          },
+          "shared": {
+            "total": 34196840448,
+            "used": null
+          },
+          "type": null
+        },
+        "driver": "32.0.101.6129",
+        "name": "Intel(R) UHD Graphics 770",
+        "temperature": null,
+        "type": "Integrated",
+        "vendor": "Intel",
+        "platformApi": "DXCore",
+        "frequency": null,
+        "deviceId": 9223372036864919049
+      }
+    ]
+  },
+  {
+    "type": "Memory",
+    "result": {
+      "total": 33489530880,
+      "used": 17566490624
+    }
+  },
+  {
+    "type": "Swap",
+    "result": [
+      {
+        "name": "/dev/sdc",
+        "used": 3775799296,
+        "total": 8589934592
+      }
+    ]
+  },
+  {
+    "type": "Disk",
+    "result": [
+      {
+        "bytes": {
+          "available": 600371486720,
+          "free": 655363842048,
+          "total": 1081101176832,
+          "used": 425737334784
+        },
+        "files": {
+          "total": 67108864,
+          "used": 1154056
+        },
+        "filesystem": "ext4",
+        "mountpoint": "/",
+        "mountFrom": "/dev/sdd",
+        "name": "",
+        "volumeType": [
+          "Regular"
+        ],
+        "createTime": "2023-05-18T16:08:38.000-0600"
+      },
+      {
+        "bytes": {
+          "available": 120648065024,
+          "free": 120648065024,
+          "total": 999212183552,
+          "used": 878564118528
+        },
+        "files": {
+          "total": null,
+          "used": null
+        },
+        "filesystem": "9p",
+        "mountpoint": "/mnt/c",
+        "mountFrom": "C:\\",
+        "name": "",
+        "volumeType": [
+          "Regular"
+        ],
+        "createTime": null
+      },
+      {
+        "bytes": {
+          "available": 1324152971264,
+          "free": 1324152971264,
+          "total": 2000382062592,
+          "used": 676229091328
+        },
+        "files": {
+          "total": null,
+          "used": null
+        },
+        "filesystem": "9p",
+        "mountpoint": "/mnt/d",
+        "mountFrom": "D:\\",
+        "name": "",
+        "volumeType": [
+          "Regular"
+        ],
+        "createTime": null
+      },
+      {
+        "bytes": {
+          "available": 600371486720,
+          "free": 655363842048,
+          "total": 1081101176832,
+          "used": 425737334784
+        },
+        "files": {
+          "total": 67108864,
+          "used": 1154056
+        },
+        "filesystem": "ext4",
+        "mountpoint": "/mnt/wsl/docker-desktop-bind-mounts/Ubuntu/33b96756f091cb663c2b495b391ca25ca7c682c3e72b6b855cbed8c20816e98b",
+        "mountFrom": "/dev/sdd",
+        "name": "",
+        "volumeType": [
+          "Subvolume"
+        ],
+        "createTime": "2026-02-20T23:22:19.613-0700"
+      },
+      {
+        "bytes": {
+          "available": 600371486720,
+          "free": 655363842048,
+          "total": 1081101176832,
+          "used": 425737334784
+        },
+        "files": {
+          "total": 67108864,
+          "used": 1154056
+        },
+        "filesystem": "ext4",
+        "mountpoint": "/mnt/wsl/docker-desktop-bind-mounts/Ubuntu/58facffa7a12adeadf090f2a6f60e860c66e6feeec7038d6cbf2200933f4d0af",
+        "mountFrom": "/dev/sdd",
+        "name": "",
+        "volumeType": [
+          "Subvolume"
+        ],
+        "createTime": "2026-03-14T11:32:12.261-0600"
+      },
+      {
+        "bytes": {
+          "available": 600371486720,
+          "free": 655363842048,
+          "total": 1081101176832,
+          "used": 425737334784
+        },
+        "files": {
+          "total": 67108864,
+          "used": 1154056
+        },
+        "filesystem": "ext4",
+        "mountpoint": "/mnt/wsl/docker-desktop-bind-mounts/Ubuntu/a493b6793413e8bcd32e1716a662a70f080eba57ee8c88e5c2c27b03212a4ed1",
+        "mountFrom": "/dev/sdd",
+        "name": "",
+        "volumeType": [
+          "Subvolume"
+        ],
+        "createTime": "2026-03-13T14:39:40.969-0600"
+      },
+      {
+        "bytes": {
+          "available": 57313280,
+          "free": 68396032,
+          "total": 142625792,
+          "used": 74229760
+        },
+        "files": {
+          "total": 38608,
+          "used": 836
+        },
+        "filesystem": "ext4",
+        "mountpoint": "/mnt/wsl/docker-desktop/docker-desktop-user-distro",
+        "mountFrom": "/dev/sde",
+        "name": "",
+        "volumeType": [
+          "Regular"
+        ],
+        "createTime": "2026-02-05T22:56:43.000-0700"
+      },
+      {
+        "bytes": {
+          "available": 600371486720,
+          "free": 655363842048,
+          "total": 1081101176832,
+          "used": 425737334784
+        },
+        "files": {
+          "total": 67108864,
+          "used": 1154056
+        },
+        "filesystem": "ext4",
+        "mountpoint": "/mnt/wslg/distro",
+        "mountFrom": "/dev/sdd",
+        "name": "",
+        "volumeType": [
+          "Subvolume",
+          "Read-only"
+        ],
+        "createTime": "2023-05-18T16:08:38.000-0600"
+      },
+      {
+        "bytes": {
+          "available": 600371486720,
+          "free": 655363842048,
+          "total": 1081101176832,
+          "used": 425737334784
+        },
+        "files": {
+          "total": 67108864,
+          "used": 1154056
+        },
+        "filesystem": "ext4",
+        "mountpoint": "/snap",
+        "mountFrom": "/dev/sdd",
+        "name": "",
+        "volumeType": [
+          "Subvolume"
+        ],
+        "createTime": "2023-05-18T16:08:38.992-0600"
+      }
+    ]
+  },
+  {
+    "type": "LocalIp",
+    "result": [
+      {
+        "name": "eth0",
+        "defaultRoute": {
+          "ipv4": true
+        },
+        "ipv4": "172.26.0.43/20"
+      }
+    ]
+  },
+  {
+    "type": "Battery",
+    "result": []
+  },
+  {
+    "type": "PowerAdapter",
+    "result": []
+  },
+  {
+    "type": "Locale",
+    "result": "C.UTF-8"
+  },
+  {
+    "type": "Break",
+    "error": "Unsupported for JSON format"
+  },
+  {
+    "type": "Colors",
+    "error": "Unsupported for JSON format"
+  }
+]
diff --git a/docs/environments/primary-dev-machine.md b/docs/environments/primary-dev-machine.md
deleted file mode 100644
index 95eb13d..0000000
--- a/docs/environments/primary-dev-machine.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# Primary dev machine
-
-Captured: 2026-03-02
-
-## Hardware (user-reported)
-- GPU: NVIDIA RTX 4090 (24 GB VRAM)
-  - Note: user reported “55.8 GB of GPU memory” shown by the OS/UI; that typically includes **shared/system memory**. This repo’s guidance assumes **VRAM (24 GB)** when discussing “GPU memory”.
-- CPU: Intel i9
-- RAM: 64 GB
-
-## Usage intent
-- Prefer running models fully on VRAM (no CPU offload).
-- Used for local HF checkpoints under `/home/poop/ml/models/` and for evaluating long-context behavior.
-
diff --git a/docs/environments/useful_cli_commands b/docs/environments/useful_cli_commands
index 0153d36..01b5586 100644
--- a/docs/environments/useful_cli_commands
+++ b/docs/environments/useful_cli_commands
@@ -1,4 +1,39 @@
+  Examples:
+
+  On this Fedora machine, raw vLLM CLI calls need the repo-local Torch/NVIDIA libs on
+  `LD_LIBRARY_PATH`. The managed `./vllm-up` wrapper already does this for you. For direct
+  CLI inspection, use:
+
+  export LD_LIBRARY_PATH="/home/poop/code/dev/model-runner/.venv/lib/python3.12/site-packages/torch/lib:/home/poop/code/dev/model-runner/.venv/lib/python3.12/site-packages/nvidia/cuda_runtime/lib:/home/poop/code/dev/model-runner/.venv/lib/python3.12/site-packages/nvidia/cu13/lib:/home/poop/code/dev/model-runner/.venv/lib/python3.12/site-packages/nvidia/cudnn/lib:/home/poop/code/dev/model-runner/.venv/lib/python3.12/site-packages/nvidia/nccl/lib:/home/poop/code/dev/model-runner/.venv/lib/python3.12/site-packages/nvidia/nvshmem/lib:/home/poop/code/dev/model-runner/.venv/lib/python3.12/site-packages/nvidia/cusparselt/lib:${LD_LIBRARY_PATH:-}"
+
+  .venv/bin/python -m vllm.entrypoints.cli.main serve --help=all | rg "FLASH|flash|attn|attention"
+
+  For FlashInfer specifically:
+
+  .venv/bin/python -m vllm.entrypoints.cli.main serve --help=all | rg "FLASHINFER|flashinfer"
+
+  For KV cache options:
+
+  .venv/bin/python -m vllm.entrypoints.cli.main serve --help=all | rg "kv-cache|kv cache|fp8"
+
+  If you want to see the attention backend enum line only:
+
+  .venv/bin/python -m vllm.entrypoints.cli.main serve --help=all | rg "^  --attention-backend"
+
+  And if you want a bit of surrounding context:
+
+  .venv/bin/python -m vllm.entrypoints.cli.main serve --help=all | rg -n -C 3 "attention-backend|FLASHINFER|kv-cache-dtype|fp8"
+
 # Useful CLI Commands
+
+# Repo-local command surface
+# Add once per shell/session:
+export PATH="/home/poop/ml/model-runner/bin:$PATH"
+
+# Managed vLLM from repo config
+./vllm-up --config Qwen3.5-9B
+./vllm-up --config Qwen3.5-9B --bg
+./vllm-down --config Qwen3.5-9B
 # nvidia-smi with GPU utilization, memory usage, temperature, and power draw, updated every 0.5 seconds, formatted in a readable table
 nvidia-smi --query-gpu=index,name,utilization.gpu,utilization.memory,memory.used,memory.total,temperature.gpu,power.draw
 --format=csv,noheader,nounits -l 0.5 \
@@ -175,4 +210,4 @@ And:
 import flash_attn, torch
 print("flash_attn", flash_attn.__version__)
 print("torch", torch.__version__, "cuda", torch.version.cuda)
-PY
\ No newline at end of file
+PY
diff --git a/docs/kv_quant_w_compressor b/docs/kv_quant_w_compressor
new file mode 100644
index 0000000..f57c384
--- /dev/null
+++ b/docs/kv_quant_w_compressor
@@ -0,0 +1,85 @@
+"""
+[Recommended] Calibration Using a Dataset (with llm-compressor)¶
+For the highest-quality quantization, we recommend calibrating against a dataset using llm-compressor. This enables advanced strategies such as per-attention-head quantization.
+
+Install the required package¶
+
+pip install llmcompressor
+Example: Quantize Llama Attention & KV Cache to FP8¶
+
+
+Quantize Llama attention + KV cache to FP8 (choose either 'tensor' or 'attn_head' strategy)
+using llm-compressor one-shot calibration.
+"""
+
+from datasets import load_dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from llmcompressor import oneshot
+from llmcompressor.modifiers.quantization import QuantizationModifier
+from compressed_tensors.quantization import QuantizationScheme, QuantizationArgs
+
+# -----------------------------
+# Config
+# -----------------------------
+MODEL_ID = "meta-llama/Llama-3.1-8B-Instruct"
+DATASET_ID = "HuggingFaceH4/ultrachat_200k"
+DATASET_SPLIT = "train_sft"
+STRATEGY = "tensor"       # or "attn_head"
+NUM_CALIB_SAMPLES = 512   # Good starting value
+MAX_SEQ_LEN = 2048
+
+# -----------------------------
+# Helpers
+# -----------------------------
+def process_and_tokenize(example, tokenizer: AutoTokenizer):
+    """Convert chat messages to tokens."""
+    text = tokenizer.apply_chat_template(example["messages"], tokenize=False)
+    return tokenizer(
+        text,
+        padding=False,
+        max_length=MAX_SEQ_LEN,
+        truncation=True,
+        add_special_tokens=False,
+    )
+
+def build_recipe(strategy: str) -> QuantizationModifier:
+    fp8_args = QuantizationArgs(num_bits=8, type="float", strategy=strategy)
+    return QuantizationModifier(
+        config_groups={
+            "attention": QuantizationScheme(
+                targets=["LlamaAttention"],  # Quantize queries: q_scale
+                input_activations=fp8_args,
+            )
+        },
+        kv_cache_scheme=fp8_args,           # Quantize KV cache: k/v_scale
+    )
+
+# -----------------------------
+# Main
+# -----------------------------
+def main():
+    model = AutoModelForCausalLM.from_pretrained(MODEL_ID, torch_dtype="auto")
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+    ds = load_dataset(DATASET_ID, split=f"{DATASET_SPLIT}[:{NUM_CALIB_SAMPLES}]")
+    ds = ds.shuffle(seed=42)
+    ds = ds.map(
+        lambda ex: process_and_tokenize(ex, tokenizer),
+        remove_columns=ds.column_names,
+    )
+
+    recipe = build_recipe(STRATEGY)
+    oneshot(
+        model=model,
+        dataset=ds,
+        recipe=recipe,
+        max_seq_length=MAX_SEQ_LEN,
+        num_calibration_samples=NUM_CALIB_SAMPLES,
+    )
+
+    save_dir = f"{MODEL_ID.rstrip('/').split('/')[-1]}-kvattn-fp8-{STRATEGY}"
+    model.save_pretrained(save_dir, save_compressed=True)
+    tokenizer.save_pretrained(save_dir)
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/docs/memory_options.md b/docs/memory_options.md
new file mode 100644
index 0000000..b480397
--- /dev/null
+++ b/docs/memory_options.md
@@ -0,0 +1,64 @@
+# Here are the main “clever” strategies that fit this repo:
+
+## 1) Sliding “working set” + summarization (classic)
+
+Policy:
+
+- Keep the last N turns verbatim (your working set).
+- Everything older collapses into a running summary (“long-term memory”) that gets injected as a system/developer message.
+
+Practical details that matter:
+
+- Summaries must be stable and structured (facts, decisions, TODOs), not prose.
+- Update summary only when needed (e.g. every 3 turns or when tokens exceed threshold) to avoid drift/cost.
+
+Where it plugs in here:
+
+- Right before backend prompt rendering (i.e., build trimmed_messages).
+- This is exactly the place we’re already standardizing with trimmed_messages + context trimming.
+
+## 2) Hybrid: “facts memory” + “scratchpad memory”
+
+Instead of one summary, keep two:
+
+- Facts/Preferences/Config: stable, rarely changes.
+- Scratchpad/Progress: current task state, recent steps.
+
+This reduces “summary churn” and keeps the model anchored.
+
+## 3) Retrieval-lite (no vector DB) using “notebook pages”
+
+Create a local “notebook” file per session:
+
+- Append key items (decisions, code refs, constraints).
+- When tokens get tight, inject only the relevant notebook sections (by simple keyword match).
+
+This avoids embeddings infra and is surprisingly effective for coding/ops workflows.
+
+## 4) Tool-augmented memory (once tool harness exists)
+
+
+- takes the overflow transcript chunk
+- returns a structured summary block
+Then store it and inject it next turn.
+
+This gives you controllable, logged summarization, and you can swap the summarizer model later (fast small model).
+
+## 5) “Never re-feed chain-of-thought” (already aligned with your direction)
+
+This is basically history_strip_think=true (spec 0019):
+
+- show thinking in UI
+- don’t re-inject it into context
+This alone can reclaim a lot of budget on reasoning-ish models.
+
+## 6) “Token budget governor”
+
+Before each turn:
+
+- compute prompt_tokens (we’re standardizing this now)
+- if near limit:
+    - drop low-value messages first (banter, acknowledgements)
+    - then summarize
+    - then drop entire tool bundles as units (per spec 0020)
+    This makes behavior predictable and debuggable.
\ No newline at end of file
diff --git a/docs/observability_dashboard b/docs/observability_dashboard
new file mode 100644
index 0000000..597db0c
--- /dev/null
+++ b/docs/observability_dashboard
@@ -0,0 +1,307 @@
+Local LLM Runtime Observability System — Build Requirements
+
+Objective
+Provide a unified observability system for a local LLM experimentation environment that allows real-time monitoring and analysis of inference performance across multiple backends (vLLM, ExLlamaV2, Transformers/PyTorch, GGUF runtimes, and future engines). The system must operate alongside an existing TUI-driven runner and expose standardized runtime metrics that enable model loading verification, performance tuning, and backend comparison.
+
+Scope
+The system introduces a metrics instrumentation layer within the model runner and an external visualization stack. The runner remains the control interface for experiments while the observability system provides passive monitoring and historical analysis.
+
+The system must support both production-grade inference engines (vLLM, ExLlamaV2) and experimental backends (raw Transformers/PyTorch) without requiring engine-specific dashboards.
+
+Primary Deliverables
+
+Metrics Instrumentation Layer (Runner Integration)
+A standardized instrumentation layer embedded within the runner process that exposes runtime metrics describing model configuration, GPU usage, inference throughput, latency, batching behavior, and KV-cache utilization.
+
+This layer must provide a unified metrics interface across all backends and expose metrics via a Prometheus-compatible HTTP endpoint.
+
+Functional deliverables:
+
+• metrics interface abstraction used by all engines
+• backend adapters for each inference engine
+• runtime metric collectors
+• metrics HTTP endpoint
+• metric lifecycle management during engine load/unload
+• experiment metadata tagging
+
+Supported backends:
+
+• vLLM
+• ExLlamaV2
+• HuggingFace Transformers / PyTorch
+• GGUF runtimes (llama.cpp based)
+• future custom engines
+
+Metrics must remain backend-agnostic and use the same schema regardless of runtime implementation.
+
+Metrics Schema Definition
+A standardized schema describing all metrics produced by the system. This schema ensures consistent visualization and enables cross-engine comparisons.
+
+The schema must define the following metric categories.
+
+Model Configuration Metrics
+
+Purpose: verify how a model actually loaded into memory.
+
+Required fields:
+
+• model_identifier
+• model_parameter_count
+• model_weight_bytes
+• model_dtype
+• kv_cache_dtype
+• quantization_type
+• context_length
+• engine_name
+• engine_version
+
+These metrics confirm whether the runtime configuration matches expected parameters.
+
+GPU Metrics
+
+Purpose: monitor hardware resource utilization.
+
+Required fields:
+
+• gpu_vram_total_bytes
+• gpu_vram_used_bytes
+• gpu_vram_reserved_bytes
+• gpu_vram_free_bytes
+• gpu_utilization_percent
+• gpu_memory_bandwidth_percent
+• gpu_power_usage_watts
+
+These metrics may be sourced from GPU exporters or internal collectors.
+
+PyTorch Runtime Metrics
+
+Purpose: detect memory allocation behavior and tensor usage within raw transformer backends.
+
+Required fields:
+
+• torch_cuda_memory_allocated_bytes
+• torch_cuda_memory_reserved_bytes
+• torch_cuda_max_allocated_bytes
+• torch_cuda_active_tensors
+
+These metrics help detect silent dtype promotion, memory fragmentation, or allocator behavior.
+
+KV Cache Metrics
+
+Purpose: monitor attention memory allocation and runtime usage.
+
+Required fields:
+
+• kv_cache_total_bytes
+• kv_cache_used_bytes
+• kv_cache_utilization_ratio
+• kv_cache_block_size
+• kv_cache_sequence_count
+
+These metrics are critical for tuning context length and batching parameters.
+
+Throughput Metrics
+
+Purpose: measure inference performance.
+
+Required fields:
+
+• tokens_generated_total
+• tokens_generated_per_second
+• effective_tokens_per_second
+• requests_completed_total
+• requests_in_flight
+• requests_queued
+
+Effective tokens/sec represents user-perceived performance including latency overhead.
+
+Latency Metrics
+
+Purpose: detect architectural bottlenecks.
+
+Required fields:
+
+• request_latency_seconds
+• prefill_latency_seconds
+• decode_latency_seconds
+• time_to_first_token_seconds
+
+Latency distributions must support percentile aggregation:
+
+• p50
+• p95
+• p99
+
+Batch Metrics
+
+Purpose: analyze batching efficiency and request aggregation.
+
+Required fields:
+
+• batch_size_current
+• batch_size_average
+• batch_tokens_current
+• batch_tokens_average
+
+Generation Metrics
+
+Purpose: monitor generation behavior and request characteristics.
+
+Required fields:
+
+• generation_tokens_requested
+• generation_tokens_output
+• generation_stop_reason
+• generation_streaming_enabled
+
+Experiment Metadata Metrics
+
+Purpose: tag and differentiate experimental runs.
+
+Required fields:
+
+• experiment_id
+• engine_name
+• quantization_type
+• kv_cache_quantization
+• attention_backend
+• model_variant
+
+These tags allow comparison between runs.
+
+Metrics Endpoint
+The runner must expose a Prometheus-compatible metrics endpoint accessible via HTTP.
+
+Deliverables:
+
+• standardized /metrics endpoint
+• structured metric export
+• scrape compatibility with external collectors
+• configurable update interval
+
+This endpoint serves as the sole data source for external monitoring systems.
+
+Observability Infrastructure
+A monitoring stack responsible for collecting, storing, and visualizing runtime metrics.
+
+Components required:
+
+• Prometheus metrics collector
+• Grafana visualization dashboard
+• GPU metrics exporter
+• system metrics exporter
+
+The infrastructure must operate locally without cloud dependencies and support persistent metric storage for experiment comparison.
+
+Visualization Dashboard
+A set of Grafana dashboards designed specifically for local inference tuning.
+
+Required dashboard panels.
+
+Hardware Panel
+
+Displays:
+
+• GPU utilization
+• VRAM usage
+• memory bandwidth
+• power consumption
+
+Model Panel
+
+Displays:
+
+• model size
+• dtype
+• quantization configuration
+• KV cache allocation
+
+Throughput Panel
+
+Displays:
+
+• tokens/sec
+• effective tokens/sec
+• requests/sec
+• batch size
+
+Latency Panel
+
+Displays:
+
+• time to first token
+• prefill latency
+• decode latency
+• request latency percentiles
+
+Cache Panel
+
+Displays:
+
+• KV cache usage
+• active sequences
+• context utilization
+
+Batch Panel
+
+Displays:
+
+• real-time batch size
+• batch token count
+• batching efficiency
+
+These panels provide the live feedback loop required for runtime tuning.
+
+Backend Metrics Adapters
+Each engine must include a metrics adapter that maps engine-specific information into the standardized schema.
+
+Adapters required for:
+
+• vLLM runtime metrics
+• ExLlamaV2 inference statistics
+• HuggingFace / PyTorch profiling metrics
+• GGUF runtime telemetry
+
+The adapter layer ensures dashboards remain consistent regardless of backend.
+
+Experiment Tracking Capability
+The system must support labeling and comparing experiments.
+
+Capabilities required:
+
+• experiment identifiers
+• configuration tagging
+• metric comparison across runs
+• time-series analysis of tuning changes
+
+This allows users to observe the effect of configuration changes such as context size, quantization format, or batching limits.
+
+Integration With Existing Runner
+The observability system must operate alongside the existing TUI-based model runner.
+
+Integration requirements:
+
+• TUI remains the control interface
+• dashboards operate as passive observers
+• metrics update in real time during experiments
+• no disruption to existing runner workflows
+
+The runner must remain responsible for:
+
+• model loading
+• experiment execution
+• backend selection
+
+The observability system remains read-only.
+
+System Outcome
+Completion of this system provides a unified runtime observability environment enabling:
+
+• verification of model loading behavior
+• monitoring of GPU and memory usage
+• measurement of inference performance
+• comparison of backend implementations
+• tuning of runtime parameters
+• identification of inference bottlenecks
+
+The system converts the local model runner into a full experimentation laboratory for LLM runtime optimization.
\ No newline at end of file
diff --git a/docs/onboarding-standards.md b/docs/onboarding-standards.md
new file mode 100644
index 0000000..0686ccc
--- /dev/null
+++ b/docs/onboarding-standards.md
@@ -0,0 +1,128 @@
+# Onboarding Standards (Models + Backends)
+
+This doc defines the standards for adding new backends or extending existing ones so the repo stays consistent as it grows.
+
+Primary goal:
+- “Run a model” should feel the same in the TUI regardless of backend, even when the underlying engines differ.
+
+## Model Onboarding (Adding A New Model Folder)
+
+1. Use the scaffold tool
+- `python scripts/model add <model_name> <backend> [--id <backend_id>]`
+
+2. Fill in the basics
+- `models/<model>/<backend>/notes/README.md`: backend-specific runtime notes (what breaks, what to set, known-good profiles)
+- `models/<model>/<backend>/notes/model_card.md`: upstream card (HF README) when applicable
+- `models/<model>/<backend>/config/default.toml`: base config (runs out of the box)
+- `models/<model>/<backend>/config/profiles/fast.toml`: “go fast” overlay
+- `models/<model>/<backend>/config/profiles/longctx.toml`: “go long context” overlay
+
+3. Profiles are overlays, not full copies
+- Base config stays readable and stable.
+- Profiles should only override what they change.
+
+## Backend Onboarding (Adding A New Engine/Protocol)
+
+### 1. Pick the backend type
+Classify before writing code; this determines where standardization is possible.
+
+- In-process engine (local weights, Python API): HF, GGUF, EXL2
+- External server attach (OpenAI-compatible): OpenAI backend
+- Managed server engine (spawn + attach): vLLM backend
+- Vendor-specific server (custom protocol): Ollama backend
+
+### 2. Required implementation surface (TUI)
+Every backend must provide:
+- `create_session(args)` returning an object that matches `BackendSession` protocol
+- `backend_name` and `resolved_model_id`
+- `generate_turn(turn_id, messages, emit)` that emits `TurnStart` and ends with either `Finish` or `Error`
+- `get_recent_logs(n=80)`
+
+Recommended optional methods:
+- `describe()` for `/status` and debugging
+- `get_last_request()` for request capture parity when applicable
+
+### 3. Thinking behavior must be consistent in UI
+
+Backend must route output into the same UI affordances:
+- Thinking panel receives `ThinkDelta`
+- Answer panel receives `AnswerDelta`
+
+Standard approach:
+- Use `ThinkRouter(assume_think=args.assume_think)` for any backend that streams plain text.
+- If backend provides a dedicated “thinking channel” (e.g., Ollama `message.thinking`, some OpenAI-like servers), emit that via `ThinkDelta` directly and route the rest via `ThinkRouter`.
+
+### 4. Token accounting standard (must)
+New backends must implement “token truth” if the backend provides it.
+
+Preferred order of truth:
+1. Backend-native usage counters (server usage fields, token IDs from engine)
+2. Backend tokenization API (e.g. llama.cpp tokenize)
+3. Retokenization fallback (only when a tokenizer is already loaded; avoid loading new heavy deps just for metrics)
+
+At minimum, emit:
+- `Meta(prompt_tokens=...)` when knowable
+- `Meta(completion_tokens=...)` when knowable
+- `Meta(total_tokens=...)` when knowable
+
+### 5. Knob mapping must be explicit
+If a backend cannot honor a knob, we must not silently accept it.
+
+Standard requirement:
+- Backends report (per turn or once per session):
+  - `sent` values (actually applied)
+  - `deferred` values (unset, backend default)
+  - `ignored` values (user set, backend can’t honor)
+
+This is the only scalable way to avoid “placebo configs”.
+
+### 6. Logging parity
+Every backend must:
+- support `log_file` in config
+- expose `get_recent_logs()` for `/show logs`
+- redact secrets in any captured request output
+
+### 7. Context management parity
+Every backend must implement repo-consistent context-fit behavior before hard context failures where feasible.
+
+Required UX:
+- preserve the current user turn
+- preserve the system message on a best-effort basis
+- drop oldest prior conversation turns first
+- reserve room for generation
+- report when trimming happened
+
+Allowed implementation strategies:
+- exact token-count preflight
+- backend-native counters/tokenization
+- server-side truncation controls
+- deterministic overflow-retry with oldest-turn dropping
+
+Backends must also report if the system message was dropped or could not be preserved.
+
+### 8. Config + templates + prompts
+Each backend must have a `_TEMPLATE` scaffold at:
+- `models/_TEMPLATE/<backend>/config/default.toml`
+- `models/_TEMPLATE/<backend>/notes/README.md`
+- `models/_TEMPLATE/<backend>/templates/README.md`
+- `models/_TEMPLATE/<backend>/prompts/README.md`
+
+If the backend supports local templating:
+- provide clear “template source” semantics (tokenizer_config.json vs inline vs override file)
+- document any sanitization rules (e.g., don’t re-feed `<think>` into history)
+
+### 9. Documentation requirements
+For any non-trivial backend:
+- Add a spec under `docs/specs/` for the backend integration contract.
+- Add a decision under `docs/decisions/` for any repo-wide change (config format, naming, standard UI behavior).
+
+## Review Checklist (PR Gate)
+
+Before merging a new backend/model addition:
+1. `tui` run works from a clean venv with only required deps installed.
+2. `TurnStart` and `Finish`/`Error` are always emitted.
+3. Thinking routing works with `assume_think` toggles.
+4. Token counts are correct or explicitly “unavailable”.
+5. Knob mapping is explicit (sent/deferred/ignored).
+6. Logs are accessible and secrets are redacted.
+7. Context trimming behavior is documented and system-message retention behavior is explicit.
diff --git a/docs/openclaw/04-model-runner-openclaw-compat-checklist.md b/docs/openclaw/04-model-runner-openclaw-compat-checklist.md
new file mode 100644
index 0000000..2c78f76
--- /dev/null
+++ b/docs/openclaw/04-model-runner-openclaw-compat-checklist.md
@@ -0,0 +1,117 @@
+# Model Runner -> OpenClaw Compatibility Checklist
+
+## Must support
+
+- `GET /v1/models`
+- `POST /v1/chat/completions`
+- SSE streaming
+- request `tools` array
+- assistant tool calls
+- follow-up `tool` role messages
+- `stream=false` chat completions for compatibility checks
+
+## Message roles
+
+Your backend must accept:
+
+- `system`
+- `user`
+- `assistant`
+- `tool`
+
+Notes:
+- OpenClaw avoids `developer` role for non-native OpenAI-compatible backends.
+- `role="tool"` messages may include an optional `name` field; tolerate it even if it is not semantically required.
+
+## Tool call streaming
+
+Stream tool calls in OpenAI-compatible delta form:
+
+- `choices[0].delta.tool_calls[*].index`
+- `choices[0].delta.tool_calls[*].id`
+- `choices[0].delta.tool_calls[*].type`
+- `choices[0].delta.tool_calls[*].function.name`
+- `choices[0].delta.tool_calls[*].function.arguments`
+
+Arguments may arrive in fragments.
+Clients must accumulate them incrementally.
+
+Handle these cases correctly:
+- assistant `content` is `null`, empty, or whitespace while tool calls stream
+- finish arrives as `finish_reason="tool_calls"`
+
+## Tool loop behavior
+
+Your backend must correctly handle:
+
+1. assistant emits tool call(s)
+2. client executes tool(s)
+3. next request includes:
+   - assistant message with `tool_calls`
+   - tool message(s) with `tool_call_id`
+4. model continues from tool result
+
+Assistant tool-call messages and their tool results should remain protocol-consistent across follow-up turns.
+
+## Request compatibility expectations
+
+Safest assumptions:
+
+- accept `parallel_tool_calls: false`
+- accept `tool_choice` when sent
+- accept `max_tokens`
+- ignore unknown safe fields instead of crashing
+- do not require hosted-only OpenAI features
+
+Accepted `tool_choice` shapes:
+- `"auto"`
+- `"none"`
+- object form selecting a named function
+
+## SSE behavior
+
+Streaming implementations should tolerate:
+- `event:` fields
+- unknown SSE fields
+- multi-line `data:` blocks
+- `[DONE]` end marker
+
+Server-side errors should surface clearly when received as:
+- top-level `{"error": {...}}`
+- an `event: error` frame
+- a non-standard error envelope carrying readable error text
+
+## Non-stream response behavior
+
+For `stream=false`, check:
+- `choices[0].message.content`
+- `choices[0].message.tool_calls`
+- `usage` when present
+
+## Multimodal stance
+
+Current stance for model-runner OpenAI-compatible requests:
+- OpenAI-style content parts arrays are supported
+- TUI image attachments are converted to `image_url` content parts using local data URLs
+- local size limits still apply
+
+For OpenClaw integration, this should be treated as vLLM-first behavior for now.
+
+## Recommended local defaults
+
+- low temperature (`0.0` to `0.2`) for tool-heavy loops
+- `parallel_tool_calls: false`
+- one tool call at a time in early tuning passes
+- prefer accurate function-name emission over creativity
+
+## Success criteria
+
+A run is good enough for POC when:
+
+- the model picks the right tool name
+- the JSON args parse cleanly
+- tool call ids are stable
+- the model correctly consumes tool results
+- `finish_reason` is sensible (`tool_calls` or normal stop)
+- server-side errors are surfaced clearly instead of silently hanging or looping
+- it can finish a small edit/test/fix loop without hallucinating unavailable tools
diff --git a/docs/reference/compressor.md b/docs/reference/compressor.md
new file mode 100644
index 0000000..8611f10
--- /dev/null
+++ b/docs/reference/compressor.md
@@ -0,0 +1,59 @@
+# Offline Compressor
+
+Use `scripts/compress_model.py` to build vLLM-compatible FP8 artifacts outside the repo.
+
+## Current status
+
+The main repo environment is now anchored on `vllm>=0.18`.
+
+Released `llmcompressor` builds do not currently resolve with `vllm 0.18.x` in the same environment because of upstream dependency conflicts around `compressed-tensors`, `torch`, and related packages.
+
+Practical consequence:
+- compression is currently **not** part of the main repo sync
+- do not design the serving environment around compression
+- treat compression as a deferred/offline workflow until a compatible released stack exists
+
+OmniCoder-specific status and recipe rationale:
+- [omnicoder-fp8-status.md](/home/poop/code/dev/model-runner/docs/reference/omnicoder-fp8-status.md)
+
+## Quick start
+1. Edit `models/<model>/vllm/compressor/default.toml`
+2. Point `model.source` at the source weights
+3. Run:
+
+```bash
+python scripts/compress_model.py --model OmniCoder-9B --scheme fp8
+```
+
+## Current contract
+- Qwen3.5 and OmniCoder compression should not constrain the serving environment.
+- The script loads the source model object directly so multimodal checkpoints stay `qwen3_5` instead of collapsing to `qwen3_5_text`.
+- OmniCoder now defaults to `FP8_DYNAMIC` with `calibration.source = "none"`.
+- `FP8_DYNAMIC` runs data-free in the current `llmcompressor` stack; the script must not force a calibration dataset or sequential calibration pipeline for that path.
+- OmniCoder excludes the full visual tower from quantization via `re:^model\.visual($|\.)` and also excludes `lm_head`.
+- Local calibration files can still be plain JSONL with a `text` column when using a scheme that actually requires calibration.
+
+## Output layout
+- `~/models/local/quants/<model>/fp8/runs/<timestamp-or-label>/<Compressed-Name>/`
+- `~/models/local/quants/<model>/fp8/current`
+
+`current` is a symlink to the latest successful artifact directory. Point vLLM or `agentmux` at that path if you want the most recent FP8 build.
+
+## Useful overrides
+```bash
+python scripts/compress_model.py \
+  --model OmniCoder-9B \
+  --recipe-scheme FP8_DYNAMIC \
+  --ignore 're:^model\\.visual($|\\.)' \
+  --ignore lm_head \
+  --run-label fp8-dynamic
+```
+
+For a calibration-requiring recipe, supply a real dataset and split explicitly.
+
+## Dry run
+Use `--dry-run` to print the resolved plan before compression:
+
+```bash
+python scripts/compress_model.py --model OmniCoder-9B --scheme fp8 --dry-run
+```
diff --git a/docs/reference/local-layout.md b/docs/reference/local-layout.md
new file mode 100644
index 0000000..3ca136e
--- /dev/null
+++ b/docs/reference/local-layout.md
@@ -0,0 +1,76 @@
+# Local Layout
+
+`model-runner` stays model-first in the repo, but actual assets and generated state live outside the repo.
+
+## Repo vs Machine Layout
+
+### In repo
+
+Use `models/<model>/<backend>/` for:
+- `config/`
+- `notes/`
+- `prompts/`
+- `templates/`
+- `compressor/` recipes and backend-specific authored metadata
+
+This is the control plane.
+
+### Outside the repo
+
+Use the home-directory layout for machine state:
+
+- `~/models/local/`
+  - local model folders you intentionally keep
+- `~/models/local/gguf/`
+  - GGUF artifacts
+- `~/models/local/exl2/`
+  - EXL2 artifacts
+- `~/models/local/quants/`
+  - quantized/compressed outputs
+- `~/models/hf/`
+  - Hugging Face managed cache
+- `~/data/model-runner/`
+  - calibration datasets and durable evaluation inputs
+- `~/runs/model-runner/`
+  - telemetry, logs, transcripts, outputs, state
+
+This is the data plane.
+
+## Runtime Path Contract
+
+Runtime artifacts should be organized by logical identity, not by repo path.
+
+Use:
+
+- `~/runs/model-runner/logs/<backend>/<model>/<slot>/`
+- `~/runs/model-runner/state/<backend>/<model>/<slot>/`
+- `~/runs/model-runner/outputs/`
+- `~/runs/model-runner/telemetry/`
+- `~/runs/model-runner/transcripts/`
+
+Examples:
+
+- `~/runs/model-runner/logs/vllm/qwen3.5-9b/default/vllm-engine.stdout.log`
+- `~/runs/model-runner/logs/vllm/qwen3.5-9b/default/vllm-engine.stderr.log`
+- `~/runs/model-runner/state/vllm/qwen3.5-9b/default/vllm-managed.json`
+
+Do not mirror repo-internal paths like `models/<model>/<backend>/config/...` under `~/runs`.
+The repo layout is for authored control-plane files; the run layout is for machine-local runtime state.
+
+## Why This Split Works
+
+It preserves the useful part of the old repo design:
+- model-first notes and config are still easy to find
+
+while removing the bad part:
+- runtime clutter and heavy artifacts no longer live in the repo
+
+## Practical Rule
+
+Ask:
+
+- "Is this something I authored and want to version?"
+  - keep it in the repo
+
+- "Is this a weight file, quant, dataset, transcript, telemetry stream, or run artifact?"
+  - keep it outside the repo
diff --git a/docs/reference/omnicoder-fp8-status.md b/docs/reference/omnicoder-fp8-status.md
new file mode 100644
index 0000000..290173e
--- /dev/null
+++ b/docs/reference/omnicoder-fp8-status.md
@@ -0,0 +1,83 @@
+# OmniCoder FP8 Status
+
+## Current Recommendation
+
+This document describes the recipe shape, not the active Fedora serving environment.
+
+The repo’s main environment is now anchored on `vllm>=0.18`, and released `llmcompressor` builds do not currently coexist with that stack in one environment.
+
+The current recommended OmniCoder path is no longer the old calibrated `FP8` recipe.
+
+Use:
+- `scheme = "FP8_DYNAMIC"`
+- `targets = "Linear"`
+- `ignore = ["lm_head", "re:^model\\.visual($|\\.)"]`
+- `calibration.source = "none"`
+
+This recommendation is based on three verified facts from the current local environment:
+- the local OmniCoder checkpoint is a `Qwen3_5ForConditionalGeneration` multimodal model with a full `model.visual` tower and `model.visual.merger`
+- the installed `llmcompressor` version is `0.10.0.1`
+- the current `llmcompressor` docs and entrypoint README describe `FP8_DYNAMIC` as the standard W8A8 FP8 path and explicitly state that no calibration dataset is required for RTN / dynamic activation quantization
+
+## Why The Old OmniCoder Recipe Failed
+
+The old recipe was:
+- `scheme = "FP8"`
+- `targets = "Linear"`
+- `ignore = ["lm_head", "re:.*mlp.gate$"]`
+- calibration data from plain JSONL built out of SWE-smith trajectories
+
+That path had two fundamental problems:
+- it quantized the visual tower because the ignore list never excluded `model.visual.*`
+- it treated calibration shaping as the main recovery lever even though the current library’s recommended high-quality FP8 path is `FP8_DYNAMIC`, which does not require a calibration dataset in the first place
+
+There was also a smaller but important correctness issue:
+- OmniCoder’s dense MLP modules are named `mlp.gate_proj`, not `mlp.gate`, so the previous ignore rule did not exclude anything relevant in the dense text backbone
+
+## Verified OmniCoder Module Shape
+
+A local module-tree audit of the checkpoint shows:
+- vision modules live under `model.visual.*`
+- the vision merger also lives under `model.visual.merger.*`
+- text modules live under `model.language_model.layers.*`
+- text layers include both `linear_attn.*` and `self_attn.*` linear projections
+- dense MLP modules are `mlp.gate_proj`, `mlp.up_proj`, and `mlp.down_proj`
+
+That means the exclusion we actually need for the multimodal-safe FP8 recipe is the visual subtree, not a guessed gate rule.
+
+## Current Script Contract
+
+`scripts/compress_model.py` now supports all three calibration modes explicitly:
+- `local`
+- `hf`
+- `none`
+
+For `FP8_DYNAMIC` and `FP8_BLOCK`:
+- the script allows `calibration.source = "none"`
+- it does not force a dataset
+- it does not force the sequential calibration pipeline
+
+For calibration-requiring schemes such as plain `FP8`:
+- the script still requires a real dataset and split
+- local JSONL staging is still supported
+
+## Recommended Command
+
+```bash
+python scripts/compress_model.py --model OmniCoder-9B --scheme fp8
+```
+
+The current default config already resolves to the recommended OmniCoder recipe.
+
+## What Is Still Missing
+
+One thing is still not proven yet in-repo:
+- empirical quality validation of the resulting OmniCoder FP8_DYNAMIC artifact against the source checkpoint on a representative coding/chat prompt set
+
+The recipe is now derived from the actual checkpoint structure and current upstream guidance, not from guesswork.
+The remaining work is validation, not further recipe speculation.
+
+## Serving-env note
+
+For now, keep the repo’s main `.venv` optimized for vLLM serving and general runtime work.
+If compression is needed before upstream packages converge, handle it as a separate one-off workflow rather than redefining the main project environment around it.
diff --git a/docs/specs/0008-reviews-branch-mirror.md b/docs/specs/0008-reviews-branch-mirror.md
new file mode 100644
index 0000000..f7f3bbc
--- /dev/null
+++ b/docs/specs/0008-reviews-branch-mirror.md
@@ -0,0 +1,327 @@
+# Spec: Mirror PR review output into a `reviews` branch
+
+## Why
+PR review bots (e.g. `codex-connector`) post findings on GitHub, but this repo’s local Codex sessions may not reliably access GitHub APIs.
+We want a git-native way to pull those findings into the local workspace without copy/paste.
+
+## Goal
+- Every PR gets a “review bundle” written to a dedicated branch (`reviews`) as:
+  - `docs/reviews/pr-<num>.md` (human-readable)
+  - `docs/reviews/pr-<num>.json` (machine-readable)
+- Local workflow is always:
+  - `git fetch origin reviews`
+  - `git show origin/reviews:docs/reviews/pr-<num>.md`
+
+## Non-goals
+- No attempt to “apply fixes” automatically.
+- No requirement that local environments can reach `github.com` APIs.
+- No publishing for PRs from forks (avoid token/permission/security complexity).
+
+## Branch model
+- `reviews` is an **orphan branch** (no shared history with `main`).
+- It contains only generated artifacts under `docs/reviews/`.
+- It is write-only from CI.
+
+## Output format
+`docs/reviews/pr-<num>.md` includes:
+- PR metadata: title, author, base/head refs, head SHA, updated timestamp.
+- Codex-bot findings:
+  - Issue comments by bot login(s)
+  - PR reviews by bot login(s)
+  - PR review comments by bot login(s)
+- Optional: Check runs summary for the PR head SHA.
+
+`docs/reviews/pr-<num>.json` includes the same data as structured JSON for downstream tooling.
+
+## Bot login configuration
+The workflow reads `REVIEW_BOT_LOGINS` (comma-separated).
+Default:
+- `codex-connector[bot]`
+- `codex-connector`
+
+## Concurrency
+Only one run at a time may update `reviews`:
+- `concurrency.group: reviews-branch`
+- `cancel-in-progress: false`
+
+## GitHub Actions workflow
+Create: `.github/workflows/reviews-branch-mirror.yml`
+
+```yaml
+name: PR Review Mirror
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, edited, ready_for_review]
+
+permissions:
+  contents: write
+  pull-requests: read
+  issues: read
+  checks: read
+
+concurrency:
+  group: reviews-branch
+  cancel-in-progress: false
+
+env:
+  REVIEW_BOT_LOGINS: codex-connector[bot],codex-connector
+
+jobs:
+  ci:
+    name: CI (lightweight)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      # Keep this cheap: no heavyweight GPU deps, no full `requirements.txt` install.
+      - name: Syntax check
+        run: python -m compileall -q .
+      # Optional: lint/typecheck can be added later without installing torch/cuda wheels.
+      # - name: Ruff
+      #   run: |
+      #     python -m pip install -U ruff
+      #     ruff check .
+      # - name: Pyright
+      #   run: |
+      #     python -m pip install -U pyright
+      #     pyright
+
+  publish_review:
+    name: Publish review bundle to `reviews`
+    runs-on: ubuntu-latest
+    needs: [ci]
+    if: github.event.pull_request.head.repo.full_name == github.repository
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Gather PR review data
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require("fs");
+            const path = require("path");
+            const botLogins = (process.env.REVIEW_BOT_LOGINS || "")
+              .split(",")
+              .map(s => s.trim())
+              .filter(Boolean);
+
+            const { owner, repo } = context.repo;
+            const pr = context.payload.pull_request;
+            const prNumber = pr.number;
+            const headSha = pr.head.sha;
+
+            const issueComments = await github.paginate(
+              github.rest.issues.listComments,
+              { owner, repo, issue_number: prNumber, per_page: 100 },
+            );
+            const reviews = await github.paginate(
+              github.rest.pulls.listReviews,
+              { owner, repo, pull_number: prNumber, per_page: 100 },
+            );
+            const reviewComments = await github.paginate(
+              github.rest.pulls.listReviewComments,
+              { owner, repo, pull_number: prNumber, per_page: 100 },
+            );
+
+            let checkRuns = [];
+            try {
+              const res = await github.rest.checks.listForRef({ owner, repo, ref: headSha, per_page: 100 });
+              checkRuns = res.data.check_runs || [];
+            } catch (e) {
+              // checks permission may not be available in all org settings; keep optional.
+              checkRuns = [];
+            }
+
+            const byBot = (items) =>
+              items.filter((x) => botLogins.length === 0 ? false : botLogins.includes(x.user?.login));
+
+            const payload = {
+              generated_at: new Date().toISOString(),
+              pr: {
+                number: prNumber,
+                title: pr.title,
+                url: pr.html_url,
+                author: pr.user?.login || "",
+                base: { ref: pr.base.ref, sha: pr.base.sha },
+                head: { ref: pr.head.ref, sha: headSha },
+                draft: !!pr.draft,
+              },
+              bot_logins: botLogins,
+              issue_comments: byBot(issueComments).map(c => ({
+                id: c.id,
+                created_at: c.created_at,
+                updated_at: c.updated_at,
+                url: c.html_url,
+                user: c.user?.login || "",
+                body: c.body || "",
+              })),
+              reviews: byBot(reviews).map(r => ({
+                id: r.id,
+                submitted_at: r.submitted_at,
+                state: r.state,
+                url: r.html_url,
+                user: r.user?.login || "",
+                body: r.body || "",
+              })),
+              review_comments: byBot(reviewComments).map(rc => ({
+                id: rc.id,
+                created_at: rc.created_at,
+                updated_at: rc.updated_at,
+                url: rc.html_url,
+                user: rc.user?.login || "",
+                path: rc.path || "",
+                position: rc.position ?? null,
+                line: rc.line ?? null,
+                side: rc.side ?? "",
+                body: rc.body || "",
+              })),
+              check_runs: checkRuns.map(cr => ({
+                name: cr.name,
+                status: cr.status,
+                conclusion: cr.conclusion,
+                details_url: cr.details_url,
+                started_at: cr.started_at,
+                completed_at: cr.completed_at,
+              })),
+              ci: { result: "${{ needs.ci.result }}" },
+            };
+
+            const outDir = path.join(process.cwd(), "build", "reviews");
+            fs.mkdirSync(outDir, { recursive: true });
+
+            fs.writeFileSync(
+              path.join(outDir, `pr-${prNumber}.json`),
+              JSON.stringify(payload, null, 2),
+              "utf-8",
+            );
+
+            const lines = [];
+            lines.push(`# PR #${prNumber}: ${pr.title}`);
+            lines.push("");
+            lines.push(`- URL: ${pr.html_url}`);
+            lines.push(`- Author: ${payload.pr.author}`);
+            lines.push(`- Base: ${payload.pr.base.ref} @ ${payload.pr.base.sha}`);
+            lines.push(`- Head: ${payload.pr.head.ref} @ ${payload.pr.head.sha}`);
+            lines.push(`- Draft: ${payload.pr.draft}`);
+            lines.push(`- Generated: ${payload.generated_at}`);
+            lines.push(`- Bot logins: ${botLogins.join(", ") || "(none configured)"}`);
+            lines.push("");
+
+            const section = (title, items, render) => {
+              lines.push(`## ${title}`);
+              if (!items.length) {
+                lines.push("");
+                lines.push("_None._");
+                lines.push("");
+                return;
+              }
+              lines.push("");
+              for (const item of items) {
+                lines.push(render(item));
+                lines.push("");
+              }
+            };
+
+            section(
+              "Bot issue comments",
+              payload.issue_comments,
+              (c) => `- ${c.updated_at || c.created_at} (${c.user})\\n  - ${c.url}\\n\\n\\n${c.body}`.trim(),
+            );
+
+            section(
+              "Bot PR reviews",
+              payload.reviews,
+              (r) => `- ${r.submitted_at || ""} (${r.user}) [${r.state}]\\n  - ${r.url}\\n\\n\\n${r.body}`.trim(),
+            );
+
+            section(
+              "Bot PR review comments",
+              payload.review_comments,
+              (rc) => `- ${rc.updated_at || rc.created_at} (${rc.user})\\n  - ${rc.url}\\n  - ${rc.path}${rc.line ? `:${rc.line}` : ""}\\n\\n\\n${rc.body}`.trim(),
+            );
+
+            lines.push("## Check runs (head SHA)");
+            lines.push("");
+            if (!payload.check_runs.length) {
+              lines.push("_None or unavailable._");
+              lines.push("");
+            } else {
+              for (const cr of payload.check_runs) {
+                lines.push(`- ${cr.name}: ${cr.status} / ${cr.conclusion || "n/a"}`);
+              }
+              lines.push("");
+            }
+
+            fs.writeFileSync(
+              path.join(outDir, `pr-${prNumber}.md`),
+              lines.join("\\n"),
+              "utf-8",
+            );
+
+      - name: Update `reviews` branch
+        run: |
+          set -euo pipefail
+
+          PR_NUM="${{ github.event.pull_request.number }}"
+          SRC_DIR="build/reviews"
+
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+
+          git fetch origin reviews || true
+          if git show-ref --verify --quiet refs/remotes/origin/reviews; then
+            git checkout -B reviews origin/reviews
+          else
+            git checkout --orphan reviews
+            find . -mindepth 1 -maxdepth 1 ! -name .git -exec rm -rf {} +
+          fi
+
+          mkdir -p docs/reviews
+          cat > docs/reviews/README.md <<'EOF'
+          # PR Review Bundles
+
+          This branch is generated by CI. It mirrors PR review bot output into git-tracked files so offline/local tooling can read it.
+
+          Local usage:
+          - `git fetch origin reviews`
+          - `git show origin/reviews:docs/reviews/pr-123.md`
+          - `git show origin/reviews:docs/reviews/pr-123.json`
+          EOF
+
+          cp -f "${SRC_DIR}/pr-${PR_NUM}.md" "docs/reviews/pr-${PR_NUM}.md"
+          cp -f "${SRC_DIR}/pr-${PR_NUM}.json" "docs/reviews/pr-${PR_NUM}.json"
+
+          python - <<'PY'
+          import glob
+          import os
+          files = sorted(glob.glob("docs/reviews/pr-*.md"))
+          lines = ["# Index", ""]
+          for f in files:
+              name = os.path.basename(f)
+              pr = name.removeprefix("pr-").removesuffix(".md")
+              lines.append(f"- [{name}](./{name})")
+          lines.append("")
+          open("docs/reviews/index.md","w",encoding="utf-8").write("\\n".join(lines))
+          PY
+
+          git add docs/reviews
+          if git diff --cached --quiet; then
+            echo "No changes to publish."
+            exit 0
+          fi
+
+          git commit -m "reviews: PR #${PR_NUM} mirror"
+          git push origin reviews
+```
+
+## Local usage (no checkout required)
+```bash
+git fetch origin reviews
+git show origin/reviews:docs/reviews/pr-123.md
+```
+
diff --git a/docs/specs/0009-toml-config-profiles-and-machine-overrides.md b/docs/specs/0009-toml-config-profiles-and-machine-overrides.md
new file mode 100644
index 0000000..7fd823c
--- /dev/null
+++ b/docs/specs/0009-toml-config-profiles-and-machine-overrides.md
@@ -0,0 +1,234 @@
+# Spec: TOML config (profiles + machine overrides) prep for vLLM/OpenAI backend
+
+Date: 2026-03-07
+
+## Context
+Config files in this repo are now doing triple-duty:
+- **Model/run settings** (max tokens, temperature, context limits)
+- **Backend/engine settings** (dtype, quantization, GGUF engine knobs, Ollama host, EXL2 cache type)
+- **Frontend/TUI settings** (follow/scroll, thinking display, transcript saving)
+
+As more backends are added (notably vLLM/OpenAI-compatible servers), mixing these concerns in a single flat JSON object becomes hard to read and easy to misconfigure.
+
+We also want:
+- Multiple “virtual builds” per model (fast vs long-context vs agent/tooling)
+- A small set of local-only settings (paths, hosts) that should not be committed
+- Comments and sectioning for human readability
+
+Python 3.11 includes `tomllib` in the standard library, making TOML a good fit without adding dependencies.
+
+## Goals
+- Move to a **human-friendly** config format with:
+  - comments
+  - sections by concern (model/gen/ui/backend)
+- Add **profiles** per model/backend (fast, longctx, agent, etc.).
+- Add a **machine-local override** file (not committed) for paths/hosts.
+- Preserve existing config precedence and make it explicit.
+- Keep backends isolated: each backend only reads its own section/keys.
+- Keep a migration path: don’t break existing JSON configs immediately.
+- Make it easy to add a new backend (vLLM/OpenAI) without bloating existing configs.
+
+## Non-goals (this iteration)
+- Interactive config editing inside the TUI.
+- A full schema validation system (we’ll keep it pragmatic: parse + warn on unknown keys).
+- A hard cutover that removes JSON support.
+
+## Proposed config layering (merge order)
+Precedence from lowest → highest:
+1. **Script defaults** (argparse defaults / code defaults)
+2. **Backend template defaults** (optional, in-repo)
+3. **Model backend default config** (committed, per model/backend)
+4. **Profile config** (committed, per model/backend)
+5. **Machine override config** (local-only, not committed)
+6. **CLI flags** (highest precedence)
+
+Rules:
+- For scalar values: last writer wins.
+- For lists: last writer wins (no list concatenation).
+- For dicts: deep merge (recursive last-writer-wins).
+- A value of empty string `""` means “empty string”, not “unset”. (Avoid using it to mean null.)
+- Booleans must be overrideable both directions from CLI (`--foo` and `--no-foo`).
+
+## File layout
+
+### Per-model/backend (committed)
+Keep model-first layout:
+- `models/<model>/<backend>/config/default.toml` (baseline for this backend)
+- `models/<model>/<backend>/config/profiles/<name>.toml` (optional profiles)
+
+Example:
+- `models/Qwen3.5-9B/hf/config/default.toml`
+- `models/Qwen3.5-9B/hf/config/profiles/longctx.toml`
+- `models/Qwen3.5-9B/openai/config/default.toml` (future vLLM/OpenAI backend)
+
+### Templates (committed)
+- `models/_TEMPLATE/<backend>/config/default.toml`
+- `models/_TEMPLATE/<backend>/config/profiles/` (optional example profiles)
+
+### Machine-local overrides (not committed)
+Add a top-level local-only config:
+- `config/machine.toml` (gitignored)
+- `config/machine.example.toml` (committed)
+
+Purpose:
+- paths: local model roots, cache dirs
+- server endpoints: Ollama host, OpenAI base URL
+- local defaults you don’t want copied into the repo history
+
+## TOML schema (sections)
+Use section names to make “what applies where” obvious.
+
+### `[model]` (identifiers and paths)
+- `id` (string): model identifier for the backend (path or name)
+  - HF: local path or HF ID
+  - GGUF: `.gguf` file path
+  - Ollama/OpenAI: model name on the server
+- `display_name` (optional string): purely for UI and notes
+
+### `[gen]` (cross-backend generation knobs)
+These are intentionally “generic” and map to different engines where possible:
+- `max_new_tokens` (int)
+- `max_context_tokens` (int | null)
+- `temperature` (float)
+- `top_p` (float)
+- `top_k` (int | null)
+- `min_p` (float | null)
+- `typical_p` (float | null)
+- `repetition_penalty` (float)
+- `presence_penalty` (float | null)
+- `frequency_penalty` (float | null)
+- `stop_strings` (list[string] | null)
+- `seed` (int | null)
+- `stream` (bool)
+
+Backend mapping notes:
+- Some engines can’t support every knob; the runner must print a one-time “ignored knobs” summary.
+
+### `[prompt]` (system/prefix/template mode)
+- `system` (string | optional)
+- `system_file` (string | optional, path)
+- `user_prefix` (string | optional)
+- `prompt_mode` (`"chat"` or `"plain"`, HF/EXL2 primarily)
+- `chat_template` (string | optional, path or `default`)
+
+### `[ui]` (TUI-only)
+- `show_thinking` (bool)
+- `no_animate_thinking` (bool)
+- `assume_think` (bool)
+- `scroll_lines` (int)
+- `ui_tick_ms` (int)
+- `ui_max_events_per_tick` (int)
+- `save_transcript` (string | empty to disable, path resolved relative to config)
+
+### `[backend.<name>]` (backend-specific)
+Examples:
+- `[backend.hf]`
+  - `dtype` (`auto|float16|bfloat16|float32|torch_auto|checkpoint`)
+  - `use_4bit` / `use_8bit` (bool)
+  - `attn_implementation` (`eager|sdpa|flash_attention_2`)
+- `[backend.gguf]`
+  - `n_ctx`, `n_batch`, `n_ubatch`, `n_threads`, `n_gpu_layers`, rope/yarn knobs
+- `[backend.ollama]`
+  - `host`, `timeout`, `think_mode`
+- `[backend.openai]` (future)
+  - `base_url`, `api_key` (optional), `timeout`
+  - `tool_mode` (future)
+
+### `[machine]` (only in `config/machine.toml`)
+Recommended keys:
+- `model_root` (e.g. `/home/poop/ml/models`)
+- `hf_cache_dir` (optional)
+- `ollama_host` (optional)
+- `openai_base_url` (optional)
+
+Machine config is *never* required; it only fills blanks.
+
+## CLI integration
+
+### Selection
+Keep a single `--config` but add `--profile`:
+- `--config` selects a baseline config:
+  - path to `.toml` or `.json`
+  - or model name (resolved to `models/<model>/<backend>/config/default.*`)
+- `--profile <name>` loads `models/<model>/<backend>/config/profiles/<name>.toml` (if present)
+
+Rationale:
+- Users keep typing `--config <model>` today; `--profile` is additive and readable.
+
+### Backward compatibility
+For a transition period:
+- If `default.toml` exists, prefer it.
+- Else fall back to `config.json`.
+- Support loading JSON explicitly via `.json` extension.
+
+### “Effective config” introspection
+Extend `/show config` and `/show gen` to include:
+- which files were loaded (default/profile/machine)
+- the origin of each shown value (cli/profile/default/machine)
+- a backend “payload” view when applicable (what will actually be sent)
+
+## Path resolution rules
+- `~` expansion for all paths.
+- Relative paths resolve relative to the TOML file that declared them.
+- Windows paths (WSL) normalized as currently done in `tui.py`.
+
+## Templates and onboarding
+Update `scripts/model add` scaffolding to create:
+- `models/<model>/<backend>/config/default.toml`
+- optional `profiles/fast.toml` and `profiles/longctx.toml` stubs
+- `config/machine.example.toml` once at repo root (if missing)
+
+## Example: HF model config
+`models/Qwen3.5-9B/hf/config/default.toml`
+```toml
+[model]
+id = "/home/poop/ml/models/Qwen3.5-9B"
+
+[gen]
+stream = true
+max_new_tokens = 2048
+max_context_tokens = 16384
+temperature = 0.7
+top_p = 1.0
+
+[prompt]
+prompt_mode = "chat"
+system = ""
+user_prefix = ""
+
+[ui]
+show_thinking = true
+assume_think = false
+save_transcript = ""
+
+[backend.hf]
+dtype = "bfloat16"
+attn_implementation = "sdpa"
+use_4bit = false
+use_8bit = false
+```
+
+## Example: machine config
+`config/machine.example.toml`
+```toml
+[machine]
+model_root = "/home/poop/ml/models"
+hf_cache_dir = ""
+ollama_host = "http://127.0.0.1:11434"
+openai_base_url = "http://127.0.0.1:8000/v1"
+```
+
+## Rollout plan
+1. Add TOML loading behind existing JSON loader (no breaking changes).
+2. Add `config/machine.toml` support (optional, local-only).
+3. Add `--profile` and wire profiles resolution.
+4. Update templates + `scripts/model add` to generate TOML configs.
+5. Migrate a couple models (Nanbeige/Qwen) to TOML to validate the flow.
+6. Only then add the OpenAI/vLLM backend spec/implementation that consumes `[backend.openai]`.
+
+## Risks / gotchas
+- TOML uses explicit types; avoid ambiguous “empty string means unset” patterns.
+- Deep merges must be predictable; document them and keep them simple.
+- Some knobs are backend-specific; ensure “ignored knobs” are visible to the user.
+- Keep secrets out of committed configs (API keys belong only in `config/machine.toml` or env vars).
+
diff --git a/docs/specs/0010-openai-compatible-backend-vllm.md b/docs/specs/0010-openai-compatible-backend-vllm.md
new file mode 100644
index 0000000..0c9349f
--- /dev/null
+++ b/docs/specs/0010-openai-compatible-backend-vllm.md
@@ -0,0 +1,241 @@
+# Spec: OpenAI-compatible backend (vLLM) + “backend build” workflow
+
+Date: 2026-03-07
+
+## Context
+We now support TOML config layering (base + profile + machine overrides) per `docs/specs/0009-toml-config-profiles-and-machine-overrides.md`.
+
+Next goal: run local models in a way that is compatible with OpenClaw-style agent loops and tool calling.
+vLLM is a strong candidate because it can expose an **OpenAI-compatible** HTTP API with streaming.
+
+This spec covers two parts:
+1) **Backend build**: how to run a vLLM server for a chosen HF-format model (local path).
+2) **Client integration**: how this repo’s unified TUI should talk to an OpenAI-compatible server backend.
+
+## Goals
+- Add a new backend: `openai` (OpenAI-compatible HTTP server).
+- First supported engine: **vLLM** (others can follow later using the same backend).
+- Support streaming tokens into existing TUI events (`ThinkDelta` / `AnswerDelta`).
+- Support OpenAI-style tool calls *as raw text/events* (no execution yet).
+- Support TUI image attachments for OpenAI backends using data URLs (best-effort).
+- Keep dependencies optional: vLLM is not required unless `--backend openai` is used.
+
+## Non-goals (v1)
+- Running GGUF/EXL2 models through vLLM (not supported by vLLM; these remain separate engines).
+- Full tool execution loop UI (OpenClaw execution). We only surface tool-call content.
+- Perfect parity of all generation knobs across engines.
+
+## Terminology
+- **Model format**: HF folder (Transformers), GGUF, EXL2, Ollama model name.
+- **Engine**: Transformers, llama.cpp, ExLlamaV2, Ollama server, vLLM server.
+- **Backend** (repo): the adapter that produces TUI events (HF/GGUF/Ollama/EXL2/OpenAI-compatible).
+
+## 1) vLLM “backend build” (server side)
+
+### Recommended build strategy
+- Run vLLM as a separate long-running process, then point this repo at it.
+- Put server endpoint defaults in `config/machine.toml` (gitignored).
+
+### Minimal server start (text-only)
+Example (exact flags may vary by vLLM version; keep it simple):
+```bash
+vllm serve /home/poop/ml/models/Qwen3.5-9B \\
+  --host 127.0.0.1 --port 8000
+```
+
+### Vision / multimodal
+If the model is vision-capable, enable whatever vLLM requires for multimodal inputs for your installed version.
+Goal is to accept OpenAI-like message content segments that include image URLs / data URLs.
+
+### Tool calling
+vLLM’s OpenAI server supports OpenAI-compatible tool fields at the HTTP layer.
+Whether the model actually produces correct tool calls depends on:
+- the checkpoint (instruct vs base)
+- prompting/tool schema
+- decoding settings
+
+### Debug endpoints (sanity)
+- `GET /v1/models` should list the served model name(s).
+- A basic streaming chat completion request should stream token deltas.
+
+## 2) Repo integration: `openai` backend
+
+### CLI / detection
+Add:
+- `--backend openai`
+- Support a model ref scheme: `openai:<model_name>` (optional)
+
+Default backend selection remains unchanged; `openai` must be explicit in v1 to avoid ambiguity.
+
+### Config (TOML)
+Add new template:
+- `models/_TEMPLATE/openai/config/default.toml`
+
+Shape:
+```toml
+[model]
+id = ""               # model name as known by the server (required; see “Model resolution”)
+
+[gen]
+stream = true
+max_new_tokens = 1024
+temperature = 0.7
+top_p = 1.0
+stop_strings = []
+
+[prompt]
+system = ""
+system_file = ""
+user_prefix = ""
+
+[ui]
+show_thinking = true
+assume_think = false
+
+[backend.openai]
+base_url = ""         # e.g. http://127.0.0.1:8000/v1
+api_key = ""          # optional; prefer env var if used
+timeout_s = 600       # total request timeout (see “Timeout semantics”)
+```
+
+### Machine overrides
+Extend `config/machine.toml` support:
+- `openai_base_url` should fill `[backend.openai].base_url` if it’s unset.
+
+Important: machine overrides must not rewrite HF Hub ids into local paths.
+If `model.id` looks like `org/name`, treat it as a server-side model name, not a filesystem path.
+
+### Model resolution (MUST)
+In practice, many vLLM/OpenAI-compatible servers require the `model` field.
+
+v1 behavior:
+- If `[model].id` is set (non-empty), the backend MUST send it as the request `model`.
+- If `[model].id` is empty:
+  1) the backend MUST call `GET /v1/models` once at startup
+  2) if exactly one model is returned, the backend MUST use that model id
+  3) otherwise, the backend MUST fail with a clear error listing available model ids and instructing the user to set `[model].id`
+
+### API contract (v1 MUST target)
+v1 targets the OpenAI Chat Completions API shape:
+- Request: `POST /v1/chat/completions`
+- Streaming: Server-Sent Events (SSE)
+  - Frames are lines beginning with `data: `
+  - End marker: `data: [DONE]`
+  - Error frames must be surfaced as a single `Error(...)` event with the server-provided message
+
+Streaming JSON contract (common subset):
+- `choices[0].delta.content` (text chunks)
+- `choices[0].finish_reason` (terminal reason)
+- `choices[0].delta.tool_calls[]` (tool-call fragments; see below)
+
+### Payload building contract (v1)
+The backend MUST build an OpenAI Chat Completions request with:
+- `model` (string): resolved per “Model resolution”
+- `messages`: list of `{role, content}` objects
+  - `content` may be:
+    - string (text-only)
+    - list of segments (multimodal):
+      - `{ "type": "text", "text": "..." }`
+      - `{ "type": "image_url", "image_url": { "url": "data:image/png;base64,..." } }`
+- generation knobs mapping:
+  - `max_new_tokens` MUST be sent as `max_tokens` (v1 requirement)
+  - `temperature`, `top_p`
+  - `stop_strings` MUST be sent as `stop` when present
+  - `seed` only if server supports it (otherwise treat as deferred)
+
+The backend MUST report (once at startup and via `/show gen`) which knobs are:
+- **sent** (included in the HTTP payload)
+- **deferred** (not sent; server/model defaults apply)
+- **ignored** (configured but the backend does not implement them)
+
+### Streaming event mapping
+For OpenAI-style streaming responses, map server deltas to TUI events:
+- If the server yields a dedicated reasoning field (server-specific; e.g. `delta.reasoning` or `delta.reasoning_content`), route that to `ThinkDelta`.
+- Else: run `ThinkRouter` on streamed text to split `<think>...</think>` markers.
+
+Stop conditions:
+- Respect server termination and emit `Finish` with a `TurnRecord` containing:
+  - `raw`: concatenated streamed content (and tool call text if included)
+  - `think`/`answer`: extracted via router if applicable
+  - `gen`: snapshot of “sent” payload values (not “configured but omitted”)
+
+### Tool-call streaming contract (v1 MUST)
+Tool calls may stream incrementally under `choices[0].delta.tool_calls`.
+
+v1 MUST:
+- Buffer tool call fragments per tool index (and per tool id if provided), accumulating:
+  - function name
+  - arguments string fragments
+- Do NOT interleave partial tool-call JSON/arguments fragments into `AnswerDelta`.
+- On `Finish`, append a stable textual representation to `TurnRecord.raw` (and optionally store parsed tool calls under `TurnRecord.gen["tool_calls"]`).
+
+Example stable text representation appended to `raw`:
+```
+<tool_call>
+<function=name>
+<arguments>
+{...}
+</arguments>
+</function>
+</tool_call>
+```
+
+### Image attachments from the TUI (`/image`) (v1 MUST)
+`/image` currently exists in the TUI.
+
+v1 MUST update behavior:
+- Allow `/image` when backend is `hf` OR `openai`.
+- Deny (with a clear message) for `gguf`, `ollama`, `exl2`.
+
+For `openai` backend:
+- Convert local image file paths to `data:` URLs (base64) at request time.
+- Enforce local size caps (fail-fast):
+  - **10 MB per image** (raw file size on disk)
+  - **20 MB total** across all attached images for the turn
+- Error message MUST suggest remediation:
+  - resize the image
+  - attach fewer images
+  - or use a hosted URL (future)
+
+For `hf` backend:
+- Keep current local-path behavior (processor loads images from disk).
+
+### Auth precedence and secrecy (v1 MUST)
+Auth is optional for local vLLM but should be supported.
+
+Precedence for API key:
+1. CLI `--openai-api-key` (if provided)
+2. Environment variable `OPENAI_API_KEY`
+3. Config `[backend.openai].api_key`
+4. Machine config `config/machine.toml` (if we ever add it; otherwise skip)
+
+Rules:
+- Never print the API key value in `/show *`, exceptions, or logs.
+- `/show backend` MAY only show `api_key: (set)` / `(unset)` and the source label, never the value.
+
+### Timeout semantics (v1 MUST)
+`timeout_s` MUST be treated as a **total request timeout** (connect + read) for the chat completion request.
+If the HTTP client supports separate connect/read timeouts, v1 uses:
+- connect timeout = `min(10, timeout_s)`
+- read timeout = `timeout_s`
+
+## Testing checklist
+- Config resolution:
+  - base TOML only
+  - base + profile
+  - base + machine override
+  - CLI overrides above all
+- Server connectivity errors are surfaced clearly.
+- Streaming works:
+  - tokens stream without UI stutter
+  - thinking routing works (when model emits think tags)
+- Image path attach:
+  - `/image` + prompt produces a multimodal request for openai backend
+  - large image fails fast with a clear message
+
+## Rollout plan
+1. Add `openai` backend skeleton + config template.
+2. Add machine override mapping for `openai_base_url`.
+3. Add a minimal streaming client implementation (no tools/images first).
+4. Add tool-call surfacing (no execution).
+5. Add image segment serialization (data URL) as an optional enhancement.
diff --git a/docs/specs/0011-openclaw-tool-compat-layer.md b/docs/specs/0011-openclaw-tool-compat-layer.md
new file mode 100644
index 0000000..416cf07
--- /dev/null
+++ b/docs/specs/0011-openclaw-tool-compat-layer.md
@@ -0,0 +1,173 @@
+# Spec: OpenClaw-compatible tool schema + tool-call normalization layer
+
+Date: 2026-03-08
+
+## Context
+We want local models (HF / GGUF / EXL2 / vLLM/OpenAI) to be usable in OpenClaw-style agent loops.
+
+OpenClaw’s current “tools” approach is:
+- typed tools (no shelling as the primary interface)
+- policy-driven allow/deny + profiles + provider/model overrides
+- tools are presented to the model in **two parallel channels**:
+  1) system prompt text (human-readable list + guidance)
+  2) structured tool schema sent to the model API
+
+Key implication (worth repeating because it drives the whole design):
+- If a tool doesn’t appear in the system prompt text or the tool schema, the model cannot call it.
+
+This spec defines a repo-local layer that:
+- loads a tool schema (OpenAI-compatible function definitions)
+- applies a policy (allow/deny, optional profiles/groups)
+- sends tool schema to backends that support it (OpenAI-compatible servers like vLLM)
+- provides a **tool-call normalization** pipeline so model-emitted tool calls can be converted into a canonical structure (even when emitted as text)
+
+## Goals
+- Make tool calling “plug-and-play” from this repo by standardizing:
+  - tool schema inputs
+  - tool-call outputs (canonical form)
+  - streaming behavior (buffering partial tool calls)
+- Prefer structured tool calls when the backend provides them; fall back to text parsing when it does not.
+- Keep execution out of scope for v1: we surface tool calls reliably; OpenClaw (or later code) executes them.
+
+## Non-goals (v1)
+- Executing tools from the TUI.
+- Perfect compatibility with every model’s proprietary tool format.
+- Enforcing OpenClaw’s full policy language (we’ll start with a compatible subset).
+
+## Definitions
+
+### Canonical tool schema (input)
+Use OpenAI-style “function tool” schema:
+- `tools`: list of `{ type: "function", function: { name, description?, parameters } }`
+- `tool_choice`: `"auto" | "none" | {type:"function", function:{name:"..."}}` (optional)
+
+### Canonical tool call (output)
+Internal representation (language-agnostic):
+- `id`: optional string (server-provided if available)
+- `name`: function name (string, required)
+- `arguments_json`: JSON string (required; may be `{}`), not a dict to preserve exact bytes
+- `status`: `partial | complete`
+- `source`: `structured | parsed_text`
+
+### “Structured-first” rule
+If a backend provides tool calls as structured fields, they are the source of truth.
+Do NOT also parse `content` for tool calls in that case (avoid double-processing).
+
+## Config (TOML)
+Add a new section that is backend-agnostic:
+
+```toml
+[tools]
+enabled = false
+schema_file = ""          # path to a JSON file (OpenAI tool schema)
+policy_profile = "full"   # "minimal" | "coding" | "messaging" | "full" (subset)
+allow = []                # optional allowlist, case-insensitive, supports group:* entries
+deny = []                 # optional denylist, deny wins
+parse_mode = "strict"     # "off" | "strict" | "lenient"
+
+[tools.byBackend]
+openai = { enabled = true }
+hf = { enabled = false }
+gguf = { enabled = false }
+exl2 = { enabled = false }
+ollama = { enabled = false }
+```
+
+Notes:
+- `schema_file` is a repo asset (committed) unless it contains secrets.
+- `byBackend` is a local analogue of OpenClaw provider/model restriction (subset).
+
+## Tool policy (subset aligned with OpenClaw concepts)
+OpenClaw supports `tools.allow` / `tools.deny` with wildcards and groups, and tool profiles that set a base allowlist.
+
+Repo v1 policy subset:
+1) Start with `policy_profile` base allowlist:
+   - `minimal`: `session_status` only (if present in schema), else none
+   - `coding`: allow `group:fs`, `group:runtime`, `group:sessions`, `group:memory`, `image` (when present)
+   - `messaging`: allow `group:messaging`, `sessions_list`, `sessions_history`, `sessions_send`, `session_status` (when present)
+   - `full`: allow everything in schema
+2) Apply `allow` if non-empty (restrict to allowlist)
+3) Apply `deny` (deny wins)
+4) Expand `group:*` entries using a local mapping table (optional)
+
+We do NOT implement `byProvider` in v1 (that is OpenClaw-side), but we support `byBackend`.
+
+## Backend behavior
+
+### `openai` backend (vLLM first)
+- Send tool schema via the API’s `tools` field.
+- Send `tool_choice` when configured (optional).
+- Parse streaming `tool_calls` deltas (buffer per index) per `docs/specs/0010-openai-compatible-backend-vllm.md`.
+
+### `hf` / `gguf` / `exl2` / `ollama` backends
+v1: do not send structured tool schema (unless the engine provides an equivalent).
+
+Instead, when `tools.enabled` is true:
+- Inject a compact human-readable tool list into the system prompt text (system channel).
+- Expect tool calls to be emitted as text, then normalize via parsing (below).
+
+This matches OpenClaw’s “system prompt text” channel even when tool schema can’t be sent.
+
+## OpenClaw tool shape note (important for schema authors)
+OpenClaw tools are often “multi-action” tools:
+- Example: a single `browser` tool handles actions like `status`, `snapshot`, `act`, etc via an `action`/`kind`-style argument.
+- This means the OpenAI tool “function name” can be stable (`"browser"`), and the “subcommand” lives in `arguments`.
+
+When building a schema file intended to mimic OpenClaw, prefer this pattern (single tool name with an enum field) over inventing separate tool names like `browser_snapshot`.
+
+## Tool-call parsing + normalization
+
+### Parsing sources
+We support multiple parsers; each produces canonical tool calls.
+
+Order of precedence (v1):
+1) Structured tool calls from backend (OpenAI `tool_calls`)
+2) Model-specific “tag protocols” (configured per model/backend)
+3) JSON-in-text fallback (strict)
+
+### Parsers (v1 set)
+1) `openai_structured`:
+   - Input: streaming delta fragments and/or final structured tool_calls array
+   - Output: canonical tool calls
+   - MUST buffer fragments per index; do not leak partial arguments into answer stream
+
+2) `qwen_xmlish`:
+   - Recognize Qwen-style `<tool_call>...<function=NAME>...<parameter=...>...</parameter>...</function>...</tool_call>`
+   - Convert `<parameter=foo>bar</parameter>` into JSON arguments `{ "foo": "bar" }` (strings by default)
+   - `strict` mode: reject malformed blocks
+   - `lenient` mode: best-effort with explicit “uncertain” marker in meta
+
+3) `json_object`:
+   - Recognize a single top-level JSON object that looks like a tool call:
+     - `{ "tool_call": { "name": "...", "arguments": ... } }` or
+     - `{ "name": "...", "arguments": ... }`
+   - `strict` mode requires valid JSON and a known tool name.
+
+### Where parsing happens
+- Streaming: buffer until a complete call is detected; only then emit a tool-call event.
+- Non-streaming: parse the full text at end.
+
+### How to display in the TUI (v1)
+Keep it minimal:
+- Append a non-executed tool call to transcript as an InfoMessage block:
+  - tool name
+  - arguments JSON (pretty-printed)
+- Also store the canonical calls under `TurnRecord.gen["tool_calls"]`.
+
+Do NOT attempt to execute the tool.
+
+## History injection (tool results)
+When integrating with OpenClaw (or later local execution), tool results should be injected as `role="tool"` messages.
+
+This repo should preserve backends’ conventions:
+- OpenAI: `role="tool"` messages.
+- HF template-based: map to the model’s expected tool-response format if a parser/template requires it.
+
+## Testing checklist
+- A model that returns structured `tool_calls` (OpenAI backend):
+  - tool call arguments stream correctly (buffered)
+  - answer stream remains clean
+- A Qwen-style model (tag protocol):
+  - emits `<tool_call>` blocks; parser extracts name/args
+- A “JSON prints in content” model:
+  - strict JSON-only mode either parses cleanly or refuses with clear message
diff --git a/docs/specs/0012-openai-targets-and-server-config-separation.md b/docs/specs/0012-openai-targets-and-server-config-separation.md
new file mode 100644
index 0000000..1c85aec
--- /dev/null
+++ b/docs/specs/0012-openai-targets-and-server-config-separation.md
@@ -0,0 +1,114 @@
+#!/usr/bin/env markdown
+# Spec: OpenAI-compatible targets + client/server config separation
+
+Date: 2026-03-08
+
+Status: **Deferred / future** (kept for reference)
+
+## Problem
+The repo has an `openai` backend (OpenAI-compatible HTTP protocol adapter). We want to use it primarily with vLLM, but also with other OpenAI-compatible servers later.
+
+Two pain points:
+1) Naming confusion: “vLLM integration” vs “openai backend”.
+2) Config shape confusion: mixing *client intent* (model/prompt/gen) with *server endpoint/auth* (base_url/key/timeout), especially when you have multiple servers.
+
+## Why deferred
+We decided to make **vLLM a first-class engine backend** (managed start/stop) instead of making “OpenAI-compatible HTTP” the primary user-facing backend.
+
+That direction is specified in:
+- `docs/specs/0013-vllm-engine-first-managed-server.md`
+
+This spec remains useful if/when we add:
+- “external attach” mode (connect to an already-running vLLM)
+- support for remote OpenAI-compatible servers (OpenRouter/LM Studio/etc)
+- named transport “targets” that can be shared across models/engines
+
+## Goals
+- Keep the backend named by **protocol contract** (`openai`), while making it easy to target vLLM and other OpenAI-compatible servers.
+- Reduce duplication when you have many models but only a few server endpoints.
+- Make it obvious which settings are:
+  - model-level / prompt-level / generation-level (client intent)
+  - transport/auth (client-to-server)
+  - server launch knobs (server-side; out of scope for the TUI client)
+
+## Non-goals (v1)
+- Starting/stopping vLLM from the TUI.
+- Capturing every vLLM CLI flag in repo config.
+
+## Terminology
+- **Backend (repo)**: adapter that emits the TUI streaming events. Example: `hf`, `gguf`, `ollama`, `exl2`, `openai`.
+- **Server engine**: the thing actually running the model. Example: vLLM (HF models), LM Studio, OpenRouter, etc.
+- **Target**: a named OpenAI-compatible server endpoint + auth settings.
+
+## Current state (today)
+- Model config lives under: `models/<model>/<backend>/config/default.toml`
+- Optional per-model profiles live under: `models/<model>/<backend>/config/profiles/<name>.toml`
+- Machine defaults (gitignored) live at: `config/machine.toml`
+
+This already supports targeting multiple servers, but only by duplicating profiles per model (or constantly passing CLI flags).
+
+## Proposed change: add global “targets”
+Add a repo-level folder for server targets:
+- `config/targets/openai/<target>.toml`
+
+Each target file contains only transport/auth keys:
+```toml
+[backend.openai]
+base_url = "http://127.0.0.1:8000/v1"
+api_key = ""
+timeout_s = 600
+```
+
+Rules:
+- Targets contain **no** model/prompt/gen/ui keys.
+- Secrets still belong in `config/machine.toml` (gitignored) unless you explicitly want them in a target file.
+
+## Config layering order (MUST)
+For `--backend openai`, merge layers in this order:
+1) Base: `models/<model>/openai/config/default.toml`
+2) Optional per-model profile: `models/<model>/openai/config/profiles/<profile>.toml`
+3) Optional target: `config/targets/openai/<target>.toml`
+4) Optional machine: `config/machine.toml`
+5) CLI flags (highest precedence)
+
+Rationale:
+- Per-model profile should override the base model defaults.
+- Target should allow switching servers without rewriting per-model configs.
+- Machine should set per-machine defaults without committing secrets.
+- CLI always wins.
+
+Note: If we want “machine overrides win” semantics later, we can swap (3) and (4). v1 chooses “target beats machine” so you can quickly switch endpoints without editing machine.toml.
+
+## CLI changes (MUST)
+Add:
+- `--target` (string): resolves to `config/targets/openai/<target>.toml` for the `openai` backend.
+
+Examples:
+- `tui Qwen3.5-9B --backend openai --target vllm-local`
+- `tui Qwen3.5-9B --backend openai --target openrouter`
+
+If `--target` is set but the file doesn’t exist, fail with a clear error listing:
+- expected path
+- existing targets in `config/targets/openai/` (if any)
+
+## Recommended repo layout conventions
+- Keep model “intent” in model config:
+  - `[model].id` (server-side model name)
+  - `[prompt]` system/system_file/user_prefix
+  - `[gen]` temperature/top_p/max_new_tokens/stop_strings/seed…
+  - `[ui]` show_thinking, assume_think, save_transcript…
+- Keep endpoint/auth in targets + machine:
+  - `[backend.openai]` base_url/api_key/timeout_s
+- Keep server launch instructions as docs:
+  - `docs/environments/vllm.md` (optional, not required for v1)
+
+## vLLM “isn’t a backend” clarification (docs requirement)
+Docs/entrypoints MUST clearly state:
+- The `openai` backend is a protocol adapter.
+- vLLM is the recommended **server engine** that exposes that protocol locally.
+
+Optionally: add an alias in CLI (`--backend vllm` == `--backend openai`) later, but do not rename the backend.
+
+## Open questions
+- Do we want targets for other backends too (`config/targets/ollama/...`), or keep targets OpenAI-only for now?
+- Should machine config be allowed to set a default target name (e.g. `openai_target_default = "vllm-local"`)?
diff --git a/docs/specs/0013-vllm-engine-first-managed-server.md b/docs/specs/0013-vllm-engine-first-managed-server.md
new file mode 100644
index 0000000..8e2fc24
--- /dev/null
+++ b/docs/specs/0013-vllm-engine-first-managed-server.md
@@ -0,0 +1,302 @@
+#!/usr/bin/env markdown
+# Spec: vLLM as a first-class engine backend (managed server)
+
+Date: 2026-03-08
+
+## Context / problem
+Today the unified TUI treats most backends as “engines”:
+- `hf` (Transformers, in-process)
+- `gguf` (llama.cpp via `llama-cpp-python`, in-process)
+- `exl2` (ExLlamaV2, in-process)
+- `ollama` (Ollama server, out-of-process)
+
+But the vLLM work was introduced as an `openai` backend (OpenAI-compatible HTTP protocol). That makes the repo inconsistent:
+- In the repo, “backend” usually means **what runs the model** (engine).
+- `openai` is instead **how we talk to a server** (transport/protocol).
+
+This spec makes vLLM “first-class” in the same way as EXL2: you choose vLLM as an engine, the TUI starts/stops it, and the transport used to speak to it is an implementation detail.
+
+## Goals
+- Add a **`vllm` engine backend** that:
+  - starts a vLLM OpenAI-compatible server process on launch
+  - waits for readiness
+  - streams chat via the existing OpenAI-compatible client logic
+  - stops the server on clean exit
+- Make user workflow consistent:
+  - `tui Qwen3.5-9B vllm`
+  - model config lives at `models/<model>/vllm/...`
+- Keep future flexibility:
+  - v2 can add “persist server” mode
+  - later engines that expose OpenAI-compatible APIs (e.g. “tabby server”) can reuse the same transport module without becoming “transport-named backends”.
+
+## Non-goals (v1)
+- Persistable server lifecycle (leave vLLM running after exit). Design so v2 can bolt this on.
+- Supporting GGUF/EXL2 through vLLM (not a vLLM target).
+- Full tool execution loop in TUI (still “surface only”).
+
+## Design overview (2-layer internal model)
+Keep the user-facing choice as **engine backends**.
+
+Internally:
+- “Engine backend” = chooses how a model runs.
+- “Transport client” = how we talk to an engine when it is out-of-process.
+
+For vLLM:
+- engine backend: `vllm`
+- transport client: `openai_http` (OpenAI-compatible chat-completions streaming)
+
+Important: `openai_http` is a reusable module, not a user-facing engine choice in the normal local workflow.
+
+## CLI / UX
+### Backend selection
+Add `vllm` as a backend choice:
+- positional: `tui <model> vllm`
+- flag: `tui <model> --backend vllm`
+
+Deprecation stance (docs only, v1):
+- Prefer `vllm` for local vLLM usage.
+- Keep the existing `openai` backend as the “external OpenAI-compatible server attach” backend (supported in v1; not deprecated).
+
+### Profiles
+Profiles remain the mechanism for “combos”:
+- `tui <model> vllm --profile maxctx`
+- `tui <model> vllm --profile tp2`
+
+Profiles should be engine-scoped and narrow: only override vLLM-related knobs for that model.
+
+## Repo layout
+Add model-first layout for vLLM:
+- `models/<model>/vllm/config/default.toml`
+- `models/<model>/vllm/config/profiles/<name>.toml`
+- `models/<model>/vllm/notes/README.md`
+- `models/<model>/vllm/templates/` (optional; vLLM uses tokenizer templates indirectly, but we may still keep reference templates here)
+- `models/<model>/vllm/prompts/` (ignored by git, may contain secrets)
+
+Also add:
+- `models/_TEMPLATE/vllm/...`
+
+## Config shape (TOML)
+Constraint: current config loader flattens only `backend.<selected_backend>.*`.
+Therefore, vLLM config must include **both** server-lifecycle knobs and OpenAI-HTTP transport knobs under `backend.vllm`.
+
+Recommended template (`models/_TEMPLATE/vllm/config/default.toml`):
+```toml
+[model]
+id = ""                 # local path to HF model folder OR a served model name override (see below)
+
+[gen]
+stream = true
+max_new_tokens = 1024
+temperature = 0.7
+top_p = 1.0
+stop_strings = []
+
+[prompt]
+system = ""
+system_file = ""
+user_prefix = ""
+
+[ui]
+show_thinking = true
+assume_think = false
+
+[backend.vllm]
+# Lifecycle
+mode = "managed"        # "managed" (v1), future: "external", "managed_persist"
+
+# Where to bind the server (managed mode)
+host = "127.0.0.1"
+port = 8000             # if 0, auto-select a free port (recommended to avoid collisions)
+
+# How to start vLLM
+cmd = "vllm"            # or python module invocation; keep configurable
+extra_args = []         # list of extra CLI args (strings), appended verbatim
+
+# OpenAI-compatible client transport (used to talk to the managed server)
+base_url = ""           # if empty in managed mode, derive from host/port as http://host:port/v1
+api_key = ""            # optional; prefer env var if set
+timeout_s = 600
+
+# vLLM common knobs (examples; keep modest in v1)
+served_model_name = ""  # if set, pass --served-model-name (controls `model` string clients must send)
+tensor_parallel_size = 1
+gpu_memory_utilization = 0.90
+max_model_len = 0       # 0 means “let vLLM decide”; otherwise pass explicit
+```
+
+### Model id semantics
+We need a clear rule so “run a model” is consistent with other engines:
+- In managed mode:
+  - If `model.id` is a local directory, use it as the vLLM `--model` path.
+  - `served_model_name` controls the OpenAI-visible model name (and the `model` field the client sends).
+- In external mode (future):
+  - `model.id` is a server-side model name (string), and we do not start a server.
+
+## Implementation plan (code-level)
+### 1) Factor OpenAI-compatible HTTP logic into a reusable module
+Refactor existing `tui_app/backends/openai.py` into something like:
+- `tui_app/transports/openai_http.py` (preferred), or
+- keep file but make it clearly “transport” with no engine-specific naming.
+
+It should accept:
+- `base_url`, `api_key`, `timeout_s`
+- a resolved `model` string
+- messages + gen knobs
+and return the same streaming event types used today.
+
+### 2) Add a `vllm` backend that manages server lifecycle
+Add:
+- `tui_app/backends/vllm.py` (engine backend)
+Responsibilities:
+- Build server command from config:
+  - `cmd` + `serve`/module invocation + `--host/--port`
+  - `--model <local_path>`
+  - optional: `--served-model-name`
+  - optional knobs (tp, gpu mem util, max_model_len, etc)
+- Spawn with `subprocess.Popen(argv, shell=False, ...)` (MUST be argv-list; no shell string execution).
+  - If `cmd` is a string, split using `shlex.split(cmd)` into argv.
+  - If we later support `cmd_argv` (list), prefer that as the most deterministic.
+- Port collision handling (MUST):
+  - If `port == 0`, select a free port before spawning (e.g. bind a local socket to port 0, read assigned port, close, then launch vLLM with that port).
+  - If `port != 0` and spawn fails due to bind error, fail fast with a clear message.
+    - Include the attempted host/port and suggest a “find free port” command (e.g. `ss -ltnp | rg :8000`).
+- Wait for readiness (MUST):
+  - Normalize to a canonical OpenAI base URL ending in `/v1`.
+  - Probe readiness by polling `GET <base_url>/models` (i.e. `/v1/models`) until success or timeout.
+- fail with clear error output if server does not come up
+- Once ready: create an OpenAI HTTP transport session and stream tokens.
+- On app exit: terminate the process group and wait with a short timeout.
+  - Shutdown escalation (MUST): TERM → wait short timeout → KILL if still alive.
+  - Lifecycle scope (MUST): start server once per TUI session, not per turn.
+  - Abnormal exit behavior (MUST): ensure shutdown occurs on `KeyboardInterrupt` and normal TUI exit; best-effort on signals (wrap main run loop with `try/finally`).
+
+Startup failure diagnostics (MUST):
+- Capture stdout/stderr to a ring buffer (last N lines).
+- On readiness timeout or non-zero exit:
+  - show exact launch argv
+  - show last N lines from captured logs
+
+### 3) Wire into `tui.py`
+- Add `vllm` to:
+  - backend choices (`backend_hint` and `--backend`)
+  - default config lookup
+  - `create_session` dispatch table
+
+### 4) Templates / onboarding
+- Add `models/_TEMPLATE/vllm/` and ensure `scripts/model add ... vllm` works (copy only the vllm subtree).
+- Decide where to import model cards for vllm (usually same as HF because the served model is an HF folder).
+
+## Deterministic “model id” contract (managed mode) (MUST)
+In managed mode we are starting a vLLM server intended to serve *one* model. The client MUST always send one unambiguous `model` string.
+
+Rules:
+- If `backend.vllm.served_model_name` is set:
+  - pass it to vLLM (`--served-model-name ...`)
+  - client MUST send that same name in requests
+- Else:
+  - after readiness, call `GET <base_url>/models`
+  - if exactly one model is listed, client MUST use that id
+  - otherwise fail with a clear message telling the user to set `backend.vllm.served_model_name`
+
+This avoids overloading `[model].id` with “local path” vs “server-visible model string”.
+
+## Config plumbing / key mapping plan (MUST)
+Because config flattening is backend-scoped, vLLM needs explicit flatten + argparse wiring so config values are not silently ignored.
+
+Flatten mapping (TOML → flat keys):
+- `[backend.vllm] host` → `vllm_host`
+- `[backend.vllm] port` → `vllm_port`
+- `[backend.vllm] mode` → `vllm_mode`
+- `[backend.vllm] cmd` → `vllm_cmd`
+- `[backend.vllm] extra_args` → `vllm_extra_args`
+- `[backend.vllm] served_model_name` → `vllm_served_model_name`
+- `[backend.vllm] tensor_parallel_size` → `vllm_tensor_parallel_size`
+- `[backend.vllm] gpu_memory_utilization` → `vllm_gpu_memory_utilization`
+- `[backend.vllm] max_model_len` → `vllm_max_model_len`
+
+Transport keys under vLLM (vLLM uses OpenAI-compatible HTTP under the hood):
+- `[backend.vllm] base_url` → `vllm_base_url` (optional; derived from host/port when empty)
+- `[backend.vllm] api_key` → `vllm_api_key`
+- `[backend.vllm] timeout_s` → `vllm_timeout_s`
+
+Argparse + CLI flags should mirror these names (with `--vllm-*` flags) and continue to support `/show gen` showing sent/deferred/ignored.
+
+## Knob parity for vLLM (MUST)
+User expectation: vLLM should not be a “minimal backend”. If the repo already exposes a knob for other engines, vLLM should:
+- send it when vLLM supports it, or
+- clearly mark it as **ignored** (not silently dropped).
+
+### Chat-completions request knobs to support (v1 MUST)
+Send these in the `/v1/chat/completions` JSON body when set:
+
+OpenAI-standard (expected to work on vLLM and most compatible servers):
+- `max_new_tokens` → `max_tokens`
+- `temperature` → `temperature`
+- `top_p` → `top_p`
+- `stop_strings` → `stop`
+- `presence_penalty` → `presence_penalty`
+- `frequency_penalty` → `frequency_penalty`
+
+vLLM-supported extras (supported by vLLM Chat API as “extra parameters”; safe to use for the **vllm engine backend**):
+- `top_k` → `top_k`
+- `min_p` → `min_p`
+- `repetition_penalty` → `repetition_penalty`
+- `stop_token_ids` (new) → `stop_token_ids`
+- `ignore_eos` (new) → `ignore_eos`
+- `min_tokens` (new) → `min_tokens`
+- `seed` → `seed`
+- `best_of` (new) → `best_of`
+- `use_beam_search` (new) → `use_beam_search`
+- `length_penalty` (new) → `length_penalty`
+- `include_stop_str_in_output` (new) → `include_stop_str_in_output`
+- `skip_special_tokens` (new) → `skip_special_tokens`
+- `spaces_between_special_tokens` (new) → `spaces_between_special_tokens`
+- `truncate_prompt_tokens` (new) → `truncate_prompt_tokens`
+- `allowed_token_ids` (new) → `allowed_token_ids`
+- `prompt_logprobs` (new) → `prompt_logprobs`
+
+Notes:
+- vLLM’s docs explicitly mention passing non-OpenAI parameters (e.g. `top_k`) as “extra parameters” / `extra_body` in the OpenAI client; for direct HTTP, they are simply included in the request JSON body.
+- Some OpenAI-compatible providers reject unknown fields; this is a key reason vLLM should be its own engine backend (so we can safely send vLLM extras there without breaking generic “openai attach” mode).
+
+### Knobs that may not exist in vLLM (v1 behavior)
+If these are set in CLI/config for vLLM, they MUST be surfaced as ignored/deferred (choose one, but be consistent):
+- `typical_p` (not present in vLLM chat request schema)
+- `max_time` (not a vLLM chat request field)
+- HF-only knobs like `num_beams` / `no_repeat_ngram_size` (unless we intentionally map them to vLLM equivalents; otherwise ignore)
+
+## Server defaults that affect “knob behavior” (MUST document + expose)
+vLLM will, by default, apply `generation_config.json` from the HF model repo if present, which can override defaults for sampling parameters.
+
+To keep behavior predictable in this repo:
+- add a vLLM server launch knob to control this, e.g. `backend.vllm.generation_config = "hf" | "vllm"`
+  - `"hf"`: default vLLM behavior (applies `generation_config.json` if present)
+  - `"vllm"`: pass `--generation-config vllm` at launch to disable HF generation_config defaults
+
+## How profiles solve “server combos” (explicit)
+With vLLM as an engine backend, profiles become the safe place for variations:
+- same model, different vLLM launch knobs:
+  - `profiles/maxctx.toml` sets `backend.vllm.max_model_len`
+  - `profiles/tp2.toml` sets `backend.vllm.tensor_parallel_size = 2`
+  - `profiles/gpu90.toml` sets `backend.vllm.gpu_memory_utilization = 0.90`
+
+This keeps navigation consistent:
+- you always look under `models/<model>/vllm/…` when you’re “running vLLM”.
+
+## v2: persistable server mode (design hook)
+Do not implement now, but keep the design compatible:
+- `backend.vllm.mode` can later add:
+  - `managed_persist`: do not stop server on exit
+  - `external`: never start/stop server, just connect
+- If we add persistence:
+  - write a small state file under `~/.cache/model-runner/vllm/<model>/server.json`
+  - store pid/port/base_url/served_model_name/model_path/start_time
+  - validate “is alive + matches expected model” before reuse
+
+## Acceptance criteria (v1)
+- `tui Qwen3.5-9B vllm` starts vLLM, connects, and streams chat.
+- Exiting the TUI stops the vLLM process reliably.
+- Profiles work without moving files:
+  - `tui Qwen3.5-9B vllm --profile maxctx` loads profile overrides.
+- Repo navigation is consistent:
+  - all local engines appear under `models/<model>/<engine>/...`.
diff --git a/docs/specs/0014-tui-status-and-show-inspect.md b/docs/specs/0014-tui-status-and-show-inspect.md
new file mode 100644
index 0000000..377d313
--- /dev/null
+++ b/docs/specs/0014-tui-status-and-show-inspect.md
@@ -0,0 +1,239 @@
+#!/usr/bin/env markdown
+# Spec: `/status` + a cleaner `/show` (“inspect”) UX for the TUI
+
+Date: 2026-03-08
+
+## Context / problem
+We added many slash commands/topics while the repo grew quickly.
+
+Pain points:
+- Too many “power user” commands are presented as primary (noisy help).
+- Debugging managed backends (notably managed vLLM) is hard because important runtime state/log tails are not visible in the UI.
+- Users want a consistent, low-cognitive-load flow:
+  - *concise when you want concise*
+  - *deep inspection when you need it*
+
+## Goals
+- Add a new `/status` command for a concise runtime summary (the “default” debugging view).
+- Keep `/show` as the primary deep inspection surface (i.e., “inspect”), but:
+  - make it easy to discover topics
+  - keep default output minimal
+  - provide `--verbose` for the full dump
+- Keep backward compatibility:
+  - keep existing “shortcut” commands as **hidden aliases** temporarily
+  - do not break muscle memory in the short term
+- Improve in-TUI debugging for managed backends:
+  - show managed vLLM server state (pid/port/url)
+  - show recent server log tail on demand
+
+## Non-goals (v1)
+- Session save/restore (future).
+- Live editing of config files.
+- Tool execution loop UI.
+
+## Command set (v1)
+
+### Primary
+- `/?` and `/help` (synonyms): show help
+- `/status`: concise runtime/session summary
+- `/show <topic> [args...]`: deep inspection
+
+### Prompt-related (keep)
+- `/system`: show active system prompt and source
+- `/prefix`: show prefix/template-related prompt settings
+
+### Utilities (keep)
+- `/image ...` (where supported)
+- `/clear`
+- `/exit`, `/quit`
+
+## `/status` output contract
+`/status` should fit on a screen and be stable across backends.
+
+Recommended fields (exact formatting is flexible):
+
+**Identity**
+- backend: `hf|gguf|exl2|ollama|openai|vllm|...`
+- model: resolved model id / path (as known by the session)
+- config: base config path + active profile (if any)
+
+**Run state**
+- generating: `true|false`
+- follow_output: `true|false`
+- pending_images: count
+
+**Gen summary (effective intent)**
+- max_new_tokens, temperature, top_p
+- include `top_k` only when set (or “default/deferred” if we already track it)
+
+**Backend summary**
+- A one-liner derived from `session.describe()` when available.
+  - Examples:
+    - vLLM: `managed pid=..., base_url=..., model=...`
+    - OpenAI attach: `base_url=..., model=...`
+    - Ollama: `host=..., model=...`
+
+**Last turn (if available)**
+- last elapsed seconds
+- last ended_in_think
+- lengths: raw/think/answer (already tracked in `TurnRecord`)
+
+Important: `/status` must be safe to use during generation (read-only).
+
+## `/show` redesign (still `/show`, but acts like “inspect”)
+`/show` remains the detailed inspector. Topics are stable and additive.
+
+### Default behavior
+- `/show` (no args) prints:
+  - `Usage: /show <topic> [--verbose]`
+  - list of topics (grouped)
+  - a couple of examples
+  - a pointer to `/status` (“use /status for a concise summary”)
+
+### Common flags (v1)
+All `/show` topics should accept:
+- `--verbose` (or `-v`): include more fields, expanded dumps, and log tails where relevant
+- `--json`: emit JSON for copy/paste (optional per topic; recommended for `args`, `config`, `backend`)
+
+If a topic doesn’t support `--json`, it must say so.
+
+### Per-topic flag support matrix (v1 MUST)
+To keep UX consistent and testable, v1 defines the supported flags per topic:
+
+| topic | `--verbose` | `--json` |
+|---|---:|---:|
+| `status` | ✅ | ✅ |
+| `session` | ✅ | ✅ |
+| `model` | ✅ | ✅ |
+| `prompt` | ✅ | ✅ |
+| `gen` | ✅ | ✅ |
+| `ui` | ✅ | ✅ |
+| `history` | ✅ | ✅ |
+| `last` | ✅ | ✅ |
+| `files` | ✅ | ✅ |
+| `env` | ✅ | ✅ |
+| `config` | ✅ | ✅ |
+| `backend` | ✅ | ✅ |
+| `aliases` | ✅ | ✅ |
+| `logs` | ✅ | ❌ |
+| `request` | ✅ | ✅ |
+
+Notes:
+- `--json` is intentionally disabled for `logs` to avoid “log data as an API” and to keep output human-oriented.
+
+### Topic list (v1)
+Keep existing topics but polish output contracts:
+- `session`: full session state (superset of `/status`)
+- `model`: backend + resolved model id (minimal)
+- `prompt`: prompt-related config (system + prefix summary)
+- `gen`: “effective generation settings” in sent/deferred/ignored buckets
+- `ui`: UI knobs (follow mode, tick, etc.)
+- `history`: conversation history summary (counts + last roles)
+- `last`: last `TurnRecord` summary
+- `files`: resolved file paths (system_file, save_transcript, etc.)
+- `env`: env variables that influence behavior (CUDA_VISIBLE_DEVICES, OLLAMA_HOST, etc.)
+- `config`: loaded layers + per-key origin map (already implemented)
+- `backend`: backend-specific details (session.describe)
+- `aliases`: show alias map
+
+#### `/show gen` default output contract (v1 MUST)
+To avoid clutter regressions, `/show gen` output is strictly defined:
+
+- Default (`/show gen`):
+  - `sent.*` (what is actually sent to the backend)
+  - `deferred` (known knobs not sent; backend defaults apply)
+  - `ignored` (configured but not supported by this backend)
+  - MUST NOT include a full `args.*` dump.
+
+- Verbose (`/show gen --verbose`):
+  - includes everything in default output, plus:
+  - `args.*` (post-merge config+CLI values)
+  - optionally: per-key origin labels if already tracked
+
+### New debugging topics (v1)
+Add:
+- `logs`: show recent backend logs (when available)
+  - Default: a short message (“no logs captured” / “use --verbose”)
+  - `--verbose`: show last N lines
+  - Optional args:
+    - `--n <int>` (default 80)
+    - `--filter <substring>` (best-effort, local)
+
+Backend behavior for `logs`:
+- v1 MUST support a standardized in-memory ring buffer across all backends.
+  - `logs` shows the in-memory ring buffer tail.
+  - If the current backend does not emit into the buffer (bug/misconfig), `logs` MUST say so explicitly.
+
+Also show the configured log sink (if any), even if the buffer is empty:
+- `log_file` path (if configured)
+- `tee` suggestion (when applicable)
+
+Also add:
+- `request`: show the last request payload summary (sanitized)
+  - Intended for OpenAI-compatible backends and Ollama
+  - Must redact secrets (api keys)
+  - Default should be short; `--verbose` shows full JSON (truncated to a safe limit)
+
+If we haven’t captured the last request yet, output:
+- “No request captured (enable request capture in config)” and explain how.
+
+## Hidden aliases (backward compatibility)
+Goal: keep old shortcuts working, but reduce help noise.
+
+### Which aliases to keep (examples)
+Keep these as hidden aliases mapping to canonical handlers:
+- `/gen` → `/show gen`
+- `/args` → `/show args`
+- `/config` → `/show config`
+- `/backend` → `/show backend`
+- `/env` → `/show env`
+- `/files` → `/show files`
+- `/last` → `/show last`
+- `/history` → `/show history`
+- `/model` → `/show model`
+- `/session` → `/show session`
+
+Help behavior:
+- `/help` lists only primary commands by default.
+- `/help --all` (or `/help aliases`) shows hidden aliases.
+
+## Implementation notes
+
+### Registry
+Keep a single registry for commands. Add metadata:
+- `hidden: bool` for help listing
+- `read_only: bool` to allow during generation
+
+### `/show` parsing
+Continue using `shlex.split`.
+`/show <topic> --help` prints that topic’s usage.
+
+### Surfacing managed vLLM logs
+All backends should emit log lines to a standardized in-memory ring buffer (size N).
+Expose it via `/show logs` and include a short “log_tail available (N lines)” indicator in `/status`.
+
+### Request capture (v1 toggle)
+For debugging issues like “decoder prompt cannot be empty” we need to see what the client sent.
+
+Add a config/UI flag:
+- `ui.capture_last_request = false` (default)
+When enabled:
+- store a sanitized copy of the last request payload per backend session (in memory)
+- surface via `/show request`
+
+Hard limits + redaction rules (v1 MUST):
+- Max stored bytes per captured request: 256 KB.
+  - If larger, truncate and include a marker like `"...(truncated)"`.
+- Always redact secrets:
+  - Authorization headers
+  - API keys / bearer tokens
+- Always omit or summarize binary/large data:
+  - image `data:` URLs MUST NOT be stored verbatim; replace with metadata:
+    - `{"type":"image_url","image_url":{"url":"(data-url omitted)","bytes":12345,"mime":"image/png"}}`
+  - For local image paths, store only the path basename (or a redacted path if you prefer).
+
+## Acceptance criteria
+- `/status` exists and is useful across backends.
+- `/show` remains the detailed inspector, with `--verbose`.
+- `/show logs` displays vLLM managed log tail without leaving the TUI.
+- Hidden aliases work but do not clutter `/help`.
diff --git a/docs/specs/0015-backend-standardization-contracts.md b/docs/specs/0015-backend-standardization-contracts.md
new file mode 100644
index 0000000..753f9b2
--- /dev/null
+++ b/docs/specs/0015-backend-standardization-contracts.md
@@ -0,0 +1,174 @@
+#!/usr/bin/env markdown
+# Spec: Backend standardization contracts (TUI)
+
+Date: 2026-03-08
+
+## Context / problem
+This repo grew from “a few runner scripts” into a multi-backend playground with a unified Textual TUI (`tui.py` + `tui_app/`).
+
+We now have:
+- a solid shared UI
+- multiple engines/protocols with different capabilities
+
+But we lack a single, explicit “contract” that every backend must meet, which makes it easy to:
+- accidentally implement inconsistent UX
+- silently accept placebo knobs
+- lose debuggability when adding new backends/models
+
+This spec defines the repo-wide backend contracts that keep the TUI consistent.
+
+Supporting audits:
+- `docs/audits/0003-standardization.md`
+- `docs/audits/0004_tui_logging.md`
+
+## Goals
+- Make backend additions predictable:
+  - consistent thinking behavior
+  - consistent debugging surfaces (`/show`, logs, last request)
+  - consistent metrics (token counts, tok/s) when available
+- Avoid abstraction tax:
+  - do not force full knob parity across engines
+  - do not require heavyweight tokenizers purely for metrics
+
+## Non-goals
+- Refactor all backends in one PR.
+- Add new UI features unrelated to consistency.
+
+## Terms
+- **Engine backend**: what runs the model (HF, GGUF, EXL2, vLLM managed, Ollama).
+- **Transport**: how we talk to an out-of-process engine (OpenAI-compatible HTTP, Ollama HTTP).
+- **Template control level**: whether the repo can enforce chat template/history shaping for a backend.
+
+## Contract: Backend surface (must)
+Every backend must implement the `BackendSession` protocol and follow the event contract:
+- Emits `TurnStart(turn_id)` exactly once per turn.
+- Emits any number of:
+  - `ThinkDelta`
+  - `AnswerDelta`
+  - `Meta`
+- Terminates with exactly one of:
+  - `Finish(turn_id, record=TurnRecord)`
+  - `Error(turn_id, message=...)`
+
+Required session methods/fields:
+- `backend_name: str`
+- `resolved_model_id: str`
+- `generate_turn(turn_id: int, messages: list[dict[str, object]], emit: EventEmitter) -> None`
+- `get_recent_logs(n: int = 80) -> list[str]`
+
+Recommended optional methods:
+- `describe() -> dict[str, object]` (for `/status` and `/show backend`)
+- `get_last_request() -> dict | None` (for `/show request` parity)
+
+## Contract: Thinking behavior (must)
+User-facing behavior:
+- Thinking is routed to the thinking panel (`ThinkDelta`).
+- Final output is routed to the answer panel (`AnswerDelta`).
+
+Standard routing:
+- For text-streaming backends, use `ThinkRouter(assume_think=args.assume_think)` to split think vs answer based on markers.
+- If a backend provides a dedicated reasoning/thinking channel, emit that text via `ThinkDelta` directly, and route any remaining “content” via `ThinkRouter`.
+
+Notes:
+- Do not force “think tags” to exist; not all models emit them.
+- `assume_think` exists specifically for models that emit only `</think>` (or emit markers inconsistently).
+
+## Contract: Token accounting and metrics (must where available)
+Tokens are the unit for:
+- context windows
+- generation budgets
+- throughput measurements (tok/s)
+
+Source of truth order (preferred):
+1. Backend-native usage counters / token IDs
+2. Backend tokenization API
+3. Retokenization fallback (last resort, only if already loaded)
+
+Minimum Meta keys (when knowable):
+- `prompt_tokens: int`
+- `completion_tokens: int`
+- `total_tokens: int`
+
+UI rules:
+- `/show last` and `/status` must prefer token metrics when available.
+- If token metrics are unavailable, show `unavailable` explicitly.
+- Character counts may still be shown as a secondary diagnostic signal, but never presented as tokens.
+
+See ADR:
+- `docs/decisions/0015-token-accounting-and-metrics.md`
+
+## Contract: Knob mapping semantics (must)
+We will not standardize “every knob works everywhere”.
+We will standardize **reporting** so users know what actually happened.
+
+Per-turn (preferred) or per-session (minimum) reporting:
+- `sent`: values that were actually applied/sent to the engine/server
+- `deferred`: values left unset, meaning backend defaults apply
+- `ignored`: values the user set but the backend cannot honor
+
+The UI (`/show gen`) must surface this in a consistent format.
+
+## Contract: Logging (must)
+Use the standardized log buffer contract from:
+- `docs/audits/0004_tui_logging.md`
+
+Hard requirements:
+- per-session/worker ring buffer (never global)
+- UTC timestamp format: `YYYY-MM-DDTHH:MM:SS.sssZ`
+- source tagging (at least: `app`, `engine_stdout`, `engine_stderr`, `transport`)
+- redaction: never print secrets; omit or summarize data URLs
+- logging must not block generation; do not log per-token
+
+## Contract: Chat template and history control (best-effort)
+Knob:
+- Standardize a single `chat_template` config/CLI knob across backends where it is meaningful.
+
+Capability:
+- Every backend declares `template_control_level`:
+  - `local_template`: template is rendered locally (HF/GGUF/EXL2)
+  - `managed_server_template`: repo controls server launch template (vLLM managed)
+  - `server_owned_template`: template is not realistically controllable by this repo (Ollama `/api/chat`, arbitrary external OpenAI servers)
+
+Rules:
+- If `server_owned_template`, `chat_template` must be reported as ignored (or “unsupported”) and must not claim to have taken effect.
+- History sanitization rules (e.g., stripping `<think>...</think>` from the text we re-feed) apply to the **messages we send on future turns**,
+  regardless of template control level.
+  - This is a message-history policy, not a template-formatting policy.
+  - It does not retroactively change what a model “already saw” in a completed turn; it only affects future requests.
+
+## Contract: Context management (must)
+Backends must converge on the same user-facing context-fit behavior even if the implementation mechanism differs.
+
+Required user-visible effect:
+- Drop oldest prior conversation history first when context must be reduced.
+- Preserve the current user turn.
+- Preserve the system message when possible.
+- Reserve room for generation instead of filling the entire context with prompt/history.
+- Report when trimming happened.
+
+Required retention/trim order:
+- Keep the system message if present, on a best-effort basis.
+- Keep the current user turn.
+- Drop oldest prior `user` / `assistant` / `tool` turns first.
+- Only fail once no more droppable history remains and the request still cannot fit.
+
+Failure behavior:
+- If the request still cannot fit after history trimming, raise a clear “input too large even after history trimming” style error.
+- Do not misreport this as “increase max_new_tokens” unless the real issue is specifically the requested generation budget.
+
+Implementation allowance:
+- Exact token preflight is preferred.
+- Acceptable implementations may also use backend-native counters, server-supported truncation controls, or deterministic retry-on-overflow with oldest-turn dropping.
+- The exact mechanism is backend-specific; the required outcome is repo-consistent UX.
+
+Reporting:
+- Backends must emit/report when history trimming was applied.
+- Backends must report if the system message was dropped or could not be preserved.
+- If exact counts are knowable, report how many messages were dropped.
+
+## Rollout plan
+This spec is an umbrella contract. Implementation should be delivered in separate phased specs/PRs:
+1. Token accounting and real tok/s
+2. Knob mapping (sent/deferred/ignored)
+3. Logging unification (ring buffer parity + `/show logs`)
+4. Template control standardization (`chat_template` + capability gating)
diff --git a/docs/specs/0016-token-accounting-and-real-toks.md b/docs/specs/0016-token-accounting-and-real-toks.md
new file mode 100644
index 0000000..1f49125
--- /dev/null
+++ b/docs/specs/0016-token-accounting-and-real-toks.md
@@ -0,0 +1,111 @@
+#!/usr/bin/env markdown
+# Spec: Token accounting + real tok/s in the TUI (Phase 1)
+
+Date: 2026-03-08
+
+Status: Draft
+
+## Context / problem
+We need reliable token metrics in the TUI for:
+- understanding context constraints (prompt + completion)
+- diagnosing “thinking ate the budget”
+- measuring throughput (tok/s) accurately
+
+Today, token reporting is inconsistent:
+- HF has a think-token counter, but not standardized prompt/completion/total.
+- GGUF can tokenize but only uses it for think increments.
+- EXL2 emits prompt token count, but not completion/total in a standard way.
+- OpenAI/vLLM transport does not parse usage; think tokens are approximated from whitespace.
+- `/show last` displays character lengths for raw/think/answer, which is not sufficient for token-based tuning.
+
+Umbrella contract:
+- `docs/specs/0015-backend-standardization-contracts.md`
+
+ADR:
+- `docs/decisions/0015-token-accounting-and-metrics.md`
+
+## Goals
+- Provide real token counts when the backend can provide them.
+- Provide real tok/s (based on completion tokens and elapsed time).
+- Keep overhead low; avoid retokenizing unless necessary.
+- Keep behavior consistent across backends:
+  - prefer backend-native truth
+  - clearly show “unavailable” when not possible
+
+## Non-goals (Phase 1)
+- Perfect token accounting for arbitrary external OpenAI-compatible servers.
+- A single universal tokenizer strategy across all backends.
+
+## Data model changes (required)
+Extend `TurnRecord` to include token counts when available:
+- `token_counts: {prompt_tokens?: int, completion_tokens?: int, total_tokens?: int}`
+- Optionally: `throughput: {tokens_per_s?: float}`
+
+Also extend `/show last` output to include:
+- `chars_*` and `tokens_*` (tokens optional)
+
+Notes:
+- Preserve backward compatibility: if token counts aren’t present, omit them or show `unavailable`.
+
+## Backend implementation requirements
+
+### 1. vLLM managed + OpenAI-compatible transport
+Approach: parse backend-native usage from SSE frames.
+
+Requirements:
+- Add a vLLM managed launch option (config + template) to force usage in responses.
+  - vLLM supports a “force include usage” flag (version dependent), and may support stream options.
+- In `tui_app/transports/openai_http.py`, parse:
+  - `frame["usage"]` when present
+  - aggregate across frames (use final non-null usage as authoritative)
+- Store in `TurnRecord.token_counts`.
+
+If usage is unavailable:
+- do not “fake” it with character counts.
+- explicitly mark as `unavailable` in `/show`.
+
+### 2. EXL2
+Approach: use token IDs already exposed by the generator.
+
+Requirements:
+- Emit Meta keys:
+  - `prompt_tokens` (already emitted today)
+  - `completion_tokens` (count generated tokens)
+  - `total_tokens = prompt_tokens + completion_tokens`
+- Store these counts into `TurnRecord.token_counts`.
+
+### 3. GGUF (llama.cpp)
+Approach: use llama.cpp tokenization API (low overhead, already present).
+
+Requirements:
+- Prompt tokens:
+  - for `create_chat_completion`, compute tokens by tokenizing the final rendered prompt (or use llama.cpp prompt token count if exposed).
+- Completion tokens:
+  - count emitted tokens incrementally via tokenization of appended output (preferred), or use engine counters if exposed by API.
+
+### 4. HF
+Approach: we control tokenizer and inputs; prompt token length is known.
+
+Requirements:
+- Prompt tokens: `input_ids.shape[-1]` after applying context limit/templating.
+- Completion tokens: count generated tokens. In streaming mode, use streamer token IDs; in non-stream mode, use generated token IDs.
+
+## UI / slash command requirements
+- `/status`:
+  - show last turn tokens when available
+  - show tok/s when available
+- `/show last`:
+  - show `prompt_tokens`, `completion_tokens`, `total_tokens` when available
+  - keep `len_raw/len_think/len_answer` but label them as `chars_*`
+
+## Testing checklist
+- vLLM managed:
+  - usage present in server frames and is captured
+  - tok/s matches rough expectation vs vLLM logs
+- HF:
+  - prompt token count changes as context trimming drops messages
+- EXL2:
+  - completion tokens stop at `max_new_tokens`
+- GGUF:
+  - token counts non-zero and stable across runs
+
diff --git a/docs/specs/0017-tui-logging-ring-buffer.md b/docs/specs/0017-tui-logging-ring-buffer.md
new file mode 100644
index 0000000..0812d47
--- /dev/null
+++ b/docs/specs/0017-tui-logging-ring-buffer.md
@@ -0,0 +1,139 @@
+#!/usr/bin/env markdown
+# Spec: TUI logging ring buffer (backend-standard)
+
+Date: 2026-03-09
+
+Status: Draft
+
+Related audit:
+- `docs/audits/0004_tui_logging.md`
+
+Related umbrella contract:
+- `docs/specs/0015-backend-standardization-contracts.md`
+
+## Context / problem
+We want `/show logs` to work consistently across **all** TUI backends, regardless of whether file logging is enabled.
+
+Today we have backend-specific logging patterns (some use file-only logging; some log only to stdout; some can surface a small tail; some can’t).
+This makes in-TUI debugging inconsistent and forces “tee to file” even for simple investigations.
+
+## Goals
+- Every backend session maintains an **in-memory ring buffer** of recent log lines.
+- `/show logs` works for every backend (at least tail + metadata).
+- Timestamps are explicit and unambiguous:
+  - UTC
+  - ISO 8601: `YYYY-MM-DDTHH:MM:SS.sssZ`
+- Optional file sink stays supported, but is not required for `/show logs`.
+- Redaction rules are standardized (never leak API keys / auth headers / data URLs).
+- Allow richer backends (managed engines) to capture multiple sources (stdout/stderr) without forcing that complexity onto every backend.
+
+## Non-goals (v1)
+- A full structured logging system (levels, JSON logs everywhere).
+- “Live tail” that updates without a command (we can add later).
+- Guaranteed capture of stdout/stderr from third-party processes (handled by managed engines as best-effort).
+
+## Standard interface (required)
+All backend sessions MUST implement:
+- `get_recent_logs(n: int = 80, sources: list[str] | None = None) -> list[str]`
+
+Behavior:
+- Returns up to `n` most recent log lines, newest last.
+- Lines are already formatted with timestamp and source prefix (format invariants below).
+- If backend has no logger configured, it still returns ring-buffer contents.
+- If ring buffer is empty, returns `[]`.
+
+All backend sessions SHOULD implement:
+- `list_log_sources() -> list[str]`
+
+This enables `/show logs` to show what sources exist in the current session.
+
+## Data model / formatting rules
+Each stored line MUST have:
+- `ts_utc`: `YYYY-MM-DDTHH:MM:SS.sssZ`
+- `source`: short stable source tag (see Source tag contract below)
+- `message`: single-line text (newline characters replaced with `\\n`)
+
+Recommended line format:
+- `<ts_utc> [<source>] <message>`
+
+Important: although the logical record has fields (`ts_utc`, `source`, `message`), the public interface returns `list[str]`.
+These fields are therefore **formatting invariants of the rendered string**, not a structured return type.
+
+## Source tag contract (MUST)
+To avoid per-backend drift, sources MUST use a small standard vocabulary when possible.
+
+Minimum required source tags:
+- `app` (TUI / session-level orchestration)
+- `backend` (backend engine wrapper: hf/gguf/exl2/openai_http/etc.)
+- `transport` (HTTP streaming, request/retry plumbing, etc.)
+
+Managed-engine backends (e.g. vLLM managed mode) SHOULD also provide:
+- `engine_stdout`
+- `engine_stderr`
+
+Notes:
+- Backends MAY add additional sources, but SHOULD prefer the standard tags above.
+- `/show logs --filter` is a TUI feature; the logger stays simple and only supports optional source filtering at retrieval time.
+
+## Redaction requirements (MUST)
+Before a line enters the ring buffer (and before writing to file), apply the following pipeline (MUST, in order):
+1. Normalize to a single line (replace newlines with `\\n`).
+2. Redact secrets.
+3. Truncate to hard limits.
+
+Redaction rules (MUST):
+- API keys: replace any known API key fields with `***`.
+- Authorization headers: replace with `***`.
+- Image data URLs: replace with a placeholder like `<image:data_url omitted size=<n>>`.
+- URLs with embedded secrets (bearer tokens in query strings, `token=` params, etc.) MUST be redacted.
+- Extremely long payloads: truncate (see hard limits below).
+
+Hard limits (MUST):
+- Per-line max: 8 KiB (truncate with `…<truncated>` marker).
+- Ring buffer total: configurable (default 500 lines).
+
+## File sink (optional)
+If configured, a backend MAY write the same formatted lines to a file sink.
+
+Requirements:
+- File sink does not replace ring buffer; it mirrors it.
+- File path resolution MUST be explicit and handled by the shared logger helper:
+  - if path is relative, resolve relative to `args._config_path` directory when available; otherwise resolve relative to CWD.
+- If file sink fails:
+  - session continues (log to ring buffer only)
+  - emit a one-time warning line into the ring buffer (MUST be one-time; MUST not spam).
+
+## TUI command behavior
+`/show logs`:
+- Shows the tail from `get_recent_logs()`.
+- If `list_log_sources()` exists, show the available sources (once) before the tail.
+- If empty: prints `No logs captured for this session.`
+
+## Implementation sketch
+1. Add a shared helper (module) that implements a session-owned logger object:
+   - ring buffer storage (default 500 lines, configurable)
+   - formatting + UTC timestamping (`YYYY-MM-DDTHH:MM:SS.sssZ`)
+   - redaction + truncation
+   - optional mirrored file sink with config-relative path resolution
+   - `warn_once(key, message)` helper for sink failure and similar one-time warnings
+2. Replace backend-specific “log tail” ad-hoc code with the shared logger.
+3. For managed engines (e.g. vLLM):
+   - continue capturing child process output if already available
+   - route stdout/stderr into the shared session logger with `engine_stdout` / `engine_stderr` sources
+   - do not downgrade richer backends to match simpler ones
+
+## Compatibility / migration guidance
+- vLLM’s richer logging approach can remain; the only requirement is that it feeds into the shared session logger so `/show logs` is uniform.
+- Backends that currently only have file logging can migrate by:
+  - replacing direct file writes with `session_logger.log(source=..., message=...)`
+  - optionally enabling the file sink in the logger.
+
+## Testing checklist
+- Start each backend with no log file configured:
+  - `/show logs` still returns useful lines.
+- With a log file configured:
+  - `/show logs` matches file tail content (within truncation limits).
+- Confirm redaction:
+  - `/show args` never prints API keys
+  - `/show request --verbose` never prints image data URLs
+  - `/show logs` never prints secrets
diff --git a/docs/specs/0018-generation-knob-reporting.md b/docs/specs/0018-generation-knob-reporting.md
new file mode 100644
index 0000000..8a0a9d6
--- /dev/null
+++ b/docs/specs/0018-generation-knob-reporting.md
@@ -0,0 +1,154 @@
+#!/usr/bin/env markdown
+# Spec: Generation knob reporting (sent / deferred / ignored)
+
+Date: 2026-03-09
+
+Status: Draft
+
+Related umbrella contract:
+- `docs/specs/0015-backend-standardization-contracts.md`
+
+## Context / problem
+This repo is a “local LLM playground”, and the user expectation is:
+- If a knob is exposed, it must either do something or be explicitly reported as ignored/deferred.
+- The TUI should show **what we actually sent**, what we **deferred to backend/model defaults**, and what was **ignored**.
+
+Right now, this is inconsistent across backends:
+- Some backends silently ignore unsupported knobs.
+- Others warn once, but the TUI doesn’t have a consistent per-turn view.
+
+## Goals
+- Standardize a per-turn report of generation knobs:
+  - `sent`: key/value pairs actually applied to the backend call
+  - `deferred`: keys intentionally omitted so backend/model defaults apply
+  - `ignored`: keys provided by CLI/config but not supported or not applied
+- Expose this report via `/show gen` with a stable, testable output contract.
+
+## Non-goals (v1)
+- Perfect detection of whether a server truly used a parameter internally (we can’t always prove it).
+- A complete mapping for every possible vLLM/llama.cpp/private knob.
+- Reporting UI knobs or prompt-shaping knobs (e.g. `show_thinking`, `assume_think`, `chat_template`, `system`, `/image` state).
+
+## Data model (required)
+Extend `TurnRecord` with:
+- `knobs: dict[str, object] | None`
+
+Shape (recommended):
+```json
+{
+  "sent": { "temperature": 0.7, "top_p": 0.95 },
+  "deferred": ["top_k"],
+  "ignored": ["typical_p"],
+  "notes": ["GGUF: chat API failed; fell back to plain completion"]
+}
+```
+
+Rules:
+- `sent` MUST only contain values included in the actual backend request (payload / kwargs / settings) for the completed turn.
+- `deferred` MUST list knobs the user could set but did not (or were default/None) and thus were intentionally omitted.
+- `ignored` MUST list knobs present in CLI/config that were not applied.
+- `notes` is OPTIONAL and MUST be omitted when empty.
+
+## Canonical knob names (MUST)
+To support cross-backend comparison, the report MUST use canonical repo knob names (user-facing names), not backend payload keys.
+
+Examples:
+- Use `stop_strings` (repo knob), not `stop` (OpenAI payload field).
+- Use `repetition_penalty` (repo knob), not `repeat_penalty` (llama.cpp kwarg).
+- Use `max_new_tokens` (repo knob), not `max_tokens` (OpenAI payload field).
+
+Backend adapters MAY include payload aliases in `notes`, but MUST NOT replace the canonical names in `sent/deferred/ignored`.
+
+## Derivation point (MUST)
+The report MUST be derived from the **final** request/settings actually used for the completed turn, after:
+- retries
+- fallbacks (e.g. GGUF chat → plain completion)
+- normalization (e.g. clamping, “shrink max tokens”, dropping oldest turns)
+
+This ensures `/show gen` answers “what happened” rather than “what we hoped would happen”.
+
+## User-set detection (MUST)
+`ignored` vs `deferred` MUST be determined using **user-set detection**, not only raw arg values.
+
+Requirement:
+- A knob is considered **user-set** if it came from CLI/config/profile/machine overrides (i.e. not a parser default).
+- Parser defaults MUST NOT be treated as “user intent”.
+
+Implementation note:
+- This repo already tracks config origins; use that to avoid misclassifying defaults.
+
+## `/show gen` output contract (MUST)
+Default output:
+- `sent.*` block
+- `deferred` list
+- `ignored` list
+
+Verbose (`/show gen --verbose`):
+- includes `args.*` (raw configured values)
+- includes `notes` if present
+
+JSON mode (`/show gen --json`):
+- returns full `TurnRecord.knobs` object (plus `args` if `--verbose`).
+
+### Before the first completed turn (MUST)
+If there is no completed turn yet:
+- `/show gen` MUST NOT pretend it has “sent” values from a real turn.
+- It MUST either:
+  1. print `No completed turn yet.` and exit, OR
+  2. show an **intent view** derived from current args/config, clearly labeled as intent (recommended).
+
+If (2) is chosen, the output MUST include:
+- `mode: intent`
+- the same top-level shape as a real turn (`sent/deferred/ignored`), derived purely from args/config
+- and MUST NOT include backend-mutated values (since no request occurred).
+
+## Backend requirements
+Each backend MUST populate `TurnRecord.knobs` per turn.
+
+### HF
+Derive `sent` from `generate_kwargs` (post-normalization).
+Examples:
+- `top_k` in `sent` only if non-None and actually passed.
+- `stop_strings` included only when supported and enabled.
+Non-knobs / backend internals:
+- HF always passes various internal fields (e.g. `do_sample`, `pad_token_id`, `eos_token_id`) that are not exposed as repo knobs.
+- These MUST NOT be included in canonical `sent/deferred/ignored` unless/until we explicitly promote them to repo knobs.
+
+### GGUF (llama.cpp)
+Derive `sent` from `create_chat_completion` / `create_completion` kwargs.
+Do not treat “repo does not expose this knob at all” as `deferred` by default.
+Only mention non-surfaced knobs in `notes` when it provides concrete user value for troubleshooting or tuning.
+If the backend switches paths (chat → plain completion, or max token shrink), it MUST record a `notes[]` entry describing the change.
+
+### EXL2
+Derive `sent` from ExLlama settings object used for generation.
+
+### vLLM (managed OpenAI-compatible)
+Derive `sent` from the final HTTP payload after filtering.
+Additionally:
+- Track `deferred` knobs explicitly when we omit them (e.g. `top_k=None`).
+- Track `ignored` knobs for parameters we parse but don’t send (or can’t send due to protocol).
+
+## Ordering and stability (MUST)
+- `ignored` MUST be sorted by canonical knob name.
+- `deferred` MUST be sorted by canonical knob name.
+- `sent` keys MUST be emitted in stable sorted order in JSON.
+
+## “Sent even if user didn’t touch it” (MUST)
+Some transports always send certain fields (e.g. `temperature`, `top_p`) even if the user never changed them.
+
+Rule:
+- If the backend actually sent the field, it MUST appear in `sent` (because it is “what we actually sent”).
+- Whether it was user-set or default MAY be reflected in `notes`, but MUST NOT change the definition of `sent`.
+
+## One-time startup summary (optional)
+Backends MAY emit a one-time `Meta(ignored_knobs=[...])` at session start or first turn,
+but this does not replace per-turn `TurnRecord.knobs`.
+
+## Testing checklist
+- Set a knob that is unsupported on a backend (e.g. `min_p` on HF):
+  - verify `/show gen` shows it in `ignored`.
+- Omit a knob (leave None):
+  - verify `/show gen` shows it in `deferred`.
+- Set a knob and ensure it is in the actual request:
+  - verify `/show gen` includes it in `sent`.
diff --git a/docs/specs/0019-chat-template-and-history-control.md b/docs/specs/0019-chat-template-and-history-control.md
new file mode 100644
index 0000000..174ffc1
--- /dev/null
+++ b/docs/specs/0019-chat-template-and-history-control.md
@@ -0,0 +1,117 @@
+#!/usr/bin/env markdown
+# Spec: Chat template + history control (best effort, repo-wide)
+
+Date: 2026-03-09
+
+Status: Draft
+
+Related audit:
+- `docs/audits/0003-standardization.md`
+
+Related umbrella contract:
+- `docs/specs/0015-backend-standardization-contracts.md`
+
+## Context / problem
+Model behavior varies dramatically based on:
+- chat template formatting
+- whether “thinking” content is included in conversation history
+
+This repo’s direction is: **model-first, repo-controlled**, and “best-effort” consistency across engines/backends.
+
+However, not every backend gives us the same control surface:
+- HF / GGUF / EXL2: client-side prompt rendering is under repo control.
+- vLLM managed: server launch is under repo control; template control depends on vLLM flags/version.
+- Ollama `/api/chat`: template is baked into the model/build and not worth trying to override in this repo.
+
+## Goals
+- Standardize a `chat_template` knob across all backends where it’s meaningful.
+- Standardize history sanitation so we can avoid feeding raw `<think>...</think>` back into the model context (when desired).
+- Keep behavior explicit per backend (no silent “we tried”).
+
+## Non-goals
+- Forcing Ollama `/api/chat` to use repo templates.
+- Tool-call schema templating in this spec (separate work).
+
+## Standard config knobs (required)
+Repo-wide knob (always present):
+- `chat_template` (string):
+  - file path (repo-relative or config-relative), or
+  - empty to mean “use backend/model default”, or
+  - ignored when the backend cannot honor it (see capability reporting).
+
+Backends that can honor templates (MUST):
+- If `template_control_level` is `local_template` or `managed_server_template`, the backend MUST attempt to apply `chat_template` when set.
+Backends that cannot honor templates (MUST):
+- If `template_control_level` is `server_owned_template`, the backend MUST report the template override as ignored and MUST NOT claim it took effect.
+
+All backends MUST support:
+- `history_strip_think` (bool, default: false):
+  - If true: when preparing the messages that will be re-fed on the next turn, remove any `<think>...</think>` spans.
+  - If `assume_think=true`, apply the same policy to “assumed-think” spans (i.e., content routed to the think channel even without a start marker).
+  - Display in the UI is unchanged; this only affects future turns.
+
+Notes:
+- `history_strip_think` is independent of `show_thinking`.
+
+## Capability reporting (required)
+Every backend session MUST expose (via `describe()` or `/show backend`):
+- `template_control_level`:
+  - `local_template` (HF / GGUF / EXL2)
+  - `managed_server_template` (vLLM managed mode)
+  - `server_owned_template` (Ollama `/api/chat`, external OpenAI server attach)
+
+Every backend session SHOULD also expose:
+- `chat_template_requested: str` (raw config value; resolved path only when local file-based and safe to disclose, otherwise keep raw spec)
+- `chat_template_applied: bool`
+- `chat_template_reason: str` (e.g. `applied`, `ignored_server_owned`, `unsupported_flag`, `empty_default`)
+
+This is for UX and debugging (so “why isn’t template change working?” is obvious).
+
+## Backend specifics
+### HF
+- `chat_template` overrides `tokenizer.chat_template` (and processor tokenizer if present).
+- `history_strip_think` implemented by sanitizing assistant `content` in `trimmed_messages` (the messages that will be re-fed next turn).
+
+### GGUF
+- `chat_template` supports:
+  - file-based Jinja template (preferred for repo-controlled templates)
+  - llama.cpp built-in chat formats (when selected explicitly)
+- `history_strip_think` applied to the messages that will be re-fed next turn (trimmed/sanitized history).
+
+### EXL2
+- `chat_template` controls local Jinja rendering.
+- `history_strip_think` applied to the messages that will be re-fed next turn (trimmed/sanitized history).
+
+### vLLM managed
+- `chat_template` best-effort:
+  - attempt to pass template flag(s) at server launch when configured
+  - if the flags are not supported at runtime, report `chat_template_applied=false` with `chat_template_reason=unsupported_flag`
+- `history_strip_think` is always applied client-side before sending `messages` payload (when enabled).
+
+### OpenAI (external attach)
+- `chat_template` is ignored (report explicitly as ignored in `/show gen` / `/show backend`).
+- `history_strip_think` still applies client-side (we control message history).
+
+### Ollama
+- `chat_template` is ignored (template is baked into the build).
+- `history_strip_think` applies to future requests only (it cannot retroactively change a completed turn).
+
+## Think-only turns under `history_strip_think=true` (MUST)
+Some turns may end with thinking only (no final answer), especially with `assume_think=true` or when the model fails to emit an end marker.
+
+Rule:
+- If `history_strip_think=true` and the assistant content becomes empty/whitespace after stripping, the backend MUST omit that assistant message
+  from the `trimmed_messages` that will be re-fed next turn.
+  - This prevents injecting an empty assistant turn into the next request.
+  - The UI transcript still retains the full `TurnRecord` for inspection.
+
+If a backend wants additional visibility, it MAY add a `notes[]` entry in the generation knob report (spec 0018) such as:
+- `history_strip_think: dropped assistant message (think-only)`
+
+## Testing checklist
+- Switch `chat_template` file and confirm prompt formatting changes (HF/GGUF/EXL2).
+- Enable `history_strip_think` with a reasoning model:
+  - verify the UI still shows thinking
+  - verify next-turn prompt sent to backend does not include `<think>` spans.
+- vLLM managed:
+  - verify template support is reported correctly (applied vs ignored).
diff --git a/docs/specs/0020-tui-mvp-tool-execution-harness.md b/docs/specs/0020-tui-mvp-tool-execution-harness.md
new file mode 100644
index 0000000..0a3dce9
--- /dev/null
+++ b/docs/specs/0020-tui-mvp-tool-execution-harness.md
@@ -0,0 +1,281 @@
+#!/usr/bin/env markdown
+# Spec: MVP tool execution harness in the TUI (safe, debuggable)
+
+Date: 2026-03-11
+
+Status: Draft
+
+Related specs:
+- `docs/specs/0011-openclaw-tool-compat-layer.md` (schema + normalization, no execution)
+- `docs/specs/0015-backend-standardization-contracts.md` (contracts)
+- `docs/specs/0017-tui-logging-ring-buffer.md` (logging contract)
+
+## Context / problem
+We want to test “tool-capable” models (e.g. Qwen) locally in this repo before using them in OpenClaw.
+
+Today:
+- vLLM/OpenAI transport can parse streamed `tool_calls`, but we do not execute them.
+- HF/GGUF/EXL2 can be prompted to emit tool calls as text, but there is no shared loop.
+
+This spec adds a minimal tool execution harness to the TUI, focused on:
+- correctness and debuggability
+- safety by default
+- minimal initial tool surface (pure/safe tools)
+
+## Goals
+- Add an opt-in, local tool loop:
+  - model emits tool call(s)
+  - repo executes safe tools
+  - tool results are fed back to the model
+  - model produces final answer
+- Provide excellent debugging:
+  - tool call blocks in the transcript show the exact call shape + the result/error
+  - tool activity is logged to the session logger (ring buffer + optional file sink)
+- Minimize new “special prompting” requirements:
+  - prefer structured tools when the backend supports it (vLLM/OpenAI)
+
+## Non-goals (MVP)
+- Network / filesystem / shell tools (dangerous surface area).
+- OpenClaw’s full policy language and multi-provider tool routing.
+- Parallel tool execution.
+- Streaming UI for partial tool-call arguments (show complete calls only).
+
+## MVP tools (built-in)
+Start with 3 tools that are safe and deterministic:
+1. `calc(expression: str) -> str`
+2. `get_time(tz: str = "America/Denver") -> str`
+3. `echo(text: str) -> str`
+
+Notes:
+- These are enough to validate that a model can select tools and produce valid arguments.
+- Add more tools later behind explicit allowlists.
+
+### `calc` safety requirements (MUST)
+`calc` MUST NOT use Python `eval` (directly or indirectly).
+
+Define a strict allowed arithmetic grammar, for example:
+- numeric literals (ints/floats)
+- parentheses
+- operators: `+ - * / // % **`
+- unary `+/-`
+
+Implementation must:
+- parse with `ast.parse(..., mode="eval")`
+- reject any nodes outside an allowlist
+- cap input length (e.g. 200 chars)
+- cap exponent size / recursion depth to avoid DoS
+- return a string result (or a structured error string)
+
+## Config (TOML)
+Add a backend-agnostic tools section (extends the shape introduced in spec 0011).
+
+```toml
+[tools]
+enabled = false                # master switch
+mode = "dry_run"               # "off" | "dry_run" | "execute"
+schema_file = ""               # optional path to OpenAI tool schema JSON
+allow = []                     # optional allowlist (names). If empty: allow all from schema/builtins
+deny = []                      # deny wins
+max_calls_per_turn = 3
+timeout_s = 10
+max_result_chars = 8000        # truncate tool output before feeding back / displaying
+```
+
+Behavior:
+- `enabled=false` or `mode="off"` disables all tool handling (current behavior).
+- `mode="dry_run"` displays tool calls but does not execute them (see dry_run contract below).
+- `mode="execute"` executes tools and runs the follow-up model call(s).
+
+## Tool schema sources
+Tool definitions presented to the model come from:
+1. `schema_file` if provided (OpenAI tools JSON, committed in-repo when possible)
+2. built-in schema for the MVP tools (always available)
+
+Merge rule (MUST):
+- Final tool set exposed to the model is the union of (schema_file tools) ∪ (built-ins).
+- Name collisions MUST be handled explicitly:
+  - default: fail fast with a clear error listing the colliding names
+  - optional future knob: allow schema_file to override built-ins (out of scope for MVP)
+
+Policy application:
+- If `allow` is non-empty, restrict to allowlisted tool names.
+- Apply `deny` after allow (deny wins).
+
+## Backend behavior (MVP scope)
+
+### vLLM (managed) + OpenAI (attach)
+Primary path for MVP.
+
+Server requirements (vLLM-specific):
+- vLLM defaults `tool_choice="auto"` when `tools` are present. For vLLM tool calling to function, the server MUST be started with:
+  - `--enable-auto-tool-choice`
+  - `--tool-call-parser <parser>`
+- Valid parsers are vLLM-version dependent. Discover via:
+  - `vllm serve --help=Frontend` (then search for `--tool-call-parser`)
+
+Request:
+- Send `tools=[...]` in the OpenAI Chat Completions payload when tools are enabled.
+- `tool_choice` remains out of scope for MVP (defaults to auto).
+
+Response parsing:
+- Use structured `tool_calls` deltas (buffered per index) as source of truth.
+- Do NOT parse `content` for tool calls when structured tool calls are present.
+- If assistant content and tool_calls arrive together, preserve both.
+
+Tool loop:
+1. First model call produces an assistant message that MAY include both:
+   - `content` (assistant text), and/or
+   - `tool_calls` (one or more tool calls)
+2. The client MUST preserve and re-send the assistant tool-call message as part of history:
+   - append an assistant message with `role="assistant"`, `content`, and `tool_calls` (as received/assembled)
+3. For each tool call (bounded by `max_calls_per_turn` across the whole outer turn):
+   - validate name against allow/deny policy
+   - execute tool (when mode=execute)
+   - append `role="tool"` message with `tool_call_id` linkage and tool result content (or error content)
+4. Call the model again with updated messages to produce the final answer (or additional tool calls).
+5. Repeat until:
+   - the model produces no new tool calls, or
+   - `max_calls_per_turn` is reached, or
+   - an unrecoverable error occurs.
+
+### HF / GGUF / EXL2
+Out of scope for MVP execution.
+
+However, the transcript UI should still be able to display “tool call blocks” if the backend emits canonical tool calls in `TurnRecord`
+(for later parity).
+
+## Canonical message + record shape (MUST for MVP)
+To avoid lossy history replay and enable tool-aware trimming, the tool harness MUST use a richer message shape internally.
+
+Minimum required message fields (OpenAI-compatible shape):
+- `role: "system"|"user"|"assistant"|"tool"`
+- `content: str | None` (assistant content may be absent/null for tool-only assistant messages; do not invent content)
+- `tool_calls: list[...]` (assistant-only; optional)
+- `tool_call_id: str` (tool-only; required when responding to a tool call)
+
+TurnRecord MUST preserve (tool activity):
+- assembled tool call arguments string exactly as emitted/assembled (for debugging)
+- parsed JSON arguments object when parsing succeeds (optional field)
+
+Compatibility (MUST for MVP):
+- Tool calls MAY be stored in a dedicated `TurnRecord.tool_activity` structure.
+- Tool calls MUST also remain mirrored in `TurnRecord.gen["tool_calls"]` (existing behavior) for one phase, to avoid breaking `/show gen`
+  and any downstream consumers. A later spec can migrate/soft-deprecate the `gen.tool_calls` mirror.
+
+## Context trimming with tools (MUST)
+History trimming MUST treat tool exchanges as an atomic unit.
+
+Definition: a “tool exchange” is:
+- 1 assistant message containing `tool_calls` (call ids set A)
+- followed by all contiguous `role="tool"` messages whose `tool_call_id` is in A
+
+Notes:
+- This definition is unambiguous even when multiple tool rounds occur in one outer user turn, because each tool exchange is identified by
+  the assistant message’s call id set A.
+
+Rule:
+- When trimming oldest history, drop tool exchanges as a unit (assistant tool_calls message + its tool result messages).
+- Never drop the assistant tool_calls message while retaining its tool results, or vice versa.
+
+## Transcript UI requirements
+When a tool call happens, the transcript MUST show a distinct tool block that is easy to inspect:
+- tool name
+- tool_call_id (if present)
+- arguments:
+  - raw assembled arguments string (exact bytes as assembled from deltas)
+  - parsed JSON pretty-print when parsing succeeds
+- result or error (truncated to `max_result_chars`)
+
+Minimum UX:
+- show blocks after the call completes (no partial-argument streaming required)
+- preserve the exact call bytes for debugging
+
+## Logging requirements
+All tool activity MUST go through the session logger (ring buffer + optional file sink):
+- tool_call_received
+- tool_call_execute_start
+- tool_call_execute_success (include output length)
+- tool_call_execute_error
+- tool_call_result_injected
+
+Redaction:
+- never log secrets (rely on logger redaction pipeline)
+- never log image data URLs (not in MVP, but keep invariant)
+
+Source tags:
+- Prefer `app` for orchestrator events.
+- Prefer `transport` for HTTP request/response diagnostics.
+
+## Persistence / transcript saving
+If `--save-transcript` is enabled, the saved record MUST include tool activity for that turn.
+
+Recommended representation:
+- Store canonical tool calls and results on the `TurnRecord` (new fields), rather than only embedding into `raw` text.
+
+## Error handling and safety
+- If a tool call references an unknown tool name:
+  - log error
+  - surface an in-transcript tool error block
+  - inject a tool result indicating the tool is unavailable (so the model can recover)
+- Enforce:
+  - `max_calls_per_turn`
+  - `timeout_s`
+  - `max_result_chars` truncation
+- No implicit enabling of dangerous tools.
+
+`max_result_chars` truncation (MUST):
+- Apply truncation once at the tool executor boundary, before:
+  - transcript display
+  - tool-result injection back to the model
+  - log persistence
+- This keeps all three surfaces consistent and avoids “full result leaked in logs” surprises.
+
+## /show / commands (MVP)
+Add:
+- `/show tools`:
+  - show tools enabled/mode, schema source, allow/deny, and list tool names exposed to the model
+  - in `--verbose`, include the schema path(s) and the post-policy filtered tool list
+
+Alias:
+- `/tools` is an alias for `/show tools`
+
+## `dry_run` behavior (MUST)
+`dry_run` exists to test “does the model produce tool_calls and are they shaped correctly” without executing anything.
+
+Rules:
+- In `dry_run`, the client MUST still send `tools=[...]` (otherwise you are not testing tool calling).
+- If the model emits tool_calls:
+  - show tool blocks in the transcript
+  - DO NOT execute tools
+  - DO NOT inject synthetic tool results
+  - End the outer turn after the tool_calls are displayed (do not auto re-call), because re-calling without results often loops.
+  - The turn may end with no final answer; use the existing “no final answer” UX path (no special one-off messaging).
+- If the model emits no tool_calls, the turn behaves like normal chat.
+
+Denied tool calls in `dry_run`:
+- Still show the tool block with status `denied_by_policy`.
+- Do not inject synthetic tool results (since we do not continue the loop in `dry_run`).
+
+## Implementation plan (suggested)
+1. Add a small `tui_app/tools/` package:
+   - builtin tools + OpenAI schema representation
+   - registry + executor with allow/deny policy
+2. Extend the OpenAI transport to attach `tools=[...]` when enabled.
+3. Add an orchestrator loop for OpenAI/vLLM sessions:
+   - execute tool calls
+   - inject `role="tool"` messages
+   - re-call for final answer
+4. Add transcript tool blocks + `/tools`.
+5. Add saved transcript serialization for tool activity.
+
+## Testing checklist
+- With tools enabled (`mode=execute`), prompt the model to use `calc`:
+  - tool call appears in transcript
+  - result injected
+  - model produces final answer referencing tool result
+- With `mode=dry_run`:
+  - tool call appears in transcript
+  - no tool execution occurs
+- With denylist:
+  - model attempts a forbidden tool
+  - tool error block appears and model recovers
diff --git a/docs/specs/0021-safe-browser-tool-v1.md b/docs/specs/0021-safe-browser-tool-v1.md
new file mode 100644
index 0000000..ee8b44c
--- /dev/null
+++ b/docs/specs/0021-safe-browser-tool-v1.md
@@ -0,0 +1,153 @@
+#!/usr/bin/env markdown
+# Spec: Safe “browser” tool v1 (fetch-only, prompt-injection resistant)
+
+Date: 2026-03-11
+
+Status: Draft
+
+Related specs:
+- `docs/specs/0020-tui-mvp-tool-execution-harness.md` (tool loop)
+- `docs/specs/0011-openclaw-tool-compat-layer.md` (schema + normalization concepts)
+- `docs/specs/0017-tui-logging-ring-buffer.md` (logging contract)
+
+## Context / problem
+Once a model has a “browser” tool, risks jump significantly:
+- prompt injection from web content
+- SSRF / internal network probing
+- unbounded crawling / huge downloads
+- accidental side effects (forms, actions)
+
+We want a browser tool for local agent testing in this repo **without** opening the full dangerous surface area.
+
+This spec defines a safe v1 browser tool that is:
+- GET-only
+- no cookies/auth/session state
+- strict size/time budgets
+- hard blocks private/localhost ranges by default
+- returns content wrapped as **untrusted**
+
+## Goals
+- Provide a single, simple browser tool usable in the TUI tool harness.
+- Make it safe enough to test “tool calling” behavior without turning the repo into a crawler.
+- Make debugging easy (logs + transcript blocks show exactly what happened).
+
+## Non-goals (v1)
+- Clicking, form submission, POST/PUT/DELETE.
+- JS rendering / headless browser automation.
+- File downloads beyond small text/HTML.
+- Automatic multi-hop browsing (agent loop across many pages). (We can add later behind budgets.)
+
+## Tool surface (v1)
+Expose exactly one function tool:
+
+### `browser_fetch`
+Signature:
+- `url: str` (required)
+
+Optional args (v1):
+- `max_bytes: int` (optional; capped by config hard limit)
+
+Returns:
+- UTF-8 text (sanitized) wrapped in an “untrusted content” envelope.
+
+Notes:
+- The tool MUST only support `http://` and `https://`.
+- The tool MUST only perform GET.
+- Redirects MAY be followed up to a small limit (default 3) while re-applying policy for each hop.
+
+## Config (TOML)
+Extend the tool harness config with a browser subsection:
+
+```toml
+[tools.browser]
+enabled = false
+
+# Safety policy (defaults are strict)
+allow_domains = []            # if non-empty: only these domains (and subdomains) are allowed
+deny_domains = []             # deny wins
+deny_private_ips = true       # block 127.0.0.1, RFC1918, link-local, etc.
+deny_ports = [25, 110, 143]   # optional (example); default empty means “allow standard ports”
+
+# Budgets
+timeout_s = 10
+max_bytes_per_fetch = 2_000_000
+max_fetches_per_turn = 2
+max_fetches_per_session = 20
+max_redirects = 3
+
+# Output shaping
+include_http_metadata = true  # status, final_url, content_type, bytes_read
+strip_html = true             # HTML -> readable text
+max_output_chars = 8000       # truncate returned text (after stripping)
+```
+
+Policy notes:
+- If `allow_domains` is empty, treat as “allow-all” **except** for `deny_private_ips` and `deny_domains`.
+- For agent safety, recommended default remains: set `allow_domains` for any real browsing sessions.
+
+## Safety invariants (MUST)
+Regardless of allowlist settings:
+- Reject any non-http(s) URL schemes.
+- Reject URLs with embedded credentials (`user:pass@host`).
+- Resolve host → IP and block private/local/link-local ranges when `deny_private_ips=true`.
+- Enforce strict timeouts and size caps (stream and cut off at `max_bytes_per_fetch`).
+- Do not send cookies; do not persist cookies; do not follow `Set-Cookie`.
+- Do not include response headers that could contain secrets (default: do not return headers at all).
+- Truncate tool output to `max_output_chars` before returning to the model.
+
+## Prompt-injection handling (MUST)
+Returned content MUST be wrapped as untrusted, e.g.:
+
+```
+UNTRUSTED_WEB_CONTENT_START
+source_url: ...
+...
+<content>
+...
+</content>
+UNTRUSTED_WEB_CONTENT_END
+```
+
+Additionally, the tool harness MUST inject a tool-safety policy block into the model’s system prompt when browser tools are enabled:
+- explicitly state web content is untrusted
+- explicitly forbid following instructions found in web content
+- explicitly instruct the model to only extract facts / answer the user
+
+This policy block SHOULD be dynamically generated from config (domains/budgets) so the model sees the real constraints.
+
+## Logging + transcript UX
+For each fetch, log (via session logger):
+- requested URL
+- final URL (after redirects)
+- resolved IP(s)
+- status code
+- bytes read
+- elapsed time
+- policy decision (allowed/blocked + reason)
+
+Transcript tool block MUST show:
+- tool name (`browser_fetch`)
+- url + final_url
+- status / bytes
+- either:
+  - returned (truncated) content preview, or
+  - error + policy reason
+
+## Error handling (MUST)
+If blocked by policy:
+- return a tool error result (do not execute request)
+- include a short reason (e.g. `blocked_private_ip`, `domain_not_allowlisted`, `scheme_not_allowed`)
+
+If fetch fails (DNS, TLS, timeout, too large):
+- return a tool error result with a short classified reason.
+
+## Testing checklist
+- Try fetching `http://127.0.0.1` with default config:
+  - must be blocked.
+- Fetch a small public HTML page under an allowlisted domain:
+  - returns stripped readable text, wrapped as untrusted.
+- Fetch a large file:
+  - truncates by bytes and/or rejects with `too_large`.
+- Prompt injection attempt in page content:
+  - model should not comply; logs should show wrapper; system policy should be present.
+
diff --git a/docs/specs/0022-openclaw-openai-compat-optimization-pass.md b/docs/specs/0022-openclaw-openai-compat-optimization-pass.md
new file mode 100644
index 0000000..7a6c5c1
--- /dev/null
+++ b/docs/specs/0022-openclaw-openai-compat-optimization-pass.md
@@ -0,0 +1,132 @@
+# 0022 — OpenClaw / OpenAI Compatibility Optimization Pass
+
+## Summary
+Tighten our OpenAI-compatible behavior and diagnostics so OpenClaw (and other OpenAI-style clients) can reliably drive a tool-capable local model server (primarily vLLM) without edge-case protocol breakage.
+
+This is an “optimization pass” focused on correctness, robustness, and debuggability—not adding new agent features.
+
+## Background / Motivation
+We already run tool-capable sessions via vLLM’s OpenAI-compatible server and our `openai_http` transport.
+We also maintain a checklist for OpenClaw interoperability at `docs/openclaw/04-model-runner-openclaw-compat-checklist.md`.
+
+Recent tool testing exposed that “mostly compatible” isn’t enough: small protocol mismatches (tool-call shapes, SSE edge cases, error frames, finish semantics) can cause confusing failures or loops.
+
+## Goals
+- Make the OpenAI-compatible path resilient to common API variants:
+  - SSE streaming variations (multi-line frames, event fields, error frames).
+  - Tool-call completion semantics (`finish_reason="tool_calls"`, empty content, etc.).
+  - Tool-choice input variants (string + object forms) when used by upstream clients.
+- Improve visibility:
+  - Ensure request/response capture can show the exact payload that was sent and any error body/frames received.
+  - Surface “sent/deferred/ignored” knob reporting consistently.
+- Update the OpenClaw checklist to reflect the actual compatibility contract we want to hold.
+
+## Non-goals
+- Implementing full OpenAI Responses API orchestration semantics.
+- Adding new tools beyond what’s already planned (see `0021-safe-browser-tool-v1.md`).
+- Building a separate “OpenAI server adapter” for non-vLLM engines in this pass.
+
+## Scope
+This spec covers:
+- `tui_app/transports/openai_http.py` (OpenAI-compatible HTTP + SSE parsing, tool-call deltas, request capture)
+- `tui_app/backends/vllm.py` (managed vLLM launch ergonomics where it affects protocol behavior)
+- `docs/openclaw/04-model-runner-openclaw-compat-checklist.md` (checklist improvements)
+
+## Requirements
+
+### R1. SSE parsing robustness
+Our OpenAI-compatible stream parser MUST:
+- Handle SSE frames that include fields other than `data:` (ignore unknown fields).
+- Handle multi-line `data:` blocks (accumulate until blank line delimiter).
+- Treat `[DONE]` as end-of-stream.
+- Detect and surface server-side error frames:
+  - `{"error": {...}}` at top-level
+  - and/or error events that embed error text in a non-standard envelope
+- On timeout or disconnect, emit a single clear error that includes:
+  - backend name
+  - url
+  - elapsed
+  - and the last captured error/body snippet when available
+
+### R2. Tool-call response handling correctness
+When streaming tool calls, we MUST support incremental accumulation of:
+- `choices[0].delta.tool_calls[*].index`
+- `...id`
+- `...type`
+- `...function.name`
+- `...function.arguments` (string fragments)
+
+We MUST correctly handle cases where:
+- tool calls are present but `content` is `null`, empty, or whitespace
+- finish is signaled with `finish_reason="tool_calls"`
+
+### R3. Non-stream response support (compat)
+Even if our TUI continues to use `stream=true` by default, the OpenAI HTTP transport SHOULD support `stream=false` responses for:
+- test harnesses
+- upstream compatibility checks
+
+Minimum required:
+- Parse `choices[0].message.content`
+- Parse `choices[0].message.tool_calls` when present
+- Capture `usage` when present
+
+### R4. Tool-choice input compatibility
+If a client/session specifies tool choice, we MUST accept and forward (when backend supports it) the OpenAI-compatible shapes:
+- `"auto"`, `"none"`
+- object form that selects a named tool/function
+
+We MUST clearly report in `/show gen`:
+- what was sent
+- what was ignored (unsupported backend)
+
+### R5. Tool role message tolerance
+We MUST accept tool role messages that include optional fields used by some clients/servers:
+- `name` on `role="tool"` messages (ignore if unsupported; preserve if harmless)
+
+### R6. Multimodal content tolerance (documented)
+We MUST make an explicit decision and document it (either):
+- Support OpenAI-style content parts arrays for images on OpenAI-compatible backends, OR
+- Explicitly mark it as unsupported for OpenClaw integration and fail with a clear error
+
+### R7. Checklist alignment
+`docs/openclaw/04-model-runner-openclaw-compat-checklist.md` MUST be updated to include:
+- `finish_reason` expectations
+- `tool_choice` accepted forms
+- SSE error frame behavior
+- tool message field tolerance (`name`)
+- `stream=false` tool_calls location (`choices[0].message.tool_calls`) (for completeness)
+- explicit multimodal stance
+
+## Proposed implementation notes (high level)
+- Extend the SSE parser to true SSE semantics (blank-line delimited events) rather than “one JSON per `data:` line”.
+- Ensure request capture stores:
+  - request payload (sanitized)
+  - response error bodies/frames (sanitized, truncated)
+- Add config/CLI key(s) for tool choice if not already present (or explicitly defer if not needed yet).
+- Keep all compatibility behavior backend-gated:
+  - don’t assume vLLM-only semantics for external OpenAI-compatible servers
+
+## Acceptance criteria
+- A streamed tool-call turn works end-to-end with:
+  - tool call deltas arriving fragmented
+  - `finish_reason="tool_calls"`
+  - assistant `content` empty/`null`
+  - follow-up tool messages with `tool_call_id`
+  - subsequent assistant completion
+- Any server-side tool/template error is surfaced to the user with:
+  - clear context (“server error frame”, url)
+  - and is visible in logs/request capture
+- Updated checklist is consistent with the implemented behavior.
+
+## Test plan
+- Add a small “compat smoke” script (local-only) that:
+  - calls `/v1/chat/completions` with `stream=false` and `stream=true`
+  - includes a minimal tool schema and validates:
+    - tool_calls shape in stream deltas
+    - tool_calls shape in non-stream `message.tool_calls`
+    - finish_reason values
+    - usage parsing when present
+- Run the same smoke against:
+  - managed vLLM
+  - an external OpenAI-compatible server (when available)
+
diff --git a/docs/specs/0023-telemetry-mvp-schema-publisher-and-export.md b/docs/specs/0023-telemetry-mvp-schema-publisher-and-export.md
new file mode 100644
index 0000000..082a2f9
--- /dev/null
+++ b/docs/specs/0023-telemetry-mvp-schema-publisher-and-export.md
@@ -0,0 +1,562 @@
+#!/usr/bin/env markdown
+# Spec: Telemetry MVP schema, publisher, and export
+
+Date: 2026-03-15
+
+Status: Draft
+
+Related decisions:
+- `docs/decisions/0015-token-accounting-and-metrics.md`
+- `docs/decisions/0016-observability-boundary-and-external-dashboard.md`
+- `docs/decisions/0017-canonical-telemetry-schema-and-dual-export.md`
+
+Related specs:
+- `docs/specs/0015-backend-standardization-contracts.md`
+- `docs/specs/0016-token-accounting-and-real-toks.md`
+- `docs/specs/0017-tui-logging-ring-buffer.md`
+- `docs/specs/0018-generation-knob-reporting.md`
+
+## Context / problem
+This repo needs a standardized observability layer, but after decisions `0016` and `0017`, its scope is:
+- telemetry production
+- schema standardization
+- backend emission
+- optional external export
+
+This repo should not absorb the browser dashboard product.
+
+That means the implementation work here is to define and emit a stable telemetry contract that external consumers can use.
+
+## Goals
+- Define an MVP canonical telemetry schema for this repo.
+- Add a shared publisher interface usable by existing runners and backend sessions.
+- Emit enough telemetry to support:
+  - local runtime truth
+  - backend comparison
+  - external dashboard consumption
+  - optional Prometheus/Grafana integration
+- Keep the implementation lightweight and local-first.
+
+## Non-goals
+- Building the dashboard UI in this repo.
+- Designing long-retention analytics storage.
+- Capturing every streamed token forever.
+- Full parity for every backend-specific metric on day one.
+
+## Deliverables
+- shared telemetry schema module
+- shared publisher interface
+- no-op publisher default
+- session-owned telemetry emission from active runners/backends
+- optional export surface(s)
+- minimal tests for schema and emission behavior
+
+## Event envelope
+Every exported telemetry event should use a common envelope.
+
+Required fields:
+- `schema_version`
+- `event_type`
+- `event_id`
+- `ts`
+- `session_id`
+- `payload`
+
+Optional fields:
+- `experiment_id`
+- `backend_name`
+- `resolved_model_id`
+- `resolved_model_id_kind`
+- `model_display_name`
+- `model_display_name_source`
+- `model_path`
+
+Notes:
+- `schema_version` should be a short string such as `v1`
+- `event_type` is one of the event families defined below
+- `event_id` must be globally unique enough for append-only consumers
+- `payload` contains the event-specific entity body
+- the envelope exists for JSON/app exports; Prometheus metrics remain derived numeric views
+
+## Canonical entities
+### Session
+Required fields:
+- `session_id`
+- `started_at`
+- `ended_at`
+- `status`
+- `backend_name`
+- `transport_name`
+- `resolved_model_id`
+- `config_path`
+- `profile_name`
+
+Optional identity clarification fields:
+- `resolved_model_id_kind`
+- `model_display_name`
+- `model_display_name_source`
+- `model_path`
+
+Allowed status values:
+- `running`
+- `finished`
+- `error`
+
+### Load report
+Load reports may be emitted partially and incrementally as confirmed facts become available.
+Multiple `load_reported` events per session are allowed.
+Consumers should merge load reports by `session_id`, carrying forward the latest known value for each field.
+Later confirmed values are authoritative for the fields they provide.
+
+Required fields when knowable:
+- `engine_name`
+- `engine_version`
+- `model_identifier`
+- `model_parameter_count`
+- `model_weight_bytes`
+- `model_dtype`
+- `kv_cache_dtype`
+- `quantization_type`
+- `context_length`
+
+Optional fields:
+- `attention_backend`
+- `tensor_parallelism`
+- `model_identifier_kind`
+- `model_display_name`
+- `model_path`
+- `extension`
+
+Recommended `extension` content when requested intent differs from confirmed runtime truth:
+- `runtime_truth.requested`
+- `runtime_truth.confirmed`
+- `runtime_truth.mismatches`
+- `runtime_truth.unconfirmed_requested`
+
+### Turn summary
+Required fields:
+- `session_id`
+- `turn_id`
+- `started_at`
+- `ended_at`
+- `streaming_enabled`
+
+Token fields when knowable:
+- `prompt_tokens`
+- `completion_tokens`
+- `total_tokens`
+
+Timing and outcome fields when knowable:
+- `time_to_first_token_seconds`
+- `decode_latency_seconds`
+- `request_latency_seconds`
+- `stop_reason`
+
+Timing rules:
+- emit `request_latency_seconds` whenever end-to-end elapsed time is known
+- emit `time_to_first_token_seconds` when the runner can observe the first streamed token
+- emit `decode_latency_seconds` only when it can be derived honestly; do not reuse total request latency as a fake decode latency
+
+Required integration:
+- `knobs` should reuse the contract from `0018`
+
+### Runtime sample
+Required fields:
+- `session_id`
+- `ts`
+
+Sampling is session-owned and must not block generation threads.
+Publishers may drop or coalesce samples under pressure.
+
+Optional groups:
+- `gpu`
+- `memory`
+- `kv_cache`
+- `throughput`
+- `requests`
+- `batch`
+- `extension`
+
+Recommended numeric fields inside groups:
+
+`gpu`
+- `vram_total_bytes`
+- `vram_used_bytes`
+- `vram_reserved_bytes`
+- `vram_free_bytes`
+- `utilization_percent`
+- `memory_bandwidth_percent`
+- `power_usage_watts`
+- `temperature_celsius`
+- `measurement_state`
+- `unavailable_reason`
+- `diagnosis_state`
+- `diagnosis_reason`
+
+`memory`
+- `torch_cuda_memory_allocated_bytes`
+- `torch_cuda_memory_reserved_bytes`
+- `torch_cuda_max_allocated_bytes`
+- `torch_cuda_active_tensors`
+
+`kv_cache`
+- `total_bytes`
+- `used_bytes`
+- `utilization_ratio`
+- `block_size`
+- `sequence_count`
+- `measurement_state`
+- `unavailable_reason`
+
+`throughput`
+- `tokens_generated_total`
+- `tokens_generated_per_second`
+- `effective_tokens_per_second`
+- `reported_speed_type`
+- `effective_measurement_state`
+- `effective_unavailable_reason`
+- `measurement_state`
+- `measurement_basis`
+- `sample_window_seconds`
+- `trust_level`
+- `trust_reason`
+
+`requests`
+- `requests_completed_total`
+- `requests_in_flight`
+- `requests_queued`
+- `activity_state`
+
+`batch`
+- `batch_size_current`
+- `batch_size_average`
+- `batch_tokens_current`
+- `batch_tokens_average`
+
+### Log event
+Required fields:
+- `session_id`
+- `ts`
+- `source`
+- `message`
+
+This should reuse the formatting and redaction rules from `0017`.
+`message` must be the canonical message body, not a preformatted line that repeats timestamp or source metadata already carried by the event.
+MVP export is new log records only after telemetry is attached; no historical ring-buffer replay.
+
+### Error event
+Required fields:
+- `session_id`
+- `ts`
+- `scope`
+- `message`
+
+## Event families
+The publisher must support these event families:
+- `session_started`
+- `load_reported`
+- `turn_finished`
+- `runtime_sample`
+- `log_recorded`
+- `error_reported`
+- `session_finished`
+
+V1 deliberately does not require per-token stream capture in telemetry storage.
+
+## Event payload rules
+- `session_started` payload should contain the canonical Session shape with `status=running`
+- `load_reported` payload should contain the canonical Load report shape
+- `turn_finished` payload should contain the canonical Turn summary shape
+- `runtime_sample` payload should contain the canonical Runtime sample shape
+  - Runtime samples should distinguish open-but-idle sessions from active generation with an explicit activity field.
+  - Runtime throughput fields must not imply a live tok/s number when no request is in flight.
+  - If KV cache runtime usage is unavailable, emit an explicit unavailable state instead of implying a working cache metric.
+  - If live throughput is derived from local streamed token counts plus elapsed time, mark it as provisional.
+  - Do not fabricate `effective_tokens_per_second` when only raw streamed completion throughput is known.
+- `log_recorded` payload should contain the canonical Log event shape
+  - `message` should not duplicate `ts` or `source` formatting already present in the payload.
+- `error_reported` payload should contain the canonical Error event shape
+- `session_finished` payload should contain the canonical Session shape with terminal status
+- `session_finished` may use `status=error` for terminal failures
+- when a failure is terminal and details are available, emit `error_reported` before `session_finished`
+
+Each payload may include:
+- `extension`: backend-specific extra fields
+
+Rules for `extension`:
+- it must be namespaced by backend or subsystem when practical
+- consumers must treat it as optional
+- canonical fields must not be hidden only in `extension`
+- example: `{ "vllm": { "scheduler": "fcfs" } }`
+
+## Publisher interface
+Add a shared publisher interface under a repo-owned telemetry module.
+
+Required behavior:
+- safe to call from existing session code
+- non-blocking in normal use
+- default no-op implementation
+- tolerant of partial/unavailable fields
+
+Recommended shape:
+- `publish_session_started(...)`
+- `publish_load_report(...)`
+- `publish_turn_finished(...)`
+- `publish_runtime_sample(...)`
+- `publish_log_record(...)`
+- `publish_error(...)`
+- `publish_session_finished(...)`
+
+Implementation note:
+- the concrete naming can differ, but the semantic event families must remain stable
+
+## Initial data sources
+### Reuse existing contracts
+- token accounting from `0016`
+- knob truth from `0018`
+- log ring buffer from `0017`
+
+### Backend-specific collection
+Backends should populate what they can without lying.
+
+Examples:
+- HF:
+  - torch allocator metrics
+  - generation timing
+  - model/load metadata when available
+- GGUF:
+  - generation timing
+  - runtime/config metadata
+  - token counts via llama tokenization when available
+- EXL2:
+  - generation timing
+  - engine token IDs/usage when available
+- managed vLLM:
+  - server/native usage where available
+  - queue and batch metrics where available
+
+Unknown fields must remain absent rather than fabricated.
+Consumers may render them as unavailable.
+Requested or configured intent must not be exported as runtime truth in canonical fields.
+If exported at all, requested/config values must be clearly namespaced outside canonical runtime fields.
+
+## Export surfaces
+V1 should support two export surfaces.
+
+### 1. JSON event/export surface
+Purpose:
+- richer downstream dashboard consumption
+- sessions, turns, logs, and inspect semantics
+
+MVP path:
+- in-process publisher
+- optional file-backed JSONL sink
+
+This is the only app export path required in v1.
+Direct HTTP/SSE app export from `model-runner` is explicitly deferred.
+The payload shape must remain stable regardless of sink choice.
+For JSONL sinks, each line must contain exactly one complete event envelope encoded as a single-line JSON object.
+JSONL output is append-only and must not rely on multiline framing.
+
+Minimum consumer expectations:
+- events are append-only
+- events can be processed in timestamp order
+- unknown event types are safely ignorable
+- unknown payload fields are safely ignorable
+
+### 2. Prometheus-compatible metrics export
+Purpose:
+- scrape-friendly numeric metrics
+- Grafana compatibility
+- quick validation and charting
+
+Requirements:
+- supported and disabled by default
+- must not bind listeners or expose scrape surfaces unless explicitly enabled
+- derived from canonical telemetry, not a separate source of truth
+- limited to numeric time-series-friendly values
+
+High-cardinality identifiers such as `event_id` and `session_id` are not part of the default Prometheus label surface.
+
+Do not attempt to force logs, knobs, or inspect payloads into Prometheus labels.
+
+## Metric naming guidance
+Use stable, explicit names.
+
+Recommended prefixes:
+- `model_runner_session_*`
+- `model_runner_turn_*`
+- `model_runner_gpu_*`
+- `model_runner_kv_cache_*`
+- `model_runner_requests_*`
+- `model_runner_tokens_*`
+
+Labels should be bounded and practical.
+
+Allowed examples:
+- `backend`
+- `engine`
+- `model`
+- `session_id` only if cardinality remains acceptable for local usage
+
+Avoid:
+- unbounded prompt text
+- raw payload fragments
+- per-message text content
+
+## Sampling policy
+Runtime sampling should be bounded.
+
+V1 guidance:
+- sample every 1s by default while a session is active
+- allow configuration
+- avoid heavy collectors on hot generation paths
+
+Turn summaries should be emitted once on completion.
+
+## Versioning
+The telemetry schema must carry a version.
+
+Requirements:
+- JSON payloads include `schema_version`
+- additive evolution preferred
+- breaking changes require a new documented version
+
+## Example JSON events
+### `session_started`
+```json
+{
+  "schema_version": "v1",
+  "event_type": "session_started",
+  "event_id": "evt_01",
+  "ts": "2026-03-15T18:30:00.000Z",
+  "session_id": "sess_01",
+  "experiment_id": "exp_01",
+  "backend_name": "hf",
+  "resolved_model_id": "Qwen3.5-9B",
+  "payload": {
+    "session_id": "sess_01",
+    "started_at": "2026-03-15T18:30:00.000Z",
+    "ended_at": null,
+    "status": "running",
+    "activity_state": "idle",
+    "backend_name": "hf",
+    "transport_name": "inproc",
+    "resolved_model_id": "Qwen3.5-9B",
+    "config_path": "models/Qwen3.5-9B/hf/config/default.toml",
+    "profile_name": "default"
+  }
+}
+```
+
+### `turn_finished`
+```json
+{
+  "schema_version": "v1",
+  "event_type": "turn_finished",
+  "event_id": "evt_02",
+  "ts": "2026-03-15T18:31:10.000Z",
+  "session_id": "sess_01",
+  "payload": {
+    "session_id": "sess_01",
+    "turn_id": 4,
+    "started_at": "2026-03-15T18:31:00.000Z",
+    "ended_at": "2026-03-15T18:31:10.000Z",
+    "streaming_enabled": true,
+    "prompt_tokens": 812,
+    "completion_tokens": 146,
+    "total_tokens": 958,
+    "time_to_first_token_seconds": 0.72,
+    "decode_latency_seconds": 9.10,
+    "request_latency_seconds": 10.00,
+    "stop_reason": "stop",
+    "knobs": {
+      "sent": {
+        "temperature": 0.7,
+        "top_p": 0.95
+      },
+      "deferred": [
+        "top_k"
+      ],
+      "ignored": []
+    }
+  }
+}
+```
+
+### `runtime_sample`
+```json
+{
+  "schema_version": "v1",
+  "event_type": "runtime_sample",
+  "event_id": "evt_03",
+  "ts": "2026-03-15T18:31:05.000Z",
+  "session_id": "sess_01",
+  "payload": {
+    "session_id": "sess_01",
+    "ts": "2026-03-15T18:31:05.000Z",
+    "activity_state": "generating",
+    "gpu": {
+      "vram_total_bytes": 25769803776,
+      "vram_used_bytes": 17179869184,
+      "utilization_percent": 91.0
+    },
+    "throughput": {
+      "tokens_generated_total": 88,
+      "tokens_generated_per_second": 14.2,
+      "measurement_state": "active_generation",
+      "trust_level": "provisional"
+    },
+    "kv_cache": {
+      "total_bytes": 8589934592,
+      "used_bytes": 2147483648,
+      "utilization_ratio": 0.25,
+      "measurement_state": "available"
+    },
+    "requests": {
+      "requests_completed_total": 3,
+      "requests_in_flight": 1,
+      "activity_state": "in_flight"
+    }
+  }
+}
+```
+
+## Rollout plan
+### Phase 1
+- add telemetry schema module
+- add publisher interface and no-op publisher
+- emit session start/finish
+- emit load reports
+- emit completed-turn summaries
+
+### Phase 2
+- emit log events from the shared log buffer path
+- add runtime sampling for supported backends
+- include GPU/allocator/KV/throughput metrics where available
+
+### Phase 3
+- add optional JSON export surface
+- add optional Prometheus-compatible metrics export
+
+Implementation target for Phase 3:
+- JSON export means optional JSONL sink
+- Prometheus export remains disabled by default
+- HTTP/SSE export is deferred
+
+### Phase 4
+- add tests for backend adapter mapping and export stability
+
+## Testing checklist
+- A runner can execute with no telemetry configured and behave normally.
+- A runner with telemetry enabled emits `session_started` and `session_finished`.
+- A completed turn emits canonical token/timing/knob truth when available.
+- Unsupported metrics remain absent rather than fabricated.
+- Prometheus export only includes numeric fields.
+- Log export follows redaction rules from `0017`.
+
+## Acceptance criteria
+- This repo has a stable telemetry publisher usable by existing runners/backends.
+- At least HF, GGUF, EXL2, and managed vLLM can emit baseline session and turn telemetry.
+- Canonical telemetry can be consumed externally without importing runner internals.
+- Prometheus export is optional, disabled by default, and derived from the canonical telemetry model.
diff --git a/docs/specs/README.md b/docs/specs/README.md
index 2cf2051..08f31c8 100644
--- a/docs/specs/README.md
+++ b/docs/specs/README.md
@@ -9,3 +9,19 @@ Implementation specs for features we plan to add (kept lightweight and pragmatic
 - `docs/specs/0005-gguf-chat-templates.md`: GGUF client-side chat templates (no rebuild) via llama.cpp handlers.
 - `docs/specs/0006-gguf-engine-knobs.md`: Expose GGUF engine knobs (batch/threads/RoPE/YARN).
 - `docs/specs/0007-exl2-backend.md`: Add ExLlamaV2 (EXL2) as a TUI backend (client-side templates).
+- `docs/specs/0008-reviews-branch-mirror.md`: Mirror PR review bot output into a dedicated `reviews` branch for local/offline consumption.
+- `docs/specs/0009-toml-config-profiles-and-machine-overrides.md`: TOML config format with profiles + machine-local overrides (prep for vLLM/OpenAI backend).
+- `docs/specs/0010-openai-compatible-backend-vllm.md`: Add an OpenAI-compatible HTTP backend (vLLM first) and document the “backend build” workflow.
+- `docs/specs/0011-openclaw-tool-compat-layer.md`: OpenAI tool schema loading + policy + tool-call normalization (OpenClaw-oriented).
+- `docs/specs/0012-openai-targets-and-server-config-separation.md`: Deferred reference spec for OpenAI “targets” and clearer client/server config separation.
+- `docs/specs/0013-vllm-engine-first-managed-server.md`: Make vLLM a first-class engine backend (managed start/stop).
+- `docs/specs/0014-tui-status-and-show-inspect.md`: `/status` + a cleaner `/show` inspector UX for the TUI.
+- `docs/specs/0015-backend-standardization-contracts.md`: Umbrella contract for backend consistency (thinking, metrics, logging, knobs, templates).
+- `docs/specs/0016-token-accounting-and-real-toks.md`: Phase 1 spec to add real token counts and tok/s across backends.
+- `docs/specs/0017-tui-logging-ring-buffer.md`: Standardize session-owned in-memory log tail across all backends.
+- `docs/specs/0018-generation-knob-reporting.md`: Standardize per-turn reporting of sent/deferred/ignored generation knobs.
+- `docs/specs/0019-chat-template-and-history-control.md`: Best-effort repo-wide chat template control + think-stripping for history.
+- `docs/specs/0020-tui-mvp-tool-execution-harness.md`: Minimal, safe tool execution loop in the TUI (vLLM/OpenAI first).
+- `docs/specs/0021-safe-browser-tool-v1.md`: Fetch-only browser tool with SSRF + injection guardrails.
+- `docs/specs/0022-openclaw-openai-compat-optimization-pass.md`: OpenClaw / OpenAI Compatibility Optimization Pass.
+- `docs/specs/0023-telemetry-mvp-schema-publisher-and-export.md`: Repo-scoped telemetry MVP covering canonical schema, publisher interface, baseline events, and optional JSON/Prometheus export.
diff --git a/docs/specs/offline-vllm-compressor-fp8.md b/docs/specs/offline-vllm-compressor-fp8.md
new file mode 100644
index 0000000..a8398bc
--- /dev/null
+++ b/docs/specs/offline-vllm-compressor-fp8.md
@@ -0,0 +1,46 @@
+# Offline vLLM Compressor FP8
+
+## Summary
+- add a standalone offline compression script
+- keep model-specific compressor config under `models/<model>/vllm/compressor/`
+- write quantized artifacts outside the repo under `~/ml/models/quants`
+- target vLLM-compatible FP8 artifacts first
+
+## Contract
+- compression is not a runtime backend and not a TUI feature
+- this repo owns config, script, and notes for quantization
+- `agentmux` or other runtimes consume the saved artifact path later
+- each run writes to a versioned path and updates a stable `current` symlink
+
+## Script
+- entrypoint: `scripts/compress_model.py`
+- input: model-local TOML with CLI overrides
+- output: compressed artifact directory plus `compression-manifest.json`
+
+## Output Layout
+```text
+~/ml/models/quants/<model>/fp8/runs/<timestamp>-<label>/<compressed-name>/
+~/ml/models/quants/<model>/fp8/current -> runs/.../<compressed-name>
+```
+
+## Config Layout
+```text
+models/<model>/vllm/compressor/default.toml
+```
+
+Sections:
+- `[model]`
+- `[output]`
+- `[calibration]`
+- `[recipe]`
+
+## Calibration
+- local datasets and HF datasets are both valid inputs
+- local inputs are expected to be formats supported by Hugging Face datasets loading
+- FP8 defaults to `FP8_BLOCK` in the starter TOMLs
+- recipe scheme, sample count, and sequence length are all configurable without changing the script
+
+## Non-goals
+- no AWQ or GPTQ in v1
+- no launch-path integration
+- no in-repo model artifact storage
diff --git a/expand b/expand
new file mode 100755
index 0000000..f436a57
--- /dev/null
+++ b/expand
@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import runpy
+import sys
+from pathlib import Path
+
+
+if __name__ == "__main__":
+    script = Path(__file__).resolve().parent / "scripts" / "expand_transcript.py"
+    sys.argv[0] = str(script)
+    runpy.run_path(str(script), run_name="__main__")
diff --git a/models/Angelic_Eclipse_12B_FP8/vllm/config/default.toml b/models/Angelic_Eclipse_12B_FP8/vllm/config/default.toml
new file mode 100644
index 0000000..9bb8e0a
--- /dev/null
+++ b/models/Angelic_Eclipse_12B_FP8/vllm/config/default.toml
@@ -0,0 +1,81 @@
+[model]
+id = "Angelic_Eclipse_12B_FP8"
+
+[gen]
+stream = true
+max_new_tokens = 8192
+temperature = 0.77
+top_p = 0.83
+top_k = 320
+min_p = 0.0
+repetition_penalty = 1.03
+presence_penalty = 0.0
+frequency_penalty = 0.0
+stop_strings = []
+stop_token_ids = []
+ignore_eos = false
+min_tokens = 0
+best_of = 1
+use_beam_search = false
+length_penalty = 1.0
+include_stop_str_in_output = false
+skip_special_tokens = true
+spaces_between_special_tokens = true
+truncate_prompt_tokens = 0
+allowed_token_ids = []
+prompt_logprobs = 0
+
+[prompt]
+chat_template = ""
+system = ""
+system_file = "models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/prompts/system.txt"
+user_prefix = ""
+
+[ui]
+show_thinking = true
+assume_think = false
+history_strip_think = true
+no_animate_thinking = false
+save_transcript = ""
+capture_last_request = true
+scroll_lines = 9
+show_tool_activity = false
+show_tool_arguments = false
+ui_tick_ms = 33
+ui_max_events_per_tick = 120
+
+[telemetry]
+jsonl = ""
+sample_interval_s = 1.0
+
+[tools]
+enabled = false
+mode = "execute"
+schema_file = ""
+tool_choice = ""
+allow = []
+deny = []
+max_calls_per_turn = 3
+timeout_s = 10
+max_result_chars = 8000
+
+[backend.vllm]
+mode = "managed"
+host = "127.0.0.1"
+port = 40223
+cmd = "vllm"
+extra_args = ["--max-num-seqs", "1"]
+base_url = ""
+api_key = ""
+timeout_s = 900
+generation_config = "vllm"
+attention_backend = ""
+dtype = "bfloat16"
+kv_cache_dtype = "fp8_e4m3"
+enable_auto_tool_choice = true
+tool_call_parser = "qwen3_xml"
+log_file = ""
+served_model_name = "Angelic_Eclipse_12B_FP8"
+tensor_parallel_size = 1
+gpu_memory_utilization = 0.933
+max_model_len = 42240
diff --git a/models/Angelic_Eclipse_12B_FP8/vllm/config/profiles/fast.toml b/models/Angelic_Eclipse_12B_FP8/vllm/config/profiles/fast.toml
new file mode 100644
index 0000000..a299998
--- /dev/null
+++ b/models/Angelic_Eclipse_12B_FP8/vllm/config/profiles/fast.toml
@@ -0,0 +1,2 @@
+[gen]
+max_new_tokens = 1024
diff --git a/models/Angelic_Eclipse_12B_FP8/vllm/config/profiles/longctx.toml b/models/Angelic_Eclipse_12B_FP8/vllm/config/profiles/longctx.toml
new file mode 100644
index 0000000..ee4e986
--- /dev/null
+++ b/models/Angelic_Eclipse_12B_FP8/vllm/config/profiles/longctx.toml
@@ -0,0 +1,2 @@
+[gen]
+max_new_tokens = 2048
diff --git a/models/Angelic_Eclipse_12B_FP8/vllm/notes/README.md b/models/Angelic_Eclipse_12B_FP8/vllm/notes/README.md
new file mode 100644
index 0000000..bd93acf
--- /dev/null
+++ b/models/Angelic_Eclipse_12B_FP8/vllm/notes/README.md
@@ -0,0 +1,3 @@
+# vLLM backend notes
+
+Use this folder for backend-specific notes (launch caveats, tuning, known good profiles).
diff --git a/models/Angelic_Eclipse_12B_FP8/vllm/prompts/README.md b/models/Angelic_Eclipse_12B_FP8/vllm/prompts/README.md
new file mode 100644
index 0000000..1d9ec5a
--- /dev/null
+++ b/models/Angelic_Eclipse_12B_FP8/vllm/prompts/README.md
@@ -0,0 +1,4 @@
+# Angelic_Eclipse_12B_FP8 prompts (vllm)
+
+This folder is for prompt assets (system prompts, few-shots, tool schemas).
+It may be git-ignored except for this README.
diff --git a/models/Angelic_Eclipse_12B_FP8/vllm/templates/README.md b/models/Angelic_Eclipse_12B_FP8/vllm/templates/README.md
new file mode 100644
index 0000000..aaec679
--- /dev/null
+++ b/models/Angelic_Eclipse_12B_FP8/vllm/templates/README.md
@@ -0,0 +1,3 @@
+# Angelic_Eclipse_12B_FP8 templates (vllm)
+
+This folder is for prompt/template overrides or experiments.
diff --git a/models/Nanbeige4.1-3B/hf/config/default.toml b/models/Nanbeige4.1-3B/hf/config/default.toml
new file mode 100644
index 0000000..a2791b5
--- /dev/null
+++ b/models/Nanbeige4.1-3B/hf/config/default.toml
@@ -0,0 +1,55 @@
+[model]
+id = "Nanbeige4.1-3B"
+
+[gen]
+max_context_tokens = 120832
+max_new_tokens = 32768
+no_repeat_ngram_size = 0
+num_beams = 1
+repetition_penalty = 1.05
+stream = true
+temperature = 0.4
+top_k = 40
+top_p = 0.9
+
+[prompt]
+chat_template = "models/Nanbeige4.1-3B/hf/templates/agent_en_minimal.jinja"
+prompt_mode = "chat"
+prompt_prefix = ""
+system_file = "models/Nanbeige4.1-3B/hf/prompts/agent_en_fast.txt"
+user_prefix = ""
+
+[ui]
+assume_think = false
+history_strip_think = false
+hide_think = true
+no_animate_thinking = false
+save_transcript = ""
+capture_last_request = false
+scroll_lines = 9
+show_thinking = false
+show_tool_activity = false
+show_tool_arguments = false
+strict_think_strip = true
+ui_max_events_per_tick = 33
+ui_tick_ms = 33
+
+[telemetry]
+jsonl = ""
+sample_interval_s = 1.0
+
+[tools]
+enabled = false
+mode = "dry_run"
+schema_file = ""
+allow = []
+deny = []
+max_calls_per_turn = 3
+timeout_s = 10
+max_result_chars = 8000
+
+[backend.hf]
+dtype = "bfloat16"
+use_4bit = false
+use_8bit = false
+log_file = ""
diff --git a/models/OmniCoder-9B/openai/config/default.toml b/models/OmniCoder-9B/openai/config/default.toml
new file mode 100644
index 0000000..210eebc
--- /dev/null
+++ b/models/OmniCoder-9B/openai/config/default.toml
@@ -0,0 +1,39 @@
+[model]
+id = "OmniCoder-9B"
+
+[gen]
+stream = true
+max_new_tokens = 8192
+temperature = 0.6
+top_p = 0.9
+top_k = 64
+min_p = 0.0
+repetition_penalty = 1.03
+
+[prompt]
+
+
+[ui]
+show_thinking = false
+assume_think = true
+history_strip_think = true
+no_animate_thinking = false
+save_transcript = ""
+capture_last_request = false
+show_tool_activity = false
+show_tool_arguments = false
+scroll_lines = 9
+ui_tick_ms = 33
+ui_max_events_per_tick = 120
+
+[telemetry]
+jsonl = ""
+sample_interval_s = 1.0
+
+[tools]
+
+[backend.openai]
+base_url = "http://127.0.0.1:8002/v1"
+api_key = ""
+timeout_s = 600
+log_file = ""
diff --git a/models/OmniCoder-9B/openai/config/profiles/fast.toml b/models/OmniCoder-9B/openai/config/profiles/fast.toml
new file mode 100644
index 0000000..a299998
--- /dev/null
+++ b/models/OmniCoder-9B/openai/config/profiles/fast.toml
@@ -0,0 +1,2 @@
+[gen]
+max_new_tokens = 1024
diff --git a/models/OmniCoder-9B/openai/config/profiles/longctx.toml b/models/OmniCoder-9B/openai/config/profiles/longctx.toml
new file mode 100644
index 0000000..ee4e986
--- /dev/null
+++ b/models/OmniCoder-9B/openai/config/profiles/longctx.toml
@@ -0,0 +1,2 @@
+[gen]
+max_new_tokens = 2048
diff --git a/models/OmniCoder-9B/openai/notes/README.md b/models/OmniCoder-9B/openai/notes/README.md
new file mode 100644
index 0000000..2fbd662
--- /dev/null
+++ b/models/OmniCoder-9B/openai/notes/README.md
@@ -0,0 +1,3 @@
+# openai backend notes template
+
+Use this folder for OpenAI-compatible server notes (vLLM/OpenAI-compatible endpoints), model IDs, and local setup details.
diff --git a/models/OmniCoder-9B/openai/prompts/README.md b/models/OmniCoder-9B/openai/prompts/README.md
new file mode 100644
index 0000000..ca9641b
--- /dev/null
+++ b/models/OmniCoder-9B/openai/prompts/README.md
@@ -0,0 +1,4 @@
+# OmniCoder3.5-9B prompts (openai)
+
+This folder is for prompt assets (system prompts, few-shots, tool schemas).
+It may be git-ignored except for this README.
diff --git a/models/OmniCoder-9B/openai/templates/README.md b/models/OmniCoder-9B/openai/templates/README.md
new file mode 100644
index 0000000..bba50e4
--- /dev/null
+++ b/models/OmniCoder-9B/openai/templates/README.md
@@ -0,0 +1,3 @@
+# OmniCoder3.5-9B templates (openai)
+
+This folder is for prompt/template overrides or experiments.
diff --git a/models/OmniCoder-9B/vllm/compressor/calibration/README.md b/models/OmniCoder-9B/vllm/compressor/calibration/README.md
new file mode 100644
index 0000000..8079a59
--- /dev/null
+++ b/models/OmniCoder-9B/vllm/compressor/calibration/README.md
@@ -0,0 +1,4 @@
+Replace this placeholder with a real local calibration dataset file or override `dataset_path` on the CLI.
+
+Supported local inputs should be formats that Hugging Face datasets can read directly, such as JSON/JSONL, CSV, or Parquet.
+
diff --git a/models/OmniCoder-9B/vllm/config/default.toml b/models/OmniCoder-9B/vllm/config/default.toml
new file mode 100644
index 0000000..a31669b
--- /dev/null
+++ b/models/OmniCoder-9B/vllm/config/default.toml
@@ -0,0 +1,79 @@
+[model]
+id = "omnicoder-9b"
+
+[gen]
+stream = true
+max_new_tokens = 8192
+temperature = 0.6
+top_p = 1.0
+top_k = -1
+min_p = 0.05
+repetition_penalty = 0.0
+presence_penalty = 0.5
+frequency_penalty = 0.0
+stop_strings = []
+stop_token_ids = []
+ignore_eos = false
+min_tokens = 0
+best_of = 1
+use_beam_search = false
+length_penalty = 1.0
+include_stop_str_in_output = false
+skip_special_tokens = true
+spaces_between_special_tokens = true
+truncate_prompt_tokens = 0
+allowed_token_ids = []
+prompt_logprobs = 0
+
+[prompt]
+chat_template = "models/Qwen3.5-9B/hf/templates/chat_template.jinja"
+system = ""
+system_file = ""
+user_prefix = ""
+
+[ui]
+show_thinking = false
+assume_think = true
+history_strip_think = true
+no_animate_thinking = false
+save_transcript = ""
+capture_last_request = true
+scroll_lines = 9
+show_tool_activity = false
+show_tool_arguments = false
+ui_tick_ms = 33
+ui_max_events_per_tick = 120
+
+[telemetry]
+jsonl = ""
+sample_interval_s = 1.0
+
+[tools]
+enabled = true
+mode = "execute"
+schema_file = ""
+allow = []
+deny = []
+max_calls_per_turn = 3
+timeout_s = 10
+max_result_chars = 8000
+
+[backend.vllm]
+mode = "managed"
+host = "127.0.0.1"
+port = 40223
+cmd = "vllm"
+extra_args = ["--max-num-seqs", "1", "--enable-log-requests", "--stream-interval", "1", "--kv-cache-dtype", "fp8"]
+base_url = ""
+api_key = ""
+timeout_s = 900
+generation_config = "vllm"
+attention_backend = "FLASH_ATTN"
+dtype = "bfloat16"
+enable_auto_tool_choice = true
+tool_call_parser = "qwen3_xml"
+log_file = ""
+served_model_name = "Omnicoder-9B"
+tensor_parallel_size = 1
+gpu_memory_utilization = 0.933
+max_model_len = 16384
diff --git a/models/OmniCoder-9B/vllm/config/profiles/fast.toml b/models/OmniCoder-9B/vllm/config/profiles/fast.toml
new file mode 100644
index 0000000..a299998
--- /dev/null
+++ b/models/OmniCoder-9B/vllm/config/profiles/fast.toml
@@ -0,0 +1,2 @@
+[gen]
+max_new_tokens = 1024
diff --git a/models/OmniCoder-9B/vllm/config/profiles/longctx.toml b/models/OmniCoder-9B/vllm/config/profiles/longctx.toml
new file mode 100644
index 0000000..ee4e986
--- /dev/null
+++ b/models/OmniCoder-9B/vllm/config/profiles/longctx.toml
@@ -0,0 +1,2 @@
+[gen]
+max_new_tokens = 2048
diff --git a/models/OmniCoder-9B/vllm/notes/README.md b/models/OmniCoder-9B/vllm/notes/README.md
new file mode 100644
index 0000000..bd93acf
--- /dev/null
+++ b/models/OmniCoder-9B/vllm/notes/README.md
@@ -0,0 +1,3 @@
+# vLLM backend notes
+
+Use this folder for backend-specific notes (launch caveats, tuning, known good profiles).
diff --git a/models/OmniCoder-9B/vllm/prompts/README.md b/models/OmniCoder-9B/vllm/prompts/README.md
new file mode 100644
index 0000000..52f3b4d
--- /dev/null
+++ b/models/OmniCoder-9B/vllm/prompts/README.md
@@ -0,0 +1,4 @@
+# OmniCoder-9B prompts (vllm)
+
+This folder is for prompt assets (system prompts, few-shots, tool schemas).
+It may be git-ignored except for this README.
diff --git a/models/OmniCoder-9B/vllm/templates/README.md b/models/OmniCoder-9B/vllm/templates/README.md
new file mode 100644
index 0000000..86c87a3
--- /dev/null
+++ b/models/OmniCoder-9B/vllm/templates/README.md
@@ -0,0 +1,3 @@
+# OmniCoder-9B templates (vllm)
+
+This folder is for prompt/template overrides or experiments.
diff --git a/models/Qwen3.5-9B/hf/config/config.json b/models/Qwen3.5-9B/hf/config/config.json
new file mode 100644
index 0000000..29b184f
--- /dev/null
+++ b/models/Qwen3.5-9B/hf/config/config.json
@@ -0,0 +1,35 @@
+{
+  "model_id": "Qwen3.5-9B",
+  "dtype": "bfloat16",
+  "hf_attn_implementation": "flash_attention_2",
+  "use_8bit": false,
+  "use_4bit": false,
+  "stream": true,
+  "max_new_tokens": 8192,
+  "temperature": 0.7,
+  "top_p": 0.95,
+  "top_k": 20,
+  "typical_p": null,
+  "min_p": null,
+  "repetition_penalty": 1.0,
+  "num_beams": 1,
+  "no_repeat_ngram_size": 0,
+  "max_time": null,
+  "stop_strings": null,
+  "hide_think": false,
+  "strict_think_strip": false,
+  "prompt_mode": "chat",
+  "chat_template": "models/Qwen3.5-9B/hf/templates/chat_template.jinja",
+  "system": "",
+  "system_file": "",
+  "user_prefix": "",
+  "prompt_prefix": "",
+  "max_context_tokens": 131072,
+  "show_thinking": true,
+  "no_animate_thinking": false,
+  "save_transcript": "",
+  "assume_think": true,
+  "scroll_lines": 9,
+  "ui_tick_ms": 33,
+  "ui_max_events_per_tick": 64
+}
diff --git a/models/Qwen3.5-9B/hf/config/default.toml b/models/Qwen3.5-9B/hf/config/default.toml
new file mode 100644
index 0000000..20fb379
--- /dev/null
+++ b/models/Qwen3.5-9B/hf/config/default.toml
@@ -0,0 +1,61 @@
+[model]
+id = "Qwen3.5-9B"
+
+[gen]
+max_context_tokens = 49152
+max_new_tokens = 8192
+no_repeat_ngram_size = 0
+num_beams = 1
+repetition_penalty = 1.0
+stream = true
+temperature = 0.7
+top_k = 20
+top_p = 0.95
+
+[prompt]
+chat_template = "models/Qwen3.5-9B/hf/templates/chat_template.jinja"
+prompt_mode = "chat"
+prompt_prefix = ""
+system = ""
+system_file = ""
+user_prefix = ""
+
+[ui]
+assume_think = true
+history_strip_think = true
+hide_think = true
+no_animate_thinking = false
+save_transcript = ""
+capture_last_request = false
+scroll_lines = 9
+show_thinking = false
+show_tool_activity = false
+show_tool_arguments = false
+strict_think_strip = false
+ui_max_events_per_tick = 64
+ui_tick_ms = 33
+
+[telemetry]
+jsonl = ""
+sample_interval_s = 1.0
+
+[tools]
+enabled = false
+mode = "dry_run"
+schema_file = ""
+allow = []
+deny = []
+max_calls_per_turn = 3
+timeout_s = 10
+max_result_chars = 8000
+
+[backend.hf]
+attn_implementation = "TORCH_SDPA"
+dtype = "bfloat16"
+device_map = ""
+max_memory = ""
+low_cpu_mem_usage = true
+text_only = false
+use_4bit = false
+use_8bit = false
+log_file = ""
diff --git a/models/Qwen3.5-9B/hf/notes/README.md b/models/Qwen3.5-9B/hf/notes/README.md
new file mode 100644
index 0000000..c2d88ec
--- /dev/null
+++ b/models/Qwen3.5-9B/hf/notes/README.md
@@ -0,0 +1,150 @@
+# Qwen3.5-9B (HF, vision-capable)
+
+## Where
+- HF ID: `Qwen/Qwen3.5-9B`
+- Local path: `/home/poop/ml/models/Qwen3.5-9B`
+- HF cache revision (if known): (local folder)
+
+## TL;DR
+- What it’s good at: general chat + vision “image + text → text” prompts; supports tool-call formatting via its chat template.
+- Biggest gotcha(s): it’s a multimodal checkpoint (`ForConditionalGeneration`), so you need a processor + multimodal auto-model (not `AutoModelForCausalLM`) if you want images.
+- Recommended runner (`chat.py` vs `runner.py`): `tui.py` (HF backend) for `/image` + streaming thinking.
+
+## What it is (from local `config.json`)
+- Backend: HF / Transformers
+- `model_type` / architecture: `qwen3_5` / `Qwen3_5ForConditionalGeneration`
+- Vision token markers present: `vision_start_token_id=248053`, `vision_end_token_id=248054`
+- Context/window: `text_config.max_position_embeddings=262144` (very large; practical limits depend on VRAM/kv-cache)
+
+## Tokenizer / prompting (from local tokenizer files)
+- `bos_token` / `eos_token` / `pad_token`:
+  - `eos_token`: `<|im_end|>` (id `248046`)
+  - `pad_token`: `<|endoftext|>` (id `248044`)
+  - `bos_token`: none
+- Chat template format (high level):
+  - Roles are wrapped in Qwen-style `"<|im_start|>{role}\\n...<|im_end|>"`.
+  - Images are injected as placeholder tokens in user content: `<|vision_start|><|image_pad|><|vision_end|>`.
+  - Tools are documented in a system header, and tool calls are expected as an XML-ish block.
+- Special tags present:
+  - Thinking: `<think>` (single token id `248068`), `</think>` (single token id `248069`)
+  - Tools: `<tool_call>...</tool_call>`, `<tool_response>...</tool_response>`
+
+### System prompt behavior
+- Does it inject a default system prompt if you don’t provide one?
+- Language/identity defaults: none enforced by the tokenizer; behavior depends on checkpoint.
+- Recommended system prompt for your use cases: keep it short; vision prompts tend to be longer already.
+
+### Tool calling format (if applicable)
+- Tool schema expected (OpenAI-like or custom): custom (template embeds `<tools>` JSON list in system; calls are *not* OpenAI JSON).
+- Tool call emission format (text tags vs structured fields): text tags:
+  - `<tool_call><function=name>...<parameter=...>...</parameter>...</function></tool_call>`
+- Tool response injection format: tool messages are wrapped as `<tool_response>...</tool_response>` inside a synthetic `user` turn.
+- Parsing considerations: treat this as a model-specific protocol; you’ll need an adapter to map it to OpenAI-style tool calls.
+
+### Reasoning / “thinking” behavior (if applicable)
+- Does it emit `<think>...</think>`?
+- Yes (the chat template inserts a `<think>` prefix for generation by default).
+- Are think tags special tokens (does `skip_special_tokens=True` remove them)? No; they’re normal tokens (but are single-token markers).
+- Do you want to hide/store reasoning in logs/UI? Use TUI thinking panel (grey) and `/show last` for raw/think/answer splits.
+
+Note: the shipped chat template has an `enable_thinking` switch. If it’s set false, it emits an *empty* `<think>\\n\\n</think>` prefix.
+This repo doesn’t pass template kwargs yet, so you can’t toggle that without editing the template or adding a runner knob.
+
+## Recommended settings
+- Model author recommended defaults (if any):
+- Practical defaults for your machine:
+  - Primary machine reference: `docs/environments/primary-dev-machine.md` (RTX 4090 24GB VRAM, i9, 64GB RAM).
+  - Start: `--dtype auto` (CUDA → fp16) and a conservative `--max-context-tokens` until you confirm KV-cache headroom.
+  - If you OOM, try `-4bit` (CUDA required) or reduce context.
+
+### “Max context”: what’s the real max?
+This checkpoint advertises a very large window:
+- Theoretical (model limit): `262,144` tokens (`text_config.max_position_embeddings` and tokenizer `model_max_length`).
+
+Practical max is limited by **VRAM** because KV cache scales linearly with tokens.
+
+For Qwen3.5-9B, from `text_config`:
+- layers = `32`
+- kv heads = `4`
+- head dim = `256`
+
+Approx KV-cache per token (fp16/bf16 KV) is:
+`32 layers * 4 kv_heads * 256 head_dim * 2 (K+V) * 2 bytes ≈ 131,072 bytes/token` (≈ **128 KiB/token**)
+
+Rule-of-thumb KV-cache sizes:
+- `16k` tokens ≈ `2 GB` KV
+- `32k` tokens ≈ `4 GB` KV
+- `64k` tokens ≈ `8 GB` KV
+- `128k` tokens ≈ `16 GB` KV
+- `262k` tokens ≈ `32 GB` KV (**won’t fit** on a 24 GB card even if weights were free)
+
+What this means on a 24 GB GPU:
+- If you run **fp16/bf16 weights** (no quant), you likely top out around **~32k–64k** context depending on overhead (and lower when using vision inputs).
+- If you run **4-bit weights** (`-4bit`), you free up more VRAM for KV; higher contexts (e.g. **64k+**) become plausible, but speed will degrade sharply at long contexts.
+
+If you want to “max it out” safely, treat it as an experiment:
+1) use `-4bit`
+2) set `--max-context-tokens` to a big number (e.g. `65536`)
+3) increase in steps (or binary search) until you hit OOM / slowdowns you don’t like
+
+Also remember: `max_new_tokens` spends from the same total window: `prompt_tokens + max_new_tokens <= usable_context`.
+
+### Tweakable runtime parameters (this repo’s current CLI flags)
+`chat.py`:
+- (list the flags you actually used/validated for this model)
+
+`runner.py`:
+- (list the flags you actually used/validated for this model)
+
+### Generation parameters (cross-model reference)
+- If you need “all possible generation knobs”, refer to `transformers.GenerationConfig` keys for the repo’s current `.venv`.
+- List any generation parameters that are especially relevant for this model (e.g. `top_k`, `stop_strings`, `num_beams`).
+
+## Suggested commands
+```bash
+# Text-only chat in the unified TUI
+python tui.py --config Qwen3.5-9B
+
+# Vision chat: attach an image, then send a prompt
+#   /image /path/to/pic.png
+#   What is in this image?
+
+# Bypass /image and run HF directly (for quick sanity checks)
+python - <<'PY'
+from transformers import AutoProcessor, AutoModelForMultimodalLM
+from PIL import Image
+proc = AutoProcessor.from_pretrained('/home/poop/ml/models/Qwen3.5-9B')
+model = AutoModelForMultimodalLM.from_pretrained('/home/poop/ml/models/Qwen3.5-9B', device_map='auto', torch_dtype='auto').eval()
+messages = [{'role':'user','content':[{'type':'image'},{'type':'text','text':'Describe this image.'}]}]
+prompt = proc.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+inputs = proc(text=prompt, images=[Image.new('RGB',(16,16),(255,0,0))], return_tensors='pt').to(model.device)
+out = model.generate(**inputs, max_new_tokens=64)
+print(proc.tokenizer.decode(out[0], skip_special_tokens=True))
+PY
+```
+
+## Best use cases
+- General chat:
+- Coding/math:
+- Tool/agent loops (OpenClaw):
+- Other:
+
+## Not ideal for
+- Latency-sensitive:
+- Clean assistant-only text:
+- Other:
+
+## OpenClaw integration notes (if relevant)
+- Prompt construction notes:
+- Tool call parsing:
+- Tool output injection:
+- Recommended stop criteria:
+
+## Current runner limitations (repo-specific)
+- `tui.py` currently supports image attachments via `/image` for HF only; other backends ignore/deny images.
+- Template kwargs like `enable_thinking` aren’t wired through the runner yet.
+
+## Model-specific proposed flags (if you choose to update the runners later)
+- Proposed flag: `--hf-enable-thinking {true|false}` (template kwarg passthrough)
+  - Why: Qwen’s chat template already supports it; could reduce “hung” feeling by emitting a closed empty think block.
+  - Expected impact: less/no reasoning text (depends on checkpoint behavior).
diff --git a/models/Qwen3.5-9B/hf/notes/model_card.md b/models/Qwen3.5-9B/hf/notes/model_card.md
new file mode 100644
index 0000000..0f3972c
--- /dev/null
+++ b/models/Qwen3.5-9B/hf/notes/model_card.md
@@ -0,0 +1,1173 @@
+---
+library_name: transformers
+license: apache-2.0
+license_link: https://huggingface.co/Qwen/Qwen3.5-9B/blob/main/LICENSE
+pipeline_tag: image-text-to-text
+base_model:
+- Qwen/Qwen3.5-9B-Base
+---
+
+# Qwen3.5-9B
+
+<img width="400px" src="https://qianwen-res.oss-accelerate.aliyuncs.com/logo_qwen3.5.png">
+
+[![Qwen Chat](https://img.shields.io/badge/%F0%9F%92%9C%EF%B8%8F%20Qwen%20Chat%20-536af5)](https://chat.qwen.ai)
+
+> [!Note]
+> This repository contains model weights and configuration files for the post-trained model in the Hugging Face Transformers format. 
+>
+> These artifacts are compatible with Hugging Face Transformers, vLLM, SGLang, KTransformers, etc.
+
+Over recent months, we have intensified our focus on developing foundation models that deliver exceptional utility and performance. Qwen3.5 represents a significant leap forward, integrating breakthroughs in multimodal learning, architectural efficiency, reinforcement learning scale, and global accessibility to empower developers and enterprises with unprecedented capability and efficiency.
+
+## Qwen3.5 Highlights
+
+Qwen3.5 features the following enhancement:
+
+- **Unified Vision-Language Foundation**: Early fusion training on multimodal tokens achieves cross-generational parity with Qwen3 and outperforms Qwen3-VL models across reasoning, coding, agents, and visual understanding benchmarks.
+
+- **Efficient Hybrid Architecture**: Gated Delta Networks combined with sparse Mixture-of-Experts deliver high-throughput inference with minimal latency and cost overhead.
+
+- **Scalable RL Generalization**: Reinforcement learning scaled across million-agent environments with progressively complex task distributions for robust real-world adaptability.
+
+- **Global Linguistic Coverage**: Expanded support to 201 languages and dialects, enabling inclusive, worldwide deployment with nuanced cultural and regional understanding.
+
+- **Next-Generation Training Infrastructure**: Near-100% multimodal training efficiency compared to text-only training and asynchronous RL frameworks supporting massive-scale agent scaffolds and environment orchestration.
+
+
+![Benchmark Results](https://qianwen-res.oss-accelerate-overseas.aliyuncs.com/Qwen3.5/Figures/qwen3.5_small_size_score.png)
+
+For more details, please refer to our blog post [Qwen3.5](https://qwen.ai/blog?id=qwen3.5).
+
+
+## Model Overview
+
+- Type: Causal Language Model with Vision Encoder
+- Training Stage: Pre-training & Post-training
+- Language Model
+    - Number of Parameters: 9B
+    - Hidden Dimension: 4096
+    - Token Embedding: 248320 (Padded)
+    - Number of Layers: 32
+    - Hidden Layout: 8 × (3 × (Gated DeltaNet → FFN) → 1 × (Gated Attention → FFN))
+    - Gated DeltaNet:
+        - Number of Linear Attention Heads: 32 for V and 16 for QK
+        - Head Dimension: 128
+    - Gated Attention:
+        - Number of Attention Heads: 16 for Q and 4 for KV
+        - Head Dimension: 256
+        - Rotary Position Embedding Dimension: 64
+    - Feed Forward Network:
+        - Intermediate Dimension: 12288
+    - LM Output: 248320 (Padded)
+    - MTP: trained with multi-steps  
+- Context Length: 262,144 natively and extensible up to 1,010,000 tokens.
+
+## Benchmark Results
+
+### Language
+
+<div style="font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;max-width:1000px;margin:0 auto;padding:16px 0">
+<table style="width:100%;border-collapse:collapse;font-size:13px">
+<thead><tr>
+<th style="padding:10px 7px;text-align:left;font-weight:600;border-bottom:2px solid #7c3aed;color:#7c3aed"></th><th style="padding:10px 7px;text-align:center;font-weight:500;border-bottom:2px solid #7c3aed;color:#7c3aed;font-size: 14px;">GPT-OSS-120B</th><th style="padding:10px 7px;text-align:center;font-weight:500;border-bottom:2px solid #7c3aed;color:#7c3aed;font-size: 14px;">GPT-OSS-20B</th><th style="padding:10px 7px;text-align:center;font-weight:500;border-bottom:2px solid #7c3aed;color:#7c3aed;font-size: 14px;">Qwen3-Next-80B-A3B-Thinking</th><th style="padding:10px 7px;text-align:center;font-weight:500;border-bottom:2px solid #7c3aed;color:#7c3aed;font-size: 14px;">Qwen3-30BA3B-Thinking-2507</th><th style="padding:10px 7px;text-align:center;font-weight:500;border-bottom:2px solid #7c3aed;color:#7c3aed;font-size: 14px;">Qwen3.5-9B</th><th style="padding:10px 7px;text-align:center;font-weight:500;border-bottom:2px solid #7c3aed;color:#7c3aed;font-size: 14px;">Qwen3.5-4B</th></tr></thead>
+<tbody>
+<tr><td colspan="7" style="padding:8px 12px;font-weight:600;color:#7c3aed;border-bottom:1px solid rgba(124, 58, 237, 0.2);background:rgba(124, 58, 237, 0.1)">Knowledge & STEM</td></tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">MMLU-Pro</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">80.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">74.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">82.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">80.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">82.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">79.1</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">MMLU-Redux</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">91.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">87.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">92.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">91.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">91.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">88.8</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">C-Eval</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">76.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">71.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">89.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">87.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">88.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">85.1</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">SuperGPQA</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">54.6</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">48.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">60.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">56.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">58.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">52.9</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">GPQA Diamond</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">80.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">71.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">77.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">73.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">81.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">76.2</td>
+</tr>
+<tr><td colspan="7" style="padding:8px 12px;font-weight:600;color:#7c3aed;border-bottom:1px solid rgba(124, 58, 237, 0.2);background:rgba(124, 58, 237, 0.1)">Instruction Following</td></tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">IFEval</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">88.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">88.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">88.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">88.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">91.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">89.8</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">IFBench</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">69.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">65.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">61.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">51.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">64.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">59.2</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">MultiChallenge</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">45.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">40.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">51.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">46.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">54.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">49.0</td>
+</tr>
+<tr><td colspan="7" style="padding:8px 12px;font-weight:600;color:#7c3aed;border-bottom:1px solid rgba(124, 58, 237, 0.2);background:rgba(124, 58, 237, 0.1)">Long Context</td></tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">AA-LCR</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">50.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">30.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">51.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">49.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">63.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">57.0</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">LongBench v2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">48.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">45.6</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">48.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">44.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">55.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">50.0</td>
+</tr>
+<tr><td colspan="7" style="padding:8px 12px;font-weight:600;color:#7c3aed;border-bottom:1px solid rgba(124, 58, 237, 0.2);background:rgba(124, 58, 237, 0.1)">Reasoning & Coding</td></tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">HMMT Feb 25</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">90.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">76.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">73.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">63.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">83.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">74.0</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">HMMT Nov 25</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">90.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">81.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">81.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">73.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">82.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">76.8</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">LiveCodeBench v6</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">82.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">74.6</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">68.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">66.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">65.6</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">55.8</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">OJBench</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">41.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">36.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">29.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">25.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">29.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">24.1</td>
+</tr>
+<tr><td colspan="7" style="padding:8px 12px;font-weight:600;color:#7c3aed;border-bottom:1px solid rgba(124, 58, 237, 0.2);background:rgba(124, 58, 237, 0.1)">General Agent</td></tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">BFCL-V4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">49.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">42.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">66.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">50.3</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">TAU2-Bench</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">57.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">41.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">79.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">79.9</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">VITA-Bench</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">29.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">14.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">29.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">22.0</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">DeepPlanning</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">0.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">4.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">18.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">17.6</td>
+</tr>
+<tr><td colspan="7" style="padding:8px 12px;font-weight:600;color:#7c3aed;border-bottom:1px solid rgba(124, 58, 237, 0.2);background:rgba(124, 58, 237, 0.1)">Multilingualism</td></tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">MMMLU</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">78.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">69.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">81.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">78.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">81.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">76.1</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">MMLU-ProX</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">74.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">67.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">73.6</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">69.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">76.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">71.5</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">NOVA-63</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">51.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">48.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">53.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">52.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">55.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">54.3</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">INCLUDE</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">74.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">65.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">78.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">74.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">75.6</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">71.0</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">Global PIQA</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">84.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">79.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">83.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">80.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">83.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">78.9</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">PolyMATH</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">54.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">30.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">62.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">52.6</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">57.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">51.1</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">WMT24++</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">74.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">67.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">57.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">69.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">72.6</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">66.6</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">MAXIFE</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">83.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">80.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">79.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">77.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">83.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">78.0</td>
+</tr>
+</tbody>
+</table>
+<p style="margin-top:12px;font-size:11px;opacity:0.7">
+* TAU2-Bench: we follow the official setup except for the airline domain, where all models are evaluated by applying the fixes proposed in the Claude Opus 4.5 system card.<br>
+<br>
+* MMLU-ProX: we report the averaged accuracy on 29 languages.<br>
+* WMT24++: a harder subset of WMT24 after difficulty labeling and rebalancing; we report the averaged scores on 55 languages using XCOMET-XXL.<br>
+* MAXIFE: we report the accuracy on English + multilingual original prompts (totally 23 settings).<br>
+* Empty cells (--) indicate scores not yet available or not applicable.
+</p>
+</div>
+
+
+### Vision Language
+
+<div style="font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;max-width:1000px;margin:0 auto;padding:16px 0">
+<table style="width:100%;border-collapse:collapse;font-size:13px">
+<thead><tr>
+<th style="padding:10px 7px;text-align:left;font-weight:600;border-bottom:2px solid #7c3aed;color:#7c3aed"></th><th style="padding:10px 7px;text-align:center;font-weight:500;border-bottom:2px solid #7c3aed;color:#7c3aed;font-size: 14px;">GPT-5-Nano-2025-08-07</th><th style="padding:10px 7px;text-align:center;font-weight:500;border-bottom:2px solid #7c3aed;color:#7c3aed;font-size: 14px;">Gemini-2.5-Flash-Lite</th><th style="padding:10px 7px;text-align:center;font-weight:500;border-bottom:2px solid #7c3aed;color:#7c3aed;font-size: 14px;">Qwen3-VL-30B-A3B</th><th style="padding:10px 7px;text-align:center;font-weight:500;border-bottom:2px solid #7c3aed;color:#7c3aed;font-size: 14px;">Qwen3.5-9B</th><th style="padding:10px 7px;text-align:center;font-weight:500;border-bottom:2px solid #7c3aed;color:#7c3aed;font-size: 14px;">Qwen3.5-4B</th></tr></thead>
+<tbody>
+<tr><td colspan="6" style="padding:8px 12px;font-weight:600;color:#7c3aed;border-bottom:1px solid rgba(124, 58, 237, 0.2);background:rgba(124, 58, 237, 0.1)">STEM and Puzzle </td></tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">MMMU</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">75.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">73.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">76.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">78.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">77.6</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">MMMU-Pro</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">57.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">59.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">63.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">70.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">66.3</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">MathVision</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">62.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">52.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">65.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">78.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">74.6</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">Mathvista(mini)</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">71.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">72.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">81.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">85.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">85.1</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">We-Math</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">62.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">32.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">70.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">75.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">75.4</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">DynaMath</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">78.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">69.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">80.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">83.6</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">83.3</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">ZEROBench</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">1.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">1.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">0.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">3.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">3.0</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">ZEROBench_sub</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">22.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">19.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">23.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">31.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">26.3</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">VlmsAreBlind</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">66.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">68.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">72.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">93.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">92.6</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">BabyVision</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">14.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">17.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">18.6</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">28.6/25.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">16.0/19.1</td>
+</tr>
+<tr><td colspan="6" style="padding:8px 12px;font-weight:600;color:#7c3aed;border-bottom:1px solid rgba(124, 58, 237, 0.2);background:rgba(124, 58, 237, 0.1)">General VQA</td></tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">RealWorldQA</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">71.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">72.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">77.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">80.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">79.5</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">MMStar</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">68.6</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">69.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">75.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">79.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">78.3</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">MMBench<sub><small>EN-DEV-v1.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">80.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">82.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">88.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">90.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">89.4</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">SimpleVQA</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">46.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">54.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">54.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">51.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">43.4</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">HallusionBench</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">58.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">64.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">66.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">69.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">65.0</td>
+</tr>
+<tr><td colspan="6" style="padding:8px 12px;font-weight:600;color:#7c3aed;border-bottom:1px solid rgba(124, 58, 237, 0.2);background:rgba(124, 58, 237, 0.1)">Text Recognition and Document Understanding</td></tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">OmniDocBench1.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">55.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">79.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">86.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">87.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">86.2</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">CharXiv(RQ)</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">50.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">56.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">56.6</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">73.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">70.8</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">MMLongBench-Doc</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">31.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">46.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">47.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">57.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">54.2</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">CC-OCR</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">58.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">72.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">77.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">79.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">76.7</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">AI2D_TEST</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">81.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">85.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">86.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">90.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">89.6</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">OCRBench</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">75.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">82.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">83.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">89.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">85.0</td>
+</tr>
+<tr><td colspan="6" style="padding:8px 12px;font-weight:600;color:#7c3aed;border-bottom:1px solid rgba(124, 58, 237, 0.2);background:rgba(124, 58, 237, 0.1)">Spatial Intelligence</td></tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">ERQA</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">45.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">44.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">45.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">55.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">54.0</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">CountBench</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">80.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">79.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">90.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">97.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">96.3</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">RefCOCO(avg)</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">89.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">89.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">88.1</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">EmbSpatialBench</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">74.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">66.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">80.6</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">83.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">81.3</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">RefSpatialBench</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">12.6</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">11.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">54.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">58.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">54.6</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">LingoQA</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">57.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">17.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">62.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">80.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">74.4</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">Hypersim</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">11.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">13.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">12.5</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">Nuscene</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">10.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">11.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">9.9</td>
+</tr>
+<tr><td colspan="6" style="padding:8px 12px;font-weight:600;color:#7c3aed;border-bottom:1px solid rgba(124, 58, 237, 0.2);background:rgba(124, 58, 237, 0.1)">Video Understanding</td></tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">VideoMME<sub><small>(w sub.)</sub></small></td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">71.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">74.6</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">79.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">84.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">83.5</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">VideoMME<sub><small>(w/o sub.)</sub></small></td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">66.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">72.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">73.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">78.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">76.9</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">VideoMMMU</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">63.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">69.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">75.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">78.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">74.1</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">MLVU</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">69.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">78.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">78.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">84.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">82.8</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">MVBench</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">72.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">74.4</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">71.2</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">LVBench</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">60.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">59.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">70.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">66.4</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">MMVU</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">63.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">65.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">66.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">67.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">64.9</td>
+</tr>
+<tr><td colspan="6" style="padding:8px 12px;font-weight:600;color:#7c3aed;border-bottom:1px solid rgba(124, 58, 237, 0.2);background:rgba(124, 58, 237, 0.1)">Visual Agent </td></tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">ScreenSpot Pro</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">60.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">65.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">60.3</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">OSWorld-Verified</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">30.6</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">41.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">35.6</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">AndroidWorld</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">--</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">55.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">57.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">58.6</td>
+</tr>
+<tr><td colspan="6" style="padding:8px 12px;font-weight:600;color:#7c3aed;border-bottom:1px solid rgba(124, 58, 237, 0.2);background:rgba(124, 58, 237, 0.1)">Tool Calling</td></tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">TIR-Bench</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">18.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">21.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">22.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">45.6/31.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">38.9/29.9</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">V*</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">68.1</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">69.6</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">83.2</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">90.1/88.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">84.3/86.4</td>
+</tr>
+<tr><td colspan="6" style="padding:8px 12px;font-weight:600;color:#7c3aed;border-bottom:1px solid rgba(124, 58, 237, 0.2);background:rgba(124, 58, 237, 0.1)">Medical VQA</td></tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">SLAKE</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">57.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">65.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">68.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">79.0</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">76.1</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">PMC-VQA</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">37.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">48.8</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">51.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">57.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">55.5</td>
+</tr>
+<tr>
+<td style="padding:7px 7px;padding-left:20px;border-bottom:1px solid rgba(128, 128, 128, 0.15);">MedXpertQA-MM</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">26.7</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">35.3</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">35.5</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">49.9</td>
+<td style="padding:7px 7px;text-align:center;border-bottom:1px solid rgba(128, 128, 128, 0.15)">42.9</td>
+</tr>
+</tbody>
+</table>
+
+<p style="margin-top:12px;font-size:11px;opacity:0.7">
+* MathVision: our model’s score is evaluated using a fixed prompt, e.g., “Please reason step by step, and put your final answer within \boxed{}.” For other models, we report the higher score between runs with and without the \boxed{} formatting.<br>
+* BabyVision: scores reported as "with CI / without CI".<br>
+* TIR-Bench and V*: scores reported as "with CI / without CI".<br>
+* Empty cells (--) indicate scores not yet available or not applicable.
+</p>
+
+</div>
+
+## Quickstart
+
+> [!Important]
+> Qwen3.5 models operate in thinking mode by default, generating thinking content signified by `<think>\n...</think>\n\n` before producing the final responses.
+> To disable thinking content and obtain direct response, refer to the examples [here](#instruct-or-non-thinking-mode).
+
+
+For streamlined integration, we recommend using Qwen3.5 via APIs. Below is a guide to use Qwen3.5 via OpenAI-compatible API. 
+
+### Serving Qwen3.5
+
+Qwen3.5 can be served via APIs with popular inference frameworks.
+In the following, we show example commands to launch OpenAI-Compatible API servers for Qwen3.5 models.
+
+
+> [!Important]
+> Inference efficiency and throughput vary significantly across frameworks. 
+> We recommend using the latest framework versions to ensure optimal performance and compatibility.
+> For production workloads or high-throughput scenarios, dedicated serving engines such as SGLang, KTransformers or vLLM are strongly recommended.
+
+> [!Important]
+> The model has a default context length of 262,144 tokens.
+> If you encounter out-of-memory (OOM) errors, consider reducing the context window. 
+> However, because Qwen3.5 leverages extended context for complex tasks, we advise maintaining a context length of at least 128K tokens to preserve thinking capabilities.
+
+#### SGLang
+
+[SGLang](https://github.com/sgl-project/sglang) is a fast serving framework for large language models and vision language models.
+SGLang from the main branch of the open-source repository is required for Qwen3.5, which can be installed using the following command in a fresh environment:
+```shell
+uv pip install 'git+https://github.com/sgl-project/sglang.git#subdirectory=python&egg=sglang[all]'
+```
+See [its documentation](https://docs.sglang.ai/get_started/install.html) for more details.
+
+The following will create API endpoints at `http://localhost:8000/v1`:
+
+- **Standard Version**: The following command can be used to create an API endpoint with maximum context length 262,144 tokens using tensor parallel on 8 GPUs.
+    
+    ```shell
+    python -m sglang.launch_server --model-path Qwen/Qwen3.5-9B --port 8000 --tp-size 1 --mem-fraction-static 0.8 --context-length 262144 --reasoning-parser qwen3
+    ```
+
+- **Tool Use**: To support tool use, you can use the following command.
+    
+    ```shell
+    python -m sglang.launch_server --model-path Qwen/Qwen3.5-9B --port 8000 --tp-size 1 --mem-fraction-static 0.8 --context-length 262144 --reasoning-parser qwen3 --tool-call-parser qwen3_coder
+    ```
+
+- **Multi-Token Prediction (MTP)**: The following command is recommended for MTP:
+    
+    ```shell
+    python -m sglang.launch_server --model-path Qwen/Qwen3.5-9B --port 8000 --tp-size 1 --mem-fraction-static 0.8 --context-length 262144 --reasoning-parser qwen3 --speculative-algo NEXTN --speculative-num-steps 3 --speculative-eagle-topk 1 --speculative-num-draft-tokens 4
+    ```
+
+#### vLLM
+
+[vLLM](https://github.com/vllm-project/vllm) is a high-throughput and memory-efficient inference and serving engine for LLMs.
+vLLM from the main branch of the open-source repository is required for Qwen3.5, which can be installed using the following command in a fresh environment:
+```shell
+uv pip install vllm --torch-backend=auto --extra-index-url https://wheels.vllm.ai/nightly
+```
+See [its documentation](https://docs.vllm.ai/en/stable/getting_started/installation/index.html) for more details. 
+
+For detailed Qwen3.5 usage guide, see the [vLLM Qwen3.5 recipe](https://docs.vllm.ai/projects/recipes/en/latest/Qwen/Qwen3.5.html).
+
+The following will create API endpoints at `http://localhost:8000/v1`:
+
+- **Standard Version**: The following command can be used to create an API endpoint with maximum context length 262,144 tokens using tensor parallel on 8 GPUs.
+
+    ```shell
+    vllm serve Qwen/Qwen3.5-9B --port 8000 --tensor-parallel-size 1 --max-model-len 262144 --reasoning-parser qwen3 
+    ```
+
+- **Tool Call**: To support tool use, you can use the following command.
+    
+    ```shell
+    vllm serve Qwen/Qwen3.5-9B --port 8000 --tensor-parallel-size 1 --max-model-len 262144 --reasoning-parser qwen3 --enable-auto-tool-choice --tool-call-parser qwen3_coder 
+    ```
+
+- **Multi-Token Prediction (MTP)**: The following command is recommended for MTP:
+
+    ```shell
+    vllm serve Qwen/Qwen3.5-9B --port 8000 --tensor-parallel-size 1 --max-model-len 262144 --reasoning-parser qwen3 --speculative-config '{"method":"qwen3_next_mtp","num_speculative_tokens":2}'
+    ```
+
+- **Text-Only**: The following command skips the vision encoder and multimodal profiling to free up memory for additional KV cache:
+    
+    ```shell
+    vllm serve Qwen/Qwen3.5-9B --port 8000 --tensor-parallel-size 1 --max-model-len 262144 --reasoning-parser qwen3 --language-model-only
+    ```
+
+#### KTransformers
+ 
+[KTransformers](https://github.com/kvcache-ai/ktransformers) is a flexible framework for experiencing cutting-edge LLM inference optimizations with CPU-GPU heterogeneous computing.
+For running Qwen3.5 with KTransformers, see the [KTransformers Deployment Guide](https://github.com/kvcache-ai/ktransformers/blob/main/doc/en/Qwen3.5.md).
+ 
+#### Hugging Face Transformers
+
+Hugging Face Transformers contains a _lightweight_ server which can be used for quick testing and moderate load deployment.
+The latest `transformers` is required for Qwen3.5:
+```shell
+pip install "transformers[serving] @ git+https://github.com/huggingface/transformers.git@main"
+```
+See [its documentation](https://huggingface.co/docs/transformers/main/serving) for more details. Please also make sure torchvision and pillow are installed.
+
+Then, run `transformers serve` to launch a server with API endpoints at `http://localhost:8000/v1`; it will place the model on accelerators if available:
+```shell
+transformers serve --force-model Qwen/Qwen3.5-9B --port 8000 --continuous-batching
+```
+
+### Using Qwen3.5 via the Chat Completions API
+
+The chat completions API is accessible via standard HTTP requests or OpenAI SDKs.
+Here, we show examples using the OpenAI Python SDK.
+
+Before starting, make sure it is installed and the API key and the API base URL is configured, e.g.:
+```shell
+pip install -U openai
+
+# Set the following accordingly
+export OPENAI_BASE_URL="http://localhost:8000/v1"
+export OPENAI_API_KEY="EMPTY"
+```
+
+> [!Tip]
+> We recommend using the following set of sampling parameters for generation
+> - Thinking mode for general tasks: `temperature=1.0, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0`
+> - Thinking mode for precise coding tasks (e.g. WebDev): `temperature=0.6, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=0.0, repetition_penalty=1.0`
+> - Instruct (or non-thinking) mode for general tasks: `temperature=0.7, top_p=0.8, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0`
+> - Instruct (or non-thinking) mode for reasoning tasks: `temperature=1.0, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0`
+>
+> Please note that the support for sampling parameters varies according to inference frameworks.
+
+#### Text-Only Input
+
+```python
+from openai import OpenAI
+# Configured by environment variables
+client = OpenAI()
+
+messages = [
+    {"role": "user", "content": "Type \"I love Qwen3.5\" backwards"},
+]
+
+chat_response = client.chat.completions.create(
+    model="Qwen/Qwen3.5-9B",
+    messages=messages,
+    max_tokens=81920,
+    temperature=1.0,
+    top_p=0.95,
+    presence_penalty=1.5,
+    extra_body={
+        "top_k": 20,
+    }, 
+)
+print("Chat response:", chat_response)
+```
+
+
+#### Image Input
+
+```python
+from openai import OpenAI
+# Configured by environment variables
+client = OpenAI()
+
+messages = [
+    {
+        "role": "user",
+        "content": [
+            {
+                "type": "image_url",
+                "image_url": {
+                    "url": "https://qianwen-res.oss-accelerate.aliyuncs.com/Qwen3.5/demo/CI_Demo/mathv-1327.jpg"
+                }
+            },
+            {
+                "type": "text",
+                "text": "The centres of the four illustrated circles are in the corners of the square. The two big circles touch each other and also the two little circles. With which factor do you have to multiply the radii of the little circles to obtain the radius of the big circles?\nChoices:\n(A) $\\frac{2}{9}$\n(B) $\\sqrt{5}$\n(C) $0.8 \\cdot \\pi$\n(D) 2.5\n(E) $1+\\sqrt{2}$"
+            }
+        ]
+    }
+]
+
+chat_response = client.chat.completions.create(
+    model="Qwen/Qwen3.5-9B",
+    messages=messages,
+    max_tokens=81920,
+    temperature=1.0,
+    top_p=0.95,
+    presence_penalty=1.5,
+    extra_body={
+        "top_k": 20,
+    }, 
+)
+print("Chat response:", chat_response)
+```
+
+#### Video Input
+
+```python
+from openai import OpenAI
+# Configured by environment variables
+client = OpenAI()
+
+messages = [
+    {
+        "role": "user",
+        "content": [
+            {
+                "type": "video_url",
+                "video_url": {
+                    "url": "https://qianwen-res.oss-accelerate.aliyuncs.com/Qwen3.5/demo/video/N1cdUjctpG8.mp4"
+                }
+            },
+            {
+                "type": "text",
+                "text": "Summarize the video content."
+            }
+        ]
+    }
+]
+
+# When vLLM is launched with `--media-io-kwargs '{"video": {"num_frames": -1}}'`,
+# video frame sampling can be configured via `extra_body` (e.g., by setting `fps`).
+# This feature is currently supported only in vLLM.
+#
+# By default, `fps=2` and `do_sample_frames=True`.
+# With `do_sample_frames=True`, you can customize the `fps` value to set your desired video sampling rate.
+chat_response = client.chat.completions.create(
+    model="Qwen/Qwen3.5-9B",
+    messages=messages,
+    max_tokens=81920,
+    temperature=1.0,
+    top_p=0.95,
+    presence_penalty=1.5,
+    extra_body={
+        "top_k": 20,
+        "mm_processor_kwargs": {"fps": 2, "do_sample_frames": True},
+    }, 
+)
+
+print("Chat response:", chat_response)
+```
+
+#### Instruct (or Non-Thinking) Mode
+
+> [!Important]
+> Qwen3.5 does not officially support the soft switch of Qwen3, i.e., `/think` and `/nothink`.
+
+Qwen3.5 will think by default before response.
+You can obtain direct response from the model without thinking by configuring the API parameters. 
+For example,
+```python
+from openai import OpenAI
+# Configured by environment variables
+client = OpenAI()
+
+messages = [
+    {
+        "role": "user",
+        "content": [
+            {
+                "type": "image_url",
+                "image_url": {
+                    "url": "https://qianwen-res.oss-accelerate.aliyuncs.com/Qwen3.5/demo/RealWorld/RealWorld-04.png"
+                }
+            },
+            {
+                "type": "text",
+                "text": "Where is this?"
+            }
+        ]
+    }
+]
+
+chat_response = client.chat.completions.create(
+    model="Qwen/Qwen3.5-9B",
+    messages=messages,
+    max_tokens=32768,
+    temperature=0.7,
+    top_p=0.8,
+    presence_penalty=1.5,
+    extra_body={
+        "top_k": 20,
+        "chat_template_kwargs": {"enable_thinking": False},
+    }, 
+)
+print("Chat response:", chat_response)
+```
+
+> [!Note]
+> If you are using APIs from Alibaba Cloud Model Studio, in addition to changing `model`, please use `"enable_thinking": False` instead of `"chat_template_kwargs": {"enable_thinking": False}`.
+
+
+## Agentic Usage
+
+Qwen3.5 excels in tool calling capabilities.
+
+### Qwen-Agent
+
+We recommend using [Qwen-Agent](https://github.com/QwenLM/Qwen-Agent) to quickly build Agent applications with Qwen3.5. 
+
+To define the available tools, you can use the MCP configuration file, use the integrated tool of Qwen-Agent, or integrate other tools by yourself.
+```python
+import os
+from qwen_agent.agents import Assistant
+
+# Define LLM
+# Using Alibaba Cloud Model Studio
+llm_cfg = {
+    # Use the OpenAI-compatible model service provided by DashScope:
+    'model': 'Qwen3.5-9B',
+    'model_type': 'qwenvl_oai',
+    'model_server': 'https://dashscope.aliyuncs.com/compatible-mode/v1',
+    'api_key': os.getenv('DASHSCOPE_API_KEY'),
+
+    'generate_cfg': {
+        'use_raw_api': True,
+        # When using Dash Scope OAI API, pass the parameter of whether to enable thinking mode in this way
+        'extra_body': {
+            'enable_thinking': True
+        },
+    },
+}
+
+# Using OpenAI-compatible API endpoint.
+# functionality of the deployment frameworks and let Qwen-Agent automate the related operations.
+#
+# llm_cfg = {
+#     # Use your own model service compatible with OpenAI API by vLLM/SGLang:
+#     'model': 'Qwen/Qwen3.5-9B',
+#     'model_type': 'qwenvl_oai',
+#     'model_server': 'http://localhost:8000/v1',  # api_base
+#     'api_key': 'EMPTY',
+#
+#     'generate_cfg': {
+#         'use_raw_api': True,
+#         # When using vLLM/SGLang OAI API, pass the parameter of whether to enable thinking mode in this way
+#         'extra_body': {
+#             'chat_template_kwargs': {'enable_thinking': True}
+#         },
+#     },
+# }
+
+# Define Tools
+tools = [
+    {'mcpServers': {  # You can specify the MCP configuration file
+            "filesystem": {
+                "command": "npx",
+                "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/xxxx/Desktop"]
+            }
+        }
+    }
+]
+
+# Define Agent
+bot = Assistant(llm=llm_cfg, function_list=tools)
+
+# Streaming generation
+messages = [{'role': 'user', 'content': 'Help me organize my desktop.'}]
+for responses in bot.run(messages=messages):
+    pass
+print(responses)
+
+# Streaming generation
+messages = [{'role': 'user', 'content': 'Develop a dog website and save it on the desktop'}]
+for responses in bot.run(messages=messages):
+    pass
+print(responses)
+```
+
+### Qwen Code
+
+
+[Qwen Code](https://github.com/QwenLM/qwen-code) is an open-source AI agent for the terminal, optimized for Qwen models. It helps you understand large codebases, automate tedious work, and ship faster.
+
+For more information, please refer to [Qwen Code](https://qwenlm.github.io/qwen-code-docs/).
+
+## Processing Ultra-Long Texts
+
+Qwen3.5 natively supports context lengths of up to 262,144 tokens. 
+For long-horizon tasks where the total length (including both input and output) exceeds this limit, we recommend using RoPE scaling techniques to handle long texts effectively., e.g., YaRN.
+
+YaRN is currently supported by several inference frameworks, e.g., `transformers`, `vllm`, `ktransformers` and `sglang`. 
+In general, there are two approaches to enabling YaRN for supported frameworks:
+
+- Modifying the model configuration file:
+  In the `config.json` file, change the `rope_parameters` fields in `text_config` to:
+    ```json
+    {
+        "mrope_interleaved": true,
+        "mrope_section": [
+            11,
+            11,
+            10
+        ],
+        "rope_type": "yarn",
+        "rope_theta": 10000000,
+        "partial_rotary_factor": 0.25,
+        "factor": 4.0,
+        "original_max_position_embeddings": 262144,
+    }
+    ```
+
+- Passing command line arguments:
+
+  For `vllm`, you can use
+    ```shell
+    VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 vllm serve ... --hf-overrides '{"text_config": {"rope_parameters": {"mrope_interleaved": true, "mrope_section": [11, 11, 10], "rope_type": "yarn", "rope_theta": 10000000, "partial_rotary_factor": 0.25, "factor": 4.0, "original_max_position_embeddings": 262144}}}' --max-model-len 1010000  
+    ```
+
+  For `sglang` and `ktransformers`, you can use
+    ```shell
+    SGLANG_ALLOW_OVERWRITE_LONGER_CONTEXT_LEN=1 python -m sglang.launch_server ... --json-model-override-args '{"text_config": {"rope_parameters": {"mrope_interleaved": true, "mrope_section": [11, 11, 10], "rope_type": "yarn", "rope_theta": 10000000, "partial_rotary_factor": 0.25, "factor": 4.0, "original_max_position_embeddings": 262144}}}' --context-length 1010000
+    ```
+
+> [!NOTE]
+> All the notable open-source frameworks implement static YaRN, which means the scaling factor remains constant regardless of input length, **potentially impacting performance on shorter texts.**
+> We advise modifying the `rope_parameters` configuration only when processing long contexts is required. 
+> It is also recommended to modify the `factor` as needed. For example, if the typical context length for your application is 524,288 tokens, it would be better to set `factor` as 2.0. 
+
+## Best Practices
+
+To achieve optimal performance, we recommend the following settings:
+
+1. **Sampling Parameters**:  
+   - We suggest using the following sets of sampling parameters depending on the mode and task type:  
+     - **Thinking mode for general tasks**:  
+       `temperature=1.0`, `top_p=0.95`, `top_k=20`, `min_p=0.0`, `presence_penalty=1.5`, `repetition_penalty=1.0`  
+     - **Thinking mode for precise coding tasks (e.g., WebDev)**:  
+       `temperature=0.6`, `top_p=0.95`, `top_k=20`, `min_p=0.0`, `presence_penalty=0.0`, `repetition_penalty=1.0`  
+     - **Instruct (or non-thinking) mode for general tasks**:  
+       `temperature=0.7`, `top_p=0.8`, `top_k=20`, `min_p=0.0`, `presence_penalty=1.5`, `repetition_penalty=1.0`  
+     - **Instruct (or non-thinking) mode for reasoning tasks**:  
+       `temperature=1.0`, `top_p=1.0`, `top_k=40`, `min_p=0.0`, `presence_penalty=2.0`, `repetition_penalty=1.0`  
+   - For supported frameworks, you can adjust the `presence_penalty` parameter between 0 and 2 to reduce endless repetitions. However, using a higher value may occasionally result in language mixing and a slight decrease in model performance.
+
+2. **Adequate Output Length**: We recommend using an output length of 32,768 tokens for most queries. For benchmarking on highly complex problems, such as those found in math and programming competitions, we suggest setting the max output length to 81,920 tokens. This provides the model with sufficient space to generate detailed and comprehensive responses, thereby enhancing its overall performance.
+
+3. **Standardize Output Format**: We recommend using prompts to standardize model outputs when benchmarking.
+   - **Math Problems**: Include "Please reason step by step, and put your final answer within \boxed{}." in the prompt.
+   - **Multiple-Choice Questions**: Add the following JSON structure to the prompt to standardize responses: "Please show your choice in the `answer` field with only the choice letter, e.g., `"answer": "C"`."
+
+4. **No Thinking Content in History**: In multi-turn conversations, the historical model output should only include the final output part and does not need to include the thinking content. It is implemented in the provided chat template in Jinja2. However, for frameworks that do not directly use the Jinja2 chat template, it is up to the developers to ensure that the best practice is followed.
+
+5. **Long Video Understanding**: To optimize inference efficiency for plain text and images, the `size` parameter in the released `video_preprocessor_config.json` is conservatively configured. It is recommended to set the `longest_edge` parameter in the video_preprocessor_config file to 469,762,048 (corresponding to 224k video tokens) to enable higher frame-rate sampling for hour-scale videos and thereby achieve superior performance. For example,
+    ```json
+    {"longest_edge": 469762048, "shortest_edge": 4096}
+    ```
+
+    Alternatively, override the default values via engine startup parameters. For implementation details, refer to: [vLLM](https://github.com/vllm-project/vllm/pull/34330) / [SGLang](https://github.com/sgl-project/sglang/pull/18467).
+
+
+### Citation
+
+If you find our work helpful, feel free to give us a cite.
+
+```bibtex
+@misc{qwen3.5,
+    title  = {{Qwen3.5}: Towards Native Multimodal Agents},
+    author = {{Qwen Team}},
+    month  = {February},
+    year   = {2026},
+    url    = {https://qwen.ai/blog?id=qwen3.5}
+}
+```
\ No newline at end of file
diff --git a/models/Qwen3.5-9B/hf/prompts/README.md b/models/Qwen3.5-9B/hf/prompts/README.md
new file mode 100644
index 0000000..6759b02
--- /dev/null
+++ b/models/Qwen3.5-9B/hf/prompts/README.md
@@ -0,0 +1,4 @@
+# Qwen3.5-9B prompts (hf)
+
+This folder is for prompt assets (system prompts, few-shots, tool schemas).
+It may be git-ignored except for this README.
diff --git a/models/Qwen3.5-9B/hf/templates/README.md b/models/Qwen3.5-9B/hf/templates/README.md
new file mode 100644
index 0000000..4dc32bb
--- /dev/null
+++ b/models/Qwen3.5-9B/hf/templates/README.md
@@ -0,0 +1,3 @@
+# Qwen3.5-9B templates (hf)
+
+This folder is for prompt/template overrides or experiments.
diff --git a/models/Qwen3.5-9B/hf/templates/chat_template.jinja b/models/Qwen3.5-9B/hf/templates/chat_template.jinja
new file mode 100644
index 0000000..8c82c0f
--- /dev/null
+++ b/models/Qwen3.5-9B/hf/templates/chat_template.jinja
@@ -0,0 +1,159 @@
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- macro render_content(content, do_vision_count, is_system_content=false) %}
+    {%- if content is string %}
+        {{- content }}
+    {%- elif content is iterable and content is not mapping %}
+        {%- for item in content %}
+            {%- if 'image' in item or 'image_url' in item or item.type == 'image' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain images.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Picture ' ~ image_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
+            {%- elif 'video' in item or item.type == 'video' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain videos.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Video ' ~ video_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
+            {%- elif 'text' in item %}
+                {{- item.text }}
+            {%- else %}
+                {{- raise_exception('Unexpected item type in content.') }}
+            {%- endif %}
+        {%- endfor %}
+    {%- elif content is none or content is undefined %}
+        {{- '' }}
+    {%- else %}
+        {{- raise_exception('Unexpected content type.') }}
+    {%- endif %}
+{%- endmacro %}
+{%- if not messages %}
+    {{- raise_exception('No messages provided.') }}
+{%- endif %}
+{%- if tools and tools is iterable and tools is not mapping %}
+    {{- '<|im_start|>system\n' }}
+    {{- "# Tools\n\nYou have access to the following functions:\n\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>" }}
+    {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n</IMPORTANT>' }}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {%- if content %}
+            {{- '\n\n' + content }}
+        {%- endif %}
+    {%- endif %}
+    {{- '<|im_end|>\n' }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" %}
+        {%- set content = render_content(message.content, false)|trim %}
+        {%- if not(content.startswith('<tool_response>') and content.endswith('</tool_response>')) %}
+            {%- set ns.multi_step_tool = false %}
+            {%- set ns.last_query_index = index %}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if ns.multi_step_tool %}
+    {{- raise_exception('No user query found in messages.') }}
+{%- endif %}
+{%- for message in messages %}
+    {%- set content = render_content(message.content, true)|trim %}
+    {%- if message.role == "system" %}
+        {%- if not loop.first %}
+            {{- raise_exception('System message must be at the beginning.') }}
+        {%- endif %}
+    {%- elif message.role == "user" %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {%- set reasoning_content = reasoning_content|trim %}
+        {%- if loop.index0 > ns.last_query_index %}
+            {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if tool_call.function is defined %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {%- if loop.first %}
+                    {%- if content|trim %}
+                        {{- '\n\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- else %}
+                        {{- '<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- endif %}
+                {%- else %}
+                    {{- '\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                {%- endif %}
+                {%- if tool_call.arguments is defined %}
+                    {%- if tool_call.arguments is mapping %}
+                        {%- for args_name, args_value in tool_call.arguments|items %}
+                            {{- '<parameter=' + args_name + '>\n' }}
+                            {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %}
+                            {{- args_value }}
+                            {{- '\n</parameter>\n' }}
+                        {%- endfor %}
+                    {%- else %}
+                        {%- set arguments_blob = tool_call.arguments | tojson | safe if tool_call.arguments is sequence and tool_call.arguments is not string else tool_call.arguments | string %}
+                        {{- arguments_blob }}
+                    {%- endif %}
+                {%- endif %}
+                {{- '</function>\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.previtem and loop.previtem.role != "tool" %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if not loop.last and loop.nextitem.role != "tool" %}
+            {{- '<|im_end|>\n' }}
+        {%- elif loop.last %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- else %}
+        {{- raise_exception('Unexpected message role.') }}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+    {%- if enable_thinking is defined and enable_thinking is false %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- else %}
+        {{- '<think>\n' }}
+    {%- endif %}
+{%- endif %}
diff --git a/models/Qwen3.5-9B/openai/config/default.toml b/models/Qwen3.5-9B/openai/config/default.toml
new file mode 100644
index 0000000..3fad9e4
--- /dev/null
+++ b/models/Qwen3.5-9B/openai/config/default.toml
@@ -0,0 +1,33 @@
+[model]
+id = "Qwen3.5-9B"
+
+[gen]
+stream = true
+
+[prompt]
+
+
+[ui]
+show_thinking = false
+assume_think = false
+history_strip_think = true
+no_animate_thinking = false
+save_transcript = ""
+capture_last_request = false
+show_tool_activity = false
+show_tool_arguments = false
+scroll_lines = 9
+ui_tick_ms = 33
+ui_max_events_per_tick = 120
+
+[telemetry]
+jsonl = ""
+sample_interval_s = 1.0
+
+[tools]
+
+[backend.openai]
+base_url = "http://127.0.0.1:8002/v1"
+api_key = ""
+timeout_s = 600
+log_file = ""
diff --git a/models/Qwen3.5-9B/openai/config/profiles/fast.toml b/models/Qwen3.5-9B/openai/config/profiles/fast.toml
new file mode 100644
index 0000000..a299998
--- /dev/null
+++ b/models/Qwen3.5-9B/openai/config/profiles/fast.toml
@@ -0,0 +1,2 @@
+[gen]
+max_new_tokens = 1024
diff --git a/models/Qwen3.5-9B/openai/config/profiles/longctx.toml b/models/Qwen3.5-9B/openai/config/profiles/longctx.toml
new file mode 100644
index 0000000..ee4e986
--- /dev/null
+++ b/models/Qwen3.5-9B/openai/config/profiles/longctx.toml
@@ -0,0 +1,2 @@
+[gen]
+max_new_tokens = 2048
diff --git a/models/Qwen3.5-9B/openai/notes/README.md b/models/Qwen3.5-9B/openai/notes/README.md
new file mode 100644
index 0000000..2fbd662
--- /dev/null
+++ b/models/Qwen3.5-9B/openai/notes/README.md
@@ -0,0 +1,3 @@
+# openai backend notes template
+
+Use this folder for OpenAI-compatible server notes (vLLM/OpenAI-compatible endpoints), model IDs, and local setup details.
diff --git a/models/Qwen3.5-9B/openai/prompts/README.md b/models/Qwen3.5-9B/openai/prompts/README.md
new file mode 100644
index 0000000..d441e05
--- /dev/null
+++ b/models/Qwen3.5-9B/openai/prompts/README.md
@@ -0,0 +1,4 @@
+# Qwen3.5-9B prompts (openai)
+
+This folder is for prompt assets (system prompts, few-shots, tool schemas).
+It may be git-ignored except for this README.
diff --git a/models/Qwen3.5-9B/openai/templates/README.md b/models/Qwen3.5-9B/openai/templates/README.md
new file mode 100644
index 0000000..e351b2f
--- /dev/null
+++ b/models/Qwen3.5-9B/openai/templates/README.md
@@ -0,0 +1,3 @@
+# Qwen3.5-9B templates (openai)
+
+This folder is for prompt/template overrides or experiments.
diff --git a/models/Qwen3.5-9B/vllm/compressor/calibration/README.md b/models/Qwen3.5-9B/vllm/compressor/calibration/README.md
new file mode 100644
index 0000000..8a8b1c6
--- /dev/null
+++ b/models/Qwen3.5-9B/vllm/compressor/calibration/README.md
@@ -0,0 +1,3 @@
+Replace this placeholder with a real local calibration dataset file or override `dataset_path` on the CLI.
+
+Supported local inputs should be formats that Hugging Face datasets can read directly, such as JSON/JSONL, CSV, or Parquet.
diff --git a/models/Qwen3.5-9B/vllm/config/default.toml b/models/Qwen3.5-9B/vllm/config/default.toml
new file mode 100644
index 0000000..e887b1d
--- /dev/null
+++ b/models/Qwen3.5-9B/vllm/config/default.toml
@@ -0,0 +1,80 @@
+[model]
+id = "Qwen3.5-9B"
+
+[gen]
+stream = true
+max_new_tokens = 8192
+temperature = 0.6
+top_p = 0.9
+top_k = 64
+min_p = 0.0
+repetition_penalty = 1.03
+presence_penalty = 0.0
+frequency_penalty = 0.0
+stop_strings = []
+stop_token_ids = []
+ignore_eos = false
+min_tokens = 0
+best_of = 1
+use_beam_search = false
+length_penalty = 1.0
+include_stop_str_in_output = false
+skip_special_tokens = true
+spaces_between_special_tokens = true
+truncate_prompt_tokens = 0
+allowed_token_ids = []
+prompt_logprobs = 0
+
+[prompt]
+chat_template = "models/Qwen3.5-9B/hf/templates/chat_template.jinja"
+system = ""
+system_file = ""
+user_prefix = ""
+
+[ui]
+show_thinking = false
+assume_think = true
+history_strip_think = true
+no_animate_thinking = false
+save_transcript = ""
+capture_last_request = true
+scroll_lines = 9
+show_tool_activity = false
+show_tool_arguments = false
+ui_tick_ms = 33
+ui_max_events_per_tick = 120
+
+[telemetry]
+jsonl = ""
+sample_interval_s = 1.0
+
+[tools]
+enabled = true
+mode = "execute"
+schema_file = ""
+tool_choice = ""
+allow = []
+deny = []
+max_calls_per_turn = 3
+timeout_s = 10
+max_result_chars = 8000
+
+[backend.vllm]
+mode = "managed"
+host = "127.0.0.1"
+port = 40223
+cmd = "vllm"
+extra_args = ["--max-num-seqs", "1", "--enable-log-requests", "--stream-interval", "1"]
+base_url = ""
+api_key = ""
+timeout_s = 900
+generation_config = "vllm"
+attention_backend = ""
+dtype = "bfloat16"
+enable_auto_tool_choice = true
+tool_call_parser = "qwen3_xml"
+log_file = ""
+served_model_name = "Qwen3.5-9B"
+tensor_parallel_size = 1
+gpu_memory_utilization = 0.933
+max_model_len = 21120
diff --git a/models/Qwen3.5-9B/vllm/config/profiles/fast.toml b/models/Qwen3.5-9B/vllm/config/profiles/fast.toml
new file mode 100644
index 0000000..95fcf1f
--- /dev/null
+++ b/models/Qwen3.5-9B/vllm/config/profiles/fast.toml
@@ -0,0 +1,25 @@
+[gen]
+# Leave model/prompt/ui in base `default.toml`; this profile focuses on throughput.
+max_new_tokens = 8192
+
+[backend.vllm]
+# Fast profile philosophy:
+# - Keep `max_model_len` modest to reduce KV pressure.
+# - Avoid `--enforce-eager` to allow CUDA-graph/compilation paths when they work.
+extra_args = [
+  "--max-num-seqs", "1",
+  "--max-num-batched-tokens", "16384",
+  "--stream-interval", "8",
+  "--enable-prefix-caching",
+  "--max-cudagraph-capture-size", "256",
+  "--kv-cache-dtype", "auto",
+  "--block-size", "32",
+  # If you want to hard-cap KV cache size instead of using gpu_memory_utilization:
+  # "--kv-cache-memory-bytes", "12G",
+  "--disable-log-stats",
+  # "--no-enable-log-requests",
+  "--disable-uvicorn-access-log",
+  "--enable-force-include-usage",  
+]
+gpu_memory_utilization = 0.92
+max_model_len = 16384
diff --git a/models/Qwen3.5-9B/vllm/config/profiles/lg_ctx.toml b/models/Qwen3.5-9B/vllm/config/profiles/lg_ctx.toml
new file mode 100644
index 0000000..a094e9f
--- /dev/null
+++ b/models/Qwen3.5-9B/vllm/config/profiles/lg_ctx.toml
@@ -0,0 +1,25 @@
+[gen]
+# Leave model/prompt/ui in base `default.toml`; this profile focuses on context capacity.
+max_new_tokens = 1024
+
+[backend.vllm]
+# Large-context profile philosophy:
+# - Reserve more VRAM for KV (gpu_memory_utilization + higher max_model_len).
+# - Leave CPU offload disabled so it's VRAM-only ("fits or fails").
+extra_args = [
+  "--max-num-seqs", "1",
+  "--enable-chunked-prefill",
+  "--long-prefill-token-threshold", "2048",
+  "--max-num-batched-tokens", "8192",
+  "--stream-interval", "4",
+  "--enable-prefix-caching",
+  "--kv-cache-dtype", "auto",
+  "--block-size", "16",
+  # If you want to hard-cap KV cache size instead of using gpu_memory_utilization:
+  # "--kv-cache-memory-bytes", "16G",
+  "--disable-log-stats",
+  "--no-enable-log-requests",
+  "--disable-uvicorn-access-log",
+]
+gpu_memory_utilization = 0.96
+max_model_len = 32768
diff --git a/models/Qwen3.5-9B/vllm/notes/README.md b/models/Qwen3.5-9B/vllm/notes/README.md
new file mode 100644
index 0000000..89baa03
--- /dev/null
+++ b/models/Qwen3.5-9B/vllm/notes/README.md
@@ -0,0 +1,117 @@
+# Qwen3.5-9B (vLLM) — performance playground notes
+
+This file is intentionally *vLLM-specific*. Model card + HF-specific details live in:
+- `models/Qwen3.5-9B/hf/notes/README.md`
+
+## Why vLLM (vs HF/Transformers loop)
+vLLM is a serving-oriented engine. The main things you can learn/tune here that aren’t “just Transformers knobs”:
+- Scheduler + batching: `--max-num-seqs`, `--max-num-batched-tokens`, `--stream-interval`
+- KV cache control: `--gpu-memory-utilization`, `--kv-cache-memory-bytes`, `--block-size`, `--kv-cache-dtype`
+- Prefix caching: `--enable-prefix-caching`
+- CUDA graphs / compilation: enabled when **not** passing `--enforce-eager`
+
+## Profiles
+These configs are intended as tight starting points for experiments:
+
+### Fast throughput (“see how fast it can go”)
+- Profile: `fast`
+- Run:
+  - `python tui.py --backend vllm --config Qwen3.5-9B --profile fast`
+
+What it does:
+- Keeps `max_model_len` modest (`8192`) to reduce KV cache pressure.
+- Pushes throughput knobs (`--stream-interval`, `--max-num-batched-tokens`, CUDA graph capture size, no request/stats/access logging).
+- Enables prefix caching.
+- Avoids `--enforce-eager` to keep CUDA-graph/compile paths available.
+
+### Large context (“see how far before OOM”)
+- Profile: `lg_ctx`
+- Run:
+  - `python tui.py --backend vllm --config Qwen3.5-9B --profile lg_ctx`
+
+What it does:
+- Increases `max_model_len` (`32768`) and KV reservation (via `gpu_memory_utilization`).
+- Enables chunked prefill to make long prompts less painful.
+- Leaves CPU offload disabled so it “fits or fails” on VRAM only.
+
+## Knobs (what they do + what to try)
+
+### Streaming overhead vs “smoothness”
+- `--stream-interval` (default `1`)
+  - Bigger = fewer SSE frames = lower CPU/host overhead and often higher throughput, but “bursty” streaming.
+  - Try: `1` (smooth) → `4` (good) → `8` (fastest-feeling but chunky).
+
+### Scheduler / batching (even with `max-num-seqs=1` these matter)
+- `--max-num-seqs`
+  - Max concurrent requests the server will schedule.
+  - For single-user TUI benchmarking: keep at `1`.
+- `--max-num-batched-tokens`
+  - Upper bound for tokens processed per engine iteration (prefill + decode).
+  - Bigger can improve throughput, but increases burstiness and can increase peak memory.
+  - Try: `4096`, `8192`, `16384` (if you’re not OOM’ing during long prefill).
+
+### KV cache: the “context budget” levers
+- `backend.vllm.max_model_len`
+  - Hard cap for prompt+generation tokens *that vLLM will accept*.
+  - This is your “how far can I push context” dial.
+- `--gpu-memory-utilization`
+  - Fraction of VRAM vLLM is allowed to use.
+  - Bigger usually = more KV cache = higher sustainable context, but too high can make startup fragile.
+  - Try: `0.90` → `0.94` → `0.96` → `0.98` (watch for allocator/cudagraph OOM).
+- `--kv-cache-memory-bytes`
+  - Directly sets KV cache size; **overrides** `--gpu-memory-utilization`.
+  - Use when you want deterministic KV sizing while you vary other stuff.
+  - Example: `--kv-cache-memory-bytes 16G`
+- `--kv-cache-dtype`
+  - `auto` uses model dtype. You asked *not* to quantize KV for this model, so keep `auto` (or `bfloat16`).
+  - FP8 KV (`fp8*`) can unlock more context, but changes quality/behavior and is its own experiment.
+- `--block-size {8,16,32}`
+  - KV cache granularity. Smaller may reduce fragmentation but can increase overhead.
+  - Try: `32` for throughput, `16` if you’re chasing tight-fit contexts.
+
+### Long-context latency helpers
+- `--enable-chunked-prefill`
+  - Big win for “huge prompt” responsiveness: it slices prefill work into chunks bounded by `--max-num-batched-tokens`.
+- `--long-prefill-token-threshold`
+  - Only treat prompts longer than this as “long” for chunked prefill behavior.
+  - Try: `1024` or `2048`.
+
+### CUDA graphs / compilation
+- `--enforce-eager`
+  - Passing this disables cudagraph/compile paths (more stable, often slower).
+  - For “go fast”, do **not** pass it.
+- `--max-cudagraph-capture-size`
+  - Caps which batch sizes get captured; lower reduces capture time/VRAM overhead.
+  - Try: `256` (fast startup) vs `512` (potentially more benefit).
+
+### Logging noise (benchmarking vs debugging)
+- `--enable-log-requests` / `--no-enable-log-requests`
+- `--disable-log-stats`
+- `--disable-uvicorn-access-log`
+  - Turn these off for perf experiments; turn on selectively when debugging.
+
+## “How do I push it?” (suggested experiment loops)
+- Throughput sweep:
+  1) keep `max_model_len=8192`
+  2) try `stream_interval=1 → 4 → 8`
+  3) try `max_num_batched_tokens=4096 → 8192 → 16384`
+  4) toggle `enable_prefix_caching` on/off
+- Context sweep:
+  1) raise `max_model_len` in steps: `16384 → 32768 → 49152 → 65536`
+  2) raise `gpu_memory_utilization` gradually (`0.92 → 0.96 → 0.98`)
+  3) keep CPU offload disabled so failures are obvious
+
+## Gotchas
+- Only set `gen.truncate_prompt_tokens` if you intentionally want vLLM to truncate your prompt; an overly-aggressive value can lead to
+  “The decoder prompt cannot be empty”.
+- This repo uses a sentinel: `gen.top_k = -1` means “don’t send `top_k` in the vLLM payload”.
+- When benchmarking, disable noisy request logging (`--enable-log-requests`) and stats logs unless you’re actively debugging.
+
+## Results log (fill this in as you test)
+- `fast`:
+  - tokens/s:
+  - notes:
+- `lg_ctx`:
+  - max prompt tokens before failure:
+  - tokens/s at 16k/32k:
+  - notes:
diff --git a/models/Qwen3.5-9B/vllm/notes/tool-calls.md b/models/Qwen3.5-9B/vllm/notes/tool-calls.md
new file mode 100644
index 0000000..1de386a
--- /dev/null
+++ b/models/Qwen3.5-9B/vllm/notes/tool-calls.md
@@ -0,0 +1,81 @@
+# Tool Calls per the model itself 
+
+Here's how you can integrate me with **OpenClaw** and your **vLLM** setup:
+
+### 1. vLLM + OpenAI-Compatible API
+Ensure your vLLM backend exposes the proper API:
+```bash
+python -m vllm.entrypoints.api_server \
+    --model Qwen/Qwen3.5 \
+    --host 0.0.0.0 \
+    --port 8000 \
+    --api-key YOUR_API_KEY \
+    --max-model-len 8192 \
+    --gpu-memory-utilization 0.9
+```
+This exposes the `/chat/completions` endpoint compatible with OpenAI's API specification.
+
+### 2. Tool Schema Injection in OpenClaw
+OpenClaw injects tool schemas automatically. As long as you pass your tool definitions in the `messages` payload, I'll respect them:
+
+**Example Tool Schema (JSON Schema):**
+```json
+{
+  "name": "fetch_stock_data",
+  "description": "Fetch stock data for a symbol",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "symbol": {"type": "string", "description": "Stock ticker symbol"}
+    },
+    "required": ["symbol"]
+  }
+}
+```
+
+**OpenClaw Payload Example:**
+```json
+{
+  "messages": [
+    {"role": "user", "content": "Check AAPL stock trends"},
+    {"role": "system", "content": "You are an agent. Use tools when needed."}
+  ],
+  "tools": [{"type": "function", "function": {...}}]
+}
+```
+
+### 3. Aggressive Tool Management
+For your aggressive tool management, I'll:
+- ✅ **Strictly follow schema** (no hallucinations in parameters)
+- ✅ **Refuse/Retry** invalid tool calls gracefully
+- ✅ **Chain tools** in sequence if needed (A → B → C)
+
+**Example:**
+```
+User: "Analyze AAPL and MSFT"
+→ Tool A: fetch_stock_data(AAPL)
+→ Tool B: fetch_stock_data(MSFT)
+→ Tool C: compare_data(results)
+→ Final: Summary
+```
+
+### 4. OpenClaw Integration Checklist
+| Requirement | Status | Notes |
+|-------------|--------|-------|
+| OpenAI-Compatible API | ✅ | vLLM supports it |
+| Tool Schema Injection | ✅ | Pass in `messages` |
+| Tool Execution | ⚠️ | You handle local tool calls |
+| Error Handling | ✅ | I'll self-correct |
+| Multi-step Reasoning | ✅ | I'll chain tools |
+
+### 5. vLLM Configuration for Tool Use
+To optimize for tool call performance, consider:
+```yaml
+# vLLM config.json
+"max_model_len": 8192
+"max_num_batched_tokens": 8192
+"max_num_seqs": 256
+"enforce_eager": true
+"seed": 42
+"disable_log_stats": true
+```
diff --git a/models/Qwen3.5-9B/vllm/prompts/README.md b/models/Qwen3.5-9B/vllm/prompts/README.md
new file mode 100644
index 0000000..f09e233
--- /dev/null
+++ b/models/Qwen3.5-9B/vllm/prompts/README.md
@@ -0,0 +1,4 @@
+# Qwen3.5-9B prompts (vllm)
+
+This folder is for prompt assets (system prompts, few-shots, tool schemas).
+It may be git-ignored except for this README.
diff --git a/models/Qwen3.5-9B/vllm/templates/README.md b/models/Qwen3.5-9B/vllm/templates/README.md
new file mode 100644
index 0000000..0fda796
--- /dev/null
+++ b/models/Qwen3.5-9B/vllm/templates/README.md
@@ -0,0 +1,3 @@
+# Qwen3.5-9B templates (vllm)
+
+This folder is for prompt/template overrides or experiments.
diff --git a/models/README.md b/models/README.md
index f2af8ff..ab35d6e 100644
--- a/models/README.md
+++ b/models/README.md
@@ -1,6 +1,26 @@
 # Models
 
-This folder is the model-first workspace for metadata and tooling around each model you test.
+This folder is the model-first control plane for `model-runner`.
+
+Keep durable authored metadata here:
+- backend config
+- notes
+- prompts
+- templates
+- compressor recipes
+
+Do not treat this folder as the place for:
+- weights
+- quant outputs
+- calibration datasets
+- telemetry
+- transcripts
+- logs
+
+Those belong outside the repo:
+- `~/models` for weights and quantized artifacts
+- `~/data/model-runner` for durable input datasets
+- `~/runs/model-runner` for generated output
 
 Each model gets its own directory, with backend-specific subfolders.
 
@@ -23,3 +43,14 @@ Shared assets:
 
 Templates:
 - `models/_TEMPLATE/<backend>/...` contains starter files for new models.
+
+## Mental Model
+
+Use this split:
+
+- repo `models/` = what you know about a model
+- `~/models` = the actual model assets
+- `~/data/model-runner` = reusable input data
+- `~/runs/model-runner` = generated output
+
+That keeps the repo navigable while preserving the model-first workflow.
diff --git a/models/_TEMPLATE/exl2/config/config.json b/models/_TEMPLATE/exl2/config/config.json
index ab69207..eacdd6e 100644
--- a/models/_TEMPLATE/exl2/config/config.json
+++ b/models/_TEMPLATE/exl2/config/config.json
@@ -1,6 +1,7 @@
 {
   "model_id": "",
   "model_path": "",
+  "exl2_log_file": "",
   "stream": true,
   "max_new_tokens": 2048,
   "temperature": 0.7,
@@ -20,6 +21,7 @@
   "show_thinking": false,
   "no_animate_thinking": false,
   "save_transcript": "",
+  "capture_last_request": false,
   "assume_think": false,
   "max_seq_len": null,
   "min_free_tokens": 256,
diff --git a/models/_TEMPLATE/exl2/config/default.toml b/models/_TEMPLATE/exl2/config/default.toml
new file mode 100644
index 0000000..eb1a8a9
--- /dev/null
+++ b/models/_TEMPLATE/exl2/config/default.toml
@@ -0,0 +1,50 @@
+[model]
+id = ""
+
+[gen]
+max_new_tokens = 2048
+repetition_penalty = 1.0
+stream = true
+temperature = 0.7
+top_p = 1.0
+
+[prompt]
+chat_template = ""
+prompt_mode = "chat"
+system = ""
+system_file = ""
+user_prefix = ""
+
+[ui]
+assume_think = false
+history_strip_think = false
+no_animate_thinking = false
+save_transcript = ""
+capture_last_request = false
+show_thinking = false
+show_tool_activity = false
+show_tool_arguments = false
+
+[telemetry]
+jsonl = ""
+sample_interval_s = 1.0
+
+[tools]
+enabled = false
+mode = "dry_run"
+schema_file = ""
+allow = []
+deny = []
+max_calls_per_turn = 3
+timeout_s = 10
+max_result_chars = 8000
+
+[backend.exl2]
+cache_type = "fp16"
+exl2_repeat_streak_max = 64
+exl2_repo_path = ""
+gpu_split = ""
+log_file = ""
+low_mem = false
+min_free_tokens = 256
+model_path = ""
diff --git a/models/_TEMPLATE/gguf/config/config.json b/models/_TEMPLATE/gguf/config/config.json
index 5f51624..239a6e9 100644
--- a/models/_TEMPLATE/gguf/config/config.json
+++ b/models/_TEMPLATE/gguf/config/config.json
@@ -1,6 +1,7 @@
 {
   "model_id": "",
   "model_path": "",
+  "gguf_log_file": "",
   "stream": true,
   "max_new_tokens": 2048,
   "seed": null,
@@ -25,6 +26,7 @@
   "show_thinking": false,
   "no_animate_thinking": false,
   "save_transcript": "",
+  "capture_last_request": false,
   "assume_think": false,
   "n_ctx": 4096,
   "n_batch": null,
diff --git a/models/_TEMPLATE/gguf/config/default.toml b/models/_TEMPLATE/gguf/config/default.toml
new file mode 100644
index 0000000..af34f12
--- /dev/null
+++ b/models/_TEMPLATE/gguf/config/default.toml
@@ -0,0 +1,57 @@
+[model]
+id = ""
+
+[gen]
+max_new_tokens = 2048
+repetition_penalty = 1.0
+stream = true
+temperature = 0.7
+top_p = 1.0
+
+[prompt]
+chat_template = ""
+prompt_mode = "chat"
+system = ""
+system_file = ""
+user_prefix = ""
+
+[ui]
+assume_think = false
+history_strip_think = false
+no_animate_thinking = false
+save_transcript = ""
+capture_last_request = false
+scroll_lines = 1
+show_thinking = false
+show_tool_activity = false
+show_tool_arguments = false
+ui_max_events_per_tick = 120
+ui_tick_ms = 33
+
+[telemetry]
+jsonl = ""
+sample_interval_s = 1.0
+
+[tools]
+enabled = false
+mode = "dry_run"
+schema_file = ""
+allow = []
+deny = []
+max_calls_per_turn = 3
+timeout_s = 10
+max_result_chars = 8000
+
+[backend.gguf]
+model_path = ""
+n_ctx = 4096
+n_gpu_layers = -1
+log_file = ""
+rope_freq_base = 0.0
+rope_freq_scale = 0.0
+rope_scaling_type = -1
+yarn_attn_factor = 1.0
+yarn_beta_fast = 32.0
+yarn_beta_slow = 1.0
+yarn_ext_factor = -1.0
+yarn_orig_ctx = 0
diff --git a/models/_TEMPLATE/hf/config/config.json b/models/_TEMPLATE/hf/config/config.json
index ccd295f..ede14ef 100644
--- a/models/_TEMPLATE/hf/config/config.json
+++ b/models/_TEMPLATE/hf/config/config.json
@@ -1,6 +1,8 @@
 {
   "model_id": "",
   "dtype": "auto",
+  "hf_log_file": "",
+  "hf_attn_implementation": null,
   "use_8bit": false,
   "use_4bit": false,
   "stream": false,
@@ -27,6 +29,7 @@
   "show_thinking": false,
   "no_animate_thinking": false,
   "save_transcript": "",
+  "capture_last_request": false,
   "assume_think": false,
   "scroll_lines": 1,
   "ui_tick_ms": 33,
diff --git a/models/_TEMPLATE/hf/config/default.toml b/models/_TEMPLATE/hf/config/default.toml
new file mode 100644
index 0000000..1cda0d5
--- /dev/null
+++ b/models/_TEMPLATE/hf/config/default.toml
@@ -0,0 +1,58 @@
+[model]
+id = ""
+
+[gen]
+max_new_tokens = 2048
+no_repeat_ngram_size = 0
+num_beams = 1
+repetition_penalty = 1.0
+stream = false
+temperature = 0.7
+top_p = 1.0
+
+[prompt]
+chat_template = ""
+prompt_mode = "chat"
+prompt_prefix = ""
+system = ""
+system_file = ""
+user_prefix = ""
+
+[ui]
+assume_think = false
+history_strip_think = false
+hide_think = false
+no_animate_thinking = false
+save_transcript = ""
+capture_last_request = false
+scroll_lines = 1
+show_thinking = false
+show_tool_activity = false
+show_tool_arguments = false
+strict_think_strip = false
+ui_max_events_per_tick = 120
+ui_tick_ms = 33
+
+[telemetry]
+jsonl = ""
+sample_interval_s = 1.0
+
+[tools]
+enabled = false
+mode = "dry_run"
+schema_file = ""
+allow = []
+deny = []
+max_calls_per_turn = 3
+timeout_s = 10
+max_result_chars = 8000
+
+[backend.hf]
+dtype = "auto"
+device_map = ""
+max_memory = ""
+low_cpu_mem_usage = false
+text_only = false
+use_4bit = false
+use_8bit = false
+log_file = ""
diff --git a/models/_TEMPLATE/hf/notes/README.md b/models/_TEMPLATE/hf/notes/README.md
index 375acd1..dad00df 100644
--- a/models/_TEMPLATE/hf/notes/README.md
+++ b/models/_TEMPLATE/hf/notes/README.md
@@ -1,5 +1,8 @@
 # <Model Name>
 
+Optional (recommended for HF models): save the upstream Hugging Face model card as:
+- `notes/model_card.md`
+
 ## Where
 - HF ID:
 - Local path:
@@ -81,4 +84,3 @@ python chat.py <name_or_path> ...
 - Proposed flag:
   - Why:
   - Expected impact:
-
diff --git a/models/_TEMPLATE/ollama/config/config.json b/models/_TEMPLATE/ollama/config/config.json
index c033c3f..7567603 100644
--- a/models/_TEMPLATE/ollama/config/config.json
+++ b/models/_TEMPLATE/ollama/config/config.json
@@ -12,10 +12,12 @@
   "show_thinking": false,
   "no_animate_thinking": false,
   "save_transcript": "",
+  "capture_last_request": false,
   "assume_think": false,
   "ollama_host": null,
   "ollama_timeout": 600,
   "ollama_think": "auto",
+  "ollama_log_file": "",
   "scroll_lines": 9,
   "ui_tick_ms": 33,
   "ui_max_events_per_tick": 33
diff --git a/models/_TEMPLATE/ollama/config/default.toml b/models/_TEMPLATE/ollama/config/default.toml
new file mode 100644
index 0000000..dcc0986
--- /dev/null
+++ b/models/_TEMPLATE/ollama/config/default.toml
@@ -0,0 +1,46 @@
+[model]
+id = ""
+
+[gen]
+max_new_tokens = 2048
+stream = true
+temperature = 0.7
+top_p = 1.0
+
+[prompt]
+chat_template = ""
+system = ""
+system_file = ""
+user_prefix = ""
+
+[ui]
+assume_think = false
+history_strip_think = false
+no_animate_thinking = false
+save_transcript = ""
+capture_last_request = false
+scroll_lines = 9
+show_thinking = false
+show_tool_activity = false
+show_tool_arguments = false
+ui_max_events_per_tick = 33
+ui_tick_ms = 33
+
+[telemetry]
+jsonl = ""
+sample_interval_s = 1.0
+
+[tools]
+enabled = false
+mode = "dry_run"
+schema_file = ""
+allow = []
+deny = []
+max_calls_per_turn = 3
+timeout_s = 10
+max_result_chars = 8000
+
+[backend.ollama]
+think_mode = "auto"
+timeout = 600
+log_file = ""
diff --git a/models/_TEMPLATE/openai/config/default.toml b/models/_TEMPLATE/openai/config/default.toml
new file mode 100644
index 0000000..4d613e1
--- /dev/null
+++ b/models/_TEMPLATE/openai/config/default.toml
@@ -0,0 +1,49 @@
+[model]
+id = ""
+
+[gen]
+stream = true
+max_new_tokens = 1024
+temperature = 0.7
+top_p = 1.0
+stop_strings = []
+
+[prompt]
+chat_template = ""
+system = ""
+system_file = ""
+user_prefix = ""
+
+[ui]
+show_thinking = true
+assume_think = false
+history_strip_think = false
+no_animate_thinking = false
+save_transcript = ""
+capture_last_request = false
+scroll_lines = 9
+show_tool_activity = false
+show_tool_arguments = false
+ui_tick_ms = 33
+ui_max_events_per_tick = 120
+
+[telemetry]
+jsonl = ""
+sample_interval_s = 1.0
+
+[tools]
+enabled = false
+mode = "dry_run"
+schema_file = ""
+tool_choice = ""
+allow = []
+deny = []
+max_calls_per_turn = 3
+timeout_s = 10
+max_result_chars = 8000
+
+[backend.openai]
+base_url = ""
+api_key = ""
+timeout_s = 600
+log_file = ""
diff --git a/models/_TEMPLATE/openai/notes/README.md b/models/_TEMPLATE/openai/notes/README.md
new file mode 100644
index 0000000..2fbd662
--- /dev/null
+++ b/models/_TEMPLATE/openai/notes/README.md
@@ -0,0 +1,3 @@
+# openai backend notes template
+
+Use this folder for OpenAI-compatible server notes (vLLM/OpenAI-compatible endpoints), model IDs, and local setup details.
diff --git a/models/_TEMPLATE/vllm/config/default.toml b/models/_TEMPLATE/vllm/config/default.toml
new file mode 100644
index 0000000..0714b56
--- /dev/null
+++ b/models/_TEMPLATE/vllm/config/default.toml
@@ -0,0 +1,79 @@
+[model]
+id = ""
+
+[gen]
+stream = true
+max_new_tokens = 8192
+temperature = 0.6
+top_p = 1.0
+top_k = -1
+min_p = 0.05
+repetition_penalty = 0.0
+presence_penalty = 0.2
+frequency_penalty = 0.0
+stop_strings = []
+stop_token_ids = []
+ignore_eos = false
+min_tokens = 0
+best_of = 1
+use_beam_search = false
+length_penalty = 1.0
+include_stop_str_in_output = false
+skip_special_tokens = true
+spaces_between_special_tokens = true
+truncate_prompt_tokens = 0
+allowed_token_ids = []
+prompt_logprobs = 0
+
+[prompt]
+chat_template = ""
+system = ""
+system_file = ""
+user_prefix = ""
+
+[ui]
+show_thinking = false
+assume_think = false
+history_strip_think = true
+no_animate_thinking = false
+save_transcript = ""
+capture_last_request = true
+scroll_lines = 9
+show_tool_activity = false
+show_tool_arguments = false
+ui_tick_ms = 33
+ui_max_events_per_tick = 120
+
+[telemetry]
+jsonl = ""
+sample_interval_s = 1.0
+
+[tools]
+enabled = true
+mode = "execute"
+schema_file = ""
+allow = []
+deny = []
+max_calls_per_turn = 3
+timeout_s = 10
+max_result_chars = 8000
+
+[backend.vllm]
+mode = "managed"
+host = "127.0.0.1"
+port = 40223
+cmd = "vllm"
+extra_args = ["--max-num-seqs", "1", "--enable-log-requests", "--stream-interval", "1", "--kv-cache-dtype", "fp8"]
+base_url = ""
+api_key = ""
+timeout_s = 900
+generation_config = "vllm"
+attention_backend = ""
+dtype = "bfloat16"
+# enable_auto_tool_choice = true
+tool_call_parser = ""
+log_file = ""
+served_model_name = ""
+tensor_parallel_size = 1
+gpu_memory_utilization = 0.95
+# max_model_len = 131072
\ No newline at end of file
diff --git a/models/_TEMPLATE/vllm/notes/README.md b/models/_TEMPLATE/vllm/notes/README.md
new file mode 100644
index 0000000..bd93acf
--- /dev/null
+++ b/models/_TEMPLATE/vllm/notes/README.md
@@ -0,0 +1,3 @@
+# vLLM backend notes
+
+Use this folder for backend-specific notes (launch caveats, tuning, known good profiles).
diff --git a/models/ds32b-alex/ollama/config/default.toml b/models/ds32b-alex/ollama/config/default.toml
new file mode 100644
index 0000000..020c7ee
--- /dev/null
+++ b/models/ds32b-alex/ollama/config/default.toml
@@ -0,0 +1,47 @@
+[model]
+id = "ollama:ds32b-alex"
+
+[gen]
+max_new_tokens = 2048
+stream = true
+temperature = 0.7
+top_k = 320
+top_p = 0.95
+
+[prompt]
+chat_template = ""
+system = ""
+system_file = ""
+user_prefix = "I am a consenting adult. "
+
+[ui]
+assume_think = true
+history_strip_think = false
+no_animate_thinking = false
+save_transcript = ""
+capture_last_request = false
+scroll_lines = 9
+show_thinking = false
+show_tool_activity = false
+show_tool_arguments = false
+ui_max_events_per_tick = 33
+ui_tick_ms = 33
+
+[telemetry]
+jsonl = ""
+sample_interval_s = 1.0
+
+[tools]
+enabled = false
+mode = "dry_run"
+schema_file = ""
+allow = []
+deny = []
+max_calls_per_turn = 3
+timeout_s = 10
+max_result_chars = 8000
+
+[backend.ollama]
+think_mode = "false"
+timeout = 600
+log_file = ""
diff --git a/models/ds32b-base/gguf/config/config.json b/models/ds32b-base/gguf/config/config.json
index 4cc08c9..9f4f07a 100644
--- a/models/ds32b-base/gguf/config/config.json
+++ b/models/ds32b-base/gguf/config/config.json
@@ -1,6 +1,6 @@
 {
   "model_id": "ds32b-base",
-  "model_path": "/mnt/d/AI/Local Models/lmstudio-community/DeepSeek-R1-Distill-Qwen-32B-GGUF/DeepSeek-R1-Distill-Qwen-32B-Q4_K_M.gguf",
+  "model_path": "lmstudio-community/DeepSeek-R1-Distill-Qwen-32B-GGUF/DeepSeek-R1-Distill-Qwen-32B-Q4_K_M.gguf",
   "stream": true,
   "max_new_tokens": 2048,
   "seed": null,
diff --git a/models/ds32b-base/gguf/config/default.toml b/models/ds32b-base/gguf/config/default.toml
new file mode 100644
index 0000000..47571f2
--- /dev/null
+++ b/models/ds32b-base/gguf/config/default.toml
@@ -0,0 +1,59 @@
+[model]
+id = "ds32b-base"
+
+[gen]
+max_new_tokens = 2048
+min_p = 0.03
+repetition_penalty = 1.08
+stream = true
+temperature = 0.7
+top_k = 80
+top_p = 0.95
+
+[prompt]
+chat_template = ""
+prompt_mode = "chat"
+system = ""
+system_file = ""
+user_prefix = ""
+
+[ui]
+assume_think = false
+history_strip_think = false
+no_animate_thinking = false
+save_transcript = ""
+capture_last_request = false
+scroll_lines = 9
+show_thinking = false
+show_tool_activity = false
+show_tool_arguments = false
+ui_max_events_per_tick = 60
+ui_tick_ms = 33
+
+[telemetry]
+jsonl = ""
+sample_interval_s = 1.0
+
+[tools]
+enabled = false
+mode = "dry_run"
+schema_file = ""
+allow = []
+deny = []
+max_calls_per_turn = 3
+timeout_s = 10
+max_result_chars = 8000
+
+[backend.gguf]
+model_path = "lmstudio-community/DeepSeek-R1-Distill-Qwen-32B-GGUF/DeepSeek-R1-Distill-Qwen-32B-Q4_K_M.gguf"
+log_file = ""
+n_ctx = 24576
+n_gpu_layers = -1
+rope_freq_base = 0.0
+rope_freq_scale = 0.0
+rope_scaling_type = -1
+yarn_attn_factor = 1.0
+yarn_beta_fast = 32.0
+yarn_beta_slow = 1.0
+yarn_ext_factor = -1.0
+yarn_orig_ctx = 0
diff --git a/models/gemma-3-27b-it-abliterated-exl2/exl2/config/config.json b/models/gemma-3-27b-it-abliterated-exl2/exl2/config/config.json
index 620b2f1..f547e89 100644
--- a/models/gemma-3-27b-it-abliterated-exl2/exl2/config/config.json
+++ b/models/gemma-3-27b-it-abliterated-exl2/exl2/config/config.json
@@ -1,6 +1,6 @@
 {
   "model_id": "gemma-3-27b-it-abliterated-exl2",
-  "model_path": "~/ml/models",
+  "model_path": "",
   "stream": true,
   "max_new_tokens": 2048,
   "temperature": 0.7,
diff --git a/models/gemma-3-27b-it-abliterated-exl2/exl2/config/default.toml b/models/gemma-3-27b-it-abliterated-exl2/exl2/config/default.toml
new file mode 100644
index 0000000..a1e7468
--- /dev/null
+++ b/models/gemma-3-27b-it-abliterated-exl2/exl2/config/default.toml
@@ -0,0 +1,59 @@
+[model]
+id = "gemma-3-27b-it-abliterated-exl2"
+
+[gen]
+frequency_penalty = 0.0
+max_new_tokens = 8192
+presence_penalty = 0.0
+repetition_penalty = 1.025
+stream = true
+temperature = 0.6
+top_k = 64
+top_p = 0.9
+
+[prompt]
+chat_template = "models/gemma-3-27b-it-abliterated-exl2/exl2/templates/gemma_chat_sanitized.jinja"
+prompt_mode = "chat"
+system = ""
+system_file = ""
+user_prefix = ""
+
+[ui]
+assume_think = true
+history_strip_think = false
+no_animate_thinking = false
+save_transcript = ""
+capture_last_request = false
+scroll_lines = 9
+show_thinking = true
+show_tool_activity = false
+show_tool_arguments = false
+ui_max_events_per_tick = 33
+ui_tick_ms = 33
+
+[telemetry]
+jsonl = ""
+sample_interval_s = 1.0
+
+[tools]
+enabled = false
+mode = "dry_run"
+schema_file = ""
+allow = []
+deny = []
+max_calls_per_turn = 3
+timeout_s = 10
+max_result_chars = 8000
+
+[backend.exl2]
+cache_type = "fp16"
+exl2_repeat_streak_max = 64
+exl2_repo_path = ""
+exl2_stop_tokens = ["<end_of_turn>", "<start_of_turn>"]
+gpu_split = ""
+log_file = ""
+low_mem = false
+max_seq_len = 32768
+min_free_tokens = 256
+model_path = ""
+flash_attn = true
diff --git a/models/models--coder3101--gemma-4-E4B-it-heretic/vllm/config/default.toml b/models/models--coder3101--gemma-4-E4B-it-heretic/vllm/config/default.toml
new file mode 100644
index 0000000..f25f798
--- /dev/null
+++ b/models/models--coder3101--gemma-4-E4B-it-heretic/vllm/config/default.toml
@@ -0,0 +1,83 @@
+[model]
+id = "models--coder3101--gemma-4-E4B-it-heretic"
+
+[gen]
+stream = true
+max_new_tokens = 16348
+temperature = 1.2
+# top_p = 1.0
+top_k = 64
+min_p = 0.05
+# repetition_penalty = 0.0
+presence_penalty = 0.75
+# frequency_penalty = 0.0
+stop_strings = []
+stop_token_ids = []
+ignore_eos = false
+min_tokens = 0
+best_of = 1
+use_beam_search = false
+# length_penalty = 1.0
+include_stop_str_in_output = false
+# skip_special_tokens = true
+spaces_between_special_tokens = true
+truncate_prompt_tokens = 0
+allowed_token_ids = []
+prompt_logprobs = 0
+
+[prompt]
+chat_template = ""
+system = ""
+system_file = "models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/prompts/system.txt"
+user_prefix = ""
+
+[ui]
+show_thinking = false
+assume_think = false
+history_strip_think = true
+no_animate_thinking = false
+save_transcript = ""
+capture_last_request = true
+scroll_lines = 9
+show_tool_activity = false
+show_tool_arguments = false
+ui_tick_ms = 33
+ui_max_events_per_tick = 120
+
+[telemetry]
+jsonl = ""
+sample_interval_s = 1.0
+
+[tools]
+enabled = false
+mode = "execute"
+tool_choice = "auto"
+schema_file = ""
+allow = []
+deny = []
+max_calls_per_turn = 3
+timeout_s = 10
+max_result_chars = 8000
+
+[backend.vllm]
+mode = "managed"
+host = "127.0.0.1"
+port = 40223
+cmd = "vllm"
+extra_args = ["--max-num-seqs", "1", "--enable-log-requests", "--stream-interval", "1"]
+base_url = ""
+api_key = ""
+timeout_s = 900
+generation_config = "auto"
+attention_backend = ""
+dtype = "bfloat16"
+kv_cache_dtype = "fp8-e4m3"
+performance_mode = "interactivity"
+enable_auto_tool_choice = true
+tool_call_parser = "gemma4"
+reasoning_parser = "gemma4"
+log_file = ""
+served_model_name = ""
+tensor_parallel_size = 1
+gpu_memory_utilization = 0.95
+max_model_len = 131072
\ No newline at end of file
diff --git a/models/models--coder3101--gemma-4-E4B-it-heretic/vllm/config/profiles/fast.toml b/models/models--coder3101--gemma-4-E4B-it-heretic/vllm/config/profiles/fast.toml
new file mode 100644
index 0000000..a299998
--- /dev/null
+++ b/models/models--coder3101--gemma-4-E4B-it-heretic/vllm/config/profiles/fast.toml
@@ -0,0 +1,2 @@
+[gen]
+max_new_tokens = 1024
diff --git a/models/models--coder3101--gemma-4-E4B-it-heretic/vllm/config/profiles/longctx.toml b/models/models--coder3101--gemma-4-E4B-it-heretic/vllm/config/profiles/longctx.toml
new file mode 100644
index 0000000..ee4e986
--- /dev/null
+++ b/models/models--coder3101--gemma-4-E4B-it-heretic/vllm/config/profiles/longctx.toml
@@ -0,0 +1,2 @@
+[gen]
+max_new_tokens = 2048
diff --git a/models/models--coder3101--gemma-4-E4B-it-heretic/vllm/notes/README.md b/models/models--coder3101--gemma-4-E4B-it-heretic/vllm/notes/README.md
new file mode 100644
index 0000000..bd93acf
--- /dev/null
+++ b/models/models--coder3101--gemma-4-E4B-it-heretic/vllm/notes/README.md
@@ -0,0 +1,3 @@
+# vLLM backend notes
+
+Use this folder for backend-specific notes (launch caveats, tuning, known good profiles).
diff --git a/models/models--coder3101--gemma-4-E4B-it-heretic/vllm/prompts/README.md b/models/models--coder3101--gemma-4-E4B-it-heretic/vllm/prompts/README.md
new file mode 100644
index 0000000..a55936f
--- /dev/null
+++ b/models/models--coder3101--gemma-4-E4B-it-heretic/vllm/prompts/README.md
@@ -0,0 +1,4 @@
+# models--coder3101--gemma-4-E4B-it-heretic prompts (vllm)
+
+This folder is for prompt assets (system prompts, few-shots, tool schemas).
+It may be git-ignored except for this README.
diff --git a/models/models--coder3101--gemma-4-E4B-it-heretic/vllm/templates/README.md b/models/models--coder3101--gemma-4-E4B-it-heretic/vllm/templates/README.md
new file mode 100644
index 0000000..be44f0a
--- /dev/null
+++ b/models/models--coder3101--gemma-4-E4B-it-heretic/vllm/templates/README.md
@@ -0,0 +1,3 @@
+# models--coder3101--gemma-4-E4B-it-heretic templates (vllm)
+
+This folder is for prompt/template overrides or experiments.
diff --git a/models/models--google--gemma-4-E4B-it/vllm/config/default.toml b/models/models--google--gemma-4-E4B-it/vllm/config/default.toml
new file mode 100644
index 0000000..77f7ab7
--- /dev/null
+++ b/models/models--google--gemma-4-E4B-it/vllm/config/default.toml
@@ -0,0 +1,81 @@
+[model]
+id = "models--google--gemma-4-E4B-it"
+
+[gen]
+stream = true
+max_new_tokens = 8192
+# temperature = 1.0
+# top_p = 1.0
+# top_k = -1
+# min_p = 0.05
+# repetition_penalty = 0.0
+# presence_penalty = 0.2
+# frequency_penalty = 0.0
+stop_strings = []
+stop_token_ids = []
+ignore_eos = false
+min_tokens = 0
+best_of = 1
+use_beam_search = false
+length_penalty = 1.0
+include_stop_str_in_output = false
+skip_special_tokens = true
+spaces_between_special_tokens = true
+truncate_prompt_tokens = 0
+allowed_token_ids = []
+prompt_logprobs = 0
+
+[prompt]
+chat_template = ""
+system = ""
+system_file = "models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/prompts/system.txt"
+user_prefix = ""
+
+[ui]
+show_thinking = false
+assume_think = false
+history_strip_think = true
+no_animate_thinking = false
+save_transcript = ""
+capture_last_request = true
+scroll_lines = 9
+show_tool_activity = false
+show_tool_arguments = false
+ui_tick_ms = 33
+ui_max_events_per_tick = 120
+
+[telemetry]
+jsonl = ""
+sample_interval_s = 1.0
+
+[tools]
+enabled = true
+mode = "execute"
+tool_choice = "auto"
+schema_file = ""
+allow = []
+deny = []
+max_calls_per_turn = 3
+timeout_s = 10
+max_result_chars = 8000
+
+[backend.vllm]
+mode = "managed"
+host = "127.0.0.1"
+port = 40223
+cmd = "vllm"
+extra_args = ["--max-num-seqs", "1", "--enable-log-requests", "--stream-interval", "1"]
+base_url = ""
+api_key = ""
+timeout_s = 900
+generation_config = "auto"
+attention_backend = ""
+dtype = "bfloat16"
+performance_mode = "interactivity"
+enable_auto_tool_choice = true
+tool_call_parser = "gemma4"
+log_file = ""
+served_model_name = ""
+tensor_parallel_size = 1
+gpu_memory_utilization = 0.95
+# max_model_len = 131072
\ No newline at end of file
diff --git a/models/models--google--gemma-4-E4B-it/vllm/config/profiles/fast.toml b/models/models--google--gemma-4-E4B-it/vllm/config/profiles/fast.toml
new file mode 100644
index 0000000..a299998
--- /dev/null
+++ b/models/models--google--gemma-4-E4B-it/vllm/config/profiles/fast.toml
@@ -0,0 +1,2 @@
+[gen]
+max_new_tokens = 1024
diff --git a/models/models--google--gemma-4-E4B-it/vllm/config/profiles/longctx.toml b/models/models--google--gemma-4-E4B-it/vllm/config/profiles/longctx.toml
new file mode 100644
index 0000000..ee4e986
--- /dev/null
+++ b/models/models--google--gemma-4-E4B-it/vllm/config/profiles/longctx.toml
@@ -0,0 +1,2 @@
+[gen]
+max_new_tokens = 2048
diff --git a/models/models--google--gemma-4-E4B-it/vllm/notes/README.md b/models/models--google--gemma-4-E4B-it/vllm/notes/README.md
new file mode 100644
index 0000000..bd93acf
--- /dev/null
+++ b/models/models--google--gemma-4-E4B-it/vllm/notes/README.md
@@ -0,0 +1,3 @@
+# vLLM backend notes
+
+Use this folder for backend-specific notes (launch caveats, tuning, known good profiles).
diff --git a/models/models--google--gemma-4-E4B-it/vllm/notes/model_card.md b/models/models--google--gemma-4-E4B-it/vllm/notes/model_card.md
new file mode 100644
index 0000000..e8abaaf
--- /dev/null
+++ b/models/models--google--gemma-4-E4B-it/vllm/notes/model_card.md
@@ -0,0 +1,515 @@
+---
+library_name: transformers
+license: apache-2.0
+license_link: https://ai.google.dev/gemma/docs/gemma_4_license
+pipeline_tag: any-to-any
+---
+
+<div align="center">
+  <img src=https://ai.google.dev/gemma/images/gemma4_banner.png>
+</div>
+
+
+<p align="center">
+    <a href="https://huggingface.co/collections/google/gemma-4" target="_blank">Hugging Face</a> |
+    <a href="https://github.com/google-gemma" target="_blank">GitHub</a> |
+    <a href="https://blog.google/innovation-and-ai/technology/developers-tools/gemma-4/" target="_blank">Launch Blog</a> |
+    <a href="https://ai.google.dev/gemma/docs/core" target="_blank">Documentation</a>
+    <br>
+    <b>License</b>: <a href="https://ai.google.dev/gemma/docs/gemma_4_license" target="_blank">Apache 2.0</a> | <b>Authors</b>: <a href="https://deepmind.google/models/gemma/" target="_blank">Google DeepMind</a>
+</p>
+
+Gemma is a family of open models built by Google DeepMind. Gemma 4 models are multimodal, handling text and image input (with audio supported on small models) and generating text output. This release includes open-weights models in both pre-trained and instruction-tuned variants. Gemma 4 features a context window of up to 256K tokens and maintains multilingual support in over 140 languages. 
+
+Featuring both Dense and Mixture-of-Experts (MoE) architectures, Gemma 4 is well-suited for tasks like text generation, coding, and reasoning. The models are available in four distinct sizes: **E2B**, **E4B**, **26B A4B**, and **31B**. Their diverse sizes make them deployable in environments ranging from high-end phones to laptops and servers, democratizing access to state-of-the-art AI.
+
+Gemma 4 introduces key **capability and architectural advancements**:
+
+* **Reasoning** – All models in the family are designed as highly capable reasoners, with configurable thinking modes.
+
+* **Extended Multimodalities** – Processes Text, Image with variable aspect ratio and resolution support (all models), Video, and Audio (featured natively on the E2B and E4B models).
+
+* **Diverse & Efficient Architectures** – Offers Dense and Mixture-of-Experts (MoE) variants of different sizes for scalable deployment.
+
+* **Optimized for On-Device** – Smaller models are specifically designed for efficient local execution on laptops and mobile devices.
+
+* **Increased Context Window** – The small models feature a 128K context window, while the medium models support 256K.
+
+* **Enhanced Coding & Agentic Capabilities** – Achieves notable improvements in coding benchmarks alongside native function-calling support, powering highly capable autonomous agents.
+
+* **Native System Prompt Support** – Gemma 4 introduces native support for the `system` role, enabling more structured and controllable conversations.
+
+## **Models Overview**
+
+Gemma 4 models are designed to deliver frontier-level performance at each size, targeting deployment scenarios from mobile and edge devices (E2B, E4B) to consumer GPUs and workstations (26B A4B, 31B). They are well-suited for reasoning, agentic workflows, coding, and multimodal understanding.
+
+The models employ a hybrid attention mechanism that interleaves local sliding window attention with full global attention, ensuring the final layer is always global. This hybrid design delivers the processing speed and low memory footprint of a lightweight model without sacrificing the deep awareness required for complex, long-context tasks. To optimize memory for long contexts, global layers feature unified Keys and Values, and apply Proportional RoPE (p-RoPE). 
+
+### Dense Models
+
+| Property | E2B | E4B | 31B Dense |
+| :---- | :---- | :---- | :---- |
+| **Total Parameters** | 2.3B effective (5.1B with embeddings) | 4.5B effective (8B with embeddings) | 30.7B |
+| **Layers** | 35 | 42 | 60 |
+| **Sliding Window** | 512 tokens | 512 tokens | 1024 tokens |
+| **Context Length** | 128K tokens | 128K tokens | 256K tokens  |
+| **Vocabulary Size** | 262K | 262K | 262K |
+| **Supported Modalities** | Text, Image, Audio | Text, Image, Audio | Text, Image |
+| **Vision Encoder Parameters** | *~150M* | *~150M* | *~550M* |
+| **Audio Encoder Parameters** | *~300M* | *~300M* | No Audio |
+
+The "E" in E2B and E4B stands for "effective" parameters. The smaller models incorporate Per-Layer Embeddings (PLE) to maximize parameter efficiency in on-device deployments. Rather than adding more layers or parameters to the model, PLE gives each decoder layer its own small embedding for every token. These embedding tables are large but are only used for quick lookups, which is why the effective parameter count is much smaller than the total.
+
+### Mixture-of-Experts (MoE) Model
+
+| Property | 26B A4B MoE |
+| :---- | :---- |
+| **Total Parameters** | 25.2B |
+| **Active Parameters** | 3.8B |
+| **Layers** | 30 |
+| **Sliding Window** | 1024 tokens |
+| **Context Length** | 256K tokens |
+| **Vocabulary Size** | 262K |
+| **Expert Count** | 8 active / 128 total and 1 shared |
+| **Supported Modalities** | Text, Image |
+| **Vision Encoder Parameters** | *~550M* |
+
+The "A" in 26B A4B stands for "active parameters" in contrast to the total number of parameters the model contains. By only activating a 4B subset of parameters during inference, the Mixture-of-Experts model runs much faster than its 26B total might suggest. This makes it an excellent choice for fast inference compared to the dense 31B model since it runs almost as fast as a 4B-parameter model.
+
+## **Benchmark Results** 
+
+These models were evaluated against a large collection of different datasets and metrics to cover different aspects of text generation. Evaluation results marked in the table are for instruction-tuned models.
+
+|  | Gemma 4  31B | Gemma 4  26B A4B | Gemma 4  E4B | Gemma 4  E2B | Gemma 3  27B (no think) |
+| :---- | :---- | :---- | :---- | :---- | :---- |
+| MMLU Pro | 85.2% | 82.6% | 69.4% | 60.0% | 67.6% |
+| AIME 2026 no tools | 89.2% | 88.3% | 42.5% | 37.5% | 20.8% |
+| LiveCodeBench v6 | 80.0% | 77.1% | 52.0% | 44.0% | 29.1% |
+| Codeforces ELO | 2150 | 1718 | 940 | 633 | 110 |
+| GPQA Diamond | 84.3% | 82.3% | 58.6% | 43.4% | 42.4% |
+| Tau2 (average over 3) | 76.9% | 68.2% | 42.2% | 24.5% | 16.2% |
+| HLE no tools | 19.5% | 8.7% | - | - | - |
+| HLE with search | 26.5% | 17.2% | - | - | - |
+| BigBench Extra Hard | 74.4% | 64.8% | 33.1% | 21.9% | 19.3% |
+| MMMLU | 88.4% | 86.3% | 76.6% | 67.4% | 70.7% |
+| **Vision** |  |  |  |  |  |
+| MMMU Pro | 76.9% | 73.8% | 52.6% | 44.2% | 49.7% |
+| OmniDocBench 1.5 (average edit distance, lower is better) | 0.131 | 0.149 | 0.181 | 0.290 | 0.365 |
+| MATH-Vision | 85.6% | 82.4% | 59.5% | 52.4% | 46.0% |
+| MedXPertQA MM | 61.3% | 58.1% | 28.7% | 23.5% | - |
+| **Audio** |  |  |  |  |  |
+| CoVoST | - | - | 35.54 | 33.47 | - |
+| FLEURS (lower is better) | - | - | 0.08 | 0.09 | - |
+| **Long Context** |  |  |  |  |  |
+| MRCR v2 8 needle 128k (average) | 66.4% | 44.1%  | 25.4% | 19.1% | 13.5% |
+
+## **Core Capabilities**
+
+Gemma 4 models handle a broad range of tasks across text, vision, and audio. Key capabilities include:
+
+* **Thinking** – Built-in reasoning mode that lets the model think step-by-step before answering.
+* **Long Context** – Context windows of up to 128K tokens (E2B/E4B) and 256K tokens (26B A4B/31B).
+* **Image Understanding** – Object detection, Document/PDF parsing, screen and UI understanding, chart comprehension, OCR (including multilingual), handwriting recognition, and pointing. Images can be processed at variable aspect ratios and resolutions.
+* **Video Understanding** – Analyze video by processing sequences of frames.
+* **Interleaved Multimodal Input** – Freely mix text and images in any order within a single prompt.
+* **Function Calling** – Native support for structured tool use, enabling agentic workflows.
+* **Coding** – Code generation, completion, and correction.
+* **Multilingual** – Out-of-the-box support for 35+ languages, pre-trained on 140+ languages.
+* **Audio** (E2B and E4B only) – Automatic speech recognition (ASR) and speech-to-translated-text translation across multiple languages.
+
+
+## Getting Started
+
+You can use all Gemma 4 models with the latest version of Transformers. To get started, install the necessary dependencies in your environment:
+
+`pip install -U transformers torch accelerate`
+
+Once you have everything installed, you can proceed to load the model with the code below:
+
+```python
+from transformers import AutoProcessor, AutoModelForCausalLM
+
+MODEL_ID = "google/gemma-4-E4B-it"
+
+# Load model
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+model = AutoModelForCausalLM.from_pretrained(
+    MODEL_ID,
+    dtype="auto",
+    device_map="auto"
+)
+```
+
+Once the model is loaded, you can start generating output:
+
+```python
+# Prompt
+messages = [
+    {"role": "system", "content": "You are a helpful assistant."},
+    {"role": "user", "content": "Write a short joke about saving RAM."},
+]
+
+# Process input
+text = processor.apply_chat_template(
+    messages, 
+    tokenize=False, 
+    add_generation_prompt=True, 
+    enable_thinking=False
+)
+inputs = processor(text=text, return_tensors="pt").to(model.device)
+input_len = inputs["input_ids"].shape[-1]
+
+# Generate output
+outputs = model.generate(**inputs, max_new_tokens=1024)
+response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
+
+# Parse output
+processor.parse_response(response)
+```
+
+To enable reasoning, set `enable_thinking=True` and the `parse_response` function will take care of parsing the thinking output.
+
+Below, you will also find snippets for processing audio (E2B and E4B only), images, and video alongside text:
+
+<details>
+<summary>Code for processing Audio</summary>
+
+Instead of using `AutoModelForCausalLM`, you can use `AutoModelForMultimodalLM` to process audio. To use it, make sure to install the following packages:
+
+
+`pip install -U transformers torch torchvision librosa accelerate`
+
+You can then load the model with the code below:
+
+```python
+from transformers import AutoProcessor, AutoModelForMultimodalLM
+
+MODEL_ID = "google/gemma-4-E4B-it"
+
+# Load model
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+model = AutoModelForMultimodalLM.from_pretrained(
+    MODEL_ID, 
+    dtype="auto", 
+    device_map="auto"
+)
+```
+
+Once the model is loaded, you can start generating output by directly referencing the audio URL in the prompt:
+
+
+```python
+# Prompt - add audio before text
+messages = [
+    {
+        "role": "user",
+        "content": [
+            {"type": "audio", "audio": "https://raw.githubusercontent.com/google-gemma/cookbook/refs/heads/main/Demos/sample-data/journal1.wav"},
+            {"type": "text", "text": "Transcribe the following speech segment in its original language. Follow these specific instructions for formatting the answer:\n* Only output the transcription, with no newlines.\n* When transcribing numbers, write the digits, i.e. write 1.7 and not one point seven, and write 3 instead of three."},
+        ]
+    }
+]
+
+# Process input
+inputs = processor.apply_chat_template(
+    messages,
+    tokenize=True,
+    return_dict=True,
+    return_tensors="pt",
+    add_generation_prompt=True,
+).to(model.device)
+input_len = inputs["input_ids"].shape[-1]
+
+# Generate output
+outputs = model.generate(**inputs, max_new_tokens=512)
+response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
+
+# Parse output
+processor.parse_response(response)
+```
+
+</details>
+
+<details>
+<summary>Code for processing Images</summary>
+
+Instead of using `AutoModelForCausalLM`, you can use `AutoModelForMultimodalLM` to process images. To use it, make sure to install the following packages:
+
+
+`pip install -U transformers torch torchvision accelerate`
+
+You can then load the model with the code below:
+
+```python
+from transformers import AutoProcessor, AutoModelForMultimodalLM
+
+MODEL_ID = "google/gemma-4-E4B-it"
+
+# Load model
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+model = AutoModelForMultimodalLM.from_pretrained(
+    MODEL_ID, 
+    dtype="auto", 
+    device_map="auto"
+)
+```
+
+Once the model is loaded, you can start generating output by directly referencing the image URL in the prompt:
+
+
+```python
+# Prompt - add image before text
+messages = [
+    {
+        "role": "user", "content": [
+            {"type": "image", "url": "https://raw.githubusercontent.com/google-gemma/cookbook/refs/heads/main/Demos/sample-data/GoldenGate.png"},
+            {"type": "text", "text": "What is shown in this image?"}
+        ]
+    }
+]
+
+# Process input
+inputs = processor.apply_chat_template(
+    messages,
+    tokenize=True,
+    return_dict=True,
+    return_tensors="pt",
+    add_generation_prompt=True,
+).to(model.device)
+input_len = inputs["input_ids"].shape[-1]
+
+# Generate output
+outputs = model.generate(**inputs, max_new_tokens=512)
+response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
+
+# Parse output
+processor.parse_response(response)
+```
+
+</details>
+
+
+<details>
+<summary>Code for processing Videos</summary>
+
+Instead of using `AutoModelForCausalLM`, you can use `AutoModelForMultimodalLM` to process videos. To use it, make sure to install the following packages:
+
+`pip install -U transformers torch torchvision librosa accelerate`
+
+You can then load the model with the code below:
+
+```python
+from transformers import AutoProcessor, AutoModelForMultimodalLM
+
+MODEL_ID = "google/gemma-4-E4B-it"
+
+# Load model
+processor = AutoProcessor.from_pretrained(MODEL_ID)
+model = AutoModelForMultimodalLM.from_pretrained(
+    MODEL_ID, 
+    dtype="auto", 
+    device_map="auto"
+)
+```
+
+Once the model is loaded, you can start generating output by directly referencing the video URL in the prompt:
+
+
+```python
+# Prompt - add video before text
+messages = [
+    {
+        'role': 'user',
+        'content': [
+            {"type": "video", "video": "https://github.com/bebechien/gemma/raw/refs/heads/main/videos/ForBiggerBlazes.mp4"},
+            {'type': 'text', 'text': 'Describe this video.'}
+        ]
+    }
+]
+
+# Process input
+inputs = processor.apply_chat_template(
+    messages,
+    tokenize=True,
+    return_dict=True,
+    return_tensors="pt",
+    add_generation_prompt=True,
+).to(model.device)
+input_len = inputs["input_ids"].shape[-1]
+
+# Generate output
+outputs = model.generate(**inputs, max_new_tokens=512)
+response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
+
+# Parse output
+processor.parse_response(response)
+```
+
+</details>
+
+
+
+## **Best Practices**
+
+For the best performance, use these configurations and best practices:
+
+### 1. Sampling Parameters
+
+Use the following standardized sampling configuration across all use cases:
+
+* `temperature=1.0`  
+* `top_p=0.95`  
+* `top_k=64`
+
+### 2. Thinking Mode Configuration
+
+Compared to Gemma 3, the models use standard `system`, `assistant`, and `user` roles. To properly manage the thinking process, use the following control tokens:
+
+* **Trigger Thinking:** Thinking is enabled by including the `<|think|>` token at the start of the system prompt. To disable thinking, remove the token.   
+* **Standard Generation:** When thinking is enabled, the model will output its internal reasoning followed by the final answer using this structure:  
+  `<|channel>thought\n`**[Internal reasoning]**`<channel|>`  
+* **Disabled Thinking Behavior:** For all models except for the E2B and E4B variants, if thinking is disabled, the model will still generate the tags but with an empty thought block:  
+  `<|channel>thought\n<channel|>`**[Final answer]**
+
+> [!Note]
+> Note that many libraries like Transformers and llama.cpp handle the complexities of the chat template for you.
+
+### 3. Multi-Turn Conversations
+
+* **No Thinking Content in History**: In multi-turn conversations, the historical model output should only include the final response. Thoughts from previous model turns must *not be added* before the next user turn begins.
+
+### 4. Modality order
+
+* For optimal performance with multimodal inputs, place image and/or audio content **before** the text in your prompt. 
+
+### 5. Variable Image Resolution
+
+Aside from variable aspect ratios, Gemma 4 supports variable image resolution through a configurable visual token budget, which controls how many tokens are used to represent an image. A higher token budget preserves more visual detail at the cost of additional compute, while a lower budget enables faster inference for tasks that don't require fine-grained understanding.
+
+* The supported token budgets are: **70**, **140**, **280**, **560**, and **1120**.  
+  * Use *lower budgets* for classification, captioning, or video understanding, where faster inference and processing many frames outweigh fine-grained detail.   
+  * Use *higher budgets* for tasks like OCR, document parsing, or reading small text.
+
+### 6. Audio
+
+Use the following prompt structures for audio processing:
+
+* **Audio Speech Recognition (ASR)**
+
+```text
+Transcribe the following speech segment in {LANGUAGE} into {LANGUAGE} text.
+
+Follow these specific instructions for formatting the answer:
+* Only output the transcription, with no newlines.
+* When transcribing numbers, write the digits, i.e. write 1.7 and not one point seven, and write 3 instead of three.
+```
+
+* **Automatic Speech Translation (AST)**
+
+```text
+Transcribe the following speech segment in {SOURCE_LANGUAGE}, then translate it into {TARGET_LANGUAGE}.
+When formatting the answer, first output the transcription in {SOURCE_LANGUAGE}, then one newline, then output the string '{TARGET_LANGUAGE}: ', then the translation in {TARGET_LANGUAGE}.
+```
+
+### 7. Audio and Video Length
+
+All models support image inputs and can process videos as frames whereas the E2B and E4B models also support audio inputs. Audio supports a maximum length of 30 seconds. Video supports a maximum of 60 seconds assuming the images are processed at one frame per second.
+
+## **Model Data**
+
+Data used for model training and how the data was processed.
+
+### **Training Dataset**
+
+Our pre-training dataset is a large-scale, diverse collection of data encompassing a wide range of domains and modalities, which includes web documents, code, images, audio, with a cutoff date of January 2025. Here are the key components:
+
+* **Web Documents**: A diverse collection of web text ensures the model is exposed to a broad range of linguistic styles, topics, and vocabulary. The training dataset includes content in over 140 languages.  
+* **Code**: Exposing the model to code helps it to learn the syntax and patterns of programming languages, which improves its ability to generate code and understand code-related questions.  
+* **Mathematics**: Training on mathematical text helps the model learn logical reasoning, symbolic representation, and to address mathematical queries.  
+* **Images**: A wide range of images enables the model to perform image analysis and visual data extraction tasks.
+
+The combination of these diverse data sources is crucial for training a powerful multimodal model that can handle a wide variety of different tasks and data formats.
+
+### **Data Preprocessing**
+
+Here are the key data cleaning and filtering methods applied to the training data:
+
+* **CSAM Filtering**: Rigorous CSAM (Child Sexual Abuse Material) filtering was applied at multiple stages in the data preparation process to ensure the exclusion of harmful and illegal content.  
+* **Sensitive Data Filtering**: As part of making Gemma pre-trained models safe and reliable, automated techniques were used to filter out certain personal information and other sensitive data from training sets.  
+* **Additional methods**: Filtering based on content quality and safety in line with [our policies](https://ai.google/static/documents/ai-responsibility-update-published-february-2025.pdf).
+
+## **Ethics and Safety**
+
+As open models become central to enterprise infrastructure, provenance and security are paramount. Developed by Google DeepMind, Gemma 4 undergoes the same rigorous safety evaluations as our proprietary Gemini models. 
+
+### **Evaluation Approach**
+
+Gemma 4 models were developed in partnership with internal safety and responsible AI teams. A range of automated as well as human evaluations were conducted to help improve model safety. These evaluations align with [Google’s AI principles](https://ai.google/principles/), as well as safety policies, which aim to prevent our generative AI models from generating harmful content, including:
+
+* Content related to child sexual abuse material and exploitation   
+* Dangerous content (e.g., promoting suicide, or instructing in activities that could cause real-world harm)   
+* Sexually explicit content  
+* Hate speech (e.g., dehumanizing members of protected groups)   
+* Harassment (e.g., encouraging violence against people)
+
+### **Evaluation Results**
+
+For all areas of safety testing, we saw major improvements in all categories of content safety relative to previous Gemma models. Overall, Gemma 4 models significantly outperform Gemma 3 and 3n models in improving safety, while keeping unjustified refusals low. All testing was conducted without safety filters to evaluate the model capabilities and behaviors. For both text-to-text and image-to-text, and across all model sizes, the model produced minimal policy violations, and showed significant improvements over previous Gemma models' performance. 
+
+## **Usage and Limitations**
+
+These models have certain limitations that users should be aware of.
+
+### **Intended Usage**
+
+Multimodal models (capable of processing vision, language, and/or audio) have a wide range of applications across various industries and domains. The following list of potential uses is not comprehensive. The purpose of this list is to provide contextual information about the possible use-cases that the model creators considered as part of model training and development.
+
+* **Content Creation and Communication**  
+  * **Text Generation**: These models can be used to generate creative text formats such as poems, scripts, code, marketing copy, and email drafts.  
+  * **Chatbots and Conversational AI**: Power conversational interfaces for customer service, virtual assistants, or interactive applications.  
+  * **Text Summarization**: Generate concise summaries of a text corpus, research papers, or reports.  
+  * **Image Data Extraction**: These models can be used to extract, interpret, and summarize visual data for text communications.  
+  * **Audio Processing and Interaction**: The smaller models (E2B and E4B) can analyze and interpret audio inputs, enabling voice-driven interactions and transcriptions.  
+* **Research and Education**  
+  * **Natural Language Processing (NLP) and VLM Research**: These models can serve as a foundation for researchers to experiment with VLM and NLP techniques, develop algorithms, and contribute to the advancement of the field.  
+  * **Language Learning Tools**: Support interactive language learning experiences, aiding in grammar correction or providing writing practice.  
+  * **Knowledge Exploration**: Assist researchers in exploring large bodies of text by generating summaries or answering questions about specific topics.
+
+### **Limitations**
+
+* **Training Data**  
+  * The quality and diversity of the training data significantly influence the model's capabilities. Biases or gaps in the training data can lead to limitations in the model's responses.  
+  * The scope of the training dataset determines the subject areas the model can handle effectively.  
+* **Context and Task Complexity**  
+  * Models perform well on tasks that can be framed with clear prompts and instructions. Open-ended or highly complex tasks might be challenging.  
+  * A model's performance can be influenced by the amount of context provided (longer context generally leads to better outputs, up to a certain point).  
+* **Language Ambiguity and Nuance**  
+  * Natural language is inherently complex. Models might struggle to grasp subtle nuances, sarcasm, or figurative language.  
+* **Factual Accuracy**  
+  * Models generate responses based on information they learned from their training datasets, but they are not knowledge bases. They may generate incorrect or outdated factual statements.  
+* **Common Sense**  
+  * Models rely on statistical patterns in language. They might lack the ability to apply common sense reasoning in certain situations.
+
+### **Ethical Considerations and Risks**
+
+The development of vision-language models (VLMs) raises several ethical concerns. In creating an open model, we have carefully considered the following:
+
+* **Bias and Fairness**  
+  * VLMs trained on large-scale, real-world text and image data can reflect socio-cultural biases embedded in the training material. Gemma 4 models underwent careful scrutiny, input data pre-processing, and post-training evaluations as reported in this card to help mitigate the risk of these biases.  
+* **Misinformation and Misuse**  
+  * VLMs can be misused to generate text that is false, misleading, or harmful.  
+  * Guidelines are provided for responsible use with the model, see the [Responsible Generative AI Toolkit](https://ai.google.dev/responsible).  
+* **Transparency and Accountability**  
+  * This model card summarizes details on the models' architecture, capabilities, limitations, and evaluation processes.  
+  * A responsibly developed open model offers the opportunity to share innovation by making VLM technology accessible to developers and researchers across the AI ecosystem.
+
+**Risks identified and mitigations**:
+
+* **Generation of harmful content**: Mechanisms and guidelines for content safety are essential. Developers are encouraged to exercise caution and implement appropriate content safety safeguards based on their specific product policies and application use cases.  
+* **Misuse for malicious purposes**: Technical limitations and developer and end-user education can help mitigate against malicious applications of VLMs. Educational resources and reporting mechanisms for users to flag misuse are provided.   
+* **Privacy violations**: Models were trained on data filtered for removal of certain personal information and other sensitive data. Developers are encouraged to adhere to privacy regulations with privacy-preserving techniques.  
+* **Perpetuation of biases**: It's encouraged to perform continuous monitoring (using evaluation metrics, human review) and the exploration of de-biasing techniques during model training, fine-tuning, and other use cases.
+
+### **Benefits**
+
+At the time of release, this family of models provides high-performance open vision-language model implementations designed from the ground up for responsible AI development compared to similarly sized models.
diff --git a/models/models--google--gemma-4-E4B-it/vllm/prompts/README.md b/models/models--google--gemma-4-E4B-it/vllm/prompts/README.md
new file mode 100644
index 0000000..17d665a
--- /dev/null
+++ b/models/models--google--gemma-4-E4B-it/vllm/prompts/README.md
@@ -0,0 +1,4 @@
+# models--google--gemma-4-E4B-it prompts (vllm)
+
+This folder is for prompt assets (system prompts, few-shots, tool schemas).
+It may be git-ignored except for this README.
diff --git a/models/models--google--gemma-4-E4B-it/vllm/templates/README.md b/models/models--google--gemma-4-E4B-it/vllm/templates/README.md
new file mode 100644
index 0000000..97a8288
--- /dev/null
+++ b/models/models--google--gemma-4-E4B-it/vllm/templates/README.md
@@ -0,0 +1,3 @@
+# models--google--gemma-4-E4B-it templates (vllm)
+
+This folder is for prompt/template overrides or experiments.
diff --git a/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/config/default.toml b/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/config/default.toml
new file mode 100644
index 0000000..afa6bee
--- /dev/null
+++ b/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/config/default.toml
@@ -0,0 +1,52 @@
+[model]
+id = "models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2"
+
+[gen]
+max_new_tokens = 8192
+repetition_penalty = 1.0
+stream = true
+temperature = 0.9
+top_p = 0.8
+
+[prompt]
+chat_template = ""
+prompt_mode = "chat"
+system = ""
+system_file = ""
+user_prefix = ""
+
+[ui]
+assume_think = false
+history_strip_think = false
+no_animate_thinking = false
+save_transcript = ""
+capture_last_request = false
+show_thinking = false
+show_tool_activity = false
+show_tool_arguments = false
+
+[telemetry]
+jsonl = ""
+sample_interval_s = 1.0
+
+[tools]
+enabled = false
+mode = "dry_run"
+schema_file = ""
+allow = []
+deny = []
+max_calls_per_turn = 3
+timeout_s = 10
+max_result_chars = 8000
+
+[backend.exl2]
+cache_type = "fp16"
+exl2_repeat_streak_max = 64
+exl2_repo_path = ""
+gpu_split = ""
+log_file = ""
+low_mem = false
+max_seq_len = 65536
+min_free_tokens = 256
+model_path = ""
+sdpa = true
diff --git a/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/config/profiles/fast.toml b/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/config/profiles/fast.toml
new file mode 100644
index 0000000..a299998
--- /dev/null
+++ b/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/config/profiles/fast.toml
@@ -0,0 +1,2 @@
+[gen]
+max_new_tokens = 1024
diff --git a/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/config/profiles/longctx.toml b/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/config/profiles/longctx.toml
new file mode 100644
index 0000000..ee4e986
--- /dev/null
+++ b/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/config/profiles/longctx.toml
@@ -0,0 +1,2 @@
+[gen]
+max_new_tokens = 2048
diff --git a/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/notes/README.md b/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/notes/README.md
new file mode 100644
index 0000000..c00d014
--- /dev/null
+++ b/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/notes/README.md
@@ -0,0 +1,25 @@
+# EXL2 Model Notes Template
+
+Use this as a starting point for `models/<model_name>/exl2/notes/README.md`.
+
+## Where
+- Local path:
+- Runner: `tui.py` (`--backend exl2`)
+
+## What it is
+- Base architecture (if known):
+- Quantization / format notes:
+
+## Templates
+- Active template file:
+- Notes about role markers / special tokens:
+- Any history sanitation (e.g. strip pre-`</think>`):
+
+## Recommended commands
+- `tui --backend exl2 "<model_dir>" ...`
+
+## Known issues / symptoms
+- Symptom:
+- Likely cause:
+- Fix / workaround:
+
diff --git a/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/prompts/README.md b/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/prompts/README.md
new file mode 100644
index 0000000..aac5b48
--- /dev/null
+++ b/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/prompts/README.md
@@ -0,0 +1,4 @@
+# models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2 prompts (exl2)
+
+This folder is for prompt assets (system prompts, few-shots, tool schemas).
+It may be git-ignored except for this README.
diff --git a/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/templates/README.md b/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/templates/README.md
new file mode 100644
index 0000000..4494cc4
--- /dev/null
+++ b/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/templates/README.md
@@ -0,0 +1,3 @@
+# models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2 templates (exl2)
+
+This folder is for prompt/template overrides or experiments.
diff --git a/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/templates/current.jinja b/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/templates/current.jinja
new file mode 100644
index 0000000..d67fa8f
--- /dev/null
+++ b/models/models--riveRiPH--Forgotten-Safeword-12B-v4.0-EXL2/exl2/templates/current.jinja
@@ -0,0 +1,36 @@
+{#-
+EXL2 default chat template (minimal + safe).
+
+This is a generic fallback. Many EXL2 models ship a better chat template in
+`tokenizer_config.json` (field: `chat_template`). If `chat_template` is empty in config,
+the EXL2 backend will try that first.
+
+This template also sanitizes assistant history: if an assistant message contains `</think>`,
+only replay the content after the final `</think>` into the next prompt.
+-#}
+
+{%- set ns = namespace(system_prompt="") -%}
+{%- for message in messages -%}
+  {%- if message["role"] == "system" -%}
+    {%- set ns.system_prompt = message["content"] -%}
+  {%- endif -%}
+{%- endfor -%}
+
+{{- bos_token -}}
+{%- if ns.system_prompt -%}
+System: {{ ns.system_prompt }}
+{%- endif -%}
+
+{%- for message in messages -%}
+  {%- if message["role"] == "user" -%}
+User: {{ message["content"] }}
+  {%- elif message["role"] == "assistant" and message.get("content") -%}
+    {%- set content = message["content"] -%}
+    {%- if "</think>" in content -%}
+      {%- set content = content.split("</think>")[-1] -%}
+    {%- endif -%}
+Assistant: {{ content }}
+  {%- endif -%}
+{%- endfor -%}
+
+Assistant:
diff --git a/models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/config/default.toml b/models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/config/default.toml
new file mode 100644
index 0000000..5a549e3
--- /dev/null
+++ b/models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/config/default.toml
@@ -0,0 +1,80 @@
+[model]
+id = "models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic"
+
+[gen]
+stream = true
+max_new_tokens = 8192
+temperature = 1.2
+top_p = 0.99
+top_k = 320
+min_p = 0.03
+repetition_penalty = 1.0
+presence_penalty = 1.1
+frequency_penalty = 0.0
+stop_strings = []
+stop_token_ids = []
+ignore_eos = false
+min_tokens = 0
+best_of = 1
+use_beam_search = false
+length_penalty = 1.0
+include_stop_str_in_output = false
+skip_special_tokens = true
+spaces_between_special_tokens = true
+truncate_prompt_tokens = 0
+allowed_token_ids = []
+prompt_logprobs = 0
+
+[prompt]
+chat_template = ""
+system = ""
+system_file = "models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/prompts/system.txt"
+user_prefix = ""
+
+[ui]
+show_thinking = true
+assume_think = false
+history_strip_think = false
+no_animate_thinking = false
+save_transcript = ""
+capture_last_request = true
+scroll_lines = 9
+show_tool_activity = false
+show_tool_arguments = false
+ui_tick_ms = 33
+ui_max_events_per_tick = 120
+
+[telemetry]
+jsonl = ""
+sample_interval_s = 1.0
+
+[tools]
+enabled = false
+mode = "dry_run"
+schema_file = ""
+tool_choice = ""
+allow = []
+deny = []
+max_calls_per_turn = 3
+timeout_s = 10
+max_result_chars = 8002
+
+[backend.vllm]
+mode = "managed"
+host = "127.0.0.1"
+port = 40223
+cmd = "env PYTORCH_ALLOC_CONF=expandable_segments:True VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 vllm"
+extra_args = ["--kv-cache-dtype", "fp8", "--enforce-eager"]
+base_url = ""
+api_key = ""
+timeout_s = 900
+generation_config = "vllm"
+attention_backend = ""
+dtype = ""
+enable_auto_tool_choice = false
+tool_call_parser = ""
+log_file = ""
+served_model_name = "Aethora"
+tensor_parallel_size = 1
+gpu_memory_utilization = 0.95
+max_model_len = 52784
diff --git a/models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/config/profiles/fast.toml b/models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/config/profiles/fast.toml
new file mode 100644
index 0000000..a299998
--- /dev/null
+++ b/models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/config/profiles/fast.toml
@@ -0,0 +1,2 @@
+[gen]
+max_new_tokens = 1024
diff --git a/models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/config/profiles/longctx.toml b/models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/config/profiles/longctx.toml
new file mode 100644
index 0000000..ee4e986
--- /dev/null
+++ b/models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/config/profiles/longctx.toml
@@ -0,0 +1,2 @@
+[gen]
+max_new_tokens = 2048
diff --git a/models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/notes/README.md b/models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/notes/README.md
new file mode 100644
index 0000000..bd93acf
--- /dev/null
+++ b/models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/notes/README.md
@@ -0,0 +1,3 @@
+# vLLM backend notes
+
+Use this folder for backend-specific notes (launch caveats, tuning, known good profiles).
diff --git a/models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/prompts/README.md b/models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/prompts/README.md
new file mode 100644
index 0000000..c8aa1ff
--- /dev/null
+++ b/models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/prompts/README.md
@@ -0,0 +1,4 @@
+# models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic prompts (vllm)
+
+This folder is for prompt assets (system prompts, few-shots, tool schemas).
+It may be git-ignored except for this README.
diff --git a/models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/templates/README.md b/models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/templates/README.md
new file mode 100644
index 0000000..f3b7f25
--- /dev/null
+++ b/models/models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic/vllm/templates/README.md
@@ -0,0 +1,3 @@
+# models--sh0ck0r--L3-Aethora-15B-FP8-Dynamic templates (vllm)
+
+This folder is for prompt/template overrides or experiments.
diff --git a/pyproject.toml b/pyproject.toml
index f8a3383..f2c9400 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -7,12 +7,51 @@ name = "model-runner"
 version = "0.0.0"
 description = "Lightweight local model runner scripts (HF, GGUF, Ollama) with a unified Textual TUI."
 readme = "README.md"
-requires-python = ">=3.10"
-dependencies = []
+requires-python = ">=3.12,<3.13"
+dependencies = [
+    "torch==2.10.0+cu130",
+    "torchaudio==2.10.0+cu130",
+    "torchvision==0.25.0+cu130",
+    "jinja2>=3.1,<4",
+    "huggingface_hub==1.7.2",
+    "pynvml>=13,<14",
+    "rich>=14,<15",
+    "textual>=6,<9",
+    "transformers==5.5.3",
+    "vllm==0.19.0",
+]
 
 [project.scripts]
+model-runner = "tui:main"
 tui = "tui:main"
 
+[dependency-groups]
+dev = [
+    "pytest>=8,<10",
+]
+gguf = [
+    "llama-cpp-python>=0.3.16,<0.4",
+]
+exl2 = [
+    "exllamav2>=0.3.2,<0.4",
+]
+
+[tool.uv]
+environments = ["sys_platform == 'linux'"]
+override-dependencies = [
+    "transformers==5.5.3",
+]
+
+[tool.uv.sources]
+torch = { index = "pytorch-cu130" }
+torchaudio = { index = "pytorch-cu130" }
+torchvision = { index = "pytorch-cu130" }
+
+[[tool.uv.index]]
+name = "pytorch-cu130"
+url = "https://download.pytorch.org/whl/cu130"
+explicit = true
+
 [tool.setuptools]
 py-modules = ["tui", "config_utils"]
 
diff --git a/requirements.txt b/requirements.txt
index 020573c..0c450fb 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,63 +1,196 @@
 Jinja2==3.1.6
 MarkupSafe==3.0.3
+PyJWT==2.11.0
 PyYAML==6.0.3
 Pygments==2.19.2
 accelerate==1.12.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.13.3
+aioprometheus==23.12.0
+aiosignal==1.4.0
 annotated-doc==0.0.4
+annotated-types==0.7.0
+anthropic==0.84.0
 anyio==4.12.1
+apache-tvm-ffi==0.1.9
+astor==0.8.1
+attrs==25.4.0
 bitsandbytes==0.49.2
+blake3==1.0.8
+cachetools==7.0.3
+cbor2==5.8.0
 certifi==2026.1.4
+cffi==2.0.0
+charset-normalizer==3.4.4
 click==8.3.1
+cloudpickle==3.1.2
+compressed-tensors==0.13.0
+cryptography==46.0.5
 cuda-bindings==12.9.4
 cuda-pathfinder==1.3.5
+cuda-python==12.9.4
+cupy-cuda12x==14.0.1
+depyf==0.20.0
+dill==0.4.1
+diskcache==5.6.3
+distro==1.9.0
+dnspython==2.8.0
+docstring_parser==0.17.0
+e==1.4.5
+einops==0.8.2
+email-validator==2.3.0
+fastapi-cli==0.0.24
+fastapi-cloud-cli==0.14.1
+fastapi==0.125.0
+fastar==0.8.0
 filelock==3.24.3
+flash_attn==2.8.3
+flashinfer-python==0.6.4
+frozenlist==1.8.0
 fsspec==2026.2.0
+gguf==0.18.0
+googleapis-common-protos==1.73.0
+grpcio-reflection==1.78.0
+grpcio==1.78.0
 h11==0.16.0
 hf-xet==1.2.0
 httpcore==1.0.9
+httptools==0.7.1
+httpx-sse==0.4.3
 httpx==0.28.1
-huggingface_hub==1.4.1
+huggingface_hub==0.36.2
 idna==3.11
+ijson==3.5.0
+importlib_metadata==8.7.1
+interegular==0.3.3
+jiter==0.13.0
+jmespath==1.1.0
+jsonschema-specifications==2025.9.1
+jsonschema==4.26.0
+kaldi-native-fbank==1.22.3
+lark==1.2.2
+linkify-it-py==2.1.0
+llama_cpp_python==0.3.16
+llguidance==1.3.0
+llvmlite==0.44.0
+lm-format-enforcer==0.11.3
+loguru==0.7.3
 markdown-it-py==4.0.0
+mcp==1.26.0
+mdit-py-plugins==0.5.0
 mdurl==0.1.2
+mistral_common==1.9.1
+model-hosting-container-standards==0.1.13
+model-runner @ file:///home/poop/ml/model-runner
 mpmath==1.3.0
+msgpack==1.1.2
+msgspec==0.20.0
+multidict==6.7.1
 networkx==3.6.1
-numpy==2.4.2
+ninja==1.13.0
+numba==0.61.2
+numpy==2.2.6
 nvidia-cublas-cu12==12.8.4.1
 nvidia-cuda-cupti-cu12==12.8.90
 nvidia-cuda-nvrtc-cu12==12.8.93
 nvidia-cuda-runtime-cu12==12.8.90
 nvidia-cudnn-cu12==9.10.2.21
+nvidia-cudnn-frontend==1.18.0
 nvidia-cufft-cu12==11.3.3.83
 nvidia-cufile-cu12==1.13.1.3
 nvidia-curand-cu12==10.3.9.90
 nvidia-cusolver-cu12==11.7.3.90
 nvidia-cusparse-cu12==12.5.8.93
 nvidia-cusparselt-cu12==0.7.1
+nvidia-cutlass-dsl-libs-base==4.4.1
+nvidia-cutlass-dsl==4.4.1
+nvidia-ml-py==13.590.48
 nvidia-nccl-cu12==2.27.5
 nvidia-nvjitlink-cu12==12.8.93
 nvidia-nvshmem-cu12==3.4.5
 nvidia-nvtx-cu12==12.8.90
+openai-harmony==0.0.8
+openai==2.24.0
+opencv-python-headless==4.13.0.92
+opentelemetry-api==1.40.0
+opentelemetry-exporter-otlp-proto-common==1.40.0
+opentelemetry-exporter-otlp-proto-grpc==1.40.0
+opentelemetry-exporter-otlp-proto-http==1.40.0
+opentelemetry-exporter-otlp==1.40.0
+opentelemetry-proto==1.40.0
+opentelemetry-sdk==1.40.0
+opentelemetry-semantic-conventions-ai==0.4.15
+opentelemetry-semantic-conventions==0.61b0
+orjson==3.11.7
+outlines_core==0.2.11
 packaging==26.0
+pandas==3.0.1
+partial-json-parser==0.2.1.1.post7
 pillow==12.1.1
+platformdirs==4.9.2
+prometheus-fastapi-instrumentator==7.1.0
+prometheus_client==0.24.1
+propcache==0.4.1
 protobuf==6.33.5
 psutil==7.2.2
+py-cpuinfo==9.0.0
+pyarrow==23.0.1
+pybase64==1.4.3
+pycountry==26.2.16
+pycparser==3.0
+pydantic-extra-types==2.11.0
+pydantic-settings==2.13.1
+pydantic==2.12.5
+pydantic_core==2.41.5
+python-dateutil==2.9.0.post0
+python-dotenv==1.2.2
+python-json-logger==4.0.0
+python-multipart==0.0.22
+pyzmq==27.1.0
+quack-kernels==0.2.10
+quantile-python==1.1
+ray==2.54.0
+referencing==0.37.0
 regex==2026.2.19
+requests==2.32.5
+rich-toolkit==0.19.7
 rich==14.3.3
+rignore==0.7.6
+rpds-py==0.30.0
 safetensors==0.7.0
+sentencepiece==0.2.1
+sentry-sdk==2.54.0
+setproctitle==1.3.7
 shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+sse-starlette==3.3.2
+starlette==0.50.0
+supervisor==4.3.0
 sympy==1.14.0
+tabulate==0.10.0
+textual==8.0.1
+tiktoken==0.12.0
 tokenizers==0.22.2
 torch==2.10.0
+torch_c_dlpack_ext==0.1.5
 torchaudio==2.10.0
 torchvision==0.25.0
 tqdm==4.67.3
-transformers==5.2.0
+transformers==4.57.6
 triton==3.6.0
 typer-slim==0.24.0
 typer==0.24.1
+typing-inspection==0.4.2
 typing_extensions==4.15.0
-sentencepiece
-tiktoken
-textual
-ninja
+uc-micro-py==2.0.0
+urllib3==2.6.3
+uvicorn==0.41.0
+uvloop==0.22.1
+vllm==0.17.0
+watchfiles==1.1.1
+websockets==16.0
+xformers==0.0.35
+xgrammar==0.1.29
+yarl==1.23.0
+zipp==3.23.0
diff --git a/scripts/backend_ctl.py b/scripts/backend_ctl.py
new file mode 100755
index 0000000..9a9f2a7
--- /dev/null
+++ b/scripts/backend_ctl.py
@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parent.parent
+
+
+def _python_bin() -> str:
+    venv_python = ROOT / ".venv" / "bin" / "python"
+    if venv_python.is_file() and os.access(venv_python, os.X_OK):
+        return str(venv_python)
+    return sys.executable or "python3"
+
+
+def _build_base_argv() -> list[str]:
+    return [_python_bin(), str(ROOT / "tui.py")]
+
+
+def _venv_site_packages_dir() -> Path | None:
+    lib_root = ROOT / ".venv" / "lib"
+    if not lib_root.is_dir():
+        return None
+
+    candidates = sorted(lib_root.glob("python*/site-packages"))
+    if not candidates:
+        return None
+    return candidates[-1]
+
+
+def _runtime_env() -> dict[str, str]:
+    env = os.environ.copy()
+    # Helps reduce CUDA memory fragmentation under long-lived/large-model vLLM runs.
+    # Respect explicit user overrides from the shell.
+    env.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
+    site_packages = _venv_site_packages_dir()
+    if site_packages is None:
+        return env
+
+    lib_dirs: list[str] = []
+
+    torch_lib = site_packages / "torch" / "lib"
+    if torch_lib.is_dir():
+        lib_dirs.append(str(torch_lib))
+
+    nvidia_root = site_packages / "nvidia"
+    if nvidia_root.is_dir():
+        for child in sorted(nvidia_root.iterdir()):
+            lib_dir = child / "lib"
+            if lib_dir.is_dir():
+                lib_dirs.append(str(lib_dir))
+
+    current = env.get("LD_LIBRARY_PATH", "")
+    if current:
+        lib_dirs.extend(part for part in current.split(":") if part)
+
+    deduped: list[str] = []
+    seen: set[str] = set()
+    for path in lib_dirs:
+        if path and path not in seen:
+            deduped.append(path)
+            seen.add(path)
+
+    if deduped:
+        env["LD_LIBRARY_PATH"] = ":".join(deduped)
+    return env
+
+
+def _has_flag(argv: list[str], flag: str) -> bool:
+    return any(token == flag or token.startswith(flag + "=") for token in argv)
+
+
+def _main() -> int:
+    if len(sys.argv) >= 2 and sys.argv[1] in {"vllm-up", "vllm-up-bg", "vllm-down", "backend-up-bg", "backend-down-bg"}:
+        tool_name = sys.argv[1]
+        user_args = list(sys.argv[2:])
+    else:
+        tool_name = Path(sys.argv[0]).name
+        user_args = list(sys.argv[1:])
+
+    argv = _build_base_argv()
+    if tool_name in {"vllm-up", "vllm-up-bg", "vllm-down"} and not _has_flag(user_args, "--backend"):
+        argv.extend(["--backend", "vllm"])
+
+    detached = False
+    if tool_name == "vllm-up":
+        filtered_args: list[str] = []
+        for token in user_args:
+            if token == "--bg":
+                detached = True
+                continue
+            if token == "--fg":
+                detached = False
+                continue
+            filtered_args.append(token)
+        user_args = filtered_args
+
+    if tool_name == "vllm-up":
+        argv.append("--backend-only")
+        if detached:
+            argv.append("--detach-backend")
+    elif tool_name == "vllm-up-bg":
+        argv.extend(["--backend-only", "--detach-backend"])
+    elif tool_name == "vllm-down":
+        argv.append("--shutdown-backend")
+    elif tool_name == "backend-up-bg":
+        argv.extend(["--backend-only", "--detach-backend"])
+    elif tool_name == "backend-down-bg":
+        argv.append("--shutdown-backend")
+    else:
+        print(
+            "Unsupported backend control command. "
+            f"Expected one of: vllm-up, vllm-up-bg, vllm-down, backend-up-bg, backend-down-bg (got {tool_name})",
+            file=sys.stderr,
+        )
+        return 2
+
+    argv.extend(user_args)
+    return subprocess.call(argv, cwd=str(ROOT), env=_runtime_env())
+
+
+if __name__ == "__main__":
+    raise SystemExit(_main())
diff --git a/scripts/build_swe_smith_calibration.py b/scripts/build_swe_smith_calibration.py
new file mode 100755
index 0000000..312c189
--- /dev/null
+++ b/scripts/build_swe_smith_calibration.py
@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""Build an OmniCoder calibration dataset from SWE-smith trajectories."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Build a jsonl calibration file from SWE-smith trajectories."
+    )
+    parser.add_argument(
+        "--dataset",
+        default="SWE-bench/SWE-smith-trajectories",
+        help="Hugging Face dataset id.",
+    )
+    parser.add_argument(
+        "--split",
+        default="train[:512]",
+        help="Datasets split expression to load.",
+    )
+    parser.add_argument(
+        "--output",
+        default="~/data/model-runner/calibration/omnicoder_calibration.jsonl",
+        help="Where to write the jsonl calibration file.",
+    )
+    parser.add_argument(
+        "--max-rows",
+        type=int,
+        default=512,
+        help="Maximum number of rows to write.",
+    )
+    parser.add_argument(
+        "--streaming",
+        action="store_true",
+        help="Use streaming mode so rows can be processed without full dataset materialization.",
+    )
+    return parser.parse_args()
+
+
+def stringify_message(message: Any) -> str:
+    if isinstance(message, str):
+        return message.strip()
+    if isinstance(message, dict):
+        role = message.get("role") or message.get("speaker") or message.get("type") or "message"
+        content = message.get("content") or message.get("text") or message.get("value") or message.get("message")
+        if isinstance(content, list):
+            pieces = []
+            for item in content:
+                if isinstance(item, dict):
+                    piece = item.get("text") or item.get("content") or json.dumps(item, ensure_ascii=False)
+                else:
+                    piece = str(item)
+                if piece:
+                    pieces.append(str(piece).strip())
+            content_text = "\n".join(piece for piece in pieces if piece)
+        elif content is None:
+            content_text = json.dumps(message, ensure_ascii=False)
+        else:
+            content_text = str(content).strip()
+        return f"[{role}]\n{content_text}".strip()
+    if isinstance(message, list):
+        return "\n\n".join(filter(None, (stringify_message(item) for item in message)))
+    return str(message).strip()
+
+
+def extract_text(row: dict[str, Any]) -> str:
+    preferred_keys = [
+        "messages",
+        "trajectory",
+        "conversation",
+        "transcript",
+        "history",
+        "prompt",
+        "problem_statement",
+        "issue",
+        "instance_text",
+    ]
+    for key in preferred_keys:
+        if key not in row or row[key] in (None, ""):
+            continue
+        value = row[key]
+        if isinstance(value, str):
+            text = value.strip()
+            if text.startswith("[") or text.startswith("{"):
+                try:
+                    parsed = json.loads(text)
+                except Exception:
+                    parsed = None
+                if parsed is not None:
+                    text = stringify_message(parsed)
+            if text:
+                return text
+        else:
+            text = stringify_message(value)
+            if text:
+                return text
+
+    # Fallback: stringify the whole row without obvious ids.
+    reduced = {
+        key: value
+        for key, value in row.items()
+        if key not in {"id", "instance_id", "problem_id", "patch", "test_patch", "FAIL_TO_PASS"}
+    }
+    return stringify_message(reduced)
+
+
+def main() -> int:
+    args = parse_args()
+    try:
+        from datasets import load_dataset
+    except ImportError:
+        raise SystemExit("datasets is not installed. Run `.venv/bin/python -m pip install datasets`.")
+
+    ds = load_dataset(args.dataset, split=args.split, streaming=args.streaming)
+    out_path = Path(args.output)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+
+    written = 0
+    with out_path.open("w", encoding="utf-8") as fh:
+        for row in ds:
+            text = extract_text(row)
+            if not text:
+                continue
+            fh.write(json.dumps({"text": text}, ensure_ascii=False) + "\n")
+            written += 1
+            if written >= args.max_rows:
+                break
+
+    if written == 0:
+        raise SystemExit("No calibration rows were written. Inspect the dataset schema and extraction logic.")
+
+    print(json.dumps({
+        "dataset": args.dataset,
+        "split": args.split,
+        "output": str(out_path.resolve()),
+        "rows_written": written,
+    }, indent=2))
+    sys.stdout.flush()
+    if args.streaming:
+        os._exit(0)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/compress_model.py b/scripts/compress_model.py
new file mode 100755
index 0000000..3c5f3d2
--- /dev/null
+++ b/scripts/compress_model.py
@@ -0,0 +1,560 @@
+#!/usr/bin/env python3
+"""Offline FP8 compression workflow for vLLM-compatible artifacts."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import sys
+import tempfile
+import tomllib
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from types import MethodType
+from typing import Any
+
+DEFAULT_OUTPUT_ROOT = "~/models/local/quants"
+
+
+class ConfigError(Exception):
+    """Raised when the compressor config is invalid."""
+
+
+@dataclass
+class CompressionPlan:
+    model_name: str
+    source_model: str
+    tokenizer: str | None
+    trust_remote_code: bool
+    recipe_scheme: str
+    targets: str
+    ignore: list[str]
+    compressed_name: str
+    artifact_dir: Path
+    current_link: Path
+    calibration_source: str
+    dataset_path: str | None
+    dataset_id: str | None
+    dataset_config: str | None
+    dataset_split: str | None
+    text_column: str | None
+    num_calibration_samples: int
+    max_seq_length: int
+    shuffle: bool
+    batch_size: int
+    preprocessing_num_workers: int | None
+    dataloader_num_workers: int
+    sequential_offload_device: str
+    sequential_prefetch: bool
+    max_shard_size: str
+
+
+def import_transformers_runtime():
+    from transformers import AutoModelForCausalLM, AutoModelForImageTextToText, AutoProcessor
+
+    return AutoModelForCausalLM, AutoModelForImageTextToText, AutoProcessor
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Compress a model offline into a vLLM-compatible FP8 artifact."
+    )
+    parser.add_argument("--model", required=True, help="Repo model name, e.g. OmniCoder-9B.")
+    parser.add_argument(
+        "--config",
+        help="Path to compressor TOML. Defaults to models/<model>/vllm/compressor/default.toml.",
+    )
+    parser.add_argument(
+        "--scheme",
+        choices=["fp8"],
+        default="fp8",
+        help="Compression scheme family. v1 only supports fp8.",
+    )
+    parser.add_argument("--source-model", help="Override source model path or HF model id.")
+    parser.add_argument("--tokenizer", help="Override tokenizer path or HF tokenizer id.")
+    parser.add_argument("--output-root", help=f"Output root. Defaults to {DEFAULT_OUTPUT_ROOT}.")
+    parser.add_argument("--compressed-name", help="Override the saved compressed model name.")
+    parser.add_argument("--run-label", help="Optional run label appended to the timestamp.")
+    parser.add_argument(
+        "--trust-remote-code",
+        action="store_true",
+        help="Enable trust_remote_code when loading the source model/tokenizer.",
+    )
+    parser.add_argument(
+        "--dataset-source",
+        choices=["local", "hf", "none"],
+        help="Override calibration source type.",
+    )
+    parser.add_argument("--dataset-path", help="Override local calibration dataset path.")
+    parser.add_argument("--dataset-id", help="Override Hugging Face dataset id.")
+    parser.add_argument("--dataset-config", help="Override Hugging Face dataset config name.")
+    parser.add_argument("--dataset-split", help="Override calibration dataset split.")
+    parser.add_argument("--text-column", help="Override text column for calibration data.")
+    parser.add_argument("--num-samples", type=int, help="Override number of calibration samples.")
+    parser.add_argument("--max-seq-len", type=int, help="Override max sequence length for calibration.")
+    parser.add_argument(
+        "--recipe-scheme",
+        help="Override low-level FP8 recipe scheme, e.g. FP8, FP8_DYNAMIC, or FP8_BLOCK.",
+    )
+    parser.add_argument(
+        "--targets",
+        help="Override quantization targets. Defaults to config value, usually Linear.",
+    )
+    parser.add_argument(
+        "--ignore",
+        action="append",
+        default=None,
+        help="Append ignore pattern(s) for the quantization recipe. Repeatable.",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Print the resolved compression plan and exit.",
+    )
+    return parser.parse_args()
+
+
+def default_config_path(model_name: str) -> Path:
+    return Path("models") / model_name / "vllm" / "compressor" / "default.toml"
+
+
+def load_toml(path: Path) -> dict[str, Any]:
+    try:
+        with path.open("rb") as fh:
+            return tomllib.load(fh)
+    except FileNotFoundError as exc:
+        raise ConfigError(f"Compressor config not found: {path}") from exc
+    except tomllib.TOMLDecodeError as exc:
+        raise ConfigError(f"Invalid TOML in {path}: {exc}") from exc
+
+
+def require_str(section: dict[str, Any], key: str, context: str) -> str:
+    value = section.get(key)
+    if not isinstance(value, str) or not value.strip():
+        raise ConfigError(f"Missing required string '{key}' in [{context}]")
+    return value.strip()
+
+
+def require_int(section: dict[str, Any], key: str, context: str) -> int:
+    value = section.get(key)
+    if not isinstance(value, int):
+        raise ConfigError(f"Missing required integer '{key}' in [{context}]")
+    return value
+
+
+def optional_str(section: dict[str, Any], key: str) -> str | None:
+    value = section.get(key)
+    if value is None:
+        return None
+    if not isinstance(value, str):
+        raise ConfigError(f"Expected '{key}' to be a string")
+    stripped = value.strip()
+    return stripped or None
+
+
+def list_of_str(section: dict[str, Any], key: str, default: list[str] | None = None) -> list[str]:
+    value = section.get(key, default or [])
+    if not isinstance(value, list) or not all(isinstance(item, str) for item in value):
+        raise ConfigError(f"Expected '{key}' to be an array of strings")
+    return [item.strip() for item in value if item.strip()]
+
+
+def resolve_value_path(value: str | None, config_dir: Path) -> str | None:
+    if not value:
+        return None
+    expanded = Path(os.path.expanduser(value))
+    if expanded.is_absolute():
+        return str(expanded)
+    config_relative = (config_dir / expanded).resolve()
+    if config_relative.exists():
+        return str(config_relative)
+    return str(expanded.resolve())
+
+
+def dedupe(values: list[str]) -> list[str]:
+    seen: set[str] = set()
+    result: list[str] = []
+    for value in values:
+        if value not in seen:
+            seen.add(value)
+            result.append(value)
+    return result
+
+
+def scheme_requires_dataset(recipe_scheme: str) -> bool:
+    scheme = recipe_scheme.strip().upper()
+    return scheme not in {"FP8_DYNAMIC", "FP8_BLOCK"}
+
+
+def slugify(value: str) -> str:
+    pieces: list[str] = []
+    for char in value.strip():
+        if char.isalnum():
+            pieces.append(char.lower())
+        elif char in {"-", "_"}:
+            pieces.append(char)
+    slug = "".join(pieces).strip("-_")
+    if not slug:
+        raise ConfigError("Run label must contain at least one alphanumeric character")
+    return slug
+
+
+def build_plan(args: argparse.Namespace) -> tuple[CompressionPlan, Path]:
+    config_path = Path(args.config) if args.config else default_config_path(args.model)
+    config_path = config_path.resolve()
+    config = load_toml(config_path)
+    config_dir = config_path.parent
+
+    model_cfg = config.get("model", {})
+    output_cfg = config.get("output", {})
+    calibration_cfg = config.get("calibration", {})
+    recipe_cfg = config.get("recipe", {})
+    runtime_cfg = config.get("runtime", {})
+
+    if not isinstance(model_cfg, dict) or not isinstance(output_cfg, dict):
+        raise ConfigError("Config must define [model] and [output] sections")
+
+    source_model = args.source_model or require_str(model_cfg, "source", "model")
+    tokenizer = args.tokenizer or optional_str(model_cfg, "tokenizer")
+    trust_remote_code = bool(model_cfg.get("trust_remote_code", False) or args.trust_remote_code)
+
+    compressed_name = args.compressed_name or optional_str(output_cfg, "compressed_name") or f"{args.model}-FP8"
+    output_root = Path(
+        os.path.expanduser(args.output_root or optional_str(output_cfg, "root") or DEFAULT_OUTPUT_ROOT)
+    ).resolve()
+    quant_dir_name = optional_str(output_cfg, "quant_dir_name") or "fp8"
+
+    recipe_scheme = args.recipe_scheme or optional_str(recipe_cfg, "scheme") or "FP8"
+    targets = args.targets or optional_str(recipe_cfg, "targets") or "Linear"
+    ignore = list_of_str(recipe_cfg, "ignore", ["lm_head", "re:.*mlp.gate$"])
+    if args.ignore:
+        ignore.extend(args.ignore)
+
+    calibration_source = args.dataset_source or (optional_str(calibration_cfg, "source") or "none")
+    dataset_path = args.dataset_path or resolve_value_path(optional_str(calibration_cfg, "dataset_path"), config_dir)
+    dataset_id = args.dataset_id or optional_str(calibration_cfg, "dataset_id")
+    dataset_config = args.dataset_config or optional_str(calibration_cfg, "dataset_config")
+    dataset_split = args.dataset_split or optional_str(calibration_cfg, "split")
+    text_column = args.text_column or optional_str(calibration_cfg, "text_column")
+    num_samples = args.num_samples or require_int(calibration_cfg, "num_calibration_samples", "calibration")
+    max_seq_length = args.max_seq_len or require_int(calibration_cfg, "max_seq_length", "calibration")
+    shuffle = bool(calibration_cfg.get("shuffle", True))
+    batch_size = calibration_cfg.get("batch_size", 1)
+    preprocessing_num_workers = calibration_cfg.get("preprocessing_num_workers")
+    dataloader_num_workers = calibration_cfg.get("dataloader_num_workers", 0)
+    sequential_offload_device = optional_str(runtime_cfg, "sequential_offload_device") or "cuda:0"
+    sequential_prefetch = bool(runtime_cfg.get("sequential_prefetch", False))
+    max_shard_size = optional_str(output_cfg, "max_shard_size") or "2GB"
+
+    requires_dataset = scheme_requires_dataset(recipe_scheme)
+    if calibration_source not in {"local", "hf", "none"}:
+        raise ConfigError("calibration.source must be 'local', 'hf', or 'none'")
+    if requires_dataset and calibration_source == "none":
+        raise ConfigError(
+            f"recipe scheme {recipe_scheme!r} requires calibration data; set calibration.source to 'local' or 'hf'"
+        )
+    if calibration_source == "local":
+        if not dataset_path:
+            raise ConfigError("Local calibration requires calibration.dataset_path or --dataset-path")
+        if not dataset_split:
+            raise ConfigError("Local calibration requires calibration.split or --dataset-split")
+    if calibration_source == "hf":
+        if not dataset_id:
+            raise ConfigError("HF calibration requires calibration.dataset_id or --dataset-id")
+        if not dataset_split:
+            raise ConfigError("HF calibration requires calibration.split or --dataset-split")
+    if not isinstance(batch_size, int) or batch_size < 1:
+        raise ConfigError("calibration.batch_size must be an integer >= 1")
+    if preprocessing_num_workers is not None and (
+        not isinstance(preprocessing_num_workers, int) or preprocessing_num_workers < 0
+    ):
+        raise ConfigError("calibration.preprocessing_num_workers must be an integer >= 0")
+    if not isinstance(dataloader_num_workers, int) or dataloader_num_workers < 0:
+        raise ConfigError("calibration.dataloader_num_workers must be an integer >= 0")
+
+    run_stamp = datetime.now(UTC).strftime("%Y%m%dT%H%M%SZ")
+    run_suffix = slugify(args.run_label) if args.run_label else None
+    run_name = f"{run_stamp}-{run_suffix}" if run_suffix else run_stamp
+
+    base_dir = output_root / args.model / quant_dir_name
+    artifact_dir = base_dir / "runs" / run_name / compressed_name
+    current_link = base_dir / "current"
+
+    plan = CompressionPlan(
+        model_name=args.model,
+        source_model=source_model,
+        tokenizer=tokenizer,
+        trust_remote_code=trust_remote_code,
+        recipe_scheme=recipe_scheme,
+        targets=targets,
+        ignore=dedupe(ignore),
+        compressed_name=compressed_name,
+        artifact_dir=artifact_dir,
+        current_link=current_link,
+        calibration_source=calibration_source,
+        dataset_path=dataset_path,
+        dataset_id=dataset_id,
+        dataset_config=dataset_config,
+        dataset_split=dataset_split,
+        text_column=text_column,
+        num_calibration_samples=num_samples,
+        max_seq_length=max_seq_length,
+        shuffle=shuffle,
+        batch_size=batch_size,
+        preprocessing_num_workers=preprocessing_num_workers,
+        dataloader_num_workers=dataloader_num_workers,
+        sequential_offload_device=sequential_offload_device,
+        sequential_prefetch=sequential_prefetch,
+        max_shard_size=max_shard_size,
+    )
+    return plan, config_path
+
+
+def plan_as_json(plan: CompressionPlan) -> str:
+    payload = {
+        "model_name": plan.model_name,
+        "source_model": plan.source_model,
+        "tokenizer": plan.tokenizer,
+        "trust_remote_code": plan.trust_remote_code,
+        "fp8_recipe": {
+            "scheme": plan.recipe_scheme,
+            "targets": plan.targets,
+            "ignore": plan.ignore,
+        },
+        "artifact_dir": str(plan.artifact_dir),
+        "current_link": str(plan.current_link),
+        "calibration": {
+            "source": plan.calibration_source,
+            "dataset_path": plan.dataset_path,
+            "dataset_id": plan.dataset_id,
+            "dataset_config": plan.dataset_config,
+            "split": plan.dataset_split,
+            "text_column": plan.text_column,
+            "num_calibration_samples": plan.num_calibration_samples,
+            "max_seq_length": plan.max_seq_length,
+            "shuffle": plan.shuffle,
+            "batch_size": plan.batch_size,
+            "preprocessing_num_workers": plan.preprocessing_num_workers,
+            "dataloader_num_workers": plan.dataloader_num_workers,
+        },
+        "runtime": {
+            "sequential_offload_device": plan.sequential_offload_device,
+            "sequential_prefetch": plan.sequential_prefetch,
+        },
+        "save": {
+            "max_shard_size": plan.max_shard_size,
+        },
+    }
+    return json.dumps(payload, indent=2, sort_keys=True)
+
+
+def ensure_output_dirs(plan: CompressionPlan) -> None:
+    plan.artifact_dir.parent.mkdir(parents=True, exist_ok=False)
+
+
+def update_current_link(plan: CompressionPlan) -> None:
+    link = plan.current_link
+    if link.exists() or link.is_symlink():
+        if link.is_symlink() or link.is_file():
+            link.unlink()
+        else:
+            raise ConfigError(
+                f"Refusing to replace non-symlink directory at {link}. Remove it manually once, then rerun."
+            )
+    link.parent.mkdir(parents=True, exist_ok=True)
+    relative_target = os.path.relpath(plan.artifact_dir, link.parent)
+    link.symlink_to(relative_target, target_is_directory=True)
+
+
+def build_recipe(plan: CompressionPlan) -> Any:
+    from llmcompressor.modifiers.quantization import QuantizationModifier
+
+    return QuantizationModifier(
+        targets=plan.targets,
+        scheme=plan.recipe_scheme,
+        ignore=plan.ignore,
+    )
+
+
+def load_model_and_processor(plan: CompressionPlan) -> tuple[Any, Any]:
+    AutoModelForCausalLM, AutoModelForImageTextToText, AutoProcessor = import_transformers_runtime()
+
+    model_kwargs = {
+        "trust_remote_code": plan.trust_remote_code,
+        "dtype": "auto",
+    }
+    processor_src = plan.tokenizer or plan.source_model
+
+    processor = AutoProcessor.from_pretrained(
+        processor_src,
+        trust_remote_code=plan.trust_remote_code,
+    )
+
+    model = None
+    load_errors: list[str] = []
+    for loader in (AutoModelForImageTextToText, AutoModelForCausalLM):
+        try:
+            model = loader.from_pretrained(plan.source_model, **model_kwargs)
+            break
+        except Exception as exc:
+            load_errors.append(f"{loader.__name__}: {exc!r}")
+
+    if model is None:
+        joined = "\n".join(load_errors)
+        raise ConfigError(f"Failed to load source model with Transformers auto classes:\n{joined}")
+
+    if not hasattr(model, "_get_no_split_modules") and hasattr(model, "_no_split_modules"):
+        def _compat_get_no_split_modules(self: Any, device_map: str = "auto") -> list[str]:
+            modules = getattr(self, "_no_split_modules", None)
+            if not modules:
+                return []
+            return list(modules)
+
+        model._get_no_split_modules = MethodType(_compat_get_no_split_modules, model)
+
+    return model, processor
+
+
+def configure_save_path(model: Any, max_shard_size: str) -> None:
+    original = model.save_pretrained
+
+    def _save_with_shard_size(self: Any, save_directory: str, *args: Any, **kwargs: Any):
+        kwargs.setdefault("max_shard_size", max_shard_size)
+        return original(save_directory, *args, **kwargs)
+
+    model.save_pretrained = MethodType(_save_with_shard_size, model)
+
+
+def write_manifest(plan: CompressionPlan, config_path: Path) -> None:
+    manifest = {
+        "created_at": datetime.now(UTC).isoformat(),
+        "model_name": plan.model_name,
+        "source_model": plan.source_model,
+        "tokenizer": plan.tokenizer,
+        "compressed_name": plan.compressed_name,
+        "scheme_family": "fp8",
+        "recipe_scheme": plan.recipe_scheme,
+        "targets": plan.targets,
+        "ignore": plan.ignore,
+        "artifact_dir": str(plan.artifact_dir),
+        "current_link": str(plan.current_link),
+        "config_path": str(config_path),
+        "calibration": {
+            "source": plan.calibration_source,
+            "dataset_path": plan.dataset_path,
+            "dataset_id": plan.dataset_id,
+            "dataset_config": plan.dataset_config,
+            "split": plan.dataset_split,
+            "text_column": plan.text_column,
+            "num_calibration_samples": plan.num_calibration_samples,
+            "max_seq_length": plan.max_seq_length,
+            "shuffle": plan.shuffle,
+            "batch_size": plan.batch_size,
+            "preprocessing_num_workers": plan.preprocessing_num_workers,
+            "dataloader_num_workers": plan.dataloader_num_workers,
+        },
+        "runtime": {
+            "sequential_offload_device": plan.sequential_offload_device,
+            "sequential_prefetch": plan.sequential_prefetch,
+        },
+        "save": {
+            "max_shard_size": plan.max_shard_size,
+        },
+    }
+    manifest_path = plan.artifact_dir / "compression-manifest.json"
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n")
+
+
+def validate_runtime_inputs(plan: CompressionPlan) -> None:
+    if plan.calibration_source == "local":
+        dataset_file = Path(plan.dataset_path or "")
+        if not dataset_file.exists():
+            raise ConfigError(f"Local calibration dataset does not exist: {dataset_file}")
+        if dataset_file.name.lower() == "readme.md":
+            raise ConfigError("Replace the calibration README placeholder with a real dataset path before compressing")
+
+
+def run_compression(plan: CompressionPlan, config_path: Path) -> None:
+    try:
+        from llmcompressor import oneshot
+    except ImportError:
+        try:
+            from llmcompressor.entrypoints.oneshot import oneshot
+        except ImportError as exc:
+            raise SystemExit(
+                "llmcompressor is not installed in this environment. Install a compatible llmcompressor stack before running compression."
+            ) from exc
+
+    validate_runtime_inputs(plan)
+    recipe = build_recipe(plan)
+    ensure_output_dirs(plan)
+    model, processor = load_model_and_processor(plan)
+    configure_save_path(model, plan.max_shard_size)
+
+    oneshot_kwargs: dict[str, Any] = {
+        "model": model,
+        "processor": processor,
+        "recipe": recipe,
+        "output_dir": str(plan.artifact_dir),
+    }
+    stage_dir: Path | None = None
+    if plan.calibration_source != "none":
+        oneshot_kwargs.update(
+            {
+                "num_calibration_samples": plan.num_calibration_samples,
+                "max_seq_length": plan.max_seq_length,
+                "splits": plan.dataset_split,
+                "shuffle_calibration_samples": plan.shuffle,
+                "pipeline": "sequential",
+                "batch_size": plan.batch_size,
+                "preprocessing_num_workers": plan.preprocessing_num_workers,
+                "dataloader_num_workers": plan.dataloader_num_workers,
+                "sequential_offload_device": plan.sequential_offload_device,
+                "sequential_prefetch": plan.sequential_prefetch,
+            }
+        )
+        if plan.text_column:
+            oneshot_kwargs["text_column"] = plan.text_column
+    if plan.calibration_source == "local":
+        dataset_file = Path(plan.dataset_path or "")
+        stage_dir = Path(tempfile.mkdtemp(prefix="compress-calibration-"))
+        staged_dataset = stage_dir / "train.json"
+        shutil.copy2(dataset_file, staged_dataset)
+        oneshot_kwargs["dataset"] = "json"
+        oneshot_kwargs["dataset_path"] = str(stage_dir)
+    elif plan.calibration_source == "hf":
+        oneshot_kwargs["dataset"] = plan.dataset_id
+        if plan.dataset_config:
+            oneshot_kwargs["dataset_config_name"] = plan.dataset_config
+
+    try:
+        oneshot(**oneshot_kwargs)
+        write_manifest(plan, config_path)
+        update_current_link(plan)
+    finally:
+        if stage_dir is not None:
+            shutil.rmtree(stage_dir, ignore_errors=True)
+
+
+def main() -> int:
+    args = parse_args()
+    try:
+        plan, config_path = build_plan(args)
+        if args.dry_run:
+            print(plan_as_json(plan))
+            return 0
+        run_compression(plan, config_path)
+    except ConfigError as exc:
+        print(f"config error: {exc}", file=sys.stderr)
+        return 2
+    except KeyboardInterrupt:
+        print("interrupted", file=sys.stderr)
+        return 130
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/expand_transcript.py b/scripts/expand_transcript.py
new file mode 100755
index 0000000..15fc34e
--- /dev/null
+++ b/scripts/expand_transcript.py
@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+
+def _usage() -> int:
+    print("Usage: expand <path-to-jsonl>", file=sys.stderr)
+    return 2
+
+
+def _read_records(path: Path) -> list[dict]:
+    records: list[dict] = []
+    for idx, line in enumerate(path.read_text(encoding="utf-8").splitlines(), start=1):
+        text = line.strip()
+        if not text:
+            continue
+        try:
+            obj = json.loads(text)
+        except json.JSONDecodeError as exc:
+            raise RuntimeError(f"{path}:{idx}: invalid JSON: {exc}") from exc
+        if not isinstance(obj, dict):
+            raise RuntimeError(f"{path}:{idx}: expected object per line")
+        records.append(obj)
+    return records
+
+
+def _output_path(path: Path) -> Path:
+    if path.suffix.lower() == ".jsonl":
+        return path.with_suffix(".txt")
+    return path.with_name(path.name + ".txt")
+
+
+def _fmt_value(value: object) -> str:
+    if value is None:
+        return "unavailable"
+    return str(value)
+
+
+def _append_section(lines: list[str], title: str, body: str) -> None:
+    if not body.strip():
+        return
+    lines.append(f"{title}:")
+    lines.append(body.rstrip())
+    lines.append("")
+
+
+def _render_record(index: int, record: dict) -> str:
+    timing = record.get("timing") if isinstance(record.get("timing"), dict) else {}
+    token_counts = record.get("token_counts") if isinstance(record.get("token_counts"), dict) else {}
+    throughput = record.get("throughput") if isinstance(record.get("throughput"), dict) else {}
+
+    lines = [
+        f"Turn {index}",
+        f"backend: {_fmt_value(record.get('backend'))}",
+        f"model_id: {_fmt_value(record.get('model_id'))}",
+        f"ended_in_think: {_fmt_value(record.get('ended_in_think'))}",
+        f"elapsed_s: {_fmt_value(timing.get('elapsed'))}",
+        f"prompt_tokens: {_fmt_value(token_counts.get('prompt_tokens'))}",
+        f"completion_tokens: {_fmt_value(token_counts.get('completion_tokens'))}",
+        f"total_tokens: {_fmt_value(token_counts.get('total_tokens'))}",
+        f"tokens_per_s: {_fmt_value(throughput.get('tokens_per_s'))}",
+        "",
+    ]
+
+    answer = str(record.get("answer") or "")
+    think = str(record.get("think") or "")
+    raw = str(record.get("raw") or "")
+
+    _append_section(lines, "answer", answer)
+    _append_section(lines, "think", think)
+    if raw and raw != answer and raw != think:
+        _append_section(lines, "raw", raw)
+
+    lines.append("=" * 80)
+    return "\n".join(lines)
+
+
+def main(argv: list[str]) -> int:
+    if len(argv) != 2:
+        return _usage()
+
+    src = Path(argv[1]).expanduser()
+    if not src.is_absolute():
+        src = (Path.cwd() / src).resolve()
+    if not src.is_file():
+        print(f"Input not found: {src}", file=sys.stderr)
+        return 1
+
+    try:
+        records = _read_records(src)
+    except RuntimeError as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
+
+    dst = _output_path(src)
+    body = "\n".join(_render_record(idx, rec) for idx, rec in enumerate(records, start=1))
+    if body and not body.endswith("\n"):
+        body += "\n"
+    dst.write_text(body, encoding="utf-8")
+    print(dst)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv))
diff --git a/scripts/model b/scripts/model
index 9f77afa..05c73b1 100755
--- a/scripts/model
+++ b/scripts/model
@@ -2,6 +2,7 @@
 import argparse
 import json
 import os
+import re
 import shutil
 import sys
 from pathlib import Path
@@ -10,6 +11,46 @@ from pathlib import Path
 REPO_ROOT = Path(__file__).resolve().parents[1]
 MODELS_DIR = REPO_ROOT / "models"
 TEMPLATE_DIR = MODELS_DIR / "_TEMPLATE"
+HF_CACHE_DIR = Path(os.path.expanduser(os.environ.get("HF_HUB_CACHE", "~/models/hf/hub")))
+
+
+def _looks_like_local_path(value: str) -> bool:
+    text = (value or "").strip()
+    if not text:
+        return False
+    expanded = os.path.expanduser(text)
+    if os.path.isabs(expanded):
+        return True
+    if text.startswith((".", "~")):
+        return True
+    if re.match(r"^[A-Za-z]:[\\/]", text):
+        return True
+    return False
+
+
+def _path_stem(value: str) -> str:
+    text = (value or "").strip().rstrip("/").rstrip("\\")
+    if not text:
+        return ""
+    return os.path.basename(os.path.expanduser(text))
+
+
+def _normalize_model_name(raw: str) -> str:
+    text = (raw or "").strip()
+    if not text:
+        return ""
+    if _looks_like_local_path(text) or "/" in text or "\\" in text:
+        return _path_stem(text)
+    return text.rstrip("/").rstrip("\\")
+
+
+def _normalize_backend_id(backend: str, backend_id: str | None) -> str | None:
+    text = (backend_id or "").strip()
+    if not text:
+        return None
+    if _looks_like_local_path(text) or "/" in text or "\\" in text:
+        return _path_stem(text)
+    return text
 
 
 def _copy_tree(src: Path, dst: Path, *, overwrite: bool) -> list[Path]:
@@ -60,11 +101,117 @@ def _try_update_json(path: Path, updates: dict) -> bool:
     return changed
 
 
+def _try_update_toml_model_id(path: Path, model_id: str | None) -> bool:
+    if not model_id or not path.exists():
+        return False
+    lines = path.read_text(encoding="utf-8").splitlines(keepends=True)
+
+    in_model_section = False
+    changed = False
+    for idx, line in enumerate(lines):
+        stripped = line.strip()
+        if stripped.startswith("[") and stripped.endswith("]"):
+            section = stripped.strip("[]").strip()
+            in_model_section = section == "model"
+            continue
+        if not in_model_section:
+            continue
+
+        # Replace the first `id = "..."` (or '...') within [model].
+        m = re.match(r'^(\s*)id(\s*)=(\s*)(["\'])(.*?)(\4)(\s*)$', line.rstrip("\n"))
+        if not m:
+            continue
+        prefix_ws, ws1, ws2, quote, _old, _q2, suffix_ws = m.groups()
+        new_line = f'{prefix_ws}id{ws1}={ws2}{quote}{model_id}{quote}{suffix_ws}\n'
+        lines[idx] = new_line
+        changed = True
+        break
+
+    if not changed:
+        return False
+    path.write_text("".join(lines), encoding="utf-8")
+    return True
+
+
+def _try_find_hf_model_card_from_id(model_id: str) -> Path | None:
+    """
+    Best-effort attempt to locate a model README.md for a HF id (org/name) in the local HF cache.
+    Returns the most recently modified README.md found under snapshots/.
+    """
+    if not model_id or "/" not in model_id:
+        return None
+    if not HF_CACHE_DIR.is_dir():
+        return None
+    org, name = model_id.split("/", 1)
+    repo_dir = HF_CACHE_DIR / f"models--{org}--{name}"
+    snapshots = repo_dir / "snapshots"
+    if not snapshots.is_dir():
+        return None
+    candidates: list[Path] = []
+    for snap in snapshots.iterdir():
+        if not snap.is_dir():
+            continue
+        readme = snap / "README.md"
+        if readme.is_file():
+            candidates.append(readme)
+    if not candidates:
+        return None
+    candidates.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+    return candidates[0]
+
+
+def _resolve_model_card_source(backend: str, backend_id: str | None) -> Path | None:
+    """
+    Decide where to copy a model card from.
+    - If backend_id is a local directory and has README.md, use it.
+    - If backend_id looks like a HF id, try:
+        - ~/models/local/<stem>/README.md
+        - ~/.cache/huggingface/hub/.../snapshots/*/README.md
+    """
+    if backend != "hf" or not backend_id:
+        return None
+
+    # Local directory explicit.
+    p = Path(os.path.expanduser(backend_id))
+    if p.is_dir():
+        readme = p / "README.md"
+        if readme.is_file():
+            return readme
+
+    # Common local convention: store under ~/models/local/<name>.
+    stem = backend_id.split("/")[-1]
+    local_models = Path(os.path.expanduser("~/models/local")) / stem
+    readme = local_models / "README.md"
+    if readme.is_file():
+        return readme
+
+    # HF cache lookup (offline-friendly).
+    return _try_find_hf_model_card_from_id(backend_id)
+
+
+def _resolve_model_card_source_without_id(model_name: str) -> Path | None:
+    """
+    Best-effort model card discovery when the user didn't pass --id.
+
+    Heuristics:
+    - If the user keeps local weights under ~/models/local/<model_name>, use README.md from there.
+    - Otherwise, if model_name looks like a HF id (org/name), try the HF cache.
+    """
+    if not model_name:
+        return None
+    local_dir = Path(os.path.expanduser("~/models/local")) / model_name
+    readme = local_dir / "README.md"
+    if readme.is_file():
+        return readme
+    return _try_find_hf_model_card_from_id(model_name)
+
+
 def cmd_add(args: argparse.Namespace) -> int:
-    model_name = args.model_name.strip().rstrip("/").rstrip("\\")
+    model_name = _normalize_model_name(args.model_name)
     if not model_name:
         print("model_name is required")
         return 2
+    config_model_id = _normalize_backend_id(args.backend, args.backend_id) or model_name
 
     backend = args.backend
     template_backend_dir = TEMPLATE_DIR / backend
@@ -81,6 +228,7 @@ def cmd_add(args: argparse.Namespace) -> int:
     # Ensure standard subfolders exist even if templates are empty.
     (backend_dir / "notes").mkdir(parents=True, exist_ok=True)
     (backend_dir / "config").mkdir(parents=True, exist_ok=True)
+    (backend_dir / "config" / "profiles").mkdir(parents=True, exist_ok=True)
     (backend_dir / "templates").mkdir(parents=True, exist_ok=True)
     (backend_dir / "prompts").mkdir(parents=True, exist_ok=True)
 
@@ -100,14 +248,60 @@ def cmd_add(args: argparse.Namespace) -> int:
         "This folder is for prompt/template overrides or experiments.\n",
         overwrite=False,
     )
+    _ensure_file(
+        backend_dir / "config" / "profiles" / "fast.toml",
+        "[gen]\nmax_new_tokens = 1024\n",
+        overwrite=False,
+    )
+    _ensure_file(
+        backend_dir / "config" / "profiles" / "longctx.toml",
+        "[gen]\nmax_new_tokens = 2048\n",
+        overwrite=False,
+    )
 
     # Light config population (optional; safe defaults).
     if backend == "ollama":
-        cfg = backend_dir / "config" / "config.json"
-        _try_update_json(cfg, {"model": args.backend_id})
-    elif backend in {"hf", "gguf", "exl2"}:
-        cfg = backend_dir / "config" / "config.json"
-        _try_update_json(cfg, {"model_id": args.backend_id})
+        cfg_toml = backend_dir / "config" / "default.toml"
+        _try_update_toml_model_id(cfg_toml, config_model_id)
+    elif backend in {"hf", "gguf", "exl2", "openai", "vllm"}:
+        cfg_toml = backend_dir / "config" / "default.toml"
+        _try_update_toml_model_id(cfg_toml, config_model_id)
+
+    # Optional: import upstream model card into notes/ as model_card.md (HF only).
+    # Auto-import if:
+    # - --id points to a local model directory, OR
+    # - ~/ml/models/<model_name>/README.md exists (common local workflow), OR
+    # - user explicitly requests it via --import-model-card (best-effort, may use HF cache).
+    if backend == "hf":
+        should_import = bool(args.import_model_card)
+        if not should_import and args.backend_id:
+            candidate = Path(os.path.expanduser(args.backend_id))
+            if candidate.is_dir():
+                should_import = True
+            else:
+                stem = args.backend_id.split("/")[-1]
+                local_readme = Path(os.path.expanduser("~/ml/models")) / stem / "README.md"
+                if local_readme.is_file():
+                    should_import = True
+        if not should_import:
+            local_readme = Path(os.path.expanduser("~/ml/models")) / model_name / "README.md"
+            if local_readme.is_file():
+                should_import = True
+
+        if should_import:
+            if args.backend_id:
+                src = _resolve_model_card_source(backend=backend, backend_id=args.backend_id)
+            else:
+                src = _resolve_model_card_source_without_id(model_name)
+        else:
+            src = None
+        if src is not None and src.is_file():
+            dst = backend_dir / "notes" / "model_card.md"
+            if dst.exists() and not args.force:
+                pass
+            else:
+                dst.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(src, dst)
 
     print(f"Model: {model_name}")
     print(f"Backend added: {backend}")
@@ -126,18 +320,23 @@ def build_parser() -> argparse.ArgumentParser:
 
     add = sub.add_parser("add", help="Add a backend scaffold for a model")
     add.add_argument("model_name", help="Folder name under models/ (e.g. ds32b-alex)")
-    add.add_argument("backend", choices=["hf", "gguf", "ollama", "exl2"], help="Backend to add")
+    add.add_argument("backend", choices=["hf", "gguf", "ollama", "exl2", "openai", "vllm"], help="Backend to add")
     add.add_argument(
         "--id",
         dest="backend_id",
         default=None,
-        help="Backend model identifier to prefill into config (HF/GGUF/EXL2: model_id, Ollama: model).",
+        help="Backend model identifier to prefill into config (HF/GGUF/EXL2/OpenAI: model_id, Ollama: model).",
     )
     add.add_argument(
         "--force",
         action="store_true",
         help="Overwrite existing template files when copying.",
     )
+    add.add_argument(
+        "--import-model-card",
+        action="store_true",
+        help="(HF only) Try to copy the upstream model README.md into notes/model_card.md (best-effort, offline-friendly).",
+    )
     add.set_defaults(func=cmd_add)
 
     return parser
diff --git a/scripts/openai_compat_smoke.py b/scripts/openai_compat_smoke.py
new file mode 100644
index 0000000..c51d8be
--- /dev/null
+++ b/scripts/openai_compat_smoke.py
@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from tui_app.transports.openai_http import compat_chat_completion_request, normalize_openai_base_url, resolve_model_once
+
+
+def _resolve_model(base_url: str, model: str, timeout_s: float, api_key: str) -> str:
+    if model.strip():
+        return model.strip()
+    return resolve_model_once(base_url, timeout_s=timeout_s, api_key=api_key)
+
+
+def _tool_schema() -> list[dict[str, object]]:
+    return [
+        {
+            "type": "function",
+            "function": {
+                "name": "echo",
+                "description": "Return the text unchanged.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {"text": {"type": "string"}},
+                    "required": ["text"],
+                    "additionalProperties": False,
+                },
+            },
+        }
+    ]
+
+
+def _build_messages() -> list[dict[str, object]]:
+    return [
+        {
+            "role": "system",
+            "content": "You are a tool-calling assistant. When the user asks you to use echo, respond with a tool call only.",
+        },
+        {
+            "role": "user",
+            "content": "Call the echo tool with text exactly equal to smoke-test.",
+        },
+    ]
+
+
+def _build_payload(model: str, *, stream: bool) -> dict[str, object]:
+    return {
+        "model": model,
+        "stream": stream,
+        "messages": _build_messages(),
+        "tools": _tool_schema(),
+        "tool_choice": {"type": "function", "function": {"name": "echo"}},
+        "max_tokens": 256,
+        "temperature": 0.0,
+    }
+
+
+def _validate_stream(result: dict[str, object]) -> list[str]:
+    issues: list[str] = []
+    tool_calls = result.get("tool_calls")
+    if not isinstance(tool_calls, list) or not tool_calls:
+        issues.append("stream: no tool_calls accumulated from SSE deltas")
+    else:
+        first = tool_calls[0]
+        if str(first.get("name") or "") != "echo":
+            issues.append(f"stream: expected tool name echo, got {first.get('name')!r}")
+        if "smoke-test" not in str(first.get("arguments") or ""):
+            issues.append("stream: tool arguments did not contain smoke-test")
+    finish_reason = result.get("finish_reason")
+    if finish_reason not in {"tool_calls", "stop"}:
+        issues.append(f"stream: unexpected finish_reason {finish_reason!r}")
+    return issues
+
+
+def _validate_nonstream(result: dict[str, object]) -> list[str]:
+    issues: list[str] = []
+    tool_calls = result.get("tool_calls")
+    if not isinstance(tool_calls, list) or not tool_calls:
+        issues.append("nonstream: no message.tool_calls in response")
+    else:
+        first = tool_calls[0]
+        if str(first.get("name") or "") != "echo":
+            issues.append(f"nonstream: expected tool name echo, got {first.get('name')!r}")
+        if "smoke-test" not in str(first.get("arguments") or ""):
+            issues.append("nonstream: tool arguments did not contain smoke-test")
+    return issues
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="OpenAI-compatible tool-call compatibility smoke check.")
+    parser.add_argument("--base-url", required=True)
+    parser.add_argument("--model", default="")
+    parser.add_argument("--api-key", default="")
+    parser.add_argument("--timeout-s", type=float, default=30.0)
+    args = parser.parse_args()
+
+    base_url = normalize_openai_base_url(args.base_url)
+    model = _resolve_model(base_url, args.model, args.timeout_s, args.api_key)
+
+    stream_payload = _build_payload(model, stream=True)
+    nonstream_payload = _build_payload(model, stream=False)
+
+    stream_result = compat_chat_completion_request(
+        base_url=base_url,
+        payload=stream_payload,
+        timeout_s=args.timeout_s,
+        api_key=args.api_key,
+    )
+    nonstream_result = compat_chat_completion_request(
+        base_url=base_url,
+        payload=nonstream_payload,
+        timeout_s=args.timeout_s,
+        api_key=args.api_key,
+    )
+
+    issues = _validate_stream(stream_result) + _validate_nonstream(nonstream_result)
+
+    report = {
+        "base_url": base_url,
+        "model": model,
+        "stream": {
+            "finish_reason": stream_result.get("finish_reason"),
+            "usage": stream_result.get("usage"),
+            "tool_calls": stream_result.get("tool_calls"),
+        },
+        "nonstream": {
+            "finish_reason": nonstream_result.get("finish_reason"),
+            "usage": nonstream_result.get("usage"),
+            "tool_calls": nonstream_result.get("tool_calls"),
+        },
+        "ok": not issues,
+        "issues": issues,
+    }
+    print(json.dumps(report, indent=2, ensure_ascii=False))
+    return 0 if not issues else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tests/test_telemetry.py b/tests/test_telemetry.py
new file mode 100644
index 0000000..1309277
--- /dev/null
+++ b/tests/test_telemetry.py
@@ -0,0 +1,312 @@
+from __future__ import annotations
+
+import json
+import tempfile
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+
+try:
+    from tui_app.backends.hf import _infer_hf_finish_reason
+except Exception:
+    _infer_hf_finish_reason = None
+
+from tui_app.events import TurnRecord
+from tui_app.log_file import FileLogger
+from tui_app.telemetry import (
+    JsonlTelemetryPublisher,
+    NoOpTelemetryPublisher,
+    TelemetryContext,
+    build_load_report_payload,
+    build_runtime_sample_payload,
+    resolve_model_identity,
+)
+
+
+class TelemetryTests(unittest.TestCase):
+    def test_jsonl_publisher_writes_single_line_event(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "telemetry.jsonl"
+            publisher = JsonlTelemetryPublisher(str(path))
+            ctx = TelemetryContext(
+                session_id="sess_test",
+                started_at="2026-03-15T00:00:00.000Z",
+                backend_name="hf",
+                resolved_model_id="Qwen3.5-9B",
+                resolved_model_id_kind="model_id",
+                model_display_name="Qwen3.5-9B",
+                model_display_name_source="resolved_model_id",
+                model_path=None,
+                transport_name="inproc",
+                config_path=None,
+                profile_name="default",
+                publisher=publisher,
+            )
+            ctx.publish_log_record(source="backend", message="hello")
+
+            lines = path.read_text(encoding="utf-8").splitlines()
+            self.assertEqual(len(lines), 1)
+            event = json.loads(lines[0])
+            self.assertEqual(event["event_type"], "log_recorded")
+            self.assertEqual(event["session_id"], "sess_test")
+            self.assertEqual(event["payload"]["message"], "hello")
+
+    def test_session_started_emits_model_display_name_and_path(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "telemetry.jsonl"
+            args = SimpleNamespace(
+                backend="hf",
+                model_id="/home/poop/ml/models/Qwen3.5-9B",
+                display_name="",
+                _config_path="/home/poop/ml/model-runner/models/Qwen3.5-9B/hf/config/default.toml",
+                _config_profile="",
+                telemetry_jsonl=str(path),
+            )
+            session = SimpleNamespace(backend_name="hf", resolved_model_id="/home/poop/ml/models/Qwen3.5-9B")
+            ctx = TelemetryContext.create(args, session)
+
+            ctx.publish_session_started()
+
+            event = json.loads(path.read_text(encoding="utf-8").splitlines()[0])
+            self.assertEqual(event["model_display_name"], "Qwen3.5-9B")
+            self.assertEqual(event["model_path"], "/home/poop/ml/models/Qwen3.5-9B")
+            self.assertEqual(event["resolved_model_id_kind"], "path")
+            self.assertEqual(event["payload"]["model_display_name_source"], "config_model_dir")
+
+    def test_resolve_model_identity_falls_back_to_config_model_dir(self):
+        args = SimpleNamespace(
+            model_id="/home/poop/ml/models/Qwen3.5-9B",
+            display_name="",
+            _config_path="/home/poop/ml/model-runner/models/Qwen3.5-9B/hf/config/default.toml",
+        )
+        session = SimpleNamespace(resolved_model_id="/home/poop/ml/models/Qwen3.5-9B")
+
+        identity = resolve_model_identity(args=args, session=session)
+
+        self.assertEqual(identity.model_display_name, "Qwen3.5-9B")
+        self.assertEqual(identity.model_display_name_source, "config_model_dir")
+        self.assertEqual(identity.model_path, "/home/poop/ml/models/Qwen3.5-9B")
+        self.assertEqual(identity.resolved_model_id_kind, "path")
+
+    def test_load_report_carries_standardized_model_identity(self):
+        args = SimpleNamespace(
+            backend="hf",
+            model_id="/home/poop/ml/models/Qwen3.5-9B",
+            display_name="",
+            _config_path="/home/poop/ml/model-runner/models/Qwen3.5-9B/hf/config/default.toml",
+            max_context_tokens=49152,
+            vllm_tensor_parallel_size=0,
+            dtype="bfloat16",
+            use_8bit=False,
+            use_4bit=False,
+            hf_attn_implementation="flash_attention_2",
+        )
+        session = SimpleNamespace(
+            backend_name="hf",
+            resolved_model_id="/home/poop/ml/models/Qwen3.5-9B",
+            describe=lambda: {
+                "torch_dtype_effective": "bfloat16",
+                "weights_quantization": "none",
+                "attention_backend_effective": "flash_attention_2",
+                "context_length_effective": 32768,
+                "memory_footprint_bytes": 1234,
+                "runtime_device": "cuda:0",
+                "fully_on_single_gpu": True,
+                "modules_on_cpu": 0,
+                "modules_on_disk": 0,
+                "text_only_mode": True,
+            },
+        )
+
+        payload = build_load_report_payload(session=session, args=args)
+
+        self.assertEqual(payload["model_identifier"], "/home/poop/ml/models/Qwen3.5-9B")
+        self.assertEqual(payload["model_identifier_kind"], "path")
+        self.assertEqual(payload["model_display_name"], "Qwen3.5-9B")
+        self.assertEqual(payload["model_path"], "/home/poop/ml/models/Qwen3.5-9B")
+        self.assertEqual(payload["context_length"], 32768)
+        self.assertEqual(payload["extension"]["runtime_truth"]["requested"]["context_length"], 49152)
+        self.assertEqual(payload["extension"]["runtime_truth"]["confirmed"]["context_length"], 32768)
+        self.assertEqual(
+            payload["extension"]["runtime_truth"]["mismatches"]["context_length"],
+            {"requested": 49152, "confirmed": 32768},
+        )
+
+    def test_runtime_sample_marks_idle_throughput_unavailable(self):
+        ctx = TelemetryContext(
+            session_id="sess_test",
+            started_at="2026-03-15T00:00:00.000Z",
+            backend_name="hf",
+            resolved_model_id="/home/poop/ml/models/Qwen3.5-9B",
+            resolved_model_id_kind="path",
+            model_display_name="Qwen3.5-9B",
+            model_display_name_source="config_model_dir",
+            model_path="/home/poop/ml/models/Qwen3.5-9B",
+            transport_name="inproc",
+            config_path=None,
+            profile_name="default",
+            publisher=NoOpTelemetryPublisher(),
+        )
+        session = SimpleNamespace(describe=lambda: {})
+
+        payload = build_runtime_sample_payload(
+            telemetry=ctx,
+            session=session,
+            generated_tokens=42,
+            elapsed_s=4.2,
+            requests_completed_total=1,
+            requests_in_flight=0,
+        )
+
+        self.assertEqual(payload["activity_state"], "idle")
+        self.assertEqual(payload["requests"]["activity_state"], "idle")
+        self.assertEqual(payload["gpu"]["measurement_state"], "unavailable")
+        self.assertEqual(payload["gpu"]["diagnosis_state"], "unavailable")
+        self.assertEqual(payload["throughput"]["measurement_state"], "idle")
+        self.assertEqual(payload["throughput"]["reported_speed_type"], "raw_completion")
+        self.assertEqual(payload["throughput"]["trust_level"], "unavailable")
+        self.assertEqual(payload["throughput"]["effective_measurement_state"], "unavailable")
+        self.assertEqual(payload["kv_cache"]["measurement_state"], "unavailable")
+        self.assertEqual(
+            payload["kv_cache"]["unavailable_reason"],
+            "backend_does_not_report_kv_cache_runtime_usage",
+        )
+        self.assertNotIn("tokens_generated_per_second", payload["throughput"])
+        self.assertNotIn("effective_tokens_per_second", payload["throughput"])
+
+    def test_runtime_sample_marks_active_throughput_provisional(self):
+        ctx = TelemetryContext(
+            session_id="sess_test",
+            started_at="2026-03-15T00:00:00.000Z",
+            backend_name="hf",
+            resolved_model_id="/home/poop/ml/models/Qwen3.5-9B",
+            resolved_model_id_kind="path",
+            model_display_name="Qwen3.5-9B",
+            model_display_name_source="config_model_dir",
+            model_path="/home/poop/ml/models/Qwen3.5-9B",
+            transport_name="inproc",
+            config_path=None,
+            profile_name="default",
+            publisher=NoOpTelemetryPublisher(),
+        )
+        session = SimpleNamespace(describe=lambda: {})
+
+        payload = build_runtime_sample_payload(
+            telemetry=ctx,
+            session=session,
+            generated_tokens=12,
+            elapsed_s=3.0,
+            requests_completed_total=0,
+            requests_in_flight=1,
+        )
+
+        self.assertEqual(payload["activity_state"], "generating")
+        self.assertEqual(payload["requests"]["activity_state"], "in_flight")
+        self.assertEqual(payload["throughput"]["measurement_state"], "active_generation")
+        self.assertEqual(payload["throughput"]["reported_speed_type"], "raw_completion")
+        self.assertEqual(payload["throughput"]["trust_level"], "provisional")
+        self.assertEqual(payload["throughput"]["effective_measurement_state"], "unavailable")
+        self.assertEqual(payload["throughput"]["tokens_generated_total"], 12)
+        self.assertEqual(payload["throughput"]["tokens_generated_per_second"], 4.0)
+        self.assertNotIn("effective_tokens_per_second", payload["throughput"])
+
+    def test_file_logger_subscribers_receive_canonical_message(self):
+        logger = FileLogger(path=None, default_source="backend")
+        seen: list[tuple[str, str]] = []
+        logger.subscribe(lambda source, message: seen.append((source, message)))
+
+        logger.log("hello\nworld", source="backend")
+
+        self.assertEqual(seen, [("backend", "hello\\nworld")])
+        self.assertRegex(logger.get_recent_logs(1)[0], r"^\d{4}-\d{2}-\d{2}T.* \[backend\] hello\\nworld$")
+
+    def test_turn_finished_emits_ttft_and_decode_latency_when_available(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "telemetry.jsonl"
+            ctx = TelemetryContext(
+                session_id="sess_test",
+                started_at="2026-03-15T00:00:00.000Z",
+                backend_name="hf",
+                resolved_model_id="/home/poop/ml/models/Qwen3.5-9B",
+                resolved_model_id_kind="path",
+                model_display_name="Qwen3.5-9B",
+                model_display_name_source="config_model_dir",
+                model_path="/home/poop/ml/models/Qwen3.5-9B",
+                transport_name="inproc",
+                config_path=None,
+                profile_name="default",
+                publisher=JsonlTelemetryPublisher(str(path)),
+            )
+            record = TurnRecord(
+                raw="raw",
+                think="",
+                answer="answer",
+                ended_in_think=False,
+                backend="hf",
+                model_id="/home/poop/ml/models/Qwen3.5-9B",
+                gen={"finish_reason": "stop", "finish_reason_source": "local_eos_token"},
+                timing={
+                    "start": 1.0,
+                    "end": 11.0,
+                    "elapsed": 10.0,
+                    "time_to_first_token": 0.75,
+                },
+                token_counts={"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15},
+                throughput={"tokens_per_s": 0.5},
+            )
+
+            ctx.publish_turn_finished(turn_id=1, record=record)
+
+            event = json.loads(path.read_text(encoding="utf-8").splitlines()[0])
+            payload = event["payload"]
+            self.assertEqual(payload["request_latency_seconds"], 10.0)
+            self.assertEqual(payload["time_to_first_token_seconds"], 0.75)
+            self.assertEqual(payload["decode_latency_seconds"], 9.25)
+            self.assertEqual(payload["stop_reason"], "stop")
+            self.assertEqual(payload["stop_reason_source"], "local_eos_token")
+            self.assertEqual(payload["extension"]["throughput"]["legacy_tokens_per_second"], 0.5)
+            self.assertAlmostEqual(payload["extension"]["throughput"]["raw_completion_tokens_per_second"], 5 / 9.25)
+            self.assertEqual(payload["extension"]["throughput"]["effective_completion_tokens_per_second"], 0.5)
+
+    def test_session_events_include_activity_state(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "telemetry.jsonl"
+            ctx = TelemetryContext(
+                session_id="sess_test",
+                started_at="2026-03-15T00:00:00.000Z",
+                backend_name="hf",
+                resolved_model_id="/home/poop/ml/models/Qwen3.5-9B",
+                resolved_model_id_kind="path",
+                model_display_name="Qwen3.5-9B",
+                model_display_name_source="config_model_dir",
+                model_path="/home/poop/ml/models/Qwen3.5-9B",
+                transport_name="inproc",
+                config_path=None,
+                profile_name="default",
+                publisher=JsonlTelemetryPublisher(str(path)),
+            )
+
+            ctx.publish_session_started()
+            ctx.publish_session_finished(status="finished")
+
+            started_event, finished_event = [
+                json.loads(line) for line in path.read_text(encoding="utf-8").splitlines()
+            ]
+            self.assertEqual(started_event["payload"]["activity_state"], "idle")
+            self.assertEqual(finished_event["payload"]["activity_state"], "finished")
+
+    @unittest.skipIf(_infer_hf_finish_reason is None, "HF backend dependencies unavailable")
+    def test_hf_finish_reason_infers_length_cap(self):
+        finish_reason, finish_reason_source = _infer_hf_finish_reason(
+            generated_token_ids=[1, 2, 3, 4],
+            completion_tokens=4,
+            max_new_tokens=4,
+            eos_token_id=99,
+        )
+
+        self.assertEqual(finish_reason, "length")
+        self.assertEqual(finish_reason_source, "local_max_new_tokens_cap")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tui.py b/tui.py
index 4a0b5e8..39710f8 100644
--- a/tui.py
+++ b/tui.py
@@ -1,16 +1,21 @@
 from __future__ import annotations
 
 import argparse
+import glob
+import json
 import os
 import re
+import shlex
+import signal
+import subprocess
 import sys
+from urllib import request as urllib_request
+import threading
+import time
 
-from config_utils import load_default_json_config_for_model, load_json_config
-from tui_app.app import TuiRuntime, UnifiedTuiApp
-from tui_app.backends.exl2 import create_session as create_exl2_session
-from tui_app.backends.gguf import create_session as create_gguf_session
-from tui_app.backends.hf import create_session as create_hf_session
-from tui_app.backends.ollama import create_session as create_ollama_session
+from config_utils import apply_machine_model_root, load_config_layers, load_default_config_layers_for_model
+from tui_app.backends.vllm import list_managed_servers, shutdown_managed_server
+from tui_app.transports.openai_http import normalize_openai_base_url, resolve_model_once
 
 
 def normalize_windows_path(raw: str) -> str:
@@ -30,8 +35,14 @@ def detect_backend(model: str | None, backend_override: str | None) -> str:
         return "hf"
 
     normalized = normalize_windows_path(model)
+    if normalized.startswith("attach:"):
+        return "vllm"
     if normalized.startswith("ollama:"):
         return "ollama"
+    if normalized.startswith("openai:"):
+        return "openai"
+    if normalized.startswith("vllm:"):
+        return "vllm"
     if normalized.startswith("exl2:"):
         return "exl2"
     if normalized.lower().endswith(".gguf"):
@@ -61,9 +72,50 @@ def _resolve_path_maybe_relative(path: str, config_path: str | None = None) -> s
     return os.path.abspath(expanded)
 
 
-def _load_default_backend_config(model: str, backend: str):
+def _is_bare_model_stem(value: str | None) -> bool:
+    text = (value or "").strip()
+    if not text:
+        return False
+    if text.startswith((".", "~")):
+        return False
+    if "/" in text or "\\" in text:
+        return False
+    if ":" in text:
+        return False
+    return True
+
+
+def _resolve_gguf_model_id(
+    model_id: str | None,
+    *,
+    model_path: str | None,
+    config_path: str | None,
+) -> str | None:
+    raw_model_path = (model_path or "").strip()
+    if not raw_model_path:
+        return model_id
+
+    value = (model_id or "").strip()
+    if not value:
+        return _resolve_path_maybe_relative(raw_model_path, config_path=config_path)
+    if value.lower().endswith(".gguf"):
+        return model_id
+    if _is_bare_model_stem(value):
+        return _resolve_path_maybe_relative(raw_model_path, config_path=config_path)
+    return model_id
+
+
+def _load_default_backend_config(model: str, backend: str, profile: str = ""):
     if backend != "ollama":
-        return load_default_json_config_for_model(model, backend=backend)
+        data, meta = load_default_config_layers_for_model(
+            model,
+            backend=backend,
+            profile=profile,
+            include_machine=True,
+        )
+        if meta:
+            return data, meta.get("base"), meta
+        return None, None, None
 
     candidates = [model]
     if model.startswith("ollama:"):
@@ -71,16 +123,21 @@ def _load_default_backend_config(model: str, backend: str):
     candidates.append(sanitize_ollama_stem(model))
 
     for candidate in candidates:
-        data, path = load_default_json_config_for_model(candidate, backend=backend)
-        if path:
-            return data, path
-    return None, None
+        data, meta = load_default_config_layers_for_model(
+            candidate,
+            backend=backend,
+            profile=profile,
+            include_machine=True,
+        )
+        if meta:
+            return data, meta.get("base"), meta
+    return None, None, None
 
 
 def _infer_backend_from_default_config(model: str) -> str | None:
     matches: list[str] = []
-    for backend in ("hf", "gguf", "ollama", "exl2"):
-        _, path = _load_default_backend_config(model, backend=backend)
+    for backend in ("hf", "gguf", "ollama", "exl2", "openai", "vllm"):
+        _, path, _ = _load_default_backend_config(model, backend=backend)
         if path:
             matches.append(backend)
     if len(matches) == 1:
@@ -88,11 +145,623 @@ def _infer_backend_from_default_config(model: str) -> str | None:
     return None
 
 
+def _infer_backend_from_loaded_config(config_data: dict | None, config_path: str | None) -> str | None:
+    if isinstance(config_path, str) and config_path.strip():
+        normalized = normalize_windows_path(config_path).replace("\\", "/").lower()
+        for backend in ("openai", "vllm", "ollama", "gguf", "exl2", "hf"):
+            if f"/{backend}/config/" in normalized:
+                return backend
+
+    if not isinstance(config_data, dict):
+        return None
+
+    if str(config_data.get("openai_base_url") or "").strip():
+        return "openai"
+    if (
+        str(config_data.get("vllm_base_url") or "").strip()
+        or str(config_data.get("vllm_mode") or "").strip()
+        or int(config_data.get("vllm_port") or 0) > 0
+    ):
+        return "vllm"
+    if str(config_data.get("ollama_host") or "").strip():
+        return "ollama"
+
+    model_path = str(config_data.get("model_path") or "").strip()
+    if model_path:
+        if model_path.lower().endswith(".gguf"):
+            return "gguf"
+        if str(config_data.get("exl2_repo_path") or "").strip():
+            return "exl2"
+
+    return None
+
+
+def _known_attach_selector(raw: str) -> str | None:
+    value = (raw or "").strip()
+    if not value:
+        return None
+    if value.startswith("attach:"):
+        return value if _resolve_attachable_backend(value) is not None else None
+    prefixed = f"attach:{value}"
+    if _resolve_attachable_backend(prefixed) is not None:
+        return prefixed
+    return None
+
+
+def _normalize_cli_argv(raw_argv: list[str]) -> list[str]:
+    argv = list(raw_argv)
+    backend_tokens = {"hf", "gguf", "ollama", "exl2", "openai", "vllm"}
+    if len(argv) == 1 and argv[0] in backend_tokens:
+        return ["--backend", argv[0]]
+    if len(argv) >= 2 and argv[0] == "attach":
+        selector = argv[1].strip()
+        rest = argv[2:]
+        resolved = _known_attach_selector(selector)
+        if resolved is not None:
+            selector = resolved
+        elif re.match(r"^(vllm|openai|ollama|hf|gguf|exl2|agentmux)-.+-\d+$", selector) and not selector.startswith("attach:"):
+            selector = f"attach:{selector}"
+        return [selector, *rest]
+    if argv and not argv[0].startswith("-"):
+        selector = argv[0].strip()
+        resolved = _known_attach_selector(selector)
+        if resolved is not None:
+            argv[0] = resolved
+        elif re.match(r"^(vllm|openai|ollama|hf|gguf|exl2|agentmux)-.+-\d+$", selector) and not selector.startswith("attach:"):
+            argv[0] = f"attach:{selector}"
+    return argv
+
+
+def _repo_root() -> str:
+    return os.path.dirname(os.path.abspath(__file__))
+
+
+def _slug_path_part(value: str, fallback: str) -> str:
+    text = (value or "").strip().lower()
+    text = re.sub(r"[^a-z0-9._-]+", "-", text)
+    text = re.sub(r"-{2,}", "-", text)
+    text = text.strip("-._")
+    return text or fallback
+
+
+def _attach_selector(entry: dict[str, object]) -> str:
+    kind = _slug_path_part(str(entry.get("kind") or "backend"), "backend")
+    model = _slug_path_part(str(entry.get("resolved_model_id") or entry.get("label") or "backend"), "backend")
+    port = str(entry.get("port") or "na")
+    return f"attach:{kind}-{model}-{port}"
+
+
+def _extract_flag_value(command: list[object], flag: str) -> str:
+    items = [str(item) for item in command]
+    for index, item in enumerate(items):
+        if item == flag and index + 1 < len(items):
+            return items[index + 1]
+    return ""
+
+
+def _extract_first_flag_value(command: list[object], flags: tuple[str, ...]) -> str:
+    for flag in flags:
+        value = _extract_flag_value(command, flag)
+        if value:
+            return value
+    return ""
+
+
+def _agentmux_active_path() -> str:
+    return os.path.join(os.path.expanduser("~"), "runs", "agentmux", "state", "active.json")
+
+
+def _agentmux_attach_selector(stack: str, service: str, port: int) -> str:
+    stack_slug = _slug_path_part(stack, "stack")
+    service_slug = _slug_path_part(service, "service")
+    return f"attach:agentmux-{stack_slug}-{service_slug}-{port}"
+
+
+def _list_agentmux_vllm_processes() -> list[dict[str, object]]:
+    try:
+        output = subprocess.check_output(["ps", "-eo", "pid=,args="], text=True, stderr=subprocess.DEVNULL)
+    except Exception:
+        return []
+
+    entries: list[dict[str, object]] = []
+    for raw_line in output.splitlines():
+        line = raw_line.strip()
+        if not line:
+            continue
+        try:
+            pid_text, command_text = line.split(None, 1)
+        except ValueError:
+            continue
+        if "agentmux/.venv/bin/vllm serve " not in command_text:
+            continue
+        try:
+            pid = int(pid_text)
+        except ValueError:
+            continue
+        try:
+            argv = shlex.split(command_text)
+        except Exception:
+            continue
+        if "serve" not in argv:
+            continue
+        host = _extract_flag_value(argv, "--host").strip() or "127.0.0.1"
+        if host == "0.0.0.0":
+            host = "127.0.0.1"
+        port_text = _extract_flag_value(argv, "--port").strip()
+        served_model_name = _extract_flag_value(argv, "--served-model-name").strip()
+        try:
+            port = int(port_text or 0)
+        except ValueError:
+            continue
+        if port <= 0:
+            continue
+        model_ref = ""
+        if "serve" in argv:
+            idx = argv.index("serve")
+            if idx + 1 < len(argv):
+                model_ref = argv[idx + 1]
+        service_name = "main"
+        for candidate in served_model_name, os.path.basename(model_ref):
+            text = (candidate or "").strip()
+            if text:
+                service_name = _slug_path_part(text, "main")
+                break
+        entries.append(
+            {
+                "pid": pid,
+                "host": host,
+                "port": port,
+                "served_model_name": served_model_name,
+                "service_name": service_name,
+                "source": "ps",
+            }
+        )
+    return entries
+
+
+def _list_agentmux_llama_cpp_processes() -> list[dict[str, object]]:
+    entries: list[dict[str, object]] = []
+    try:
+        output = subprocess.check_output(["ps", "-eo", "pid=,args="], text=True, stderr=subprocess.DEVNULL)
+    except Exception:
+        return entries
+
+    for line in output.splitlines():
+        stripped = line.strip()
+        if not stripped:
+            continue
+        parts = stripped.split(None, 1)
+        if len(parts) != 2:
+            continue
+        try:
+            pid = int(parts[0])
+        except ValueError:
+            continue
+        if pid == os.getpid():
+            continue
+
+        cmdline = parts[1]
+        if "llama-server" not in cmdline:
+            continue
+        try:
+            argv = shlex.split(cmdline)
+        except ValueError:
+            continue
+
+        host = _extract_first_flag_value(argv, ("--host",)).strip() or "127.0.0.1"
+        if host == "0.0.0.0":
+            host = "127.0.0.1"
+        port_text = _extract_first_flag_value(argv, ("--port",)).strip()
+        try:
+            port = int(port_text)
+        except (TypeError, ValueError):
+            port = 0
+        if port <= 0:
+            continue
+
+        alias = _extract_first_flag_value(argv, ("--alias",)).strip()
+        model_path = _extract_first_flag_value(argv, ("-m", "--model")).strip()
+        service_name = "main"
+        for candidate in (alias, os.path.basename(model_path)):
+            text = (candidate or "").strip()
+            if text:
+                service_name = _slug_path_part(text, "main")
+                break
+
+        entries.append(
+            {
+                "pid": pid,
+                "host": host,
+                "port": port,
+                "alias": alias,
+                "model_path": model_path,
+                "service_name": service_name,
+                "source": "ps",
+            }
+        )
+    return entries
+
+
+def _discover_attachable_backends() -> list[dict[str, object]]:
+    entries: list[dict[str, object]] = []
+    seen_urls: set[str] = set()
+
+    def _add(
+        base_url: str,
+        *,
+        label: str,
+        source: str,
+        pid: int | None = None,
+        control_file: str = "",
+        require_model_match: bool = False,
+    ) -> None:
+        normalized_url = normalize_openai_base_url(base_url)
+        if not normalized_url or normalized_url in seen_urls:
+            return
+        try:
+            resolved_model_id = resolve_model_once(normalized_url, timeout_s=2.0, api_key="")
+        except Exception:
+            return
+        if require_model_match:
+            expected = _slug_path_part(label, "")
+            resolved = _slug_path_part(resolved_model_id, "")
+            if expected and resolved and expected != resolved:
+                return
+        seen_urls.add(normalized_url)
+        port_match = re.search(r":(\d+)(?:/v1)?$", normalized_url)
+        port = int(port_match.group(1)) if port_match else 0
+        entry: dict[str, object] = {
+            "kind": "vllm",
+            "backend": "openai",
+            "base_url": normalized_url,
+            "resolved_model_id": resolved_model_id,
+            "label": label or resolved_model_id,
+            "source": source,
+            "pid": int(pid or 0) or None,
+            "control_file": control_file,
+            "port": port or None,
+        }
+        entry["selector"] = _attach_selector(entry)
+        entries.append(entry)
+
+    for row in list_managed_servers():
+        _add(
+            str(row.get("base_url") or ""),
+            label=str(row.get("resolved_model_id") or row.get("model_id") or ""),
+            source=str(row.get("control_file") or row.get("display_path") or "state"),
+            pid=int(row.get("pid") or 0) or None,
+            control_file=str(row.get("control_file") or ""),
+        )
+
+    active_path = _agentmux_active_path()
+    if os.path.isfile(active_path):
+        try:
+            with open(active_path, "r", encoding="utf-8") as fh:
+                active = json.load(fh)
+        except Exception:
+            active = None
+        if isinstance(active, dict):
+            stack_name = str(active.get("stack") or "").strip()
+            services = active.get("services")
+            if isinstance(services, list):
+                for service in services:
+                    if not isinstance(service, dict):
+                        continue
+                    pid = int(service.get("pid") or 0)
+                    if pid <= 0:
+                        continue
+                    try:
+                        os.kill(pid, 0)
+                    except OSError:
+                        continue
+                    command = service.get("command")
+                    command_items = command if isinstance(command, list) else []
+                    rendered = " ".join(str(item) for item in command_items)
+                    is_vllm = "vllm" in rendered and "serve" in rendered
+                    is_llama_cpp = "llama-server" in rendered
+                    if not (is_vllm or is_llama_cpp):
+                        continue
+                    service_name = str(service.get("name") or "").strip() or "service"
+                    host = _extract_first_flag_value(command_items, ("--host",)).strip() or "127.0.0.1"
+                    if host == "0.0.0.0":
+                        host = "127.0.0.1"
+                    port_text = _extract_first_flag_value(command_items, ("--port",)).strip()
+                    port = int(port_text or service.get("port") or 0)
+                    if port <= 0:
+                        continue
+                    base_url = f"http://{host}:{port}"
+                    normalized_url = normalize_openai_base_url(base_url)
+                    if not normalized_url or normalized_url in seen_urls:
+                        continue
+                    try:
+                        resolved_model_id = resolve_model_once(normalized_url, timeout_s=2.0, api_key="")
+                    except Exception:
+                        continue
+                    seen_urls.add(normalized_url)
+                    backend_kind = "agentmux-llama-cpp" if is_llama_cpp else "agentmux"
+                    entries.append(
+                        {
+                            "kind": backend_kind,
+                            "backend": "openai",
+                            "base_url": normalized_url,
+                            "resolved_model_id": resolved_model_id,
+                            "label": f"{stack_name}/{service_name}",
+                            "source": f"{active_path}:{service_name}",
+                            "pid": pid,
+                            "control_file": active_path,
+                            "port": port,
+                            "selector": _agentmux_attach_selector(stack_name or "stack", service_name, port),
+                        }
+                    )
+
+    for process in _list_agentmux_vllm_processes():
+        host = str(process.get("host") or "127.0.0.1").strip() or "127.0.0.1"
+        port = int(process.get("port") or 0)
+        pid = int(process.get("pid") or 0)
+        if port <= 0 or pid <= 0:
+            continue
+        base_url = f"http://{host}:{port}"
+        normalized_url = normalize_openai_base_url(base_url)
+        if not normalized_url or normalized_url in seen_urls:
+            continue
+        try:
+            resolved_model_id = resolve_model_once(normalized_url, timeout_s=2.0, api_key="")
+        except Exception:
+            continue
+        seen_urls.add(normalized_url)
+        service_name = str(process.get("service_name") or "main")
+        label_name = str(process.get("served_model_name") or resolved_model_id or service_name).strip()
+        entries.append(
+            {
+                "kind": "agentmux",
+                "backend": "openai",
+                "base_url": normalized_url,
+                "resolved_model_id": resolved_model_id,
+                "label": f"agentmux/{label_name}",
+                "source": "agentmux process scan",
+                "pid": pid,
+                "control_file": active_path,
+                "port": port,
+                "selector": _agentmux_attach_selector("agentmux", service_name, port),
+            }
+        )
+
+    for process in _list_agentmux_llama_cpp_processes():
+        host = str(process.get("host") or "127.0.0.1").strip() or "127.0.0.1"
+        port = int(process.get("port") or 0)
+        pid = int(process.get("pid") or 0)
+        if port <= 0 or pid <= 0:
+            continue
+        base_url = f"http://{host}:{port}"
+        normalized_url = normalize_openai_base_url(base_url)
+        if not normalized_url or normalized_url in seen_urls:
+            continue
+        try:
+            resolved_model_id = resolve_model_once(normalized_url, timeout_s=2.0, api_key="")
+        except Exception:
+            continue
+        seen_urls.add(normalized_url)
+        service_name = str(process.get("service_name") or "main")
+        label_name = str(process.get("alias") or resolved_model_id or service_name).strip()
+        entries.append(
+            {
+                "kind": "llama-cpp",
+                "backend": "openai",
+                "base_url": normalized_url,
+                "resolved_model_id": resolved_model_id,
+                "label": f"llama-cpp/{label_name}",
+                "source": "llama.cpp process scan",
+                "pid": pid,
+                "control_file": active_path,
+                "port": port,
+                "selector": _agentmux_attach_selector("llama-cpp", service_name, port),
+            }
+        )
+
+    for cfg_path in sorted(glob.glob(os.path.join(_repo_root(), "models", "*", "vllm", "config", "default.toml"))):
+        try:
+            merged, meta = load_config_layers(cfg_path, backend="vllm", include_machine=True)
+        except Exception:
+            continue
+        host = str(merged.get("vllm_host") or "127.0.0.1").strip()
+        port = int(merged.get("vllm_port") or 0)
+        base_url = ""
+        if port > 0:
+            base_url = f"http://{host}:{port}"
+        else:
+            base_url = str(merged.get("vllm_base_url") or "").strip()
+        if not base_url:
+            continue
+        label = str(merged.get("vllm_served_model_name") or merged.get("model_id") or os.path.basename(os.path.dirname(os.path.dirname(cfg_path)))).strip()
+        _add(base_url, label=label, source=str(meta.get("base") or cfg_path), require_model_match=True)
+
+    # agent-session-srv sessions (voice-stack)
+    session_base_url = os.environ.get("SESSION_BASE_URL", "http://127.0.0.1:8892").strip().rstrip("/")
+    session_root = os.path.join(os.path.expanduser("~"), "runs", "agent-session-srv", "sessions")
+    if os.path.isdir(session_root):
+        for sess_dir in sorted(glob.glob(os.path.join(session_root, "sess_*"))):
+            state_path = os.path.join(sess_dir, "state.json")
+            if not os.path.isfile(state_path):
+                continue
+            try:
+                with open(state_path, "r", encoding="utf-8") as fh:
+                    state = json.load(fh)
+            except Exception:
+                continue
+            if not isinstance(state, dict):
+                continue
+            sid = str(state.get("id") or os.path.basename(sess_dir)).strip()
+            backend = state.get("backend") if isinstance(state.get("backend"), dict) else {}
+            backend_base = normalize_openai_base_url(str(backend.get("base_url") or "").strip()) if isinstance(backend, dict) else ""
+            backend_model = str(backend.get("model") or "").strip() if isinstance(backend, dict) else ""
+            if not sid or not backend_base:
+                continue
+
+            # Filter out stale on-disk sessions that are not loaded in current session-srv process.
+            try:
+                req = urllib_request.Request(url=f"{session_base_url}/v1/sessions/{sid}", method="GET")
+                with urllib_request.urlopen(req, timeout=1.5) as resp:
+                    if int(getattr(resp, "status", 0) or 0) != 200:
+                        continue
+            except Exception:
+                continue
+
+            entries.append(
+                {
+                    "kind": "session",
+                    "backend": "openai",
+                    "base_url": backend_base,
+                    "resolved_model_id": backend_model,
+                    "label": f"session/{sid}",
+                    "source": state_path,
+                    "session_id": sid,
+                    "session_base_url": session_base_url,
+                    "selector": f"attach:session-{sid}",
+                }
+            )
+
+    entries.sort(key=lambda item: (str(item.get("kind") or ""), str(item.get("label") or ""), str(item.get("base_url") or "")))
+    return entries
+
+
+def _resolve_attachable_backend(selector: str) -> dict[str, object] | None:
+    normalized = (selector or "").strip()
+    for entry in _discover_attachable_backends():
+        if str(entry.get("selector") or "") == normalized:
+            return entry
+    return None
+
+
+def _extract_cli_option(argv: list[str], name: str) -> str:
+    for index, item in enumerate(argv):
+        if item == name and index + 1 < len(argv):
+            return argv[index + 1]
+        if item.startswith(name + "="):
+            return item.split("=", 1)[1]
+    return ""
+
+
+def _list_exl2_tui_processes() -> list[dict[str, object]]:
+    entries: list[dict[str, object]] = []
+    try:
+        output = subprocess.check_output(["ps", "-eo", "pid=,args="], text=True)
+    except Exception:
+        return entries
+
+    for line in output.splitlines():
+        stripped = line.strip()
+        if not stripped:
+            continue
+        parts = stripped.split(None, 1)
+        if len(parts) != 2:
+            continue
+        try:
+            pid = int(parts[0])
+        except ValueError:
+            continue
+        if pid == os.getpid():
+            continue
+        cmdline = parts[1]
+        if "model-runner" not in cmdline or "tui" not in cmdline:
+            continue
+        argv = shlex.split(cmdline)
+        backend = _extract_cli_option(argv, "--backend")
+        if backend != "exl2":
+            continue
+        entries.append(
+            {
+                "pid": pid,
+                "cmdline": cmdline,
+                "config_path": _extract_cli_option(argv, "--config"),
+                "model_id": _extract_cli_option(argv, "--model-id"),
+            }
+        )
+    return entries
+
+
+def shutdown_exl2_session(args: argparse.Namespace) -> dict[str, object]:
+    candidates = _list_exl2_tui_processes()
+    config_path = str(getattr(args, "_config_path", None) or "").strip()
+    model_id = str(getattr(args, "model_id", None) or "").strip()
+
+    filtered: list[dict[str, object]] = []
+    for entry in candidates:
+        entry_config = str(entry.get("config_path") or "").strip()
+        entry_model = str(entry.get("model_id") or "").strip()
+        if config_path and entry_config and os.path.abspath(entry_config) == os.path.abspath(config_path):
+            filtered.append(entry)
+            continue
+        if model_id and entry_model and entry_model == model_id:
+            filtered.append(entry)
+
+    selected = filtered if filtered else candidates
+    if not selected:
+        return {"stopped": False, "reason": "not_found", "candidates": []}
+    if len(selected) > 1:
+        return {"stopped": False, "reason": "ambiguous", "candidates": selected}
+
+    target = selected[0]
+    pid = int(target.get("pid") or 0)
+    try:
+        os.kill(pid, signal.SIGTERM)
+    except OSError as exc:
+        return {"stopped": False, "reason": f"kill_failed: {exc}", "candidates": [target]}
+
+    return {"stopped": True, "pid": pid, "reason": "terminated", "cmdline": str(target.get("cmdline") or "")}
+
+
+def _print_attachable_backends() -> None:
+    entries = _discover_attachable_backends()
+    if not entries:
+        print("No active attachable backends.")
+        return
+    print("Active attachable backends:")
+    for entry in entries:
+        selector = str(entry.get("selector") or "").strip()
+        model = str(entry.get("resolved_model_id") or entry.get("label") or "").strip() or "(unknown)"
+        base_url = str(entry.get("base_url") or "").strip() or "(unknown)"
+        backend = str(entry.get("kind") or "backend")
+        pid = int(entry.get("pid") or 0)
+        source = str(entry.get("source") or "").strip()
+        extras = [f"backend={backend}", f"model={model}", f"url={base_url}"]
+        if pid:
+            extras.append(f"pid={pid}")
+        if source:
+            extras.append(f"source={source}")
+        print(f"{selector}\t" + "\t".join(extras))
+
+
 def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(description="Unified Textual TUI for HF + GGUF + Ollama + EXL2 backends")
+    parser = argparse.ArgumentParser(
+        description="Unified Textual TUI for HF + GGUF + Ollama + EXL2 + OpenAI-compatible + managed vLLM backends"
+    )
     parser.add_argument("model_id", nargs="?", help="Model id/path, .gguf path, or ollama:<name>")
-    parser.add_argument("--backend", choices=["hf", "gguf", "ollama", "exl2"], default=None)
+    parser.add_argument(
+        "backend_hint",
+        nargs="?",
+        choices=["hf", "gguf", "ollama", "exl2", "openai", "vllm"],
+        help="Optional backend shorthand (e.g. `tui Qwen3.5-9B hf`).",
+    )
+    parser.add_argument("--backend", choices=["hf", "gguf", "ollama", "exl2", "openai", "vllm"], default=None)
+    parser.add_argument(
+        "-ls",
+        "--list",
+        action="store_true",
+        help="List active attachable backends (model-runner vLLM + agentmux first).",
+    )
     parser.add_argument("--config", default="", help="Config path or name.")
+    parser.add_argument("--profile", default="", help="Optional profile name (loads config/profiles/<name>.toml).")
+    parser.add_argument("--backend-only", action="store_true", help="Start backend only without the TUI (vLLM managed only).")
+    parser.add_argument(
+        "--detach-backend",
+        action="store_true",
+        help="Keep managed backend running after this process exits.",
+    )
+    parser.add_argument(
+        "--shutdown-backend",
+        action="store_true",
+        help="Stop the detached managed backend referenced by the current vLLM config.",
+    )
 
     parser.add_argument("--max-new-tokens", type=int, default=2048)
     parser.add_argument("--seed", type=int, default=None)
@@ -102,25 +771,91 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--top-p", type=float, default=1.0)
     parser.add_argument("--top-k", type=int, default=None)
     parser.add_argument("--stop-strings", nargs="+", default=None)
+    parser.add_argument("--stop-token-ids", nargs="+", type=int, default=None)
+    ignore_eos_group = parser.add_mutually_exclusive_group()
+    ignore_eos_group.add_argument("--ignore-eos", dest="ignore_eos", action="store_true")
+    ignore_eos_group.add_argument("--no-ignore-eos", dest="ignore_eos", action="store_false")
+    parser.add_argument("--min-tokens", type=int, default=None)
+    parser.add_argument("--best-of", type=int, default=None)
+    beam_search_group = parser.add_mutually_exclusive_group()
+    beam_search_group.add_argument("--use-beam-search", dest="use_beam_search", action="store_true")
+    beam_search_group.add_argument("--no-use-beam-search", dest="use_beam_search", action="store_false")
+    parser.add_argument("--length-penalty", type=float, default=None)
+    include_stop_group = parser.add_mutually_exclusive_group()
+    include_stop_group.add_argument(
+        "--include-stop-str-in-output", dest="include_stop_str_in_output", action="store_true"
+    )
+    include_stop_group.add_argument(
+        "--no-include-stop-str-in-output", dest="include_stop_str_in_output", action="store_false"
+    )
+    skip_special_group = parser.add_mutually_exclusive_group()
+    skip_special_group.add_argument("--skip-special-tokens", dest="skip_special_tokens", action="store_true")
+    skip_special_group.add_argument("--no-skip-special-tokens", dest="skip_special_tokens", action="store_false")
+    spaces_special_group = parser.add_mutually_exclusive_group()
+    spaces_special_group.add_argument(
+        "--spaces-between-special-tokens", dest="spaces_between_special_tokens", action="store_true"
+    )
+    spaces_special_group.add_argument(
+        "--no-spaces-between-special-tokens", dest="spaces_between_special_tokens", action="store_false"
+    )
+    parser.add_argument("--truncate-prompt-tokens", type=int, default=None)
+    parser.add_argument("--allowed-token-ids", nargs="+", type=int, default=None)
+    parser.add_argument("--prompt-logprobs", type=int, default=None)
 
     parser.add_argument("--system", default="")
     parser.add_argument("--system-file", default="")
     parser.add_argument("--user-prefix", default="")
 
     parser.add_argument("--show-thinking", action="store_true")
+    tool_blocks_group = parser.add_mutually_exclusive_group()
+    tool_blocks_group.add_argument("--show-tool-activity", dest="show_tool_activity", action="store_true")
+    tool_blocks_group.add_argument("--no-show-tool-activity", dest="show_tool_activity", action="store_false")
+    tool_args_group = parser.add_mutually_exclusive_group()
+    tool_args_group.add_argument("--show-tool-arguments", dest="show_tool_arguments", action="store_true")
+    tool_args_group.add_argument("--no-show-tool-arguments", dest="show_tool_arguments", action="store_false")
     parser.add_argument("--no-animate-thinking", action="store_true")
     parser.add_argument("--save-transcript", default="")
+    tools_enabled_group = parser.add_mutually_exclusive_group()
+    tools_enabled_group.add_argument("--tools-enabled", dest="tools_enabled", action="store_true")
+    tools_enabled_group.add_argument("--no-tools-enabled", dest="tools_enabled", action="store_false")
+    parser.add_argument("--tools-mode", choices=["off", "dry_run", "execute"], default="dry_run")
+    parser.add_argument("--tools-schema-file", default="")
+    parser.add_argument("--tools-tool-choice", default="")
+    parser.add_argument("--tools-allow", nargs="+", default=None)
+    parser.add_argument("--tools-deny", nargs="+", default=None)
+    parser.add_argument("--tools-max-calls-per-turn", type=int, default=3)
+    parser.add_argument("--tools-timeout-s", type=float, default=10.0)
+    parser.add_argument("--tools-max-result-chars", type=int, default=8000)
     think_mode_group = parser.add_mutually_exclusive_group()
     think_mode_group.add_argument("--assume-think", dest="assume_think", action="store_true")
     think_mode_group.add_argument("--no-assume-think", dest="assume_think", action="store_false")
 
-    parser.add_argument("--scroll-lines", type=int, default=1)
+    parser.add_argument("--scroll-lines", type=int, default=9)
     parser.add_argument("--ui-tick-ms", type=int, default=33)
     parser.add_argument("--ui-max-events-per-tick", type=int, default=120)
+    parser.add_argument("--capture-last-request", action="store_true")
+    parser.add_argument("--telemetry-jsonl", default="")
+    parser.add_argument("--telemetry-sample-interval-s", type=float, default=1.0)
 
     parser.add_argument("--dtype", choices=["auto", "float16", "bfloat16", "float32"], default="auto")
+    parser.add_argument("--hf-attn", dest="hf_attn_implementation", choices=["eager", "sdpa", "flash_attention_2"], default=None)
+    parser.add_argument("--hf-log-file", default="")
+    parser.add_argument("--hf-device-map", default="")
+    parser.add_argument("--hf-max-memory", default="")
+    hf_text_only_group = parser.add_mutually_exclusive_group()
+    hf_text_only_group.add_argument("--hf-text-only", dest="hf_text_only", action="store_true")
+    hf_text_only_group.add_argument("--no-hf-text-only", dest="hf_text_only", action="store_false")
+    hf_low_cpu_mem_group = parser.add_mutually_exclusive_group()
+    hf_low_cpu_mem_group.add_argument("--hf-low-cpu-mem-usage", dest="hf_low_cpu_mem_usage", action="store_true")
+    hf_low_cpu_mem_group.add_argument(
+        "--no-hf-low-cpu-mem-usage", dest="hf_low_cpu_mem_usage", action="store_false"
+    )
     parser.add_argument("--prompt-mode", choices=["chat", "plain"], default="chat")
     parser.add_argument("--chat-template", default="")
+    history_strip_group = parser.add_mutually_exclusive_group()
+    history_strip_group.add_argument("--history-strip-think", dest="history_strip_think", action="store_true")
+    history_strip_group.add_argument("--no-history-strip-think", dest="history_strip_think", action="store_false")
+    parser.set_defaults(history_strip_think=None)
     parser.add_argument("--max-context-tokens", type=int, default=None)
     parser.add_argument("--repetition-penalty", type=float, default=1.0)
     parser.add_argument("--presence-penalty", type=float, default=None)
@@ -136,6 +871,7 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--n-ctx", type=int, default=4096)
     parser.add_argument("--n-gpu-layers", type=int, default=-1)
     parser.add_argument("--model-path", default="")
+    parser.add_argument("--gguf-log-file", default="")
 
     # EXL2 / ExLlamaV2 knobs (TUI only)
     parser.add_argument("--max-seq-len", dest="max_seq_len", type=int, default=None)
@@ -149,6 +885,7 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--rope-yarn", type=float, default=None)
     parser.add_argument("--low-mem", action="store_true")
     parser.add_argument("--exl2-repo-path", default="")
+    parser.add_argument("--exl2-log-file", default="")
 
     flash_group = parser.add_mutually_exclusive_group()
     flash_group.add_argument("--flash-attn", dest="flash_attn", action="store_true")
@@ -169,9 +906,82 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--ollama-host", default=None)
     parser.add_argument("--ollama-timeout", type=int, default=600)
     parser.add_argument("--ollama-think", choices=["auto", "true", "false"], default="auto")
+    parser.add_argument("--ollama-log-file", default="")
+    parser.add_argument("--openai-base-url", default="")
+    parser.add_argument("--openai-api-key", default="")
+    parser.add_argument("--openai-timeout-s", type=int, default=600)
+    parser.add_argument("--openai-log-file", default="")
+
+    parser.add_argument("--session-base-url", default="")
+    parser.add_argument("--session-id", default="")
 
-    parser.set_defaults(stream=True, assume_think=None)
-    parser.set_defaults(flash_attn=None, xformers=None, sdpa=None, graphs=None)
+    tts_enabled_group = parser.add_mutually_exclusive_group()
+    tts_enabled_group.add_argument("--tts-enabled", dest="tts_enabled", action="store_true")
+    tts_enabled_group.add_argument("--no-tts-enabled", dest="tts_enabled", action="store_false")
+    tts_autoplay_group = parser.add_mutually_exclusive_group()
+    tts_autoplay_group.add_argument("--tts-autoplay", dest="tts_autoplay", action="store_true")
+    tts_autoplay_group.add_argument("--no-tts-autoplay", dest="tts_autoplay", action="store_false")
+    parser.add_argument("--tts-base-url", default="http://127.0.0.1:8880")
+    parser.add_argument("--tts-model", default="kokoro")
+    parser.add_argument("--tts-voice", default="af_heart")
+    parser.add_argument("--tts-speed", type=float, default=1.0)
+
+    stt_enabled_group = parser.add_mutually_exclusive_group()
+    stt_enabled_group.add_argument("--stt-enabled", dest="stt_enabled", action="store_true")
+    stt_enabled_group.add_argument("--no-stt-enabled", dest="stt_enabled", action="store_false")
+    parser.add_argument("--stt-base-url", default="http://127.0.0.1:8891")
+    parser.add_argument("--stt-model", default="whisper-1")
+    parser.add_argument("--stt-language", default="auto")
+
+    parser.add_argument("--vllm-mode", choices=["managed"], default="managed")
+    parser.add_argument("--vllm-host", default="127.0.0.1")
+    parser.add_argument("--vllm-port", type=int, default=8000)
+    parser.add_argument("--vllm-cmd", default="vllm")
+    parser.add_argument("--vllm-extra-args", nargs="*", default=None)
+    parser.add_argument("--vllm-served-model-name", default="")
+    parser.add_argument("--vllm-tensor-parallel-size", type=int, default=1)
+    parser.add_argument("--vllm-gpu-memory-utilization", type=float, default=0.9)
+    parser.add_argument("--vllm-max-model-len", type=int, default=0)
+    parser.add_argument("--vllm-base-url", default="")
+    parser.add_argument("--vllm-api-key", default="")
+    parser.add_argument("--vllm-timeout-s", type=int, default=600)
+    parser.add_argument("--vllm-generation-config", default="auto")
+    parser.add_argument("--vllm-attention-backend", default="")
+    parser.add_argument("--vllm-dtype", default="")
+    vllm_tool_choice_group = parser.add_mutually_exclusive_group()
+    vllm_tool_choice_group.add_argument(
+        "--vllm-enable-auto-tool-choice", dest="vllm_enable_auto_tool_choice", action="store_true"
+    )
+    vllm_tool_choice_group.add_argument(
+        "--no-vllm-enable-auto-tool-choice", dest="vllm_enable_auto_tool_choice", action="store_false"
+    )
+    parser.add_argument("--vllm-tool-call-parser", default="")
+    parser.add_argument("--vllm-log-file", default="")
+
+    parser.set_defaults(
+        stream=True,
+        assume_think=None,
+        tools_enabled=False,
+        show_tool_activity=False,
+        show_tool_arguments=False,
+        tts_enabled=False,
+        tts_autoplay=True,
+        stt_enabled=False,
+    )
+    parser.set_defaults(
+        flash_attn=None,
+        xformers=None,
+        sdpa=None,
+        graphs=None,
+        ignore_eos=None,
+        use_beam_search=None,
+        include_stop_str_in_output=None,
+        skip_special_tokens=None,
+        spaces_between_special_tokens=None,
+        vllm_enable_auto_tool_choice=None,
+        hf_text_only=None,
+        hf_low_cpu_mem_usage=None,
+    )
     return parser
 
 
@@ -191,17 +1001,51 @@ def _collect_config_defaults(config_data: dict | None) -> dict:
         "top_p",
         "top_k",
         "stop_strings",
+        "stop_token_ids",
+        "ignore_eos",
+        "min_tokens",
+        "best_of",
+        "use_beam_search",
+        "length_penalty",
+        "include_stop_str_in_output",
+        "skip_special_tokens",
+        "spaces_between_special_tokens",
+        "truncate_prompt_tokens",
+        "allowed_token_ids",
+        "prompt_logprobs",
         "system",
         "system_file",
         "user_prefix",
         "show_thinking",
+        "show_tool_activity",
+        "show_tool_arguments",
         "no_animate_thinking",
         "save_transcript",
+        "history_strip_think",
+        "tools_enabled",
+        "tools_mode",
+        "tools_schema_file",
+        "tools_tool_choice",
+        "tools_allow",
+        "tools_deny",
+        "tools_max_calls_per_turn",
+        "tools_timeout_s",
+        "tools_max_result_chars",
         "assume_think",
         "scroll_lines",
         "ui_tick_ms",
         "ui_max_events_per_tick",
+        "capture_last_request",
+        "telemetry_jsonl",
+        "telemetry_sample_interval_s",
         "dtype",
+        "hf_attn_implementation",
+        "hf_log_file",
+        "hf_device_map",
+        "hf_max_memory",
+        "hf_text_only",
+        "hf_low_cpu_mem_usage",
+        "hf_cache_dir",
         "prompt_mode",
         "chat_template",
         "max_context_tokens",
@@ -218,6 +1062,7 @@ def _collect_config_defaults(config_data: dict | None) -> dict:
         "n_ctx",
         "n_gpu_layers",
         "model_path",
+        "gguf_log_file",
         "max_seq_len",
         "min_free_tokens",
         "gpu_split",
@@ -229,6 +1074,7 @@ def _collect_config_defaults(config_data: dict | None) -> dict:
         "rope_yarn",
         "low_mem",
         "exl2_repo_path",
+        "exl2_log_file",
         "flash_attn",
         "xformers",
         "sdpa",
@@ -236,6 +1082,41 @@ def _collect_config_defaults(config_data: dict | None) -> dict:
         "ollama_host",
         "ollama_timeout",
         "ollama_think",
+        "ollama_log_file",
+        "openai_base_url",
+        "openai_api_key",
+        "openai_timeout_s",
+        "openai_log_file",
+        "session_base_url",
+        "session_id",
+        "tts_enabled",
+        "tts_autoplay",
+        "tts_base_url",
+        "tts_model",
+        "tts_voice",
+        "tts_speed",
+        "stt_enabled",
+        "stt_base_url",
+        "stt_model",
+        "stt_language",
+        "vllm_mode",
+        "vllm_host",
+        "vllm_port",
+        "vllm_cmd",
+        "vllm_extra_args",
+        "vllm_served_model_name",
+        "vllm_tensor_parallel_size",
+        "vllm_gpu_memory_utilization",
+        "vllm_max_model_len",
+        "vllm_base_url",
+        "vllm_api_key",
+        "vllm_timeout_s",
+        "vllm_generation_config",
+        "vllm_attention_backend",
+        "vllm_dtype",
+        "vllm_enable_auto_tool_choice",
+        "vllm_tool_call_parser",
+        "vllm_log_file",
     }
     return {k: v for k, v in normalized.items() if k in supported}
 
@@ -248,15 +1129,91 @@ def _detect_cli_overrides(argv: list[str]) -> set[str]:
         "--top-p": "top_p",
         "--top-k": "top_k",
         "--stop-strings": "stop_strings",
+        "--stop-token-ids": "stop_token_ids",
+        "--ignore-eos": "ignore_eos",
+        "--no-ignore-eos": "ignore_eos",
+        "--min-tokens": "min_tokens",
+        "--best-of": "best_of",
+        "--use-beam-search": "use_beam_search",
+        "--no-use-beam-search": "use_beam_search",
+        "--length-penalty": "length_penalty",
+        "--include-stop-str-in-output": "include_stop_str_in_output",
+        "--no-include-stop-str-in-output": "include_stop_str_in_output",
+        "--skip-special-tokens": "skip_special_tokens",
+        "--no-skip-special-tokens": "skip_special_tokens",
+        "--spaces-between-special-tokens": "spaces_between_special_tokens",
+        "--no-spaces-between-special-tokens": "spaces_between_special_tokens",
+        "--truncate-prompt-tokens": "truncate_prompt_tokens",
+        "--allowed-token-ids": "allowed_token_ids",
+        "--prompt-logprobs": "prompt_logprobs",
         "--system": "system",
         "--system-file": "system_file",
         "--user-prefix": "user_prefix",
+        "--show-tool-activity": "show_tool_activity",
+        "--no-show-tool-activity": "show_tool_activity",
+        "--show-tool-arguments": "show_tool_arguments",
+        "--no-show-tool-arguments": "show_tool_arguments",
         "--assume-think": "assume_think",
         "--no-assume-think": "assume_think",
+        "--capture-last-request": "capture_last_request",
+        "--telemetry-jsonl": "telemetry_jsonl",
+        "--telemetry-sample-interval-s": "telemetry_sample_interval_s",
+        "--tools-enabled": "tools_enabled",
+        "--no-tools-enabled": "tools_enabled",
+        "--tools-mode": "tools_mode",
+        "--tools-schema-file": "tools_schema_file",
+        "--tools-tool-choice": "tools_tool_choice",
+        "--tools-allow": "tools_allow",
+        "--tools-deny": "tools_deny",
+        "--tools-max-calls-per-turn": "tools_max_calls_per_turn",
+        "--tools-timeout-s": "tools_timeout_s",
+        "--tools-max-result-chars": "tools_max_result_chars",
         "--model-path": "model_path",
+        "--hf-log-file": "hf_log_file",
+        "--gguf-log-file": "gguf_log_file",
+        "--exl2-log-file": "exl2_log_file",
         "--ollama-host": "ollama_host",
         "--ollama-timeout": "ollama_timeout",
         "--ollama-think": "ollama_think",
+        "--ollama-log-file": "ollama_log_file",
+        "--openai-base-url": "openai_base_url",
+        "--openai-api-key": "openai_api_key",
+        "--openai-timeout-s": "openai_timeout_s",
+        "--openai-log-file": "openai_log_file",
+        "--session-base-url": "session_base_url",
+        "--session-id": "session_id",
+        "--tts-enabled": "tts_enabled",
+        "--no-tts-enabled": "tts_enabled",
+        "--tts-autoplay": "tts_autoplay",
+        "--no-tts-autoplay": "tts_autoplay",
+        "--tts-base-url": "tts_base_url",
+        "--tts-model": "tts_model",
+        "--tts-voice": "tts_voice",
+        "--tts-speed": "tts_speed",
+        "--stt-enabled": "stt_enabled",
+        "--no-stt-enabled": "stt_enabled",
+        "--stt-base-url": "stt_base_url",
+        "--stt-model": "stt_model",
+        "--stt-language": "stt_language",
+        "--vllm-mode": "vllm_mode",
+        "--vllm-host": "vllm_host",
+        "--vllm-port": "vllm_port",
+        "--vllm-cmd": "vllm_cmd",
+        "--vllm-extra-args": "vllm_extra_args",
+        "--vllm-served-model-name": "vllm_served_model_name",
+        "--vllm-tensor-parallel-size": "vllm_tensor_parallel_size",
+        "--vllm-gpu-memory-utilization": "vllm_gpu_memory_utilization",
+        "--vllm-max-model-len": "vllm_max_model_len",
+        "--vllm-base-url": "vllm_base_url",
+        "--vllm-api-key": "vllm_api_key",
+        "--vllm-timeout-s": "vllm_timeout_s",
+        "--vllm-generation-config": "vllm_generation_config",
+        "--vllm-attention-backend": "vllm_attention_backend",
+        "--vllm-dtype": "vllm_dtype",
+        "--vllm-enable-auto-tool-choice": "vllm_enable_auto_tool_choice",
+        "--no-vllm-enable-auto-tool-choice": "vllm_enable_auto_tool_choice",
+        "--vllm-tool-call-parser": "vllm_tool_call_parser",
+        "--vllm-log-file": "vllm_log_file",
     }
     seen: set[str] = set()
     for token in argv:
@@ -275,6 +1232,12 @@ def _warn_ignored_flags(parser: argparse.ArgumentParser, args: argparse.Namespac
     backend_relevant = {
         "hf": {
             "dtype",
+            "hf_attn_implementation",
+            "hf_log_file",
+            "hf_device_map",
+            "hf_max_memory",
+            "hf_text_only",
+            "hf_low_cpu_mem_usage",
             "prompt_mode",
             "chat_template",
             "max_context_tokens",
@@ -290,6 +1253,7 @@ def _warn_ignored_flags(parser: argparse.ArgumentParser, args: argparse.Namespac
         "gguf": {
             "n_ctx",
             "n_gpu_layers",
+            "gguf_log_file",
             "prompt_mode",
             "chat_template",
             "top_k",
@@ -298,7 +1262,45 @@ def _warn_ignored_flags(parser: argparse.ArgumentParser, args: argparse.Namespac
             "repetition_penalty",
             "model_path",
         },
-        "ollama": {"ollama_host", "ollama_timeout", "ollama_think"},
+        "ollama": {"ollama_host", "ollama_timeout", "ollama_think", "ollama_log_file"},
+        "openai": {"openai_base_url", "openai_api_key", "openai_timeout_s", "openai_log_file"},
+        "vllm": {
+            "vllm_mode",
+            "vllm_host",
+            "vllm_port",
+            "vllm_cmd",
+            "vllm_extra_args",
+            "vllm_served_model_name",
+            "vllm_tensor_parallel_size",
+            "vllm_gpu_memory_utilization",
+            "vllm_max_model_len",
+            "vllm_base_url",
+            "vllm_api_key",
+            "vllm_timeout_s",
+            "vllm_generation_config",
+            "vllm_attention_backend",
+            "vllm_dtype",
+            "vllm_enable_auto_tool_choice",
+            "vllm_tool_call_parser",
+            "vllm_log_file",
+            "top_k",
+            "min_p",
+            "repetition_penalty",
+            "presence_penalty",
+            "frequency_penalty",
+            "stop_token_ids",
+            "ignore_eos",
+            "min_tokens",
+            "best_of",
+            "use_beam_search",
+            "length_penalty",
+            "include_stop_str_in_output",
+            "skip_special_tokens",
+            "spaces_between_special_tokens",
+            "truncate_prompt_tokens",
+            "allowed_token_ids",
+            "prompt_logprobs",
+        },
         "exl2": {
             "model_path",
             "prompt_mode",
@@ -320,6 +1322,7 @@ def _warn_ignored_flags(parser: argparse.ArgumentParser, args: argparse.Namespac
             "rope_yarn",
             "low_mem",
             "exl2_repo_path",
+            "exl2_log_file",
             "flash_attn",
             "xformers",
             "sdpa",
@@ -331,6 +1334,10 @@ def _warn_ignored_flags(parser: argparse.ArgumentParser, args: argparse.Namespac
         "model_id",
         "backend",
         "config",
+        "profile",
+        "backend_only",
+        "detach_backend",
+        "shutdown_backend",
         "max_new_tokens",
         "seed",
         "stream",
@@ -338,6 +1345,18 @@ def _warn_ignored_flags(parser: argparse.ArgumentParser, args: argparse.Namespac
         "top_p",
         "top_k",
         "stop_strings",
+        "stop_token_ids",
+        "ignore_eos",
+        "min_tokens",
+        "best_of",
+        "use_beam_search",
+        "length_penalty",
+        "include_stop_str_in_output",
+        "skip_special_tokens",
+        "spaces_between_special_tokens",
+        "truncate_prompt_tokens",
+        "allowed_token_ids",
+        "prompt_logprobs",
         "system",
         "system_file",
         "user_prefix",
@@ -345,9 +1364,25 @@ def _warn_ignored_flags(parser: argparse.ArgumentParser, args: argparse.Namespac
         "no_animate_thinking",
         "save_transcript",
         "assume_think",
+        "history_strip_think",
         "scroll_lines",
         "ui_tick_ms",
         "ui_max_events_per_tick",
+        "capture_last_request",
+        "telemetry_jsonl",
+        "telemetry_sample_interval_s",
+        "session_base_url",
+        "session_id",
+        "tts_enabled",
+        "tts_autoplay",
+        "tts_base_url",
+        "tts_model",
+        "tts_voice",
+        "tts_speed",
+        "stt_enabled",
+        "stt_base_url",
+        "stt_model",
+        "stt_language",
     }
 
     used = common | backend_relevant[backend]
@@ -370,56 +1405,171 @@ def _warn_ignored_flags(parser: argparse.ArgumentParser, args: argparse.Namespac
 
 
 def parse_args() -> argparse.Namespace:
-    raw_argv = sys.argv[1:]
+    raw_argv = _normalize_cli_argv(sys.argv[1:])
     cli_overrides = _detect_cli_overrides(raw_argv)
 
     pre = argparse.ArgumentParser(add_help=False)
     pre.add_argument("model_id", nargs="?")
-    pre.add_argument("--backend", choices=["hf", "gguf", "ollama", "exl2"], default=None)
+    pre.add_argument("backend_hint", nargs="?", choices=["hf", "gguf", "ollama", "exl2", "openai", "vllm"])
+    pre.add_argument("--backend", choices=["hf", "gguf", "ollama", "exl2", "openai", "vllm"], default=None)
+    pre.add_argument("-ls", "--list", action="store_true")
+    pre.add_argument("--shutdown-backend", action="store_true")
     pre.add_argument("--config", default="")
-    pre_args, _ = pre.parse_known_args()
+    pre.add_argument("--profile", default="")
+    pre.add_argument("--session-base-url", default="")
+    pre.add_argument("--session-id", default="")
+    pre_args, _ = pre.parse_known_args(raw_argv)
 
-    backend = detect_backend(pre_args.model_id, pre_args.backend)
-    if pre_args.model_id and not pre_args.config and pre_args.backend is None:
+    if (
+        pre_args.model_id in {"hf", "gguf", "ollama", "exl2", "openai", "vllm"}
+        and pre_args.backend_hint is None
+        and pre_args.backend is None
+        and not pre_args.config
+    ):
+        pre_args.backend = pre_args.model_id
+        pre_args.model_id = None
+
+    backend_override = pre_args.backend or pre_args.backend_hint
+    backend = detect_backend(pre_args.model_id, backend_override)
+    if pre_args.model_id and not pre_args.config and pre_args.backend is None and pre_args.backend_hint is None:
         inferred = _infer_backend_from_default_config(pre_args.model_id)
         if inferred:
             backend = inferred
 
     config_data = {}
     config_path = None
+    config_meta = {}
     if pre_args.config:
-        config_data, config_path = load_json_config(pre_args.config, backend=backend)
+        config_data, config_meta = load_config_layers(
+            pre_args.config,
+            backend=backend,
+            profile=pre_args.profile,
+            include_machine=True,
+        )
+        config_path = config_meta.get("base")
         print(f"Loaded config: {config_path}")
     elif pre_args.model_id:
-        config_data, config_path = _load_default_backend_config(pre_args.model_id, backend=backend)
+        config_data, config_path, config_meta = _load_default_backend_config(
+            pre_args.model_id,
+            backend=backend,
+            profile=pre_args.profile,
+        )
         if config_path:
             print(f"Loaded default config: {config_path}")
+    if config_meta is None:
+        config_meta = {}
+    config_backend = _infer_backend_from_loaded_config(config_data, config_path)
+    if pre_args.config and config_backend and config_backend != backend:
+        config_data, config_meta = load_config_layers(
+            pre_args.config,
+            backend=config_backend,
+            profile=pre_args.profile,
+            include_machine=True,
+        )
+        config_path = config_meta.get("base")
+        backend = config_backend
 
     parser = build_parser()
     defaults = _collect_config_defaults(config_data)
     if defaults:
         parser.set_defaults(**defaults)
+    if config_backend and pre_args.backend is None and pre_args.backend_hint is None:
+        parser.set_defaults(backend=config_backend)
 
-    args = parser.parse_args()
+    args = parser.parse_args(raw_argv)
     args._cli_overrides = cli_overrides
     args._config_keys = set(defaults.keys())
-    if not args.model_id:
+    args._config_profile = pre_args.profile or ""
+    args._config_layers = list(config_meta.get("loaded", []) or ([] if not config_path else [config_path]))
+    args._config_origins = dict(config_meta.get("origins", {}) or {})
+    args.display_name = str(config_data.get("display_name", "") or "") if isinstance(config_data, dict) else ""
+    early_backend = detect_backend(args.model_id, args.backend or config_backend)
+    if early_backend == "openai" and not pre_args.model_id:
+        # Attach mode should not inherit a local model path from config defaults.
+        # Let the OpenAI-compatible session resolve /v1/models unless the user
+        # explicitly provided a model id.
+        args.model_id = ""
+    if not args.model_id and early_backend == "gguf":
+        args.model_id = defaults.get("model_path")
+    if early_backend == "gguf":
+        args.model_id = _resolve_gguf_model_id(
+            args.model_id,
+            model_path=args.model_path,
+            config_path=config_path,
+        )
+    if args.list:
+        args.backend = "openai"
+        args.model_id = args.model_id or ""
+        args._config_path = config_path
+        return args
+
+    if str(getattr(args, "session_base_url", "") or "").strip() and str(getattr(args, "session_id", "") or "").strip():
+        # Session mode: transport is handled via session-srv in the TUI app.
+        # Avoid requiring a local model_id/backend selection.
+        args.backend = "openai"
+        args.model_id = ""
+        args._config_path = config_path
+        return args
+    attach_entry = None
+    if isinstance(args.model_id, str) and args.model_id.startswith("attach:"):
+        attach_entry = _resolve_attachable_backend(args.model_id)
+        if attach_entry is None:
+            parser.error(f"Unknown attach selector: {args.model_id}. Run `tui --list`.")
+        args.backend = "openai"
+        args.openai_base_url = str(attach_entry.get("base_url") or "")
+        args.model_id = str(attach_entry.get("resolved_model_id") or "")
+        if str(attach_entry.get("kind") or "") == "session":
+            args.session_base_url = str(attach_entry.get("session_base_url") or "http://127.0.0.1:8892")
+            args.session_id = str(attach_entry.get("session_id") or "")
+        args._attach_entry = attach_entry
+        args._config_path = None
+        return args
+    if args.shutdown_backend and (args.backend or backend) == "vllm" and not args.model_id and not pre_args.config:
+        args.backend = "vllm"
+        args.model_id = ""
+        args._config_path = config_path
+        return args
+    if not args.model_id and early_backend != "openai":
         args.model_id = defaults.get("model_id")
-    if not args.model_id:
+    if not args.model_id and early_backend != "openai":
         parser.error("model_id is required (or provide model_id in --config).")
+    if not args.model_id and early_backend == "openai":
+        args.model_id = ""
 
-    args.backend = detect_backend(args.model_id, args.backend)
-    if args.model_id and not pre_args.config and pre_args.backend is None:
+    backend_override = args.backend or args.backend_hint or config_backend
+    args.backend = detect_backend(args.model_id, backend_override)
+    if args.model_id and not pre_args.config and pre_args.backend is None and pre_args.backend_hint is None:
         inferred = _infer_backend_from_default_config(args.model_id)
         if inferred:
             args.backend = inferred
     args._config_path = config_path
     if args.assume_think is None:
         args.assume_think = False
-    if args.backend == "gguf" and args.model_path:
-        args.model_id = _resolve_path_maybe_relative(args.model_path, config_path=config_path)
+    if args.history_strip_think is None:
+        args.history_strip_think = False
+    if args.backend == "gguf":
+        args.model_id = _resolve_gguf_model_id(
+            args.model_id,
+            model_path=args.model_path,
+            config_path=config_path,
+        )
     if args.backend == "exl2" and isinstance(args.model_id, str) and args.model_id.startswith("exl2:"):
         args.model_id = args.model_id.split(":", 1)[1]
+    if args.backend == "openai" and isinstance(args.model_id, str) and args.model_id.startswith("openai:"):
+        args.model_id = args.model_id.split(":", 1)[1]
+    if args.backend == "vllm" and isinstance(args.model_id, str) and args.model_id.startswith("vllm:"):
+        args.model_id = args.model_id.split(":", 1)[1]
+    # EXL2 uses backend-specific model_path resolution from machine config;
+    # sending its model_id through the generic model_root mapper loses the
+    # exl2_model_root and points at the wrong directory.
+    if args.backend not in {"openai", "ollama", "exl2"} and isinstance(args.model_id, str):
+        args.model_id = apply_machine_model_root(args.model_id)
+    if args.backend == "openai" and not pre_args.model_id:
+        args.model_id = ""
+    if pre_args.model_id:
+        args._config_origins["model_id"] = "cli(positional)"
+    for key in cli_overrides:
+        args._config_origins[key] = "cli"
 
     if not args.system and args.system_file:
         try:
@@ -434,8 +1584,95 @@ def parse_args() -> argparse.Namespace:
     return args
 
 
+def _mirror_engine_logs_to_stdout(
+    stdout_path: str,
+    stderr_path: str,
+    *,
+    stdout_start: int = 0,
+    stderr_start: int = 0,
+) -> tuple[threading.Event, list[threading.Thread]]:
+    stop_event = threading.Event()
+    threads: list[threading.Thread] = []
+
+    def _tail(path: str, target, start_offset: int) -> None:
+        if not path:
+            return
+        try:
+            with open(path, "r", encoding="utf-8", errors="replace") as fh:
+                fh.seek(max(0, int(start_offset)))
+                while not stop_event.is_set():
+                    line = fh.readline()
+                    if line:
+                        print(line.rstrip("\n"), file=target, flush=True)
+                        continue
+                    time.sleep(0.15)
+        except Exception:
+            return
+
+    if stdout_path:
+        t = threading.Thread(target=_tail, args=(stdout_path, sys.stdout, stdout_start), daemon=True)
+        t.start()
+        threads.append(t)
+    if stderr_path:
+        t = threading.Thread(target=_tail, args=(stderr_path, sys.stderr, stderr_start), daemon=True)
+        t.start()
+        threads.append(t)
+    return stop_event, threads
+
+
 def main() -> None:
     args = parse_args()
+    session = None
+    telemetry = None
+
+    if args.list:
+        _print_attachable_backends()
+        return
+
+    if args.shutdown_backend:
+        if args.backend == "vllm":
+            try:
+                result = shutdown_managed_server(args)
+            except Exception as exc:
+                print(f"Failed to shut down managed vLLM backend: {exc}")
+                sys.exit(1)
+            if result.get("stopped"):
+                label = "Managed vLLM stopped" if result.get("control_file") else "vLLM stopped"
+                print(f"{label}: pid={result.get('pid')} base_url={result.get('base_url')} control_file={result.get('control_file')}")
+                return
+            if result.get("reason") == "ambiguous":
+                print("Multiple active vLLM backends matched. Use --config or model_id to choose one:")
+                for entry in result.get("candidates") or []:
+                    print(
+                        f"  pid={entry.get('pid')} base_url={entry.get('base_url')} "
+                        f"model={entry.get('resolved_model_id')} control_file={entry.get('control_file')}"
+                    )
+                sys.exit(1)
+            print(f"No managed vLLM stopped ({result.get('reason')}): control_file={result.get('control_file')}")
+            return
+        if args.backend == "exl2":
+            result = shutdown_exl2_session(args)
+            if result.get("stopped"):
+                print(f"EXL2 session stopped: pid={result.get('pid')}")
+                return
+            if result.get("reason") == "ambiguous":
+                print("Multiple active EXL2 sessions matched. Use --config to choose one:")
+                for entry in result.get("candidates") or []:
+                    print(f"  pid={entry.get('pid')} config={entry.get('config_path')} cmd={entry.get('cmdline')}")
+                sys.exit(1)
+            print(f"No EXL2 session stopped ({result.get('reason')}).")
+            return
+        print("--shutdown-backend is currently supported for managed vLLM and EXL2 sessions.")
+        sys.exit(1)
+
+    from tui_app.app import TuiRuntime, UnifiedTuiApp
+    from tui_app.backends.exl2 import create_session as create_exl2_session
+    from tui_app.backends.gguf import create_session as create_gguf_session
+    from tui_app.backends.hf import create_session as create_hf_session
+    from tui_app.backends.ollama import create_session as create_ollama_session
+    from tui_app.backends.openai import create_session as create_openai_session
+    from tui_app.backends.vllm import create_session as create_vllm_session
+    from tui_app.telemetry import TelemetryContext, attach_log_subscribers
 
     try:
         if args.backend == "hf":
@@ -446,6 +1683,10 @@ def main() -> None:
             session = create_ollama_session(args)
         elif args.backend == "exl2":
             session = create_exl2_session(args)
+        elif args.backend == "openai":
+            session = create_openai_session(args)
+        elif args.backend == "vllm":
+            session = create_vllm_session(args)
         else:
             raise RuntimeError(f"Unknown backend: {args.backend}")
     except Exception as exc:
@@ -453,9 +1694,106 @@ def main() -> None:
         print("If tokenizer conversion fails, install: sentencepiece, tiktoken, protobuf")
         sys.exit(1)
 
-    print(f"TUI ready (backend={args.backend}). Commands: /exit, /quit, /clear")
-    app = UnifiedTuiApp(TuiRuntime(session=session, args=args))
-    app.run()
+    telemetry = TelemetryContext.create(args, session)
+    if telemetry.enabled:
+        attach_log_subscribers(session, lambda source, line: telemetry.publish_log_record(source=source, message=line))
+        telemetry.publish_session_started()
+        telemetry.publish_load_report(session, args)
+
+    if args.backend_only:
+        if args.backend != "vllm":
+            print("--backend-only is currently supported only for the managed vLLM backend.")
+            closer = getattr(session, "close", None)
+            if callable(closer):
+                closer()
+            sys.exit(1)
+        describe = getattr(session, "describe", None)
+        info = describe() if callable(describe) else {}
+        if not isinstance(info, dict):
+            info = {}
+        print(
+            "Backend ready "
+            f"(backend={args.backend}, base_url={info.get('base_url')}, pid={info.get('pid')}, "
+            f"control_file={info.get('control_file')})"
+        )
+        if args.detach_backend:
+            detacher = getattr(session, "detach", None)
+            if callable(detacher):
+                detacher()
+            closer = getattr(session, "close", None)
+            if callable(closer):
+                closer()
+            return
+        print("Serving in foreground. Press Ctrl+C to stop.")
+        mirror_stop = None
+        mirror_threads: list[threading.Thread] = []
+        stdout_path = str(info.get("engine_stdout_path") or "")
+        stderr_path = str(info.get("engine_stderr_path") or "")
+        if stdout_path or stderr_path:
+            mirror_stop, mirror_threads = _mirror_engine_logs_to_stdout(
+                stdout_path,
+                stderr_path,
+                stdout_start=int(info.get("engine_stdout_start") or 0),
+                stderr_start=int(info.get("engine_stderr_start") or 0),
+            )
+        try:
+            while True:
+                signal.pause()
+        except KeyboardInterrupt:
+            pass
+        finally:
+            if telemetry is not None and telemetry.enabled:
+                telemetry.publish_session_finished(status="finished")
+                telemetry.close()
+            if mirror_stop is not None:
+                mirror_stop.set()
+            for thread in mirror_threads:
+                try:
+                    thread.join(timeout=0.5)
+                except Exception:
+                    pass
+            closer = getattr(session, "close", None)
+            if callable(closer):
+                try:
+                    closer()
+                except Exception as exc:
+                    print(f"Warning: backend shutdown failed: {exc}")
+        return
+
+    print(
+        f"TUI ready (backend={args.backend}). "
+        "Commands: /exit (leave backend running), /quit (shut down backend), /clear. "
+        "Ctrl+Q exits TUI only."
+    )
+    app = UnifiedTuiApp(TuiRuntime(session=session, args=args, telemetry=telemetry))
+    if args.detach_backend:
+        app.shutdown_backend_on_exit = False
+    try:
+        app.run()
+    finally:
+        if telemetry is not None and telemetry.enabled:
+            telemetry.close()
+        if not getattr(app, "shutdown_backend_on_exit", True):
+            describe = getattr(session, "describe", None)
+            info = describe() if callable(describe) else {}
+            if not isinstance(info, dict):
+                info = {}
+            detacher = getattr(session, "detach", None)
+            if callable(detacher):
+                try:
+                    detacher()
+                except Exception:
+                    pass
+            print(
+                "TUI exited and backend was left running: "
+                f"base_url={info.get('base_url')} pid={info.get('pid')} control_file={info.get('control_file')}"
+            )
+        closer = getattr(session, "close", None)
+        if callable(closer):
+            try:
+                closer()
+            except Exception as exc:
+                print(f"Warning: backend shutdown failed: {exc}")
 
 
 if __name__ == "__main__":
diff --git a/tui_app/app.py b/tui_app/app.py
index 37c67d9..a58355f 100644
--- a/tui_app/app.py
+++ b/tui_app/app.py
@@ -1,15 +1,25 @@
 from __future__ import annotations
 
 import argparse
+import asyncio
+from collections import deque
 import difflib
 import json
+import mimetypes
 import os
 import queue
+import re
 import shlex
+import shutil
+import subprocess
 import threading
 import time
+import uuid
 from dataclasses import dataclass
 from typing import Callable
+from urllib import error as urllib_error
+from urllib import request as urllib_request
+from urllib.parse import urlencode
 
 from rich.text import Text
 from textual.app import App, ComposeResult
@@ -21,6 +31,10 @@
 
 from tui_app.backends.base import BackendSession, Event
 from tui_app.events import AnswerDelta, Error, Finish, Meta, ThinkDelta, TurnStart
+from tui_app.knobs import build_intent_knobs
+from tui_app.telemetry import TelemetryContext, build_runtime_sample_payload
+from tui_app.think_router import ThinkRouter
+from tui_app.tools import build_tool_runtime
 
 
 @dataclass
@@ -32,7 +46,13 @@ class SlashCommand:
     aliases: tuple[str, ...] = ()
     read_only: bool = True
     examples: tuple[str, ...] = ()
-    include_in_help: bool = True
+    hidden: bool = False
+
+
+@dataclass
+class ShowOptions:
+    verbose: bool = False
+    as_json: bool = False
 
 
 @dataclass
@@ -78,6 +98,17 @@ def all_commands(self) -> list[SlashCommand]:
         return [self._commands[name] for name in self.canonical_names()]
 
 
+def _format_name_grid(items: list[str], *, cols: int = 4, indent: str = "  ", min_width: int = 14) -> list[str]:
+    if not items:
+        return [f"{indent}(none)"]
+    width = max(min_width, max(len(item) for item in items) + 2)
+    rows: list[str] = []
+    for start in range(0, len(items), cols):
+        chunk = items[start : start + cols]
+        rows.append(indent + "".join(item.ljust(width) for item in chunk).rstrip())
+    return rows
+
+
 def resolve_path_maybe_relative(path: str, config_path: str | None = None) -> str:
     expanded = os.path.expanduser(path)
     if os.path.isabs(expanded):
@@ -91,12 +122,18 @@ def resolve_path_maybe_relative(path: str, config_path: str | None = None) -> st
 
 
 class UserMessage(Static):
-    def __init__(self, text: str):
+    def __init__(self, text: str, images: list[str] | None = None):
         super().__init__(classes="user-message")
         self.text = text
+        self.images = images or []
 
     def on_mount(self):
-        self.update(Text(f"You: {self.text}", style="white"))
+        body = Text(f"You: {self.text}", style=SOFT_TEXT)
+        if self.images:
+            names = ", ".join(os.path.basename(p) for p in self.images[:6])
+            suffix = "" if len(self.images) <= 6 else f" (+{len(self.images) - 6} more)"
+            body.append(f"\nImages: {names}{suffix}", style="grey70")
+        self.update(body)
 
 
 class InfoMessage(Static):
@@ -113,7 +150,7 @@ def on_mount(self):
 
 class ThinkingPanel(Container):
     expanded = reactive(False)
-    running = reactive(True)
+    running = reactive(False)
     phase = reactive(0)
 
     def __init__(self, start_expanded: bool, animate: bool):
@@ -121,11 +158,13 @@ def __init__(self, start_expanded: bool, animate: bool):
         self.expanded = start_expanded
         self.animate = animate
         self.thinking_text = ""
-        self.thinking_tokens = 0
-        self.started_at = time.time()
+        self.generated_tokens = 0
+        self.started_at: float | None = None
         self.total_seconds = 0.0
         self.tokens_per_sec = 0.0
         self.ended_in_think = False
+        self._token_events: deque[tuple[float, int]] = deque()
+        self._live_window_seconds = 2.0
 
     def compose(self) -> ComposeResult:
         yield Static(id="thinking-header")
@@ -139,21 +178,44 @@ def on_mount(self):
 
     def _tick(self):
         if self.running and not self.expanded:
+            self._trim_token_events()
             self.phase += 1
             self._render_header()
 
+    def _trim_token_events(self, now: float | None = None):
+        if now is None:
+            now = time.time()
+        cutoff = now - self._live_window_seconds
+        while self._token_events and self._token_events[0][0] < cutoff:
+            self._token_events.popleft()
+
+    def _live_tokens_per_sec(self) -> float:
+        if not self._token_events:
+            return 0.0
+        now = time.time()
+        self._trim_token_events(now)
+        if not self._token_events:
+            return 0.0
+        span = max(0.001, now - self._token_events[0][0])
+        tokens = sum(token_inc for _ts, token_inc in self._token_events)
+        return tokens / span
+
     def _header_text(self) -> Text:
         arrow = "▼" if self.expanded else ">"
-        base = "thinking..."
-        elapsed = time.time() - self.started_at if self.running else self.total_seconds
-        suffix = f" ({self.thinking_tokens} tokens"
-        if self.running:
-            suffix += f", {elapsed:.1f}s"
+        base = "model..."
+        if self.started_at is None and self.total_seconds <= 0:
+            suffix = " (waiting)"
         else:
-            suffix += f", {self.total_seconds:.1f}s, {self.tokens_per_sec:.1f} tok/sec"
-        if self.ended_in_think:
-            suffix += ", truncated"
-        suffix += ")"
+            elapsed = (time.time() - self.started_at) if (self.running and self.started_at is not None) else self.total_seconds
+            suffix = f" ({self.generated_tokens} tokens"
+            if self.running:
+                live_tps = self._live_tokens_per_sec()
+                suffix += f", {elapsed:.1f}s, {live_tps:.1f} tok/sec"
+            else:
+                suffix += f", {self.total_seconds:.1f}s, {self.tokens_per_sec:.1f} tok/sec"
+            if self.ended_in_think:
+                suffix += ", truncated"
+            suffix += ")"
 
         header = f"{arrow} {base}{suffix}"
         text = Text(header, style="grey")
@@ -161,7 +223,7 @@ def _header_text(self) -> Text:
         if self.running and self.animate and not self.expanded:
             start = 2 + (self.phase % max(1, len(base)))
             end = min(start + 3, 2 + len(base))
-            text.stylize("white", start, end)
+            text.stylize(SOFT_TEXT, start, end)
 
         return text
 
@@ -180,10 +242,20 @@ def _render_body(self):
             body.update("")
         self.refresh(layout=True)
 
-    def add_think_tokens(self, token_inc: int):
+    def start(self):
+        if self.started_at is None:
+            self.started_at = time.time()
+        self._token_events.clear()
+        self.running = True
+        self._render_header()
+
+    def add_generated_tokens(self, token_inc: int):
         if token_inc <= 0:
             return
-        self.thinking_tokens += token_inc
+        now = time.time()
+        self.generated_tokens += token_inc
+        self._token_events.append((now, int(token_inc)))
+        self._trim_token_events(now)
         self._render_header()
 
     def append_thinking(self, text: str):
@@ -195,10 +267,16 @@ def append_thinking(self, text: str):
             self._render_body()
         self.refresh(layout=True)
 
-    def finish(self, ended_in_think: bool):
+    def finish(self, *, ended_in_think: bool, completion_tokens: int | None = None, tokens_per_s: float | None = None):
         self.running = False
-        self.total_seconds = max(0.0, time.time() - self.started_at)
-        self.tokens_per_sec = self.thinking_tokens / self.total_seconds if self.total_seconds > 0 else 0.0
+        if self.started_at is not None:
+            self.total_seconds = max(0.0, time.time() - self.started_at)
+        if completion_tokens is not None and completion_tokens >= 0:
+            self.generated_tokens = int(completion_tokens)
+        if tokens_per_s is not None:
+            self.tokens_per_sec = float(tokens_per_s)
+        else:
+            self.tokens_per_sec = self.generated_tokens / self.total_seconds if self.total_seconds > 0 else 0.0
         self.ended_in_think = ended_in_think
         self._render_header()
 
@@ -214,22 +292,35 @@ def on_click(self, event):
 
 
 class AssistantMessage(Container):
-    def __init__(self, start_expanded: bool, animate_thinking: bool):
+    def __init__(
+        self,
+        start_expanded: bool,
+        animate_thinking: bool,
+        show_tool_activity: bool,
+        show_tool_arguments: bool,
+    ):
         super().__init__(classes="assistant-message")
         self.start_expanded = start_expanded
         self.animate_thinking = animate_thinking
+        self.show_tool_activity = show_tool_activity
+        self.show_tool_arguments = show_tool_arguments
         self.answer_text = ""
 
     def compose(self) -> ComposeResult:
         self.thinking_panel = ThinkingPanel(start_expanded=self.start_expanded, animate=self.animate_thinking)
         self.answer_widget = Static(classes="assistant-answer")
+        self.tools_widget = Static(classes="assistant-tools")
         self.hint_widget = Static(classes="assistant-hint")
         yield self.thinking_panel
         yield self.answer_widget
+        yield self.tools_widget
         yield self.hint_widget
 
-    def add_think_tokens(self, token_inc: int):
-        self.thinking_panel.add_think_tokens(token_inc=token_inc)
+    def start_turn(self):
+        self.thinking_panel.start()
+
+    def add_generated_tokens(self, token_inc: int):
+        self.thinking_panel.add_generated_tokens(token_inc=token_inc)
 
     def append_think(self, text: str):
         self.thinking_panel.append_thinking(text)
@@ -239,11 +330,26 @@ def append_answer(self, text: str):
             return
         self.answer_text += text
         self.answer_widget.styles.height = "auto"
-        self.answer_widget.update(Text(self.answer_text, style="white"))
+        self.answer_widget.update(Text(self.answer_text, style=SOFT_TEXT))
         self.refresh(layout=True)
 
-    def finish(self, ended_in_think: bool):
-        self.thinking_panel.finish(ended_in_think=ended_in_think)
+    def finish(self, record):
+        token_counts = dict(record.token_counts or {})
+        throughput = dict(record.throughput or {})
+        completion_tokens = token_counts.get("completion_tokens")
+        tokens_per_s = throughput.get("tokens_per_s")
+        self.thinking_panel.finish(
+            ended_in_think=record.ended_in_think,
+            completion_tokens=completion_tokens if isinstance(completion_tokens, int) else None,
+            tokens_per_s=float(tokens_per_s) if isinstance(tokens_per_s, (int, float)) else None,
+        )
+        self.tools_widget.update(
+            self._render_tool_activity(
+                record.tool_activity or [],
+                show_activity=self.show_tool_activity,
+                show_arguments=self.show_tool_arguments,
+            )
+        )
         if not self.answer_text.strip():
             msg = "(No final answer produced; generation ended during thinking. Increase max_new_tokens or adjust prompt.)"
             self.hint_widget.update(Text(msg, style="yellow"))
@@ -251,6 +357,44 @@ def finish(self, ended_in_think: bool):
     def toggle_thinking(self):
         self.thinking_panel.toggle()
 
+    @staticmethod
+    def _render_tool_activity(
+        tool_activity: list[dict[str, object]],
+        *,
+        show_activity: bool,
+        show_arguments: bool,
+    ) -> Text:
+        if not show_activity or not tool_activity:
+            return Text("")
+        body = Text()
+        for index, item in enumerate(tool_activity, start=1):
+            if index > 1:
+                body.append("\n\n")
+            status = str(item.get("status", "") or "")
+            name = str(item.get("name", "") or "")
+            tool_call_id = str(item.get("tool_call_id", "") or "")
+            body.append(f"[tool] {name}", style="bold cyan")
+            if tool_call_id:
+                body.append(f" id={tool_call_id}", style="grey70")
+            if status:
+                body.append(f" status={status}", style="yellow")
+            if show_arguments:
+                body.append("\nargs.raw:\n", style="grey70")
+                body.append(str(item.get("arguments_raw", "") or ""), style=SOFT_TEXT)
+                parsed = item.get("arguments_json")
+                if parsed is not None:
+                    body.append("\nargs.json:\n", style="grey70")
+                    body.append(json.dumps(parsed, indent=2, ensure_ascii=False, default=str), style=SOFT_TEXT)
+            result = item.get("result")
+            error = item.get("error")
+            if result not in (None, ""):
+                body.append("\nresult:\n", style="grey70")
+                body.append(str(result), style=SOFT_TEXT)
+            if error not in (None, "") and error != result:
+                body.append("\nerror:\n", style="grey70")
+                body.append(str(error), style=SOFT_TEXT)
+        return body
+
 
 class TranscriptPane(VerticalScroll):
     def _line_step(self) -> int:
@@ -317,6 +461,7 @@ def on_mouse_scroll_down(self, event: MouseScrollDown):
 class TuiRuntime:
     session: BackendSession
     args: argparse.Namespace
+    telemetry: TelemetryContext | None = None
 
 
 class UnifiedTuiApp(App):
@@ -329,18 +474,21 @@ class UnifiedTuiApp(App):
     .thinking-panel { border: none; margin: 0 0 1 0; layout: vertical; height: auto; }
     #thinking-header { color: grey; text-style: bold; }
     #thinking-body { color: grey; margin: 0 0 0 2; height: auto; width: 100%; text-wrap: wrap; }
-    .assistant-answer { color: white; height: auto; width: 100%; text-wrap: wrap; }
+    .assistant-answer { color: #e6dfcf; height: auto; width: 100%; text-wrap: wrap; }
+    .assistant-tools { color: cyan; margin: 1 0 0 2; height: auto; width: 100%; text-wrap: wrap; }
     .assistant-hint { margin: 1 0 0 0; }
     #input-band { dock: bottom; height: 6; background: #3a3a3a; padding: 0 1; }
-    #chat-input { width: 100%; height: 100%; background: #3a3a3a; color: white; border: none; }
+    #chat-input { width: 100%; height: 100%; background: #3a3a3a; color: #e6dfcf; border: none; }
     """
 
     BINDINGS = [
         Binding("t", "toggle_latest_thinking", "Toggle thinking"),
+        Binding("ctrl+q", "exit_tui_only", "Exit TUI", priority=True),
         Binding("ctrl+x", "interrupt_or_quit_hint", "Interrupt generation", priority=True),
         Binding("enter", "submit_prompt", "Send", priority=True),
         Binding("shift+enter", "insert_newline", "New line", priority=True),
         Binding("ctrl+j", "insert_newline", "New line", priority=True),
+        Binding("ctrl+r", "stt_toggle_record", "STT record toggle", priority=True),
         Binding("pageup", "scroll_page_up", "Scroll up", priority=True),
         Binding("pagedown", "scroll_page_down", "Scroll down", priority=True),
         Binding("home", "scroll_home", "Scroll top", priority=True),
@@ -350,14 +498,17 @@ class UnifiedTuiApp(App):
     def __init__(self, runtime: TuiRuntime):
         super().__init__()
         self.runtime = runtime
-        self.messages: list[dict[str, str]] = []
+        self.messages: list[dict[str, object]] = []
         if runtime.args.system:
             self.messages.append({"role": "system", "content": runtime.args.system})
+        self.pending_images: list[str] = []
+        self.pending_text_files: list[str] = []
 
         self.event_queue: queue.Queue = queue.Queue()
         self.pending_assistant: AssistantMessage | None = None
         self.pending_turn_id = 0
         self.is_generating = False
+        self.generation_thread: threading.Thread | None = None
         self.turn_records = []
         self.follow_output = True
         self._scroll_end_scheduled = False
@@ -365,8 +516,31 @@ def __init__(self, runtime: TuiRuntime):
         self.registry = SlashRegistry()
         self.show_topics: dict[str, ShowTopic] = {}
         self.show_aliases: dict[str, str] = {}
+        self._active_show_opts: ShowOptions | None = None
+        self.shutdown_backend_on_exit = True
         self._register_show_topics()
         self._register_commands()
+        self._telemetry_finished = False
+        self._telemetry_status = "finished"
+        self._pending_turn_started_at: float | None = None
+        self._pending_turn_first_token_at: float | None = None
+        self._last_assistant_answer: str = ""
+        self._last_tts_audio_path: str = ""
+        self._last_stt_audio_path: str = ""
+        self._last_stt_text: str = ""
+        self._session_event_thread: threading.Thread | None = None
+        self._session_assistants: dict[str, AssistantMessage] = {}
+        self._session_think_routers: dict[str, ThinkRouter] = {}
+        self._session_answer_accum: dict[str, str] = {}
+        self._stt_recording: bool = False
+        self._stt_record_proc: subprocess.Popen | None = None
+        self._stt_record_path: str = ""
+        self._stt_record_err_path: str = ""
+        self._stt_last_backend: str = ""
+        self._stt_busy: bool = False
+        self._stt_started_at: float = 0.0
+        self._stt_last_toggle_at: float = 0.0
+        self._tui_log_path: str = os.path.join(os.path.expanduser("~"), "runs", "model-runner", "tui.log")
 
     def compose(self) -> ComposeResult:
         self.transcript = TranscriptPane(id="transcript")
@@ -385,37 +559,282 @@ def on_mount(self):
         self.transcript.can_focus = True
         interval_s = max(0.01, float(self.runtime.args.ui_tick_ms) / 1000.0)
         self.set_interval(interval_s, self._drain_events)
+        telemetry = self.runtime.telemetry
+        sample_interval = float(getattr(self.runtime.args, "telemetry_sample_interval_s", 0.0) or 0.0)
+        if telemetry is not None and telemetry.enabled and sample_interval > 0:
+            self.set_interval(max(0.25, sample_interval), self._emit_runtime_sample)
         self.call_after_refresh(self._scroll_to_end_now)
         # Keep typing flow immediate: start with the input focused.
         self.query_one("#chat-input", TextArea).focus()
+        self._maybe_start_session_event_listener()
+
+    def on_unmount(self):
+        telemetry = self.runtime.telemetry
+        if telemetry is not None and telemetry.enabled and not self._telemetry_finished:
+            telemetry.publish_session_finished(status=self._telemetry_status)
+            self._telemetry_finished = True
+
+    def _log_tui(self, message: str) -> None:
+        try:
+            os.makedirs(os.path.dirname(self._tui_log_path), exist_ok=True)
+            if os.path.isfile(self._tui_log_path) and os.path.getsize(self._tui_log_path) > 2 * 1024 * 1024:
+                rotated = self._tui_log_path + ".1"
+                try:
+                    if os.path.isfile(rotated):
+                        os.remove(rotated)
+                except Exception:
+                    pass
+                os.replace(self._tui_log_path, rotated)
+            stamp = time.strftime("%Y-%m-%d %H:%M:%S")
+            with open(self._tui_log_path, "a", encoding="utf-8") as fh:
+                fh.write(f"[{stamp}] {message}\n")
+        except Exception:
+            pass
+
+    def _emit_runtime_sample(self) -> None:
+        telemetry = self.runtime.telemetry
+        if telemetry is None or not telemetry.enabled:
+            return
+        generated_tokens = 0
+        elapsed_s = 0.0
+        if self.is_generating and self.pending_assistant is not None:
+            generated_tokens = int(getattr(self.pending_assistant.thinking_panel, "generated_tokens", 0) or 0)
+            started_at = getattr(self.pending_assistant.thinking_panel, "started_at", None)
+            if isinstance(started_at, (int, float)):
+                elapsed_s = max(0.0, time.time() - float(started_at))
+        payload = build_runtime_sample_payload(
+            telemetry=telemetry,
+            session=self.runtime.session,
+            generated_tokens=generated_tokens,
+            elapsed_s=elapsed_s,
+            requests_completed_total=len(self.turn_records),
+            requests_in_flight=1 if self.is_generating else 0,
+        )
+        telemetry.publish_runtime_sample(payload)
 
     def action_toggle_latest_thinking(self):
         if self.pending_assistant is not None:
             self.pending_assistant.toggle_thinking()
 
+    def action_exit_tui_only(self):
+        self.shutdown_backend_on_exit = False
+        self.exit()
+
     def action_interrupt_or_quit_hint(self):
         if not self.is_generating:
             self.notify("Use Ctrl+Q to quit.", severity="warning")
             return
         if self.pending_assistant is None:
             self.is_generating = False
+            self._pending_turn_started_at = None
+            self._pending_turn_first_token_at = None
             self.pending_turn_id += 1
             self.notify("Generation stopped.", severity="information")
             return
 
         self.pending_assistant.append_answer("\n[Generation stopped by user]")
-        self.pending_assistant.finish(ended_in_think=False)
+        self.pending_assistant.thinking_panel.finish(ended_in_think=False)
         self.is_generating = False
+        self._pending_turn_started_at = None
+        self._pending_turn_first_token_at = None
         # Advance turn id so late events from the interrupted worker are ignored.
         self.pending_turn_id += 1
         if self._should_autofollow():
             self._request_scroll_end()
         self.notify("Generation stopped.", severity="information")
 
+    def _has_active_generation_worker(self) -> bool:
+        if self.generation_thread is None:
+            return False
+        if self.generation_thread.is_alive():
+            return True
+        self.generation_thread = None
+        return False
+
     def action_insert_newline(self):
         input_box = self.query_one("#chat-input", TextArea)
         input_box.insert("\n")
 
+    async def action_stt_toggle_record(self):
+        args = self.runtime.args
+        now = time.time()
+        if now - self._stt_last_toggle_at < 0.35:
+            return
+        self._stt_last_toggle_at = now
+
+        if self._stt_busy:
+            self.notify("STT busy: finishing previous action.", severity="warning")
+            self._log_tui("stt_toggle ignored: busy")
+            return
+        if not bool(getattr(args, "stt_enabled", False)):
+            self.notify("STT is off. Run /stt on first.", severity="warning")
+            self._log_tui("stt_toggle rejected: stt disabled")
+            return
+        if self.is_generating:
+            self.notify("Wait for current generation to finish.", severity="warning")
+            self._log_tui("stt_toggle rejected: generation in progress")
+            return
+        if not self._stt_recording:
+            ok, msg = self._stt_start_recording()
+            if ok:
+                self.notify(f"Recording… press Ctrl+R again to stop and send. ({msg})")
+                self._log_tui(f"stt_record_start path={msg}")
+            else:
+                self.notify(msg, severity="error")
+                self._log_tui(f"stt_record_start_failed: {msg}")
+            return
+
+        self._stt_busy = True
+        self._log_tui("stt_record_stop requested")
+        try:
+            ok, msg = await asyncio.to_thread(self._stt_stop_recording_and_transcribe_send)
+        finally:
+            self._stt_busy = False
+        if ok:
+            self.notify(msg)
+            self._log_tui(f"stt_record_stop_ok: {msg}")
+        else:
+            self.notify(msg, severity="error")
+            self._log_tui(f"stt_record_stop_failed: {msg}")
+
+    def _stt_start_recording(self) -> tuple[bool, str]:
+        if self._stt_recording:
+            return False, "Already recording."
+        stamp = time.strftime("%Y%m%d-%H%M%S")
+        uniq = int(time.time() * 1000) % 1000
+        path = os.path.join(self._stt_output_dir(), f"stt-rec-{stamp}-{uniq:03d}.wav")
+        err_path = os.path.join(self._stt_output_dir(), f"stt-rec-{stamp}-{uniq:03d}.stderr.log")
+
+        candidates: list[tuple[str, list[str], bool]] = []
+        if shutil.which("arecord"):
+            candidates.append(("arecord", ["arecord", "-f", "S16_LE", "-r", "16000", "-c", "1", path], False))
+        if shutil.which("ffmpeg"):
+            candidates.append((
+                "ffmpeg-pulse",
+                [
+                    "ffmpeg", "-hide_banner", "-loglevel", "error", "-y",
+                    "-f", "pulse", "-i", "default",
+                    "-ac", "1", "-ar", "16000", "-c:a", "pcm_s16le", "-f", "wav", path,
+                ],
+                True,
+            ))
+            candidates.append((
+                "ffmpeg-alsa",
+                [
+                    "ffmpeg", "-hide_banner", "-loglevel", "error", "-y",
+                    "-f", "alsa", "-i", "default",
+                    "-ac", "1", "-ar", "16000", "-c:a", "pcm_s16le", "-f", "wav", path,
+                ],
+                True,
+            ))
+
+        if not candidates:
+            return False, "No recorder found (ffmpeg or arecord)."
+
+        last_err = ""
+        for backend_name, cmd, ffmpeg_mode in candidates:
+            try:
+                err_fh = open(err_path, "ab")
+                proc = subprocess.Popen(
+                    cmd,
+                    stdin=subprocess.PIPE if ffmpeg_mode else subprocess.DEVNULL,
+                    stdout=subprocess.DEVNULL,
+                    stderr=err_fh,
+                )
+            except Exception as exc:
+                last_err = str(exc)
+                self._log_tui(f"stt_start_failed backend={backend_name} err={last_err}")
+                continue
+
+            time.sleep(0.2)
+            if proc.poll() is not None:
+                err_tail = ""
+                try:
+                    with open(err_path, "rb") as fh:
+                        err_tail = fh.read()[-600:].decode("utf-8", errors="replace").strip()
+                except Exception:
+                    pass
+                last_err = err_tail or f"exit={proc.returncode}"
+                self._log_tui(f"stt_start_failed backend={backend_name} rc={proc.returncode} err={last_err}")
+                continue
+
+            self._stt_record_proc = proc
+            self._stt_record_path = path
+            self._stt_record_err_path = err_path
+            self._stt_last_backend = backend_name
+            self._stt_recording = True
+            self._stt_started_at = time.time()
+            self._log_tui(f"stt_start backend={backend_name} path={path} err={err_path} pid={proc.pid}")
+            return True, path
+
+        return False, "Recorder unavailable. See ~/runs/model-runner/tui.log"
+
+    def _stt_stop_recording_and_transcribe_send(self) -> tuple[bool, str]:
+        proc = self._stt_record_proc
+        path = self._stt_record_path
+        err_path = self._stt_record_err_path
+        self._stt_record_proc = None
+        self._stt_record_path = ""
+        self._stt_record_err_path = ""
+        self._stt_recording = False
+        if proc is None or not path:
+            self._log_tui("stt_stop: no active recording")
+            return False, "No active recording."
+        try:
+            if proc.stdin is not None:
+                try:
+                    proc.stdin.write(b"q\n")
+                    proc.stdin.flush()
+                except Exception:
+                    pass
+            else:
+                proc.terminate()
+            proc.wait(timeout=4)
+        except Exception:
+            try:
+                proc.terminate()
+                proc.wait(timeout=2)
+            except Exception:
+                try:
+                    proc.kill()
+                except Exception:
+                    pass
+
+        duration_s = max(0.0, time.time() - float(self._stt_started_at or 0.0))
+        for _ in range(20):
+            if os.path.isfile(path) and os.path.getsize(path) > 1024:
+                break
+            time.sleep(0.05)
+        size = os.path.getsize(path) if os.path.isfile(path) else 0
+        err_tail = ""
+        if err_path and os.path.isfile(err_path):
+            try:
+                with open(err_path, "rb") as fh:
+                    err_tail = fh.read()[-700:].decode("utf-8", errors="replace").strip()
+            except Exception:
+                err_tail = ""
+        self._log_tui(f"stt_stop file path={path} duration_s={duration_s:.2f} size={size} err_tail={err_tail}")
+        if duration_s < 0.7 or not os.path.isfile(path) or size <= 1024:
+            return False, "Recording too short/empty. Tap Ctrl+R, speak, tap Ctrl+R again."
+        try:
+            self._log_tui(f"stt_transcribe_start path={path}")
+            text = self._stt_transcribe_file(path)
+        except urllib_error.HTTPError as exc:
+            return False, f"STT request failed: HTTP {exc.code}"
+        except Exception as exc:
+            return False, f"STT request failed: {exc}"
+        if not text.strip():
+            self._log_tui("stt_transcribe_empty")
+            return False, "Transcribed but got empty text."
+        self._log_tui(f"stt_transcribe_done chars={len(text)}")
+        self.call_from_thread(self._stt_inject_and_send, text)
+        return True, f"Transcribed + sent: {text[:80]}"
+
+    def _stt_inject_and_send(self, text: str) -> None:
+        input_box = self.query_one("#chat-input", TextArea)
+        input_box.load_text(text.strip())
+        asyncio.create_task(self.action_submit_prompt())
+
     def _break_follow(self):
         self.follow_output = False
         self._scroll_end_scheduled = False
@@ -459,10 +878,119 @@ def _request_scroll_end(self):
     def _should_autofollow(self) -> bool:
         return self.follow_output
 
+    def _session_mode_enabled(self) -> bool:
+        return bool(str(getattr(self.runtime.args, "session_base_url", "") or "").strip() and str(getattr(self.runtime.args, "session_id", "") or "").strip())
+
+    def _session_api_base(self) -> str:
+        return str(getattr(self.runtime.args, "session_base_url", "") or "").rstrip("/") + "/v1"
+
+    def _maybe_start_session_event_listener(self) -> None:
+        if not self._session_mode_enabled() or self._session_event_thread is not None:
+            return
+
+        def worker() -> None:
+            sid = str(getattr(self.runtime.args, "session_id", "") or "").strip()
+            url = f"{self._session_api_base()}/sessions/{sid}/events"
+            req = urllib_request.Request(url=url, method="GET")
+            try:
+                with urllib_request.urlopen(req, timeout=600) as resp:
+                    event_name = ""
+                    data_lines: list[str] = []
+                    for raw in resp:
+                        line = raw.decode("utf-8", errors="replace").rstrip("\r\n")
+                        if not line:
+                            if data_lines:
+                                payload = "\n".join(data_lines)
+                                self.call_from_thread(self._session_handle_event, event_name or "event", payload)
+                            event_name = ""
+                            data_lines = []
+                            continue
+                        if line.startswith("event:"):
+                            event_name = line.split(":", 1)[1].strip()
+                        elif line.startswith("data:"):
+                            data_lines.append(line.split(":", 1)[1].lstrip())
+            except Exception as exc:
+                self.call_from_thread(self.notify, f"Session SSE disconnected: {exc}", "warning")
+
+        self._session_event_thread = threading.Thread(target=worker, daemon=True)
+        self._session_event_thread.start()
+
+    def _session_handle_event(self, event_name: str, data_text: str) -> None:
+        try:
+            evt = json.loads(data_text)
+        except Exception:
+            return
+        turn_id = str(evt.get("turn_id") or "")
+        payload = evt.get("payload") if isinstance(evt.get("payload"), dict) else {}
+        etype = str(evt.get("type") or event_name)
+
+        if etype == "llm.delta":
+            delta = str(payload.get("text_delta") or "")
+            if not delta:
+                return
+            assistant = self._session_assistants.get(turn_id)
+            if assistant is None:
+                return
+            router = self._session_think_routers.setdefault(
+                turn_id,
+                ThinkRouter(assume_think=bool(getattr(self.runtime.args, "assume_think", False))),
+            )
+            answer_accum = self._session_answer_accum.get(turn_id, "")
+            for channel, text in router.feed(delta):
+                if channel == "think":
+                    assistant.append_think(text)
+                else:
+                    assistant.append_answer(text)
+                    answer_accum += text
+            self._session_answer_accum[turn_id] = answer_accum
+            if self._should_autofollow():
+                self._request_scroll_end()
+        elif etype == "llm.final":
+            text = str(payload.get("text") or "")
+            assistant = self._session_assistants.get(turn_id)
+            if assistant is not None:
+                router = self._session_think_routers.get(turn_id)
+                if router is not None:
+                    answer_accum = self._session_answer_accum.get(turn_id, "")
+                    for channel, chunk in router.flush():
+                        if channel == "think":
+                            assistant.append_think(chunk)
+                        else:
+                            assistant.append_answer(chunk)
+                            answer_accum += chunk
+                    self._session_answer_accum[turn_id] = answer_accum
+                # If no deltas were rendered, fall back to final text.
+                if not self._session_answer_accum.get(turn_id, "") and text:
+                    assistant.append_answer(text)
+                    self._session_answer_accum[turn_id] = text
+                assistant.thinking_panel.finish(ended_in_think=False)
+            final_answer = self._session_answer_accum.get(turn_id, "") or text
+            self._last_assistant_answer = final_answer
+            if final_answer:
+                self.messages.append({"role": "assistant", "content": final_answer})
+            if bool(getattr(self.runtime.args, "tts_enabled", False)) and final_answer.strip():
+                self._tts_autoplay_last_answer_async(final_answer)
+        elif etype == "turn.error":
+            msg = str(payload.get("message") or "session turn error")
+            assistant = self._session_assistants.get(turn_id)
+            if assistant is not None:
+                assistant.append_answer(f"\n[session error] {msg}")
+                assistant.thinking_panel.finish(ended_in_think=False)
+        elif etype == "turn.finished":
+            self.is_generating = False
+            if turn_id in self._session_assistants:
+                self._session_assistants.pop(turn_id, None)
+            self._session_think_routers.pop(turn_id, None)
+            self._session_answer_accum.pop(turn_id, None)
+
     async def action_submit_prompt(self):
         input_box = self.query_one("#chat-input", TextArea)
         text = input_box.text.strip()
-        if not text:
+        if not text and not self.pending_images:
+            if not self.pending_text_files:
+                input_box.load_text("")
+                return
+        if not text and not self.pending_images and not self.pending_text_files:
             input_box.load_text("")
             return
         if text.startswith("//"):
@@ -474,40 +1002,112 @@ async def action_submit_prompt(self):
         if self.is_generating:
             self.notify("Generation in progress. Wait for current turn to finish.")
             return
+        if self._has_active_generation_worker():
+            self.notify("Previous generation is still shutting down. Please wait a moment.")
+            return
         if text.lower() in {"exit", "quit"}:
+            self.shutdown_backend_on_exit = text.lower() == "quit"
             self.exit()
             return
         if text.lower() == "clear":
             self.transcript.remove_children()
             self.messages = []
+            self.turn_records = []
+            self.pending_images.clear()
+            self.pending_text_files.clear()
+            self.pending_assistant = None
             if self.runtime.args.system:
                 self.messages.append({"role": "system", "content": self.runtime.args.system})
             input_box.load_text("")
             return
 
-        user_text = f"{self.runtime.args.user_prefix}{text}" if self.runtime.args.user_prefix else text
-        self.messages.append({"role": "user", "content": user_text})
-        await self.transcript.mount(UserMessage(text))
+        if text:
+            user_text = f"{self.runtime.args.user_prefix}{text}" if self.runtime.args.user_prefix else text
+        else:
+            user_text = ""
+
+        if self.pending_text_files:
+            attached_blocks = []
+            for path in self.pending_text_files:
+                try:
+                    with open(path, "r", encoding="utf-8", errors="replace") as fh:
+                        content = fh.read()
+                except Exception as exc:
+                    self.notify(f"Failed to read attached file: {path} ({exc})", severity="error")
+                    continue
+                attached_blocks.append(f"[Attached file: {os.path.basename(path)}]\n{content}")
+            self.pending_text_files.clear()
+            if attached_blocks:
+                file_text = "\n\n".join(attached_blocks)
+                user_text = f"{user_text}\n\n{file_text}".strip() if user_text else file_text
+
+        message: dict[str, object] = {"role": "user", "content": user_text}
+        images = None
+        if self.pending_images:
+            images = list(self.pending_images)
+            message["images"] = images
+            self.pending_images.clear()
+        self.messages.append(message)
+        await self.transcript.mount(UserMessage(text or "(image)", images=images))
 
         assistant = AssistantMessage(
             start_expanded=self.runtime.args.show_thinking,
             animate_thinking=not self.runtime.args.no_animate_thinking,
+            show_tool_activity=bool(getattr(self.runtime.args, "show_tool_activity", False)),
+            show_tool_arguments=bool(getattr(self.runtime.args, "show_tool_arguments", False)),
         )
         await self.transcript.mount(assistant)
         self.pending_assistant = assistant
         self.pending_turn_id += 1
         turn_id = self.pending_turn_id
         self.is_generating = True
+        self._pending_turn_started_at = None
+        self._pending_turn_first_token_at = None
 
         self.follow_output = True
         self.transcript.refresh(layout=True)
         self._request_scroll_end()
         input_box.load_text("")
 
+        if self._session_mode_enabled():
+            sid = str(getattr(self.runtime.args, "session_id", "") or "").strip()
+            try:
+                body = json.dumps({"text": user_text, "source": "tui"}).encode("utf-8")
+                req = urllib_request.Request(
+                    url=f"{self._session_api_base()}/sessions/{sid}/input",
+                    data=body,
+                    headers={"content-type": "application/json"},
+                    method="POST",
+                )
+                with urllib_request.urlopen(req, timeout=30) as resp:
+                    result = json.loads(resp.read().decode("utf-8"))
+                session_turn_id = str(result.get("turn_id") or "")
+                if session_turn_id:
+                    self._session_assistants[session_turn_id] = assistant
+                    self._session_think_routers[session_turn_id] = ThinkRouter(
+                        assume_think=bool(getattr(self.runtime.args, "assume_think", False))
+                    )
+                    self._session_answer_accum[session_turn_id] = ""
+                else:
+                    self.is_generating = False
+                    assistant.append_answer("\n[session error] missing turn_id")
+                    assistant.thinking_panel.finish(ended_in_think=False)
+            except Exception as exc:
+                self.is_generating = False
+                assistant.append_answer(f"\n[session error] {exc}")
+                assistant.thinking_panel.finish(ended_in_think=False)
+            return
+
         thread = threading.Thread(target=self._run_generation, args=(turn_id, list(self.messages)), daemon=True)
+        self.generation_thread = thread
         thread.start()
 
     async def _append_info(self, command: str, output: str):
+        if not self.is_running:
+            return
+        transcript = getattr(self, "transcript", None)
+        if transcript is None or not getattr(transcript, "is_attached", False):
+            return
         await self.transcript.mount(InfoMessage(command=command, text=output))
         if self._should_autofollow():
             self._request_scroll_end()
@@ -552,27 +1152,65 @@ async def _run_slash_command(self, raw_text: str):
             output = "(No output)"
         await self._append_info(raw_text, output)
 
+    def _show_opts(self) -> ShowOptions:
+        return self._active_show_opts or ShowOptions()
+
+    def _to_json_or_lines(self, data: dict, lines: list[str]) -> str:
+        if self._show_opts().as_json:
+            return json.dumps(data, indent=2, ensure_ascii=False, default=str)
+        return "\n".join(lines)
+
+    def _parse_show_flags(self, argv: list[str]) -> tuple[list[str], ShowOptions, str | None]:
+        opts = ShowOptions()
+        rest: list[str] = []
+        idx = 0
+        while idx < len(argv):
+            token = argv[idx]
+            if token in {"--verbose", "-v"}:
+                opts.verbose = True
+            elif token == "--json":
+                opts.as_json = True
+            elif token in {"--help", "-h", "?"}:
+                return [], opts, "help"
+            else:
+                rest.append(token)
+            idx += 1
+        return rest, opts, None
+
     def _register_show_topics(self):
         topics = [
-            ShowTopic("session", "Session/backend state", "/show session", UnifiedTuiApp._show_session),
-            ShowTopic("prompt", "Prompt-related settings", "/show prompt", UnifiedTuiApp._show_prompt),
+            ShowTopic("status", "High-level current state", "/show status", UnifiedTuiApp._show_status),
+            ShowTopic("session", "Session overview", "/show session", UnifiedTuiApp._show_session),
+            ShowTopic("think", "Thinking and history-strip settings", "/show think", UnifiedTuiApp._show_think),
+            ShowTopic("prompt", "System/prefix/template settings", "/show prompt", UnifiedTuiApp._show_prompt),
             ShowTopic("gen", "Effective generation settings", "/show gen", UnifiedTuiApp._show_gen),
-            ShowTopic("ui", "UI behavior settings", "/show ui", UnifiedTuiApp._show_ui),
-            ShowTopic("args", "Parsed CLI args", "/show args", UnifiedTuiApp._show_args),
-            ShowTopic("history", "Conversation history summary", "/show history", UnifiedTuiApp._show_history),
+            ShowTopic("tools", "Tool harness and backend tool support", "/show tools", UnifiedTuiApp._show_tools),
+            ShowTopic("recording", "Request capture and transcript saving", "/show recording", UnifiedTuiApp._show_recording),
+            ShowTopic("connection", "Backend connection/attach state", "/show connection", UnifiedTuiApp._show_connection),
+            ShowTopic("backend", "Backend details", "/show backend", UnifiedTuiApp._show_backend),
             ShowTopic("last", "Last turn record summary", "/show last", UnifiedTuiApp._show_last),
-            ShowTopic("env", "Environment summary", "/show env", UnifiedTuiApp._show_env),
+            ShowTopic("history", "Conversation history summary", "/show history", UnifiedTuiApp._show_history),
+            ShowTopic("request", "Last captured request payload (sanitized)", "/show request", UnifiedTuiApp._show_request),
+            ShowTopic("logs", "Recent backend logs", "/show logs [--n N] [--filter TEXT]", UnifiedTuiApp._show_logs),
             ShowTopic("files", "Resolved file paths", "/show files", UnifiedTuiApp._show_files),
+            ShowTopic("config", "Loaded config layers and origins", "/show config", UnifiedTuiApp._show_config),
             ShowTopic("model", "Model/backend identifiers", "/show model", UnifiedTuiApp._show_model),
-            ShowTopic("config", "Loaded config path", "/show config", UnifiedTuiApp._show_config),
-            ShowTopic("backend", "Backend details", "/show backend", UnifiedTuiApp._show_backend),
+            ShowTopic("ui", "UI behavior settings", "/show ui", UnifiedTuiApp._show_ui),
+            ShowTopic("env", "Environment summary", "/show env", UnifiedTuiApp._show_env),
+            ShowTopic("args", "Parsed CLI args", "/show args", UnifiedTuiApp._show_args),
             ShowTopic("aliases", "Alias map for slash commands/topics", "/show aliases", UnifiedTuiApp._show_aliases),
+            ShowTopic("tts", "TTS runtime settings and state", "/show tts", UnifiedTuiApp._show_tts),
+            ShowTopic("stt", "STT runtime settings and state", "/show stt", UnifiedTuiApp._show_stt),
         ]
         self.show_topics = {topic.name: topic for topic in topics}
         self.show_aliases = {
             "session": "session",
+            "status": "status",
+            "think": "think",
             "prompt": "prompt",
             "gen": "gen",
+            "recording": "recording",
+            "connection": "connection",
             "ui": "ui",
             "args": "args",
             "history": "history",
@@ -582,7 +1220,12 @@ def _register_show_topics(self):
             "model": "model",
             "config": "config",
             "backend": "backend",
+            "tools": "tools",
             "aliases": "aliases",
+            "tts": "tts",
+            "stt": "stt",
+            "logs": "logs",
+            "request": "request",
         }
 
     def _register_commands(self):
@@ -599,10 +1242,18 @@ def _register_commands(self):
         self.registry.register(
             SlashCommand(
                 name="show",
-                summary="Show current runtime/session details",
+                summary="Inspect runtime, prompt, backend, and turn state",
                 usage="/show <topic>",
                 handler=UnifiedTuiApp._cmd_show,
-                examples=("/show", "/show gen", "/show prompt"),
+                examples=("/show", "/show status", "/show think", "/show connection"),
+            )
+        )
+        self.registry.register(
+            SlashCommand(
+                name="status",
+                summary="Concise runtime summary",
+                usage="/status",
+                handler=UnifiedTuiApp._cmd_status,
             )
         )
         self.registry.register(
@@ -621,14 +1272,91 @@ def _register_commands(self):
                 handler=UnifiedTuiApp._cmd_prefix,
             )
         )
-        for alias_name in ("model", "config", "env", "files", "session", "prompt", "gen", "ui", "args", "history", "last", "backend"):
+        self.registry.register(
+            SlashCommand(
+                name="toolblocks",
+                aliases=("tool-blocks",),
+                summary="Toggle tool block visibility in the transcript",
+                usage="/toolblocks [on|off|toggle]",
+                handler=UnifiedTuiApp._cmd_toolblocks,
+                read_only=False,
+            )
+        )
+        self.registry.register(
+            SlashCommand(
+                name="toolargs",
+                aliases=("tool-args",),
+                summary="Toggle tool argument visibility in transcript tool blocks",
+                usage="/toolargs [on|off|toggle]",
+                handler=UnifiedTuiApp._cmd_toolargs,
+                read_only=False,
+            )
+        )
+        self.registry.register(
+            SlashCommand(
+                name="image",
+                aliases=("img",),
+                summary="Attach an image to the next prompt (HF vision models only)",
+                usage="/image <path> | /image list | /image clear",
+                handler=UnifiedTuiApp._cmd_image,
+                examples=("/image ./pic.png", "/img list", "/image clear"),
+            )
+        )
+        self.registry.register(
+            SlashCommand(
+                name="file",
+                aliases=("attach", "textfile"),
+                summary="Attach a text file to the next prompt",
+                usage="/file <path> | /file list | /file clear",
+                handler=UnifiedTuiApp._cmd_file,
+                examples=("/file ./notes.txt", "/file list", "/file clear"),
+            )
+        )
+        self.registry.register(
+            SlashCommand(
+                name="tts",
+                summary="Configure and test Kokoro/OpenAI-compatible TTS",
+                usage="/tts [on|off|voices|voice <id>|speed <n>|autoplay on|off|test [text]|replay]",
+                handler=UnifiedTuiApp._cmd_tts,
+                read_only=False,
+            )
+        )
+        self.registry.register(
+            SlashCommand(
+                name="stt",
+                summary="Configure and test OpenAI-compatible STT",
+                usage="/stt [on|off|base-url <url>|model <id>|language <code|auto>|transcribe <file>|record [seconds]|toggle]",
+                handler=UnifiedTuiApp._cmd_stt,
+                read_only=False,
+            )
+        )
+        for alias_name in (
+            "model",
+            "config",
+            "env",
+            "files",
+            "session",
+            "think",
+            "prompt",
+            "gen",
+            "recording",
+            "connection",
+            "ui",
+            "args",
+            "history",
+            "last",
+            "backend",
+            "tools",
+            "logs",
+            "request",
+        ):
             self.registry.register(
                 SlashCommand(
                     name=alias_name,
                     summary=f"Alias for /show {alias_name}",
                     usage=f"/{alias_name}",
-                    handler=lambda app, argv, topic=alias_name: app._cmd_show([topic]),
-                    include_in_help=False,
+                    handler=lambda app, argv, topic=alias_name: app._cmd_show([topic, *argv]),
+                    hidden=True,
                 )
             )
         self.registry.register(
@@ -643,23 +1371,68 @@ def _register_commands(self):
         self.registry.register(
             SlashCommand(
                 name="exit",
-                aliases=("quit",),
-                summary="Exit TUI",
+                summary="Exit TUI and keep managed backend running",
                 usage="/exit",
                 handler=UnifiedTuiApp._cmd_exit,
             )
         )
+        self.registry.register(
+            SlashCommand(
+                name="quit",
+                summary="Exit TUI and shut down managed backend",
+                usage="/quit",
+                handler=UnifiedTuiApp._cmd_quit,
+            )
+        )
 
     def _cmd_help(self, argv: list[str]) -> str:
         if not argv:
-            lines = ["Available commands:"]
+            lines = [
+                "TUI commands",
+                "",
+                "Inspect",
+            ]
+            lines.extend(_format_name_grid(["/show", "/status", "/help <command>"], cols=3, min_width=22))
+            lines.extend(
+                [
+                    "",
+                    "Prompt + Session",
+                ]
+            )
+            lines.extend(_format_name_grid(["/system", "/prefix", "/image", "/file", "/tts", "/stt"], cols=4, min_width=18))
+            lines.extend(
+                [
+                    "",
+                    "Transcript View",
+                ]
+            )
+            lines.extend(_format_name_grid(["/toolblocks", "/toolargs"], cols=3, min_width=18))
+            lines.extend(
+                [
+                    "",
+                    "Session Control",
+                ]
+            )
+            lines.extend(_format_name_grid(["/clear", "/exit", "/quit"], cols=3, min_width=18))
+            lines.extend(
+                [
+                    "",
+                    "Start Here",
+                ]
+            )
+            lines.extend(_format_name_grid(["/show", "/show status", "/show session", "/show think", "/show connection"], cols=3, min_width=22))
+            lines.extend(
+                [
+                    "",
+                    "Use /help --all to include hidden aliases.",
+                ]
+            )
+            return "\n".join(lines)
+        if argv[0] in {"--all", "aliases"}:
+            lines = ["All commands (including hidden aliases):"]
             for cmd in self.registry.all_commands():
-                if not cmd.include_in_help:
-                    continue
-                lines.append(f"/{cmd.name}: {cmd.summary}")
-            lines.append("")
-            lines.append("Try: /help <command>")
-            lines.append("Alias map: /show aliases")
+                hidden = " [hidden]" if cmd.hidden else ""
+                lines.append(f"/{cmd.name}{hidden}: {cmd.summary}")
             return "\n".join(lines)
 
         target = argv[0].lstrip("/").lower()
@@ -687,15 +1460,45 @@ def _cmd_help(self, argv: list[str]) -> str:
     def _cmd_show(self, argv: list[str]) -> str:
         if not argv:
             lines = [
-                "Usage: /show <topic>",
-                "Topics: " + ", ".join(sorted(self.show_topics.keys())),
-                "Examples:",
-                "  /show session",
-                "  /show gen",
-                "  /show prompt",
+                "Usage: /show <topic> [--verbose] [--json]",
+                "",
+                "Overview",
             ]
+            lines.extend(_format_name_grid(["status", "session"], cols=4))
+            lines.extend(
+                [
+                    "",
+                    "Prompting",
+                ]
+            )
+            lines.extend(_format_name_grid(["think", "prompt", "gen", "tools"], cols=4))
+            lines.extend(
+                [
+                    "",
+                    "Backend + Debug",
+                ]
+            )
+            lines.extend(_format_name_grid(["connection", "backend", "last", "history", "request", "logs"], cols=4))
+            lines.extend(
+                [
+                    "",
+                    "Files + Config",
+                ]
+            )
+            lines.extend(_format_name_grid(["files", "config", "model", "ui", "env", "args", "aliases"], cols=4))
+            lines.extend(
+                [
+                    "",
+                    "Examples:",
+                    "  /show status",
+                    "  /show think",
+                    "  /show backend --verbose",
+                    "  /show last --verbose",
+                ]
+            )
             return "\n".join(lines)
         topic = argv[0].lower()
+        parsed_argv, show_opts, parse_err = self._parse_show_flags(argv[1:])
         if topic in {"?", "--help"}:
             return self._cmd_show([])
         topic_key = self.show_aliases.get(topic, topic)
@@ -706,9 +1509,27 @@ def _cmd_show(self, argv: list[str]) -> str:
             if matches:
                 msg += "\nDid you mean: " + ", ".join(matches)
             return msg
-        if len(argv) > 1 and argv[1] in {"?", "--help"}:
+        if parse_err == "help":
+            return f"{handler.usage}\n{handler.summary}"
+        if parse_err:
+            return parse_err
+        if parsed_argv and parsed_argv[0] in {"?", "--help"}:
             return f"{handler.usage}\n{handler.summary}"
-        return handler.handler(self, argv[1:])
+        if show_opts.as_json and topic_key == "logs":
+            return "Topic 'logs' does not support --json."
+        self._active_show_opts = show_opts
+        try:
+            return handler.handler(self, parsed_argv)
+        finally:
+            self._active_show_opts = None
+
+    def _cmd_status(self, argv: list[str]) -> str:
+        del argv
+        self._active_show_opts = ShowOptions(verbose=False, as_json=False)
+        try:
+            return self._show_status([])
+        finally:
+            self._active_show_opts = None
 
     def _cmd_system(self, argv: list[str]) -> str:
         del argv
@@ -735,234 +1556,1072 @@ def _cmd_prefix(self, argv: list[str]) -> str:
         args = self.runtime.args
         backend = self.runtime.session.backend_name
         prompt_mode = getattr(args, "prompt_mode", None) if backend == "hf" else None
-        chat_template = getattr(args, "chat_template", None) if backend == "hf" else None
+        chat_template = getattr(args, "chat_template", None)
         lines = [
             f"backend: {backend}",
             f"user_prefix: {args.user_prefix!r}",
             "prompt_prefix: N/A",
             f"prompt_mode: {prompt_mode if prompt_mode is not None else 'N/A'}",
             f"chat_template: {chat_template if chat_template else 'N/A'}",
+            f"history_strip_think: {bool(getattr(args, 'history_strip_think', False))}",
         ]
         return "\n".join(lines)
 
+    def _cmd_image(self, argv: list[str]) -> str:
+        backend = self.runtime.session.backend_name
+        if backend not in {"hf", "openai", "vllm"}:
+            return f"Images are only supported on HF and OpenAI-compatible backends (current backend={backend})."
+
+        if not argv:
+            return "\n".join(
+                [
+                    "Usage:",
+                    "  /image <path>        Attach an image file to the next user message",
+                    "  /image list          Show pending image attachments",
+                    "  /image clear         Clear pending image attachments",
+                ]
+            )
+
+        sub = argv[0].strip().lower()
+        if sub in {"list", "ls"}:
+            if not self.pending_images:
+                return "(No pending images.)"
+            lines = ["Pending images:"]
+            for idx, path in enumerate(self.pending_images, start=1):
+                lines.append(f"{idx}. {path}")
+            return "\n".join(lines)
+
+        if sub in {"clear", "reset"}:
+            count = len(self.pending_images)
+            self.pending_images.clear()
+            return f"Cleared {count} pending image(s)."
+
+        raw_path = " ".join(argv).strip()
+        path = resolve_path_maybe_relative(raw_path, config_path=self.runtime.args._config_path)
+        if not os.path.isfile(path):
+            return f"Not found: {path}"
+        self.pending_images.append(path)
+        return f"Attached: {path}\n(Will be sent with the next message.)"
+
+    def _cmd_file(self, argv: list[str]) -> str:
+        if not argv:
+            return "\n".join(
+                [
+                    "Usage:",
+                    "  /file <path>         Attach a text file to the next user message",
+                    "  /file list           Show pending text-file attachments",
+                    "  /file clear          Clear pending text-file attachments",
+                ]
+            )
+
+        sub = argv[0].strip().lower()
+        if sub in {"list", "ls"}:
+            if not self.pending_text_files:
+                return "(No pending text files.)"
+            lines = ["Pending text files:"]
+            for idx, path in enumerate(self.pending_text_files, start=1):
+                lines.append(f"{idx}. {path}")
+            return "\n".join(lines)
+
+        if sub in {"clear", "reset"}:
+            count = len(self.pending_text_files)
+            self.pending_text_files.clear()
+            return f"Cleared {count} pending text file(s)."
+
+        raw_path = " ".join(argv).strip()
+        path = resolve_path_maybe_relative(raw_path, config_path=self.runtime.args._config_path)
+        if not os.path.isfile(path):
+            return f"Not found: {path}"
+        try:
+            with open(path, "rb") as fh:
+                sample = fh.read(4096)
+        except Exception as exc:
+            return f"Failed to read: {path} ({exc})"
+        if b"\x00" in sample:
+            return f"Refusing to attach binary file: {path}"
+        self.pending_text_files.append(path)
+        return f"Attached text file: {path}\n(Will be sent with the next message.)"
+
+    def _cmd_toolargs(self, argv: list[str]) -> str:
+        current = bool(getattr(self.runtime.args, "show_tool_arguments", False))
+        if not argv:
+            return f"show_tool_arguments: {current}"
+        token = argv[0].strip().lower()
+        if token in {"on", "true", "1"}:
+            current = True
+        elif token in {"off", "false", "0"}:
+            current = False
+        elif token in {"toggle", "flip"}:
+            current = not current
+        else:
+            return "Usage: /toolargs [on|off|toggle]"
+        self.runtime.args.show_tool_arguments = current
+        return f"show_tool_arguments: {current}"
+
+    def _cmd_toolblocks(self, argv: list[str]) -> str:
+        current = bool(getattr(self.runtime.args, "show_tool_activity", False))
+        if not argv:
+            return f"show_tool_activity: {current}"
+        token = argv[0].strip().lower()
+        if token in {"on", "true", "1"}:
+            current = True
+        elif token in {"off", "false", "0"}:
+            current = False
+        elif token in {"toggle", "flip"}:
+            current = not current
+        else:
+            return "Usage: /toolblocks [on|off|toggle]"
+        self.runtime.args.show_tool_activity = current
+        return f"show_tool_activity: {current}"
+
+    def _tts_output_dir(self) -> str:
+        root = os.path.join(os.path.expanduser("~"), "runs", "model-runner", "outputs", "tts")
+        os.makedirs(root, exist_ok=True)
+        return root
+
+    def _tts_fetch_voices(self) -> list[str]:
+        base = str(getattr(self.runtime.args, "tts_base_url", "http://127.0.0.1:8880") or "").rstrip("/")
+        url = f"{base}/v1/audio/voices"
+        req = urllib_request.Request(url=url, method="GET")
+        with urllib_request.urlopen(req, timeout=15) as resp:
+            payload = json.loads(resp.read().decode("utf-8"))
+        if isinstance(payload, dict):
+            voices = payload.get("voices")
+            if isinstance(voices, list):
+                return [str(v) for v in voices if str(v).strip()]
+            data = payload.get("data")
+            if isinstance(data, list):
+                out: list[str] = []
+                for item in data:
+                    if isinstance(item, str):
+                        out.append(item)
+                    elif isinstance(item, dict):
+                        voice = item.get("id") or item.get("name")
+                        if voice:
+                            out.append(str(voice))
+                return [v for v in out if v.strip()]
+        return []
+
+    def _tts_synthesize_to_file(self, text: str, *, voice: str, speed: float) -> str:
+        base = str(getattr(self.runtime.args, "tts_base_url", "http://127.0.0.1:8880") or "").rstrip("/")
+        model = str(getattr(self.runtime.args, "tts_model", "kokoro") or "kokoro")
+        payload = {
+            "model": model,
+            "input": text,
+            "voice": voice,
+            "response_format": "wav",
+            "speed": float(speed),
+        }
+        body = json.dumps(payload).encode("utf-8")
+        req = urllib_request.Request(
+            url=f"{base}/v1/audio/speech",
+            data=body,
+            headers={"content-type": "application/json"},
+            method="POST",
+        )
+        with urllib_request.urlopen(req, timeout=120) as resp:
+            audio = resp.read()
+        stamp = time.strftime("%Y%m%d-%H%M%S")
+        dest = os.path.join(self._tts_output_dir(), f"tts-{stamp}-{int(time.time()*1000)%1000:03d}.wav")
+        with open(dest, "wb") as fh:
+            fh.write(audio)
+        self._last_tts_audio_path = dest
+        return dest
+
+    def _tts_play_file(self, path: str) -> tuple[bool, str]:
+        candidates: list[list[str]] = []
+        if shutil.which("ffplay"):
+            candidates.append(["ffplay", "-nodisp", "-autoexit", "-loglevel", "error", path])
+        if shutil.which("paplay"):
+            candidates.append(["paplay", path])
+        if shutil.which("aplay"):
+            candidates.append(["aplay", path])
+        if not candidates:
+            return False, "No audio player found (ffplay/paplay/aplay)."
+        for cmd in candidates:
+            try:
+                subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                return True, f"Playing via {cmd[0]}"
+            except Exception:
+                continue
+        return False, "Could not launch local audio player."
+
+    def _tts_speak_text(self, text: str, *, autoplay: bool = True) -> tuple[bool, str]:
+        text = (text or "").strip()
+        if not text:
+            return False, "No text to speak."
+        voice = str(getattr(self.runtime.args, "tts_voice", "af_heart") or "af_heart")
+        speed = float(getattr(self.runtime.args, "tts_speed", 1.0) or 1.0)
+        try:
+            wav_path = self._tts_synthesize_to_file(text, voice=voice, speed=speed)
+        except urllib_error.HTTPError as exc:
+            return False, f"TTS request failed: HTTP {exc.code}"
+        except Exception as exc:
+            return False, f"TTS request failed: {exc}"
+        if not autoplay:
+            return True, f"Generated: {wav_path}"
+        ok, msg = self._tts_play_file(wav_path)
+        if ok:
+            return True, f"{msg} | {wav_path}"
+        return True, f"Generated but not playing: {wav_path} ({msg})"
+
+    def _tts_autoplay_last_answer_async(self, text: str) -> None:
+        def worker() -> None:
+            self._tts_speak_text(text, autoplay=bool(getattr(self.runtime.args, "tts_autoplay", True)))
+
+        threading.Thread(target=worker, daemon=True).start()
+
+    def _cmd_tts(self, argv: list[str]) -> str:
+        args = self.runtime.args
+        if not argv:
+            return self._show_tts([])
+
+        token = argv[0].strip().lower()
+        if token in {"on", "off"}:
+            args.tts_enabled = token == "on"
+            if args.tts_enabled:
+                args.tts_autoplay = True
+            return f"tts_enabled: {bool(args.tts_enabled)}\ntts_autoplay: {bool(args.tts_autoplay)}"
+
+        if token == "autoplay":
+            if len(argv) < 2 or argv[1].strip().lower() not in {"on", "off"}:
+                return "Usage: /tts autoplay on|off"
+            args.tts_autoplay = argv[1].strip().lower() == "on"
+            return f"tts_autoplay: {bool(args.tts_autoplay)}"
+
+        if token == "voice":
+            if len(argv) < 2:
+                return "Usage: /tts voice <voice_id>"
+            args.tts_voice = argv[1].strip()
+            return f"tts_voice: {args.tts_voice}"
+
+        if token == "speed":
+            if len(argv) < 2:
+                return "Usage: /tts speed <float>"
+            try:
+                speed = float(argv[1])
+            except ValueError:
+                return "Invalid speed. Example: /tts speed 0.95"
+            args.tts_speed = speed
+            return f"tts_speed: {args.tts_speed:.2f}"
+
+        if token == "voices":
+            try:
+                voices = self._tts_fetch_voices()
+            except Exception as exc:
+                return f"Voice fetch failed: {exc}"
+            if not voices:
+                return "No voices returned."
+            lines = [f"voices ({len(voices)}):"]
+            lines.extend(f"  {v}" for v in voices)
+            return "\n".join(lines)
+
+        if token == "test":
+            text = " ".join(argv[1:]).strip() or "Hello from model-runner TTS test."
+            ok, msg = self._tts_speak_text(text, autoplay=bool(getattr(args, "tts_autoplay", True)))
+            return msg if ok else f"TTS test failed: {msg}"
+
+        if token == "replay":
+            if not self._last_assistant_answer.strip():
+                return "No assistant answer available to replay yet."
+            ok, msg = self._tts_speak_text(self._last_assistant_answer, autoplay=bool(getattr(args, "tts_autoplay", True)))
+            return msg if ok else f"Replay failed: {msg}"
+
+        return "Usage: /tts [on|off|voices|voice <id>|speed <n>|autoplay on|off|test [text]|replay]"
+
+    def _stt_output_dir(self) -> str:
+        root = os.path.join(os.path.expanduser("~"), "runs", "model-runner", "outputs", "stt")
+        os.makedirs(root, exist_ok=True)
+        return root
+
+    def _stt_transcribe_file(self, path: str) -> str:
+        args = self.runtime.args
+        base = str(getattr(args, "stt_base_url", "http://127.0.0.1:8891") or "").rstrip("/")
+        model = str(getattr(args, "stt_model", "whisper-1") or "whisper-1")
+        language = str(getattr(args, "stt_language", "auto") or "auto").strip().lower()
+        boundary = f"----modelrunner-{uuid.uuid4().hex}"
+
+        def _part(name: str, value: str) -> bytes:
+            return (
+                f"--{boundary}\r\n"
+                f"Content-Disposition: form-data; name=\"{name}\"\r\n\r\n"
+                f"{value}\r\n"
+            ).encode("utf-8")
+
+        mime, _ = mimetypes.guess_type(path)
+        if not mime:
+            mime = "application/octet-stream"
+        with open(path, "rb") as fh:
+            raw = fh.read()
+
+        body = bytearray()
+        body.extend(_part("model", model))
+        if language and language != "auto":
+            body.extend(_part("language", language))
+        body.extend(_part("response_format", "verbose_json"))
+        body.extend(
+            (
+                f"--{boundary}\r\n"
+                f"Content-Disposition: form-data; name=\"file\"; filename=\"{os.path.basename(path)}\"\r\n"
+                f"Content-Type: {mime}\r\n\r\n"
+            ).encode("utf-8")
+        )
+        body.extend(raw)
+        body.extend(b"\r\n")
+        body.extend(f"--{boundary}--\r\n".encode("utf-8"))
+
+        req = urllib_request.Request(
+            url=f"{base}/v1/audio/transcriptions",
+            data=bytes(body),
+            headers={"content-type": f"multipart/form-data; boundary={boundary}"},
+            method="POST",
+        )
+        with urllib_request.urlopen(req, timeout=300) as resp:
+            payload = json.loads(resp.read().decode("utf-8"))
+        text = str(payload.get("text") or "").strip() if isinstance(payload, dict) else ""
+        self._last_stt_audio_path = path
+        self._last_stt_text = text
+        return text
+
+    def _stt_record_to_file(self, seconds: int = 6) -> tuple[bool, str]:
+        seconds = max(1, min(120, int(seconds)))
+        stamp = time.strftime("%Y%m%d-%H%M%S")
+        uniq = int(time.time() * 1000) % 1000
+        path = os.path.join(self._stt_output_dir(), f"stt-rec-{stamp}-{uniq:03d}.wav")
+        commands: list[list[str]] = []
+        if shutil.which("ffmpeg"):
+            commands.append(["ffmpeg", "-y", "-f", "pulse", "-i", "default", "-t", str(seconds), path])
+        if shutil.which("arecord"):
+            commands.append(["arecord", "-f", "S16_LE", "-r", "16000", "-c", "1", "-d", str(seconds), path])
+        if not commands:
+            return False, "No recorder found (ffmpeg or arecord)."
+        last_err = ""
+        for cmd in commands:
+            try:
+                proc = subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, text=True)
+                if proc.returncode == 0 and os.path.isfile(path) and os.path.getsize(path) > 1024:
+                    self._last_stt_audio_path = path
+                    return True, path
+                last_err = (proc.stderr or "").strip() or f"exit={proc.returncode}"
+            except Exception as exc:
+                last_err = str(exc)
+        return False, f"Recording failed: {last_err or 'unknown error'}"
+
+    def _cmd_stt(self, argv: list[str]) -> str:
+        args = self.runtime.args
+        if not argv:
+            return self._show_stt([])
+        token = argv[0].strip().lower()
+        if token in {"on", "off"}:
+            args.stt_enabled = token == "on"
+            return f"stt_enabled: {bool(args.stt_enabled)}"
+        if token == "base-url":
+            if len(argv) < 2:
+                return "Usage: /stt base-url <url>"
+            args.stt_base_url = argv[1].strip().rstrip("/")
+            return f"stt_base_url: {args.stt_base_url}"
+        if token == "model":
+            if len(argv) < 2:
+                return "Usage: /stt model <id>"
+            args.stt_model = argv[1].strip()
+            return f"stt_model: {args.stt_model}"
+        if token == "language":
+            if len(argv) < 2:
+                return "Usage: /stt language <code|auto>"
+            args.stt_language = argv[1].strip().lower() or "auto"
+            return f"stt_language: {args.stt_language}"
+        if token == "toggle":
+            if self._stt_busy:
+                return "STT busy: finishing previous action."
+            if self._stt_recording:
+                self._stt_busy = True
+                try:
+                    ok, msg = self._stt_stop_recording_and_transcribe_send()
+                finally:
+                    self._stt_busy = False
+                return msg if ok else f"STT toggle failed: {msg}"
+            ok, msg = self._stt_start_recording()
+            return (f"Recording… run /stt toggle again to stop+send. ({msg})" if ok else msg)
+
+        if token == "record":
+            sec = 6
+            if len(argv) >= 2:
+                try:
+                    sec = int(argv[1])
+                except ValueError:
+                    return "Usage: /stt record [seconds]"
+            ok, msg = self._stt_record_to_file(sec)
+            if not ok:
+                return msg
+            return f"Recorded: {msg}"
+        if token == "transcribe":
+            if len(argv) < 2:
+                return "Usage: /stt transcribe <file>"
+            raw_path = " ".join(argv[1:]).strip()
+            path = resolve_path_maybe_relative(raw_path, config_path=self.runtime.args._config_path)
+            if not os.path.isfile(path):
+                return f"Not found: {path}"
+            try:
+                text = self._stt_transcribe_file(path)
+            except urllib_error.HTTPError as exc:
+                return f"STT request failed: HTTP {exc.code}"
+            except Exception as exc:
+                return f"STT request failed: {exc}"
+            if not text:
+                return "Transcribed, but empty text was returned."
+            return f"STT text:\n{text}"
+        return "Usage: /stt [on|off|base-url <url>|model <id>|language <code|auto>|transcribe <file>|record [seconds]|toggle]"
+
     def _cmd_clear(self, argv: list[str]) -> str:
         del argv
         self.transcript.remove_children()
         self.messages = []
+        self.turn_records = []
+        self.pending_images.clear()
+        self.pending_text_files.clear()
         if self.runtime.args.system:
             self.messages.append({"role": "system", "content": self.runtime.args.system})
         self.pending_assistant = None
-        return "Transcript and conversation history cleared."
+        return "Transcript, conversation history, turn records, and pending attachments cleared."
 
     def _cmd_exit(self, argv: list[str]) -> str:
         del argv
+        self.shutdown_backend_on_exit = False
         self.exit()
         return "Exiting."
 
-    def _show_session(self, argv: list[str]) -> str:
+    def _cmd_quit(self, argv: list[str]) -> str:
+        del argv
+        self.shutdown_backend_on_exit = True
+        self.exit()
+        return "Exiting and shutting down backend."
+
+    def _backend_summary_line(self) -> str:
+        session = self.runtime.session
+        describe = getattr(session, "describe", None)
+        if not callable(describe):
+            return "(unavailable)"
+        info = describe()
+        if not isinstance(info, dict):
+            return str(info)
+        backend = session.backend_name
+        if backend == "vllm":
+            return (
+                f"managed={info.get('managed_mode')} pid={info.get('pid')} "
+                f"base_url={info.get('base_url')} model={info.get('model_id')}"
+            )
+        if backend == "openai":
+            return f"base_url={info.get('base_url')} model={info.get('model_id')}"
+        if backend == "ollama":
+            return f"model={session.resolved_model_id}"
+        return ", ".join(f"{k}={info[k]}" for k in sorted(info.keys()))
+
+    @staticmethod
+    def _token_counts_view(record) -> dict[str, object]:
+        counts = dict(record.token_counts or {})
+        return {
+            "prompt_tokens": counts.get("prompt_tokens", "unavailable"),
+            "completion_tokens": counts.get("completion_tokens", "unavailable"),
+            "total_tokens": counts.get("total_tokens", "unavailable"),
+        }
+
+    @staticmethod
+    def _tokens_per_s_view(record) -> object:
+        throughput = dict(record.throughput or {})
+        return throughput.get("tokens_per_s", "unavailable")
+
+    @staticmethod
+    def _context_view(record) -> dict[str, object]:
+        context = dict(record.context or {})
+        return {
+            "strategy": context.get("strategy", "unavailable"),
+            "dropped_messages": context.get("dropped_messages", 0),
+            "fit": context.get("fit", "unavailable"),
+            "system_message_preserved": context.get("system_message_preserved", "unavailable"),
+            "system_drop_required": context.get("system_drop_required", "unavailable"),
+            "reserved_generation_tokens": context.get("reserved_generation_tokens", "unavailable"),
+            "context_window": context.get("context_window", "unavailable"),
+        }
+
+    def _show_status(self, argv: list[str]) -> str:
         del argv
+        args = self.runtime.args
+        session = self.runtime.session
+        profile = getattr(args, "_config_profile", "") or ""
+        system_text = args.system or ""
+        data = {
+            "backend": session.backend_name,
+            "model": session.resolved_model_id,
+            "config_path": args._config_path or "(none)",
+            "profile": profile or "(none)",
+            "generating": bool(self.is_generating),
+            "follow_output": bool(self.follow_output),
+            "pending_images": len(self.pending_images),
+            "prompt": {
+                "has_system": bool(system_text),
+                "history_strip_think": bool(getattr(args, "history_strip_think", False)),
+                "tools_enabled": bool(getattr(args, "tools_enabled", False)),
+            },
+            "generation": {
+                "max_new_tokens": args.max_new_tokens,
+                "temperature": args.temperature,
+                "top_p": args.top_p,
+            },
+            "backend_summary": self._backend_summary_line(),
+        }
+        logs_fn = getattr(session, "get_recent_logs", None)
+        if callable(logs_fn):
+            try:
+                data["log_tail_available"] = len(logs_fn(1)) > 0
+            except Exception:
+                data["log_tail_available"] = False
+        if self.turn_records:
+            last = self.turn_records[-1]
+            token_counts = self._token_counts_view(last)
+            context = self._context_view(last)
+            data["last_turn"] = {
+                "elapsed_s": last.timing.get("elapsed"),
+                "time_to_first_token_s": last.timing.get("time_to_first_token"),
+                "ended_in_think": bool(last.ended_in_think),
+                "chars_raw": len(last.raw),
+                "chars_think": len(last.think),
+                "chars_answer": len(last.answer),
+                "tool_activity_count": len(last.tool_activity or []),
+                "prompt_tokens": token_counts["prompt_tokens"],
+                "completion_tokens": token_counts["completion_tokens"],
+                "total_tokens": token_counts["total_tokens"],
+                "tokens_per_s": self._tokens_per_s_view(last),
+                "context": context,
+            }
+        else:
+            data["last_turn"] = "(none)"
         lines = [
-            f"backend: {self.runtime.session.backend_name}",
-            f"model_id: {self.runtime.session.resolved_model_id}",
-            f"config_path: {self.runtime.args._config_path or '(none)'}",
-            f"is_generating: {self.is_generating}",
-            f"follow_output: {self.follow_output}",
-            f"transcript_widgets: {len(self.transcript.children)}",
-            f"scroll_y: {float(self.transcript.scroll_y):.1f}/{float(self.transcript.max_scroll_y):.1f}",
+            f"backend: {data['backend']}",
+            f"model: {data['model']}",
+            f"config: {data['config_path']} (profile={data['profile']})",
+            (
+                "state: "
+                f"generating={str(data['generating']).lower()} "
+                f"follow_output={str(data['follow_output']).lower()} "
+                f"pending_images={data['pending_images']}"
+            ),
+            (
+                "prompt: "
+                f"system={data['prompt']['has_system']} "
+                f"history_strip={data['prompt']['history_strip_think']} "
+                f"tools={data['prompt']['tools_enabled']}"
+            ),
+            (
+                "generation: "
+                f"max_new_tokens={data['generation']['max_new_tokens']} "
+                f"temperature={data['generation']['temperature']} "
+                f"top_p={data['generation']['top_p']}"
+            ),
+            f"connection: {data['backend_summary']}",
         ]
-        return "\n".join(lines)
+        if isinstance(data["last_turn"], dict):
+            lt = data["last_turn"]
+            lines.extend(
+                [
+                    "last_turn:",
+                    (
+                        f"  elapsed_s={lt['elapsed_s']} "
+                        f"ttft_s={lt['time_to_first_token_s']} "
+                        f"ended_in_think={lt['ended_in_think']} "
+                        f"tools={lt['tool_activity_count']}"
+                    ),
+                    (
+                        "  tokens: "
+                        f"prompt={lt['prompt_tokens']} completion={lt['completion_tokens']} "
+                        f"total={lt['total_tokens']} tok/s={lt['tokens_per_s']}"
+                    ),
+                    (
+                        "  context: "
+                        f"strategy={lt['context']['strategy']} "
+                        f"dropped={lt['context']['dropped_messages']} "
+                        f"system_preserved={lt['context']['system_message_preserved']}"
+                    ),
+                ]
+            )
+            if self._show_opts().verbose:
+                lines.extend(
+                    [
+                        (
+                            "  chars: "
+                            f"raw={lt['chars_raw']} think={lt['chars_think']} answer={lt['chars_answer']}"
+                        ),
+                        f"  log_tail_available: {data.get('log_tail_available', False)}",
+                    ]
+                )
+        else:
+            lines.append("last_turn: (none)")
+        return self._to_json_or_lines(data, lines)
 
-    def _show_prompt(self, argv: list[str]) -> str:
+    def _show_think(self, argv: list[str]) -> str:
         del argv
-        return self._cmd_system([]) + "\n" + self._cmd_prefix([])
+        args = self.runtime.args
+        data = {
+            "assume_think": bool(getattr(args, "assume_think", False)),
+            "show_thinking": bool(getattr(args, "show_thinking", False)),
+            "history_strip_think": bool(getattr(args, "history_strip_think", False)),
+            "no_animate_thinking": bool(getattr(args, "no_animate_thinking", False)),
+        }
+        lines = [
+            f"assume_think: {data['assume_think']}",
+            f"show_thinking: {data['show_thinking']}",
+            f"history_strip_think: {data['history_strip_think']}",
+        ]
+        if self._show_opts().verbose:
+            lines.append(f"no_animate_thinking: {data['no_animate_thinking']}")
+        return self._to_json_or_lines(data, lines)
 
-    def _show_gen(self, argv: list[str]) -> str:
+    def _show_session(self, argv: list[str]) -> str:
         del argv
         args = self.runtime.args
-        backend = self.runtime.session.backend_name
+        session = self.runtime.session
+        profile = getattr(args, "_config_profile", "") or ""
+        system_text = args.system or ""
+        system_source = "none"
         cli_overrides = set(getattr(args, "_cli_overrides", set()) or set())
-        config_keys = set(getattr(args, "_config_keys", set()) or set())
-        user_set = cli_overrides | config_keys
+        if "system" in cli_overrides:
+            system_source = "--system"
+        elif args.system_file:
+            system_source = "--system-file"
+        elif system_text:
+            system_source = "config/default"
+        describe = getattr(session, "describe", None)
+        backend_info = describe() if callable(describe) else {}
+        if not isinstance(backend_info, dict):
+            backend_info = {"summary": str(backend_info)}
+        data = {
+            "backend": session.backend_name,
+            "model_id": session.resolved_model_id,
+            "config_path": args._config_path or "(none)",
+            "profile": profile or "(none)",
+            "state": {
+                "is_generating": bool(self.is_generating),
+                "follow_output": bool(self.follow_output),
+            },
+            "prompt": {
+                "has_system": bool(system_text),
+                "system_source": system_source,
+                "system_file": resolve_path_maybe_relative(args.system_file, config_path=args._config_path)
+                if args.system_file
+                else "(none)",
+                "user_prefix": args.user_prefix or "",
+                "chat_template": args.chat_template or "(none)",
+            },
+            "thinking": {
+                "assume_think": bool(getattr(args, "assume_think", False)),
+                "show_thinking": bool(getattr(args, "show_thinking", False)),
+                "history_strip_think": bool(getattr(args, "history_strip_think", False)),
+            },
+            "tools": {
+                "enabled": bool(getattr(args, "tools_enabled", False)),
+                "mode": getattr(args, "tools_mode", "off"),
+                "show_tool_activity": bool(getattr(args, "show_tool_activity", False)),
+                "show_tool_arguments": bool(getattr(args, "show_tool_arguments", False)),
+                "max_calls_per_turn": getattr(args, "tools_max_calls_per_turn", "unavailable"),
+            },
+            "recording": {
+                "capture_last_request": bool(getattr(args, "capture_last_request", False)),
+                "save_transcript": (
+                    resolve_path_maybe_relative(args.save_transcript, config_path=args._config_path)
+                    if getattr(args, "save_transcript", "")
+                    else "(none)"
+                ),
+            },
+            "backend_connection": backend_info,
+        }
+        lines = [
+            f"backend: {data['backend']}",
+            f"model_id: {data['model_id']}",
+            f"config: {data['config_path']} (profile={data['profile']})",
+            f"state: generating={data['state']['is_generating']} follow_output={data['state']['follow_output']}",
+            (
+                "prompt: "
+                f"system={data['prompt']['has_system']} "
+                f"source={data['prompt']['system_source']} "
+                f"user_prefix={data['prompt']['user_prefix']!r}"
+            ),
+            (
+                "thinking: "
+                f"assume={data['thinking']['assume_think']} "
+                f"show={data['thinking']['show_thinking']} "
+                f"history_strip={data['thinking']['history_strip_think']}"
+            ),
+            (
+                "tools: "
+                f"enabled={data['tools']['enabled']} "
+                f"mode={data['tools']['mode']} "
+                f"show_blocks={data['tools']['show_tool_activity']} "
+                f"show_args={data['tools']['show_tool_arguments']}"
+            ),
+            (
+                "recording: "
+                f"capture_last_request={data['recording']['capture_last_request']} "
+                f"save_transcript={data['recording']['save_transcript']}"
+            ),
+        ]
+        backend_summary = self._backend_summary_line()
+        if backend_summary and backend_summary != "(unavailable)":
+            lines.append(f"connection: {backend_summary}")
+        if self._show_opts().verbose:
+            lines.extend(
+                [
+                    f"prompt.chat_template: {data['prompt']['chat_template']}",
+                    f"prompt.system_file: {data['prompt']['system_file']}",
+                    f"tools.max_calls_per_turn: {data['tools']['max_calls_per_turn']}",
+                    f"pending_images: {len(self.pending_images)}",
+                    f"transcript_widgets: {len(self.transcript.children)}",
+                    f"scroll_y: {float(self.transcript.scroll_y):.1f}/{float(self.transcript.max_scroll_y):.1f}",
+                ]
+            )
+            for key in sorted(backend_info.keys()):
+                lines.append(f"backend.{key}: {backend_info[key]}")
+        return self._to_json_or_lines(data, lines)
+
+    def _extract_vllm_runtime_flags(self) -> dict[str, object]:
+        raw = list(getattr(self.runtime.args, "vllm_extra_args", []) or [])
+        out: dict[str, object] = {
+            "kv_cache_dtype": "none",
+            "calculate_kv_scales": False,
+            "stream_interval": "default",
+            "cpu_offload_gb": "default",
+            "max_num_seqs": "default",
+        }
+        idx = 0
+        while idx < len(raw):
+            token = raw[idx]
+            nxt = raw[idx + 1] if idx + 1 < len(raw) else None
+            if token == "--kv-cache-dtype" and nxt is not None:
+                out["kv_cache_dtype"] = nxt
+                idx += 2
+                continue
+            if token == "--calculate-kv-scales":
+                out["calculate_kv_scales"] = True
+                idx += 1
+                continue
+            if token == "--stream-interval" and nxt is not None:
+                out["stream_interval"] = nxt
+                idx += 2
+                continue
+            if token == "--cpu-offload-gb" and nxt is not None:
+                out["cpu_offload_gb"] = nxt
+                idx += 2
+                continue
+            if token == "--max-num-seqs" and nxt is not None:
+                out["max_num_seqs"] = nxt
+                idx += 2
+                continue
+            idx += 1
+        return out
 
+    def _backend_runtime_summary(self) -> dict[str, object]:
+        args = self.runtime.args
+        backend = self.runtime.session.backend_name
+        summary: dict[str, object] = {"backend": backend}
         if backend == "hf":
-            keys = [
-                "max_new_tokens",
-                "temperature",
-                "top_p",
-                "top_k",
-                "stop_strings",
-                "repetition_penalty",
-                "typical_p",
-                "min_p",
-                "max_time",
-                "num_beams",
-                "no_repeat_ngram_size",
-            ]
-            sent = {
-                "max_new_tokens": args.max_new_tokens,
-                "temperature": args.temperature,
-                "top_p": args.top_p,
-                "repetition_penalty": args.repetition_penalty,
-                "num_beams": args.num_beams,
-                "no_repeat_ngram_size": args.no_repeat_ngram_size,
+            weights_quant = "8bit" if getattr(args, "use_8bit", False) else "4bit" if getattr(args, "use_4bit", False) else "none"
+            summary.update(
+                {
+                    "weights_quantization": weights_quant,
+                    "kv_cache_quantization": "none",
+                    "attention_backend": args.hf_attn_implementation or "default",
+                    "device_map": getattr(args, "hf_device_map", "") or "auto",
+                    "max_memory": getattr(args, "hf_max_memory", "") or "(unset)",
+                    "low_cpu_mem_usage": getattr(args, "hf_low_cpu_mem_usage", None),
+                    "text_only_mode": bool(getattr(args, "hf_text_only", False)),
+                    "supports_images": bool(getattr(self.runtime.session, "supports_images", False)),
+                    "context_window_target": args.max_context_tokens if args.max_context_tokens is not None else "model_default",
+                    "context_allocation": "grows_with_sequence",
+                }
+            )
+            return summary
+        if backend == "vllm":
+            flags = self._extract_vllm_runtime_flags()
+            summary.update(
+                {
+                    "weights_quantization": "none",
+                    "kv_cache_quantization": flags["kv_cache_dtype"],
+                    "calculate_kv_scales": bool(flags["calculate_kv_scales"]),
+                    "attention_backend": args.vllm_attention_backend or "auto",
+                    "context_window_target": int(args.vllm_max_model_len or 0) or "server_default",
+                    "context_allocation": "preallocated_kv_cache",
+                    "stream_interval": flags["stream_interval"],
+                    "max_num_seqs": flags["max_num_seqs"],
+                    "cpu_offload_gb": flags["cpu_offload_gb"],
+                }
+            )
+            return summary
+        if backend == "gguf":
+            summary.update(
+                {
+                    "weights_quantization": "gguf",
+                    "kv_cache_quantization": "none",
+                    "context_window_target": args.n_ctx,
+                    "context_allocation": "reserved_context_window",
+                }
+            )
+            return summary
+        if backend == "exl2":
+            summary.update(
+                {
+                    "weights_quantization": "exl2",
+                    "kv_cache_quantization": getattr(args, "cache_type", "fp16"),
+                    "context_window_target": getattr(args, "max_seq_len", None) or "model_default",
+                    "context_allocation": "reserved_context_window",
+                }
+            )
+            return summary
+        if backend in {"openai", "ollama"}:
+            summary.update(
+                {
+                    "weights_quantization": "server_managed",
+                    "kv_cache_quantization": "server_managed",
+                    "context_window_target": "server_managed",
+                    "context_allocation": "server_managed",
+                }
+            )
+            return summary
+        return summary
+
+    def _backend_runtime_views(self) -> tuple[dict[str, object], dict[str, object]]:
+        args = self.runtime.args
+        session = self.runtime.session
+        backend = session.backend_name
+        requested: dict[str, object] = {}
+        effective: dict[str, object] = {}
+        describe = getattr(session, "describe", None)
+        info = describe() if callable(describe) else {}
+        if not isinstance(info, dict):
+            info = {}
+
+        if backend == "hf":
+            weights_quant = "8bit" if bool(getattr(args, "use_8bit", False)) else "4bit" if bool(getattr(args, "use_4bit", False)) else "none"
+            requested = {
+                "weights_quantization": weights_quant,
+                "kv_cache_quantization": "none",
+                "attention_backend": getattr(args, "hf_attn_implementation", None) or "default",
+                "device_map": getattr(args, "hf_device_map", "") or "auto",
+                "max_memory": getattr(args, "hf_max_memory", "") or "(unset)",
+                "low_cpu_mem_usage": getattr(args, "hf_low_cpu_mem_usage", None),
+                "context_window_target": args.max_context_tokens if args.max_context_tokens is not None else "model_default",
+                "text_only_mode": bool(getattr(args, "hf_text_only", False)),
             }
-            if args.top_k is not None:
-                sent["top_k"] = args.top_k
-            if args.stop_strings is not None:
-                sent["stop_strings"] = args.stop_strings
-            if args.typical_p is not None:
-                sent["typical_p"] = args.typical_p
-            if args.min_p is not None:
-                sent["min_p"] = args.min_p
-            if args.max_time is not None:
-                sent["max_time"] = args.max_time
-            deferred = []
-            for optional_key in ("top_k", "stop_strings", "typical_p", "min_p", "max_time"):
-                if optional_key not in sent:
-                    deferred.append(optional_key)
-        elif backend == "gguf":
-            keys = [
-                "max_new_tokens",
-                "temperature",
-                "top_p",
-                "top_k",
-                "min_p",
-                "typical_p",
-                "repetition_penalty",
-                "stop_strings",
-                "n_ctx",
-                "n_gpu_layers",
-                "prompt_mode",
-                "chat_template",
-            ]
-            sent = {
-                "max_tokens": args.max_new_tokens,
-                "temperature": args.temperature,
-                "top_p": args.top_p,
+            effective = {
+                "weights_quantization": info.get("weights_quantization", weights_quant),
+                "kv_cache_quantization": info.get("kv_cache_quantization", "none"),
+                "attention_backend": info.get("attention_backend_effective", "unknown"),
+                "device_map": info.get("hf_device_map", requested["device_map"]),
+                "max_memory": info.get("hf_max_memory", requested["max_memory"]),
+                "max_memory_effective": info.get("hf_max_memory_effective", "unknown"),
+                "low_cpu_mem_usage": info.get("hf_low_cpu_mem_usage", requested["low_cpu_mem_usage"]),
+                "torch_dtype": info.get("torch_dtype_effective", info.get("torch_dtype", getattr(args, "dtype", "auto"))),
+                "runtime_device": info.get("runtime_device", "unknown"),
+                "fully_on_single_gpu": info.get("fully_on_single_gpu", "unknown"),
+                "modules_on_cpu": info.get("modules_on_cpu", "unknown"),
+                "modules_on_disk": info.get("modules_on_disk", "unknown"),
+                "memory_footprint": info.get("memory_footprint", "unavailable"),
+                "cuda_memory_allocated": info.get("cuda_memory_allocated", "unavailable"),
+                "cuda_memory_reserved": info.get("cuda_memory_reserved", "unavailable"),
+                "cuda_max_memory_allocated": info.get("cuda_max_memory_allocated", "unavailable"),
+                "cuda_max_memory_reserved": info.get("cuda_max_memory_reserved", "unavailable"),
+                "qwen_fast_path_available": info.get("qwen_fast_path_available", "unknown"),
+                "context_window_target": requested["context_window_target"],
+                "context_allocation": info.get("context_allocation", "grows_with_sequence"),
+                "text_only_mode": info.get("text_only_mode", requested["text_only_mode"]),
+                "supports_images": info.get("supports_images", False),
             }
-            if args.top_k is not None:
-                sent["top_k"] = args.top_k
-            if args.min_p is not None:
-                sent["min_p"] = args.min_p
-            if args.typical_p is not None:
-                sent["typical_p"] = args.typical_p
-            if args.repetition_penalty not in (None, 1.0):
-                sent["repeat_penalty"] = args.repetition_penalty
-            if args.stop_strings is not None:
-                sent["stop"] = args.stop_strings
-            deferred = []
-            for optional_key, sent_key in (
-                ("top_k", "top_k"),
-                ("min_p", "min_p"),
-                ("typical_p", "typical_p"),
-                ("repetition_penalty", "repeat_penalty"),
-                ("stop_strings", "stop"),
-            ):
-                if sent_key not in sent:
-                    deferred.append(optional_key)
-        elif backend == "exl2":
-            keys = [
-                "max_new_tokens",
-                "temperature",
-                "top_p",
-                "top_k",
-                "min_p",
-                "typical_p",
-                "repetition_penalty",
-                "frequency_penalty",
-                "presence_penalty",
-                "stop_strings",
-                "max_seq_len",
-                "min_free_tokens",
-                "gpu_split",
-                "cache_type",
-                "exl2_stop_tokens",
-                "exl2_repeat_streak_max",
-            ]
-            sent = {
-                "max_new_tokens": args.max_new_tokens,
-                "temperature": args.temperature,
-                "top_p": args.top_p,
-                "top_k": (args.top_k or 0),
-                "min_p": (args.min_p or 0),
-                "typical": (args.typical_p or 0),
-                "repetition_penalty": args.repetition_penalty,
-                "frequency_penalty": (args.frequency_penalty or 0.0),
-                "presence_penalty": (args.presence_penalty or 0.0),
-                "max_seq_len": args.max_seq_len,
-                "min_free_tokens": args.min_free_tokens,
-                "cache_type": args.cache_type,
-                "exl2_repeat_streak_max": args.exl2_repeat_streak_max,
+            return requested, effective
+
+        if backend == "vllm":
+            flags = self._extract_vllm_runtime_flags()
+            requested = {
+                "weights_quantization": "none",
+                "kv_cache_quantization": flags["kv_cache_dtype"],
+                "calculate_kv_scales": bool(flags["calculate_kv_scales"]),
+                "attention_backend": getattr(args, "vllm_attention_backend", "") or "auto",
+                "context_window_target": int(args.vllm_max_model_len or 0) or "server_default",
+                "stream_interval": flags["stream_interval"],
+                "max_num_seqs": flags["max_num_seqs"],
+                "cpu_offload_gb": flags["cpu_offload_gb"],
             }
-            deferred = []
-            if args.stop_strings:
-                sent["stop_strings"] = args.stop_strings
-            if args.exl2_stop_tokens:
-                sent["exl2_stop_tokens"] = args.exl2_stop_tokens
-            else:
-                deferred.append("exl2_stop_tokens(auto:<end_of_turn>,<start_of_turn>,eos)")
-            if args.gpu_split and args.gpu_split != "auto":
-                sent["gpu_split"] = args.gpu_split
-            else:
-                deferred.append("gpu_split(full single-GPU load)")
-        else:
-            keys = ["max_new_tokens", "temperature", "top_p", "top_k", "stop_strings", "ollama_think"]
-            sent = {}
-            if "temperature" in user_set and args.temperature is not None:
-                sent["options.temperature"] = args.temperature
-            if "top_p" in user_set and args.top_p is not None:
-                sent["options.top_p"] = args.top_p
-            if "top_k" in user_set and args.top_k is not None:
-                sent["options.top_k"] = args.top_k
-            if "max_new_tokens" in user_set and args.max_new_tokens is not None:
-                sent["options.num_predict"] = args.max_new_tokens
-            if "stop_strings" in user_set and args.stop_strings is not None:
-                sent["options.stop"] = args.stop_strings
-            if args.ollama_think in {"true", "false"}:
-                sent["think"] = (args.ollama_think == "true")
-            deferred = []
-            if "options.temperature" not in sent:
-                deferred.append("temperature")
-            if "options.top_p" not in sent:
-                deferred.append("top_p")
-            if "options.top_k" not in sent:
-                deferred.append("top_k")
-            if "options.num_predict" not in sent:
-                deferred.append("max_new_tokens")
-            if "options.stop" not in sent:
-                deferred.append("stop_strings")
-            if "think" not in sent:
-                deferred.append("ollama_think(auto)")
-
-        args_block = {key: getattr(args, key, None) for key in keys}
+            effective = {
+                "weights_quantization": "none",
+                "kv_cache_quantization": requested["kv_cache_quantization"],
+                "calculate_kv_scales": requested["calculate_kv_scales"],
+                "attention_backend": info.get("attention_backend_effective", requested["attention_backend"]),
+                "context_window_target": requested["context_window_target"],
+                "context_allocation": "preallocated_kv_cache",
+                "stream_interval": requested["stream_interval"],
+                "max_num_seqs": requested["max_num_seqs"],
+                "cpu_offload_gb": requested["cpu_offload_gb"],
+            }
+            return requested, effective
+
+        if backend == "gguf":
+            requested = {
+                "weights_quantization": "gguf",
+                "kv_cache_quantization": "none",
+                "context_window_target": args.n_ctx,
+            }
+            effective = {
+                **requested,
+                "context_allocation": "reserved_context_window",
+            }
+            return requested, effective
+
+        if backend == "exl2":
+            requested = {
+                "weights_quantization": "exl2",
+                "kv_cache_quantization": getattr(args, "cache_type", "fp16"),
+                "context_window_target": getattr(args, "max_seq_len", None) or "model_default",
+            }
+            effective = {
+                **requested,
+                "context_allocation": "reserved_context_window",
+            }
+            return requested, effective
+
+        if backend in {"openai", "ollama"}:
+            requested = {
+                "weights_quantization": "server_managed",
+                "kv_cache_quantization": "server_managed",
+                "context_window_target": "server_managed",
+            }
+            effective = {
+                **requested,
+                "context_allocation": "server_managed",
+            }
+            return requested, effective
+
+        return requested, effective
+
+    def _show_prompt(self, argv: list[str]) -> str:
+        del argv
+        args = self.runtime.args
+        system = args.system or ""
+        cli_overrides = set(getattr(args, "_cli_overrides", set()) or set())
+        source = "none"
+        if "system" in cli_overrides:
+            source = "--system"
+        elif args.system_file:
+            source = "--system-file"
+        elif system:
+            source = "config/default"
+        data = {
+            "has_system": bool(system),
+            "system_source": source,
+            "system_file": resolve_path_maybe_relative(args.system_file, config_path=args._config_path)
+            if args.system_file
+            else "(none)",
+            "user_prefix": args.user_prefix or "",
+            "prompt_mode": getattr(args, "prompt_mode", None) if self.runtime.session.backend_name == "hf" else "N/A",
+            "chat_template": args.chat_template or "(none)",
+        }
         lines = [
-            "args.*",
-            *[f"  {k}: {args_block[k]!r}" for k in keys],
-            "sent.*",
+            f"has_system: {data['has_system']}",
+            f"system_source: {data['system_source']}",
+            f"user_prefix: {data['user_prefix']!r}",
+            f"chat_template: {data['chat_template']}",
         ]
+        if self._show_opts().verbose:
+            lines.append(f"system_file: {data['system_file']}")
+            lines.append(f"prompt_mode: {data['prompt_mode']}")
+            lines.append("system_prompt:")
+            lines.append(system if system else "(empty)")
+        return self._to_json_or_lines(data, lines)
+
+    def _show_gen(self, argv: list[str]) -> str:
+        del argv
+        args = self.runtime.args
+        if self.turn_records:
+            data = dict(self.turn_records[-1].knobs or {})
+        else:
+            data = build_intent_knobs(args, self.runtime.session.backend_name)
+
+        sent = dict(data.get("sent") or {})
+        deferred = list(data.get("deferred") or [])
+        ignored = list(data.get("ignored") or [])
+        notes = list(data.get("notes") or [])
+
+        lines = []
+        mode = data.get("mode")
+        if mode:
+            lines.append(f"mode: {mode}")
+        lines.append("sent.*")
         if sent:
             lines.extend([f"  {k}: {v!r}" for k, v in sent.items()])
         else:
             lines.append("  (none)")
-        lines.append("deferred")
-        if deferred:
-            lines.extend([f"  {k}" for k in deferred])
+        if self._show_opts().verbose:
+            lines.append("deferred")
+            if deferred:
+                lines.extend([f"  {k}" for k in deferred])
+            else:
+                lines.append("  (none)")
+            lines.append("ignored")
+            if ignored:
+                lines.extend([f"  {k}" for k in ignored])
+            else:
+                lines.append("  (none)")
+            if notes:
+                lines.append("notes")
+                lines.extend([f"  {row}" for row in notes])
         else:
-            lines.append("  (none)")
-        return "\n".join(lines)
+            lines.append(f"deferred: {deferred if deferred else []}")
+            lines.append(f"ignored: {ignored if ignored else []}")
+
+        if self._show_opts().verbose:
+            data["args"] = {
+                key: ("***" if key.endswith("api_key") or key == "api_key" else value)
+                for key, value in vars(args).items()
+                if not key.startswith("_")
+            }
+        return self._to_json_or_lines(data, lines)
 
     def _show_ui(self, argv: list[str]) -> str:
         del argv
         args = self.runtime.args
+        data = {
+            "show_thinking": args.show_thinking,
+            "show_tool_activity": bool(getattr(args, "show_tool_activity", False)),
+            "show_tool_arguments": bool(getattr(args, "show_tool_arguments", False)),
+            "no_animate_thinking": args.no_animate_thinking,
+            "scroll_lines": args.scroll_lines,
+            "ui_tick_ms": args.ui_tick_ms,
+            "ui_max_events_per_tick": args.ui_max_events_per_tick,
+            "follow_output": self.follow_output,
+            "capture_last_request": bool(getattr(args, "capture_last_request", False)),
+        }
+        lines = [f"{k}: {v}" for k, v in data.items()]
+        return self._to_json_or_lines(data, lines)
+
+    def _show_recording(self, argv: list[str]) -> str:
+        del argv
+        args = self.runtime.args
+        data = {
+            "capture_last_request": bool(getattr(args, "capture_last_request", False)),
+            "save_transcript": (
+                resolve_path_maybe_relative(args.save_transcript, config_path=args._config_path)
+                if getattr(args, "save_transcript", "")
+                else "(none)"
+            ),
+            "telemetry_jsonl": (
+                resolve_path_maybe_relative(args.telemetry_jsonl, config_path=args._config_path)
+                if getattr(args, "telemetry_jsonl", "")
+                else "(none)"
+            ),
+            "telemetry_sample_interval_s": float(getattr(args, "telemetry_sample_interval_s", 0.0) or 0.0),
+        }
         lines = [
-            f"show_thinking: {args.show_thinking}",
-            f"no_animate_thinking: {args.no_animate_thinking}",
-            f"scroll_lines: {args.scroll_lines}",
-            f"ui_tick_ms: {args.ui_tick_ms}",
-            f"ui_max_events_per_tick: {args.ui_max_events_per_tick}",
-            f"follow_output: {self.follow_output}",
+            f"capture_last_request: {data['capture_last_request']}",
+            f"save_transcript: {data['save_transcript']}",
+            f"telemetry_jsonl: {data['telemetry_jsonl']}",
+            f"telemetry_sample_interval_s: {data['telemetry_sample_interval_s']}",
         ]
-        return "\n".join(lines)
+        return self._to_json_or_lines(data, lines)
 
     def _show_args(self, argv: list[str]) -> str:
         del argv
@@ -970,81 +2629,204 @@ def _show_args(self, argv: list[str]) -> str:
         for key, value in vars(self.runtime.args).items():
             if key.startswith("_"):
                 continue
-            data[key] = value
-        return json.dumps(data, indent=2, ensure_ascii=False, default=str)
+            if key.endswith("api_key") or key == "api_key":
+                data[key] = "***" if value else value
+            else:
+                data[key] = value
+        lines = [f"{k}: {data[k]!r}" for k in sorted(data.keys())]
+        return self._to_json_or_lines(data, lines)
 
     def _show_history(self, argv: list[str]) -> str:
         del argv
         roles = [msg.get("role", "?") for msg in self.messages[-10:]]
-        lines = [
-            f"turn_records: {len(self.turn_records)}",
-            f"messages: {len(self.messages)}",
-            f"last_roles(10): {roles}",
-        ]
-        return "\n".join(lines)
+        data = {
+            "turn_records": len(self.turn_records),
+            "messages": len(self.messages),
+            "last_roles_10": roles,
+        }
+        lines = [f"{k}: {v}" for k, v in data.items()]
+        return self._to_json_or_lines(data, lines)
 
     def _show_last(self, argv: list[str]) -> str:
         del argv
         if not self.turn_records:
             return "No completed turns yet."
         last = self.turn_records[-1]
+        token_counts = self._token_counts_view(last)
+        context = self._context_view(last)
+        finish_reason = None
+        if isinstance(last.gen, dict):
+            finish_reason = last.gen.get("finish_reason")
+        data = {
+            "backend": last.backend,
+            "model_id": last.model_id,
+            "ended_in_think": last.ended_in_think,
+            "elapsed": last.timing.get("elapsed"),
+            "time_to_first_token": last.timing.get("time_to_first_token"),
+            "prompt_tokens": token_counts["prompt_tokens"],
+            "completion_tokens": token_counts["completion_tokens"],
+            "total_tokens": token_counts["total_tokens"],
+            "tokens_per_s": self._tokens_per_s_view(last),
+            "tool_activity_count": len(last.tool_activity or []),
+            "finish_reason": finish_reason if finish_reason is not None else "unavailable",
+            "context": context,
+        }
         lines = [
-            f"backend: {last.backend}",
-            f"model_id: {last.model_id}",
-            f"ended_in_think: {last.ended_in_think}",
-            f"timing.elapsed: {last.timing.get('elapsed')}",
-            f"len(raw): {len(last.raw)}",
-            f"len(think): {len(last.think)}",
-            f"len(answer): {len(last.answer)}",
+            f"backend: {data['backend']}",
+            f"model: {data['model_id']}",
+            "timing:",
+            f"  elapsed: {data['elapsed']}",
+            f"  ttft: {data['time_to_first_token']}",
+            f"  tok/s: {data['tokens_per_s']}",
+            "tokens:",
+            f"  prompt: {data['prompt_tokens']}",
+            f"  completion: {data['completion_tokens']}",
+            f"  total: {data['total_tokens']}",
+            "result:",
+            f"  finish_reason: {data['finish_reason']}",
+            f"  ended_in_think: {data['ended_in_think']}",
+            f"  tools: {data['tool_activity_count']}",
+            "context:",
+            f"  strategy: {context['strategy']}",
+            f"  dropped_messages: {context['dropped_messages']}",
+            f"  fit: {context['fit']}",
+            f"  system_preserved: {context['system_message_preserved']}",
         ]
-        return "\n".join(lines)
+        if self._show_opts().verbose:
+            data["chars_raw"] = len(last.raw)
+            data["chars_think"] = len(last.think)
+            data["chars_answer"] = len(last.answer)
+            data["raw"] = last.raw
+            data["think"] = last.think
+            data["answer"] = last.answer
+            data["tool_activity"] = list(last.tool_activity or [])
+            lines.extend(["", "chars:", f"  raw: {data['chars_raw']}", f"  think: {data['chars_think']}", f"  answer: {data['chars_answer']}"])
+            lines.extend(["", "raw:", last.raw, "", "think:", last.think, "", "answer:", last.answer])
+            lines.extend(["", "tool_activity:"])
+            if last.tool_activity:
+                for index, item in enumerate(last.tool_activity, start=1):
+                    lines.append(f"  [{index}] name={item.get('name', '')} id={item.get('tool_call_id', '')}")
+                    lines.append(f"    status: {item.get('status', '')}")
+                    lines.append(f"    arguments_raw: {item.get('arguments_raw', '')}")
+                    parsed = item.get("arguments_json")
+                    if parsed is not None:
+                        lines.append("    arguments_json:")
+                        for row in json.dumps(parsed, indent=2, ensure_ascii=False, default=str).splitlines():
+                            lines.append(f"      {row}")
+                    if item.get("result") not in (None, ""):
+                        lines.append(f"    result: {item.get('result')}")
+                    if item.get("error") not in (None, ""):
+                        lines.append(f"    error: {item.get('error')}")
+            else:
+                lines.append("  (none)")
+        return self._to_json_or_lines(data, lines)
 
     def _show_env(self, argv: list[str]) -> str:
         del argv
-        lines = [
-            f"OLLAMA_HOST: {os.environ.get('OLLAMA_HOST', '(unset)')}",
-            f"CUDA_VISIBLE_DEVICES: {os.environ.get('CUDA_VISIBLE_DEVICES', '(unset)')}",
-        ]
-        return "\n".join(lines)
+        data = {
+            "OLLAMA_HOST": os.environ.get("OLLAMA_HOST", "(unset)"),
+            "CUDA_VISIBLE_DEVICES": os.environ.get("CUDA_VISIBLE_DEVICES", "(unset)"),
+            "OPENAI_API_KEY": "***" if os.environ.get("OPENAI_API_KEY") else "(unset)",
+        }
+        lines = [f"{k}: {v}" for k, v in data.items()]
+        return self._to_json_or_lines(data, lines)
 
     def _show_files(self, argv: list[str]) -> str:
         del argv
         args = self.runtime.args
-        lines = [f"config_path: {args._config_path or '(none)'}"]
+        data = {"config_path": args._config_path or "(none)"}
+        lines = [f"config_path: {data['config_path']}"]
         if args.system_file:
-            lines.append(
-                f"system_file: {resolve_path_maybe_relative(args.system_file, config_path=args._config_path)}"
-            )
+            data["system_file"] = resolve_path_maybe_relative(args.system_file, config_path=args._config_path)
+            lines.append(f"system_file: {data['system_file']}")
         else:
+            data["system_file"] = "(none)"
             lines.append("system_file: (none)")
         if args.save_transcript:
-            lines.append(
-                f"save_transcript: {resolve_path_maybe_relative(args.save_transcript, config_path=args._config_path)}"
-            )
+            data["save_transcript"] = resolve_path_maybe_relative(args.save_transcript, config_path=args._config_path)
+            lines.append(f"save_transcript: {data['save_transcript']}")
         else:
+            data["save_transcript"] = "(none)"
             lines.append("save_transcript: (none)")
-        return "\n".join(lines)
+        return self._to_json_or_lines(data, lines)
 
     def _show_model(self, argv: list[str]) -> str:
         del argv
-        return "\n".join(
-            [
-                f"backend: {self.runtime.session.backend_name}",
-                f"model_id: {self.runtime.session.resolved_model_id}",
-            ]
-        )
+        data = {
+            "backend": self.runtime.session.backend_name,
+            "model_id": self.runtime.session.resolved_model_id,
+        }
+        lines = [f"backend: {data['backend']}", f"model_id: {data['model_id']}"]
+        return self._to_json_or_lines(data, lines)
 
     def _show_config(self, argv: list[str]) -> str:
         del argv
-        return f"config_path: {self.runtime.args._config_path or '(none)'}"
+        args = self.runtime.args
+        data = {"config_path": args._config_path or "(none)"}
+        lines = [f"config_path: {data['config_path']}"]
+        profile = getattr(args, "_config_profile", "") or ""
+        data["profile"] = profile or "(none)"
+        lines.append(f"profile: {data['profile']}")
+        loaded = list(getattr(args, "_config_layers", []) or [])
+        data["loaded_files"] = loaded
+        if loaded:
+            lines.append("loaded_files:")
+            for path in loaded:
+                lines.append(f"  - {path}")
+        else:
+            lines.append("loaded_files: (none)")
+        origins = dict(getattr(args, "_config_origins", {}) or {})
+        data["origins"] = origins
+        lines.append("origins:")
+        if origins:
+            for key in sorted(origins.keys()):
+                lines.append(f"  {key}: {origins[key]}")
+        else:
+            lines.append("  (none)")
+        return self._to_json_or_lines(data, lines)
 
     def _show_backend(self, argv: list[str]) -> str:
         del argv
         session = self.runtime.session
+        requested_runtime, effective_runtime = self._backend_runtime_views()
+        data = {
+            "backend": session.backend_name,
+            "resolved_model_id": session.resolved_model_id,
+            "effective": effective_runtime,
+        }
         lines = [
-            f"backend: {session.backend_name}",
-            f"resolved_model_id: {session.resolved_model_id}",
+            f"backend: {data['backend']}",
+            f"resolved_model_id: {data['resolved_model_id']}",
+        ]
+        preferred = [
+            "weights_quantization",
+            "kv_cache_quantization",
+            "calculate_kv_scales",
+            "torch_dtype",
+            "attention_backend",
+            "runtime_device",
+            "device_map",
+            "fully_on_single_gpu",
+            "modules_on_cpu",
+            "modules_on_disk",
+            "memory_footprint",
+            "cuda_memory_allocated",
+            "cuda_memory_reserved",
+            "max_memory_effective",
+            "qwen_fast_path_available",
+            "max_memory",
+            "low_cpu_mem_usage",
+            "text_only_mode",
+            "supports_images",
+            "context_window_target",
+            "context_allocation",
+            "stream_interval",
+            "max_num_seqs",
+            "cpu_offload_gb",
         ]
+        for key in preferred:
+            if key in effective_runtime:
+                lines.append(f"{key}: {effective_runtime[key]}")
         describe = getattr(session, "describe", None)
         info = getattr(session, "get_info", None)
         extra = None
@@ -1053,17 +2835,239 @@ def _show_backend(self, argv: list[str]) -> str:
         elif callable(info):
             extra = info()
         if isinstance(extra, dict):
-            for key in sorted(extra.keys()):
-                lines.append(f"{key}: {extra[key]}")
+            data["describe"] = extra
+            if self._show_opts().verbose:
+                data["requested"] = requested_runtime
+                lines.append("requested:")
+                if requested_runtime:
+                    for key in sorted(requested_runtime.keys()):
+                        lines.append(f"  {key}: {requested_runtime[key]}")
+                else:
+                    lines.append("  (none)")
+                lines.append("effective:")
+                if effective_runtime:
+                    for key in sorted(effective_runtime.keys()):
+                        lines.append(f"  {key}: {effective_runtime[key]}")
+                else:
+                    lines.append("  (none)")
+                lines.append("raw:")
+                for key in sorted(extra.keys()):
+                    lines.append(f"  {key}: {extra[key]}")
+        return self._to_json_or_lines(data, lines)
+
+    def _show_connection(self, argv: list[str]) -> str:
+        del argv
+        session = self.runtime.session
+        describe = getattr(session, "describe", None)
+        info = describe() if callable(describe) else {}
+        if not isinstance(info, dict):
+            info = {}
+        data = {
+            "backend": session.backend_name,
+            "model_id": session.resolved_model_id,
+            "summary": self._backend_summary_line(),
+            "backend_info": info,
+        }
+        lines = [
+            f"backend: {data['backend']}",
+            f"model_id: {data['model_id']}",
+            f"summary: {data['summary']}",
+        ]
+        if self._show_opts().verbose:
+            for key in sorted(info.keys()):
+                lines.append(f"{key}: {info[key]}")
+        return self._to_json_or_lines(data, lines)
+
+    def _show_tools(self, argv: list[str]) -> str:
+        del argv
+        runtime = build_tool_runtime(self.runtime.args, self.runtime.session.backend_name)
+        data = runtime.describe(verbose=self._show_opts().verbose)
+        backend_tooling: dict[str, object] = {}
+        if self.runtime.session.backend_name == "vllm":
+            backend_tooling = {
+                "enable_auto_tool_choice": self.runtime.args.vllm_enable_auto_tool_choice,
+                "tool_call_parser": self.runtime.args.vllm_tool_call_parser or "",
+                "tool_choice": getattr(self.runtime.args, "tools_tool_choice", "") or "",
+            }
+        elif self.runtime.session.backend_name == "openai":
+            backend_tooling = {
+                "tool_choice": getattr(self.runtime.args, "tools_tool_choice", "") or "",
+            }
+        data["backend_tooling"] = backend_tooling
+        lines = [
+            f"backend: {data['backend']}",
+            f"supported_backend: {data['supported_backend']}",
+            f"enabled: {data['enabled']}",
+            f"mode: {data['mode']}",
+            f"schema_file: {data['schema_file'] or '(none)'}",
+            f"tool_choice: {data.get('tool_choice') or '(default)'}",
+            f"allow: {data['allow']}",
+            f"deny: {data['deny']}",
+            f"max_calls_per_turn: {data['max_calls_per_turn']}",
+            f"timeout_s: {data['timeout_s']}",
+            f"max_result_chars: {data['max_result_chars']}",
+            f"tool_names: {data['tool_names']}",
+        ]
+        if backend_tooling:
+            lines.append("backend_tooling:")
+            for key, value in backend_tooling.items():
+                lines.append(f"  {key}: {value}")
+        if self._show_opts().verbose:
+            lines.append("available_tools:")
+            for name, item in sorted((data.get("available_tools") or {}).items()):
+                lines.append(f"  {name}: source={item['source']} executable={item['executable']}")
+        return self._to_json_or_lines(data, lines)
+
+    def _show_tts(self, argv: list[str]) -> str:
+        del argv
+        args = self.runtime.args
+        data = {
+            "enabled": bool(getattr(args, "tts_enabled", False)),
+            "autoplay": bool(getattr(args, "tts_autoplay", True)),
+            "base_url": str(getattr(args, "tts_base_url", "http://127.0.0.1:8880") or ""),
+            "model": str(getattr(args, "tts_model", "kokoro") or "kokoro"),
+            "voice": str(getattr(args, "tts_voice", "af_heart") or "af_heart"),
+            "speed": float(getattr(args, "tts_speed", 1.0) or 1.0),
+            "last_audio_path": self._last_tts_audio_path or "",
+        }
+        lines = [
+            f"tts.enabled: {data['enabled']}",
+            f"tts.autoplay: {data['autoplay']}",
+            f"tts.base_url: {data['base_url']}",
+            f"tts.model: {data['model']}",
+            f"tts.voice: {data['voice']}",
+            f"tts.speed: {data['speed']:.2f}",
+            f"tts.last_audio_path: {data['last_audio_path'] or '(none)'}",
+            "",
+            "Commands: /tts voices | /tts voice <id> | /tts speed <n> | /tts on|off | /tts test [text] | /tts replay",
+        ]
+        return self._to_json_or_lines(data, lines)
+
+    def _show_stt(self, argv: list[str]) -> str:
+        del argv
+        args = self.runtime.args
+        data = {
+            "enabled": bool(getattr(args, "stt_enabled", False)),
+            "base_url": str(getattr(args, "stt_base_url", "http://127.0.0.1:8891") or ""),
+            "model": str(getattr(args, "stt_model", "whisper-1") or "whisper-1"),
+            "language": str(getattr(args, "stt_language", "auto") or "auto"),
+            "last_backend": self._stt_last_backend or "",
+            "last_audio_path": self._last_stt_audio_path or "",
+            "last_text": self._last_stt_text or "",
+        }
+        lines = [
+            f"stt.enabled: {data['enabled']}",
+            f"stt.base_url: {data['base_url']}",
+            f"stt.model: {data['model']}",
+            f"stt.language: {data['language']}",
+            f"stt.last_backend: {data['last_backend'] or '(none)'}",
+            f"stt.last_audio_path: {data['last_audio_path'] or '(none)'}",
+            f"stt.last_text: {data['last_text'] or '(none)'}",
+            "",
+            "Commands: /stt on|off | /stt base-url <url> | /stt model <id> | /stt language <code|auto> | /stt record [seconds] | /stt transcribe <file> | /stt toggle",
+        ]
+        return self._to_json_or_lines(data, lines)
+
+    def _show_logs(self, argv: list[str]) -> str:
+        n = 0
+        filt = ""
+        explicit_n = False
+        explicit_filter = False
+        idx = 0
+        while idx < len(argv):
+            token = argv[idx]
+            if token == "--n":
+                if idx + 1 >= len(argv):
+                    return "Missing value for --n"
+                try:
+                    n = max(1, int(argv[idx + 1]))
+                except ValueError:
+                    return f"Invalid --n value: {argv[idx + 1]}"
+                explicit_n = True
+                idx += 2
+                continue
+            if token == "--filter":
+                if idx + 1 >= len(argv):
+                    return "Missing value for --filter"
+                filt = argv[idx + 1]
+                explicit_filter = True
+                idx += 2
+                continue
+            return f"Unknown logs arg: {token}"
+
+        effective_verbose = self._show_opts().verbose or explicit_n or explicit_filter
+        if n <= 0:
+            n = 80 if effective_verbose else 20
+
+        session = self.runtime.session
+        logs_fn = getattr(session, "get_recent_logs", None)
+        if not callable(logs_fn):
+            return f"Backend '{session.backend_name}' does not expose in-memory logs."
+        rows = logs_fn(n, None)
+        if filt:
+            rows = [r for r in rows if filt in r]
+
+        args = self.runtime.args
+        key = f"{session.backend_name}_log_file"
+        configured_log_file = getattr(args, key, "") if hasattr(args, key) else ""
+        lines = [f"backend: {session.backend_name}", f"requested_n: {n}", f"filter: {filt or '(none)'}"]
+        list_sources_fn = getattr(session, "list_log_sources", None)
+        if callable(list_sources_fn):
+            try:
+                sources = list_sources_fn()
+            except Exception:
+                sources = []
+            lines.append(f"available_sources: {', '.join(sources) if sources else '(none)'}")
+        if configured_log_file:
+            lines.append(f"log_file: {configured_log_file}")
+        else:
+            lines.append("log_file: (not configured)")
+        if not effective_verbose and not rows:
+            lines.append("No logs captured in backend ring buffer yet.")
+            lines.append("Hint: run a prompt, then `/show logs` again or use `/show logs --n 80`.")
+            return "\n".join(lines)
+        if rows:
+            lines.append("tail:")
+            lines.extend(rows)
+        else:
+            lines.append("tail: (empty)")
+        return "\n".join(lines)
+
+    def _show_request(self, argv: list[str]) -> str:
+        del argv
+        session = self.runtime.session
+        req_fn = getattr(session, "get_last_request", None)
+        if not callable(req_fn):
+            return (
+                f"Backend '{session.backend_name}' does not expose request capture.\n"
+                "No request captured (enable request capture in config: [ui] capture_last_request = true)."
+            )
+        payload = req_fn()
+        if not payload:
+            return "No request captured (enable request capture in config: [ui] capture_last_request = true)."
+        if self._show_opts().as_json:
+            return json.dumps(payload, indent=2, ensure_ascii=False, default=str)
+        lines = [
+            f"backend: {session.backend_name}",
+            f"captured: {bool(payload)}",
+            f"keys: {sorted(payload.keys())}",
+        ]
+        if self._show_opts().verbose:
+            lines.append("")
+            lines.append(json.dumps(payload, indent=2, ensure_ascii=False, default=str))
         return "\n".join(lines)
 
     def _show_aliases(self, argv: list[str]) -> str:
         del argv
+        cmd_alias_map: dict[str, list[str]] = {}
+        show_alias_map: dict[str, str] = {}
+        shortcuts: dict[str, str] = {}
         lines = ["Command aliases:"]
         for name in sorted(self.registry.canonical_names()):
             cmd = self.registry.resolve(name)
             if cmd is None or not cmd.aliases:
                 continue
+            cmd_alias_map[name] = [f"/{alias}" for alias in cmd.aliases]
             lines.append(f"  /{name}: " + ", ".join(f"/{alias}" for alias in cmd.aliases))
 
         lines.append("")
@@ -1072,6 +3076,7 @@ def _show_aliases(self, argv: list[str]) -> str:
             target = self.show_aliases[alias]
             if alias == target:
                 continue
+            show_alias_map[alias] = target
             lines.append(f"  {alias} -> {target}")
 
         lines.append("")
@@ -1081,8 +3086,12 @@ def _show_aliases(self, argv: list[str]) -> str:
             if cmd is None:
                 continue
             if cmd.summary.startswith("Alias for /show "):
+                shortcuts[f"/{name}"] = cmd.summary.removeprefix("Alias for ")
                 lines.append(f"  /{name} -> {cmd.summary.removeprefix('Alias for ')}")
-        return "\n".join(lines)
+        return self._to_json_or_lines(
+            {"command_aliases": cmd_alias_map, "show_aliases": show_alias_map, "show_shortcuts": shortcuts},
+            lines,
+        )
 
     def _emit_event(self, ev: Event):
         self.event_queue.put(ev)
@@ -1092,7 +3101,7 @@ def _run_generation(self, turn_id: int, messages: list[dict[str, str]]):
 
     def _drain_events(self):
         processed = 0
-        pending_think_token_inc = 0
+        pending_generated_token_inc = 0
         while processed < self._max_events_per_tick:
             try:
                 ev = self.event_queue.get_nowait()
@@ -1101,19 +3110,25 @@ def _drain_events(self):
             processed += 1
 
             if isinstance(ev, TurnStart):
+                if getattr(ev, "turn_id", None) == self.pending_turn_id and self.pending_assistant is not None:
+                    self._pending_turn_started_at = time.time()
+                    self.pending_assistant.start_turn()
                 continue
 
             if getattr(ev, "turn_id", None) != self.pending_turn_id or self.pending_assistant is None:
                 continue
 
             if isinstance(ev, Meta):
-                if ev.key == "think_tokens_inc":
-                    pending_think_token_inc += int(ev.value)
+                if ev.key == "generated_tokens_inc":
+                    token_inc = int(ev.value)
+                    if token_inc > 0 and self._pending_turn_first_token_at is None:
+                        self._pending_turn_first_token_at = time.time()
+                    pending_generated_token_inc += token_inc
                 continue
 
-            if pending_think_token_inc:
-                self.pending_assistant.add_think_tokens(pending_think_token_inc)
-                pending_think_token_inc = 0
+            if pending_generated_token_inc:
+                self.pending_assistant.add_generated_tokens(pending_generated_token_inc)
+                pending_generated_token_inc = 0
 
             if isinstance(ev, ThinkDelta):
                 self.pending_assistant.append_think(ev.text)
@@ -1125,24 +3140,48 @@ def _drain_events(self):
                     self._request_scroll_end()
             elif isinstance(ev, Error):
                 self.pending_assistant.append_answer(f"\n[Generation error] {ev.message}")
-                self.pending_assistant.finish(ended_in_think=False)
+                self.pending_assistant.thinking_panel.finish(ended_in_think=False)
                 self.is_generating = False
+                self._pending_turn_started_at = None
+                self._pending_turn_first_token_at = None
+                telemetry = self.runtime.telemetry
+                if telemetry is not None and telemetry.enabled:
+                    telemetry.publish_error(scope="turn", message=ev.message)
             elif isinstance(ev, Finish):
                 record = ev.record
-                self.pending_assistant.finish(ended_in_think=record.ended_in_think)
+                timing = record.timing if isinstance(record.timing, dict) else {}
+                if "time_to_first_token" not in timing and self._pending_turn_first_token_at is not None:
+                    started_at = timing.get("start")
+                    if not isinstance(started_at, (int, float)):
+                        started_at = self._pending_turn_started_at
+                    if isinstance(started_at, (int, float)):
+                        timing["time_to_first_token"] = max(
+                            0.0,
+                            float(self._pending_turn_first_token_at) - float(started_at),
+                        )
+                self.pending_assistant.finish(record)
                 if record.trimmed_messages is not None:
                     self.messages = list(record.trimmed_messages)
-                assistant_for_history = record.answer if record.answer else record.think
-                self.messages.append({"role": "assistant", "content": assistant_for_history})
+                else:
+                    assistant_for_history = record.answer if record.answer else record.think
+                    self.messages.append({"role": "assistant", "content": assistant_for_history})
+                self._last_assistant_answer = str(record.answer or "")
+                if bool(getattr(self.runtime.args, "tts_enabled", False)) and self._last_assistant_answer.strip():
+                    self._tts_autoplay_last_answer_async(self._last_assistant_answer)
                 self.turn_records.append(record)
                 if self.runtime.args.save_transcript:
                     self._append_transcript_record(record)
+                telemetry = self.runtime.telemetry
+                if telemetry is not None and telemetry.enabled:
+                    telemetry.publish_turn_finished(turn_id=ev.turn_id, record=record)
                 self.is_generating = False
+                self._pending_turn_started_at = None
+                self._pending_turn_first_token_at = None
                 if self._should_autofollow():
                     self._request_scroll_end()
 
-        if pending_think_token_inc and self.pending_assistant is not None:
-            self.pending_assistant.add_think_tokens(pending_think_token_inc)
+        if pending_generated_token_inc and self.pending_assistant is not None:
+            self.pending_assistant.add_generated_tokens(pending_generated_token_inc)
         if processed > 0:
             self.transcript.refresh(layout=True)
 
@@ -1154,3 +3193,4 @@ def _append_transcript_record(self, record):
         line = json.dumps(record.__dict__, ensure_ascii=False)
         with open(path, "a", encoding="utf-8") as fh:
             fh.write(line + "\n")
+SOFT_TEXT = "#e6dfcf"
diff --git a/tui_app/backends/base.py b/tui_app/backends/base.py
index 8b61cd0..8608d5e 100644
--- a/tui_app/backends/base.py
+++ b/tui_app/backends/base.py
@@ -12,5 +12,11 @@ class BackendSession(Protocol):
     backend_name: str
     resolved_model_id: str
 
-    def generate_turn(self, turn_id: int, messages: list[dict[str, str]], emit: EventEmitter) -> None:
+    def generate_turn(self, turn_id: int, messages: list[dict[str, object]], emit: EventEmitter) -> None:
+        ...
+
+    def get_recent_logs(self, n: int = 80, sources: list[str] | None = None) -> list[str]:
+        ...
+
+    def list_log_sources(self) -> list[str]:
         ...
diff --git a/tui_app/backends/exl2.py b/tui_app/backends/exl2.py
index 5ae08fe..aea6dff 100644
--- a/tui_app/backends/exl2.py
+++ b/tui_app/backends/exl2.py
@@ -8,12 +8,17 @@
 import sys
 import time
 from dataclasses import dataclass
+from pathlib import Path
 
 import torch
 from jinja2 import Environment
 
 from tui_app.backends.base import EventEmitter
+from tui_app.context_policy import build_context_limit_error, trim_messages_to_budget
 from tui_app.events import AnswerDelta, Error, Finish, Meta, ThinkDelta, TurnRecord, TurnStart
+from tui_app.history_control import append_assistant_history
+from tui_app.knobs import SUPPORTED_KNOBS, finalize_knob_report, unsupported_user_set
+from tui_app.log_file import FileLogger
 from tui_app.think_router import ThinkRouter
 
 
@@ -32,6 +37,7 @@ def resolve_exl2_model_dir(
     *,
     model_path: str | None = None,
     exl2_repo_path: str | None = None,
+    hf_cache_dir: str | None = None,
     config_path: str | None = None,
 ) -> str:
     primary = normalize_model_dir(model_ref)
@@ -41,6 +47,10 @@ def resolve_exl2_model_dir(
     if os.path.isabs(os.path.expanduser((model_ref or "").strip())):
         return primary
 
+    hf_candidate = _resolve_hf_snapshot_dir(hf_cache_dir, model_ref)
+    if hf_candidate:
+        return hf_candidate
+
     candidates: list[str] = []
     if model_path:
         candidates.append(os.path.join(resolve_path_maybe_relative(model_path, config_path=config_path), model_ref))
@@ -54,6 +64,47 @@ def resolve_exl2_model_dir(
     return primary
 
 
+def _resolve_hf_snapshot_dir(hf_cache_dir: str | None, model_ref: str) -> str:
+    cache_root = Path(os.path.expanduser((hf_cache_dir or "").strip()))
+    model_ref = (model_ref or "").strip()
+    if not model_ref or not cache_root.is_dir():
+        return ""
+
+    if (cache_root / "hub").is_dir():
+        cache_root = cache_root / "hub"
+
+    repo_candidates: list[Path] = []
+    if model_ref.startswith("models--"):
+        repo_candidates.append(cache_root / model_ref)
+    if "/" in model_ref and not model_ref.startswith("models--"):
+        owner, name = model_ref.split("/", 1)
+        repo_candidates.append(cache_root / f"models--{owner}--{name}")
+    repo_candidates.extend(sorted(cache_root.glob(f"models--*--{model_ref}")))
+
+    seen: set[str] = set()
+    best_path = ""
+    best_mtime = -1.0
+    for repo_dir in repo_candidates:
+        repo_key = str(repo_dir)
+        if repo_key in seen or not repo_dir.is_dir():
+            continue
+        seen.add(repo_key)
+        snapshots_dir = repo_dir / "snapshots"
+        if not snapshots_dir.is_dir():
+            continue
+        for snap_dir in snapshots_dir.iterdir():
+            if not snap_dir.is_dir():
+                continue
+            try:
+                mtime = snap_dir.stat().st_mtime
+            except OSError:
+                continue
+            if mtime > best_mtime:
+                best_mtime = mtime
+                best_path = str(snap_dir.resolve())
+    return best_path
+
+
 def resolve_path_maybe_relative(path: str, config_path: str | None = None) -> str:
     expanded = os.path.expanduser(path)
     if os.path.isabs(expanded):
@@ -270,9 +321,10 @@ def apply_context_limit_exl2(
     *,
     max_seq_len: int,
     min_free_tokens: int,
-) -> tuple[torch.Tensor, list[dict[str, str]], str]:
-    trimmed = _sanitize_messages(messages)
-    while True:
+) -> tuple[torch.Tensor, list[dict[str, str]], str, dict[str, object]]:
+    sanitized = _sanitize_messages(messages)
+
+    def _measure(trimmed):
         prompt_text = render_chat_template(
             template_text,
             messages=trimmed,
@@ -283,18 +335,19 @@ def apply_context_limit_exl2(
         length = _count_tokens(input_ids)
         if length <= 0:
             raise RuntimeError("Tokenizer returned no input ids for rendered EXL2 prompt.")
-        if length <= max(1, max_seq_len - min_free_tokens):
-            return input_ids, trimmed, prompt_text
-
-        drop_idx = None
-        start_idx = 1 if trimmed and trimmed[0].get("role") == "system" else 0
-        for idx in range(start_idx, len(trimmed)):
-            if trimmed[idx].get("role") in {"user", "assistant", "tool"}:
-                drop_idx = idx
-                break
-        if drop_idx is None:
-            return input_ids, trimmed, prompt_text
-        trimmed.pop(drop_idx)
+        return length, (input_ids, prompt_text)
+
+    trimmed, _length, payload, report = trim_messages_to_budget(
+        sanitized,
+        measure_fn=_measure,
+        context_window=max_seq_len,
+        reserved_generation_tokens=min_free_tokens,
+        strategy="exact_preflight",
+    )
+    if not report.fit:
+        raise RuntimeError(build_context_limit_error(report))
+    input_ids, prompt_text = payload
+    return input_ids, trimmed, prompt_text, report.to_dict()
 
 
 def _try_import_exllamav2(exl2_repo_path: str | None):
@@ -339,13 +392,40 @@ class _Exl2Runtime:
 class EXL2Session:
     backend_name = "exl2"
 
-    def __init__(self, runtime: _Exl2Runtime, args: argparse.Namespace, resolved_model_id: str):
+    def __init__(
+        self,
+        runtime: _Exl2Runtime,
+        args: argparse.Namespace,
+        resolved_model_id: str,
+        template_info: dict[str, object] | None = None,
+        logger: FileLogger | None = None,
+    ):
         self.runtime = runtime
         self.args = args
         self.resolved_model_id = resolved_model_id
+        self.template_info = dict(template_info or {})
+        self.logger = logger
 
     def describe(self) -> dict[str, object]:
-        return dict(self.runtime.backend_info)
+        return {
+            "template_control_level": "local_template",
+            **dict(self.runtime.backend_info),
+            **self.template_info,
+        }
+
+    def close(self) -> None:
+        if self.logger is not None:
+            self.logger.close()
+
+    def get_recent_logs(self, n: int = 80, sources: list[str] | None = None) -> list[str]:
+        if self.logger is None:
+            return []
+        return self.logger.get_recent_logs(n=n, sources=sources)
+
+    def list_log_sources(self) -> list[str]:
+        if self.logger is None:
+            return []
+        return self.logger.list_log_sources()
 
     def _build_settings(self):
         from exllamav2.generator import ExLlamaV2Sampler
@@ -365,6 +445,12 @@ def _build_settings(self):
     def generate_turn(self, turn_id: int, messages: list[dict[str, str]], emit: EventEmitter) -> None:
         emit(TurnStart(turn_id=turn_id))
         started = time.time()
+        if self.logger is not None:
+            self.logger.log(
+                f"turn_start id={turn_id} messages={len(messages)} max_new_tokens={self.args.max_new_tokens} "
+                f"max_seq_len={self.args.max_seq_len}",
+                source="backend",
+            )
         router = ThinkRouter(assume_think=self.args.assume_think)
         stage = "init"
 
@@ -386,7 +472,7 @@ def generate_turn(self, turn_id: int, messages: list[dict[str, str]], emit: Even
                     template_text = DEFAULT_TEMPLATE
 
             stage = "context_encode"
-            input_ids, trimmed_messages, prompt_text = apply_context_limit_exl2(
+            input_ids, trimmed_messages, prompt_text, context_report = apply_context_limit_exl2(
                 self.runtime.tokenizer,
                 template_text=template_text,
                 messages=messages,
@@ -395,14 +481,32 @@ def generate_turn(self, turn_id: int, messages: list[dict[str, str]], emit: Even
             )
             history_messages = list(trimmed_messages)
 
-            emit(Meta(turn_id=turn_id, key="prompt_tokens", value=_count_tokens(input_ids)))
-            emit(Meta(turn_id=turn_id, key="trimmed_messages_count", value=len(messages) - len(trimmed_messages)))
+            prompt_tokens = _count_tokens(input_ids)
+            emit(Meta(turn_id=turn_id, key="prompt_tokens", value=prompt_tokens))
 
             gen = self.runtime.generator
             settings = self._build_settings()
             stop_conditions = _build_stop_conditions(self.runtime.tokenizer, self.args)
             if stop_conditions:
                 gen.set_stop_conditions(stop_conditions)
+            knob_sent = {
+                "max_new_tokens": self.args.max_new_tokens,
+                "temperature": settings.temperature,
+                "top_p": settings.top_p,
+                "top_k": settings.top_k,
+                "min_p": settings.min_p,
+                "typical_p": settings.typical,
+                "repetition_penalty": settings.token_repetition_penalty,
+                "frequency_penalty": settings.token_frequency_penalty,
+                "presence_penalty": settings.token_presence_penalty,
+            }
+            if self.args.stop_strings:
+                knob_sent["stop_strings"] = list(self.args.stop_strings)
+            knob_report = finalize_knob_report(
+                sent=knob_sent,
+                supported=SUPPORTED_KNOBS["exl2"],
+                ignored=unsupported_user_set(self.args, "exl2"),
+            )
 
             stage = "begin_stream"
             gen.begin_stream_ex(input_ids, settings)
@@ -418,7 +522,10 @@ def generate_turn(self, turn_id: int, messages: list[dict[str, str]], emit: Even
                 eos = bool(res.get("eos"))
                 token_ids = res.get("chunk_token_ids")
                 ids = _iter_token_ids(token_ids)
-                generated_tokens += len(ids) if ids else _count_tokens(token_ids)
+                token_inc = len(ids) if ids else _count_tokens(token_ids)
+                generated_tokens += token_inc
+                if token_inc > 0:
+                    emit(Meta(turn_id=turn_id, key="generated_tokens_inc", value=token_inc))
 
                 repeat_limit = int(getattr(self.args, "exl2_repeat_streak_max", 64) or 0)
                 if repeat_limit > 0 and ids:
@@ -463,7 +570,7 @@ def generate_turn(self, turn_id: int, messages: list[dict[str, str]], emit: Even
                     if partial:
                         resume_messages.append({"role": "assistant", "content": partial})
                     stage = "context_rebuild"
-                    input_ids, resume_trimmed, _ = apply_context_limit_exl2(
+                    input_ids, resume_trimmed, _, _ = apply_context_limit_exl2(
                         self.runtime.tokenizer,
                         template_text=template_text,
                         messages=resume_messages,
@@ -477,6 +584,8 @@ def generate_turn(self, turn_id: int, messages: list[dict[str, str]], emit: Even
                     emit(Meta(turn_id=turn_id, key="context_restarts", value=context_restarts))
 
         except Exception as exc:
+            if self.logger is not None:
+                self.logger.log(f"turn_error id={turn_id} stage={stage} error={exc}", source="backend")
             emit(Error(turn_id=turn_id, message=f"{stage}: {exc}"))
             return
 
@@ -489,10 +598,19 @@ def generate_turn(self, turn_id: int, messages: list[dict[str, str]], emit: Even
                 emit(AnswerDelta(turn_id=turn_id, text=text))
 
         ended = time.time()
+        completion_tokens = int(generated_tokens)
+        total_tokens = int(prompt_tokens) + completion_tokens
+        emit(Meta(turn_id=turn_id, key="completion_tokens", value=completion_tokens))
+        emit(Meta(turn_id=turn_id, key="total_tokens", value=total_tokens))
+        elapsed = max(0.0, ended - started)
+        throughput = None
+        if completion_tokens > 0 and elapsed > 0:
+            throughput = {"tokens_per_s": completion_tokens / elapsed}
+        answer_text = "".join(answer_parts)
         record = TurnRecord(
             raw="".join(raw_parts),
             think="".join(think_parts),
-            answer="".join(answer_parts).strip(),
+            answer=answer_text,
             ended_in_think=(router.mode == "think"),
             backend=self.backend_name,
             model_id=self.resolved_model_id,
@@ -505,10 +623,29 @@ def generate_turn(self, turn_id: int, messages: list[dict[str, str]], emit: Even
                 "typical_p": self.args.typical_p,
                 "repetition_penalty": self.args.repetition_penalty,
             },
-            timing={"start": started, "end": ended, "elapsed": max(0.0, ended - started)},
-            trimmed_messages=history_messages,
+            timing={"start": started, "end": ended, "elapsed": elapsed},
+            token_counts={
+                "prompt_tokens": int(prompt_tokens),
+                "completion_tokens": completion_tokens,
+                "total_tokens": total_tokens,
+            },
+            throughput=throughput,
+            knobs=knob_report,
+            context=context_report,
+            trimmed_messages=append_assistant_history(
+                list(history_messages),
+                think="".join(think_parts),
+                answer=answer_text,
+                strip_think=bool(self.args.history_strip_think),
+            ),
         )
         emit(Finish(turn_id=turn_id, record=record))
+        if self.logger is not None:
+            self.logger.log(
+                f"turn_finish id={turn_id} elapsed_s={record.timing.get('elapsed', 0):.3f} "
+                f"think_chars={len(record.think)} answer_chars={len(record.answer)}",
+                source="backend",
+            )
 
 
 def _parse_size_to_bytes(value: str, unit: str) -> int:
@@ -611,10 +748,16 @@ def _effective_attention_target(config, caps: dict[str, object]) -> str:
 
 
 def create_session(args: argparse.Namespace) -> EXL2Session:
+    logger = FileLogger.from_value(
+        getattr(args, "exl2_log_file", ""),
+        "backend",
+        config_path=getattr(args, "_config_path", None),
+    )
     model_dir = resolve_exl2_model_dir(
         args.model_id,
         model_path=getattr(args, "model_path", None),
         exl2_repo_path=getattr(args, "exl2_repo_path", None),
+        hf_cache_dir=getattr(args, "hf_cache_dir", None),
         config_path=getattr(args, "_config_path", None),
     )
     if not os.path.isdir(model_dir):
@@ -622,6 +765,8 @@ def create_session(args: argparse.Namespace) -> EXL2Session:
             f"EXL2 model_dir not found: {model_dir} "
             "(set model_id to full path, or set model_path/exl2_repo_path to a base directory containing the model folder)"
         )
+    if logger is not None:
+        logger.log(f"session_init model_dir={model_dir}", source="app")
 
     try:
         _try_import_exllamav2(getattr(args, "exl2_repo_path", None))
@@ -748,4 +893,27 @@ def create_session(args: argparse.Namespace) -> EXL2Session:
             "sdpa_available": caps.get("sdpa_available"),
         })(_query_attention_capabilities()),
     )
-    return EXL2Session(runtime=runtime, args=args, resolved_model_id=model_dir)
+    if logger is not None:
+        logger.log(
+            "attention_runtime="
+            f"{runtime.backend_info.get('attention_backend_runtime')} "
+            f"attention_effective={runtime.backend_info.get('attention_backend_effective')}",
+            source="app",
+        )
+    requested_template = (args.chat_template or "").strip()
+    template_requested_value = requested_template
+    if requested_template:
+        try:
+            candidate = resolve_path_maybe_relative(requested_template, config_path=getattr(args, "_config_path", None))
+            if os.path.isfile(candidate):
+                template_requested_value = candidate
+        except Exception:
+            pass
+    template_info = {
+        "chat_template_requested": template_requested_value,
+        "chat_template_applied": bool(requested_template and args.prompt_mode != "plain"),
+        "chat_template_reason": (
+            "applied" if requested_template and args.prompt_mode != "plain" else ("ignored_prompt_mode" if requested_template else "empty_default")
+        ),
+    }
+    return EXL2Session(runtime=runtime, args=args, resolved_model_id=model_dir, template_info=template_info, logger=logger)
diff --git a/tui_app/backends/gguf.py b/tui_app/backends/gguf.py
index 38011a2..01fa36d 100644
--- a/tui_app/backends/gguf.py
+++ b/tui_app/backends/gguf.py
@@ -5,9 +5,21 @@
 import os
 import re
 import time
+from typing import Callable
 
 from tui_app.backends.base import EventEmitter
+from tui_app.context_policy import (
+    build_context_limit_error,
+    build_retry_report,
+    drop_oldest_history_message,
+    is_context_overflow_text,
+    reserve_generation_tokens,
+    trim_messages_to_budget,
+)
 from tui_app.events import AnswerDelta, Error, Finish, Meta, ThinkDelta, TurnRecord, TurnStart
+from tui_app.history_control import append_assistant_history
+from tui_app.knobs import SUPPORTED_KNOBS, finalize_knob_report, unsupported_user_set
+from tui_app.log_file import FileLogger
 from tui_app.think_router import ThinkRouter
 
 
@@ -82,10 +94,41 @@ def _common_gguf_sampling_kwargs(args: argparse.Namespace, stop):
 class GGUFSession:
     backend_name = "gguf"
 
-    def __init__(self, llm, args: argparse.Namespace, resolved_model_id: str):
+    def __init__(
+        self,
+        llm,
+        args: argparse.Namespace,
+        resolved_model_id: str,
+        logger: FileLogger | None = None,
+        prompt_token_counter: Callable[[list[dict[str, str]]], int | None] | None = None,
+        template_info: dict[str, object] | None = None,
+    ):
         self.llm = llm
         self.args = args
         self.resolved_model_id = resolved_model_id
+        self.logger = logger
+        self.prompt_token_counter = prompt_token_counter
+        self.template_info = dict(template_info or {})
+
+    def close(self) -> None:
+        if self.logger is not None:
+            self.logger.close()
+
+    def get_recent_logs(self, n: int = 80, sources: list[str] | None = None) -> list[str]:
+        if self.logger is None:
+            return []
+        return self.logger.get_recent_logs(n=n, sources=sources)
+
+    def list_log_sources(self) -> list[str]:
+        if self.logger is None:
+            return []
+        return self.logger.list_log_sources()
+
+    def describe(self) -> dict[str, object]:
+        return {
+            "template_control_level": "local_template",
+            **self.template_info,
+        }
 
     def _fallback_plain_prompt(self, messages: list[dict[str, str]]) -> str:
         system = self.args.system or "You are a helpful assistant."
@@ -99,6 +142,12 @@ def _fallback_plain_prompt(self, messages: list[dict[str, str]]) -> str:
     def generate_turn(self, turn_id: int, messages: list[dict[str, str]], emit: EventEmitter) -> None:
         emit(TurnStart(turn_id=turn_id))
         started = time.time()
+        if self.logger is not None:
+            self.logger.log(
+                f"turn_start id={turn_id} messages={len(messages)} prompt_mode={self.args.prompt_mode} "
+                f"max_new_tokens={self.args.max_new_tokens}",
+                source="backend",
+            )
         router = ThinkRouter(assume_think=self.args.assume_think)
         working_messages = list(messages)
 
@@ -107,31 +156,28 @@ def generate_turn(self, turn_id: int, messages: list[dict[str, str]], emit: Even
         answer_parts: list[str] = []
         think_counter_text = ""
         think_counter_tokens = 0
+        generated_counter_text = ""
+        generated_counter_tokens = 0
+        prompt_tokens: int | None = None
+        knob_notes: list[str] = []
+        context_report: dict[str, object] | None = None
+        overflow_retries = 0
+        dropped_roles: list[str] = []
 
         max_tokens = self.args.max_new_tokens
-        effective_max_tokens = max_tokens
         stop = self.args.stop_strings or None
         sampling_kwargs = _common_gguf_sampling_kwargs(self.args, stop=stop)
+        reserved_generation = reserve_generation_tokens(int(self.args.n_ctx), max_tokens)
 
         def _is_context_overflow(exc: Exception) -> bool:
-            text = str(exc).lower()
-            return "context window" in text or ("requested tokens" in text and "exceed" in text)
+            return is_context_overflow_text(str(exc))
 
         def _drop_oldest_turn() -> bool:
-            start_idx = 1 if working_messages and working_messages[0].get("role") == "system" else 0
-            for idx in range(start_idx, len(working_messages)):
-                role = working_messages[idx].get("role")
-                if role in {"user", "assistant", "tool"}:
-                    working_messages.pop(idx)
-                    return True
-            return False
-
-        def _shrink_max_tokens() -> bool:
-            nonlocal effective_max_tokens
-            if effective_max_tokens <= 64:
+            dropped_chunk = drop_oldest_history_message(working_messages)
+            if dropped_chunk is None:
                 return False
-            effective_max_tokens = max(64, int(effective_max_tokens * 0.75))
-            return effective_max_tokens > 0
+            dropped_roles.extend(dropped_chunk)
+            return True
 
         def _count_tokens(text: str) -> int:
             if not text:
@@ -159,14 +205,49 @@ def _emit_think(text: str) -> None:
             if token_inc > 0:
                 emit(Meta(turn_id=turn_id, key="think_tokens_inc", value=token_inc))
 
+        def _emit_generated(text: str) -> None:
+            nonlocal generated_counter_text, generated_counter_tokens
+            if not text:
+                return
+            generated_counter_text += text
+            current = _count_tokens(generated_counter_text)
+            token_inc = current - generated_counter_tokens
+            generated_counter_tokens = current
+            if token_inc > 0:
+                emit(Meta(turn_id=turn_id, key="generated_tokens_inc", value=token_inc))
+
         def _sampling_kwargs_for_retry():
             kwargs = dict(sampling_kwargs)
-            kwargs["max_tokens"] = effective_max_tokens
+            kwargs["max_tokens"] = max_tokens
             return kwargs
 
+        if self.prompt_token_counter is not None:
+            def _measure(trimmed_messages):
+                count = self.prompt_token_counter(trimmed_messages)
+                if count is None:
+                    raise RuntimeError("GGUF prompt token counter returned no value.")
+                return int(count), None
+
+            trimmed_messages, prompt_tokens, _unused, report = trim_messages_to_budget(
+                working_messages,
+                measure_fn=_measure,
+                context_window=int(self.args.n_ctx),
+                reserved_generation_tokens=reserved_generation,
+                strategy="exact_preflight",
+            )
+            working_messages = list(trimmed_messages)
+            if not report.fit:
+                detail = build_context_limit_error(report)
+                if self.logger is not None:
+                    self.logger.log(f"turn_error id={turn_id} error={detail}", source="backend")
+                emit(Error(turn_id=turn_id, message=detail))
+                return
+            context_report = report.to_dict()
+
         if self.args.prompt_mode == "plain":
             while True:
                 try:
+                    used_mode = "plain"
                     prompt = self._fallback_plain_prompt(working_messages)
                     response = self.llm.create_completion(
                         prompt=prompt,
@@ -176,6 +257,7 @@ def _sampling_kwargs_for_retry():
                         },
                     )
                     text = response["choices"][0].get("text", "")
+                    _emit_generated(text)
                     raw_parts.append(text)
                     for channel, part in router.feed(text):
                         if channel == "think":
@@ -185,13 +267,35 @@ def _sampling_kwargs_for_retry():
                             emit(AnswerDelta(turn_id=turn_id, text=part))
                     break
                 except Exception as exc:
-                    if _is_context_overflow(exc) and (_drop_oldest_turn() or _shrink_max_tokens()):
-                        continue
+                    if _is_context_overflow(exc):
+                        if _drop_oldest_turn():
+                            overflow_retries += 1
+                            continue
+                        detail = build_context_limit_error(
+                            build_retry_report(
+                                messages,
+                                working_messages,
+                                strategy="overflow_retry",
+                                context_window=int(self.args.n_ctx),
+                                reserved_generation_tokens=reserved_generation,
+                                overflow_retries=overflow_retries,
+                                fit=False,
+                                prompt_tokens=prompt_tokens,
+                                dropped_roles=dropped_roles,
+                            )
+                        )
+                        if self.logger is not None:
+                            self.logger.log(f"turn_error id={turn_id} error={detail}", source="backend")
+                        emit(Error(turn_id=turn_id, message=detail))
+                        return
+                    if self.logger is not None:
+                        self.logger.log(f"turn_error id={turn_id} error={exc}", source="backend")
                     emit(Error(turn_id=turn_id, message=f"Generation failed in plain mode: {exc}"))
                     return
         else:
             while True:
                 try:
+                    used_mode = "chat"
                     stream = self.llm.create_chat_completion(
                         messages=working_messages,
                         stream=True,
@@ -210,6 +314,7 @@ def _sampling_kwargs_for_retry():
                         if not delta:
                             continue
 
+                        _emit_generated(delta)
                         raw_parts.append(delta)
                         for channel, text in router.feed(delta):
                             if channel == "think":
@@ -219,9 +324,30 @@ def _sampling_kwargs_for_retry():
                                 emit(AnswerDelta(turn_id=turn_id, text=text))
                     break
                 except Exception as exc:
-                    if _is_context_overflow(exc) and (_drop_oldest_turn() or _shrink_max_tokens()):
-                        continue
+                    if _is_context_overflow(exc):
+                        if _drop_oldest_turn():
+                            overflow_retries += 1
+                            continue
+                        detail = build_context_limit_error(
+                            build_retry_report(
+                                messages,
+                                working_messages,
+                                strategy="overflow_retry",
+                                context_window=int(self.args.n_ctx),
+                                reserved_generation_tokens=reserved_generation,
+                                overflow_retries=overflow_retries,
+                                fit=False,
+                                prompt_tokens=prompt_tokens,
+                                dropped_roles=dropped_roles,
+                            )
+                        )
+                        if self.logger is not None:
+                            self.logger.log(f"turn_error id={turn_id} error={detail}", source="backend")
+                        emit(Error(turn_id=turn_id, message=detail))
+                        return
                     try:
+                        used_mode = "plain"
+                        knob_notes.append("GGUF: chat API failed; fell back to plain completion")
                         prompt = self._fallback_plain_prompt(working_messages)
                         response = self.llm.create_completion(
                             prompt=prompt,
@@ -231,6 +357,7 @@ def _sampling_kwargs_for_retry():
                             },
                         )
                         text = response["choices"][0].get("text", "")
+                        _emit_generated(text)
                         raw_parts.append(text)
                         for channel, part in router.feed(text):
                             if channel == "think":
@@ -240,8 +367,29 @@ def _sampling_kwargs_for_retry():
                                 emit(AnswerDelta(turn_id=turn_id, text=part))
                         break
                     except Exception as fallback_exc:
-                        if _is_context_overflow(fallback_exc) and (_drop_oldest_turn() or _shrink_max_tokens()):
-                            continue
+                        if _is_context_overflow(fallback_exc):
+                            if _drop_oldest_turn():
+                                overflow_retries += 1
+                                continue
+                            detail = build_context_limit_error(
+                                build_retry_report(
+                                    messages,
+                                    working_messages,
+                                    strategy="overflow_retry",
+                                    context_window=int(self.args.n_ctx),
+                                    reserved_generation_tokens=reserved_generation,
+                                    overflow_retries=overflow_retries,
+                                    fit=False,
+                                    prompt_tokens=prompt_tokens,
+                                    dropped_roles=dropped_roles,
+                                )
+                            )
+                            if self.logger is not None:
+                                self.logger.log(f"turn_error id={turn_id} error={detail}", source="backend")
+                            emit(Error(turn_id=turn_id, message=detail))
+                            return
+                        if self.logger is not None:
+                            self.logger.log(f"turn_error id={turn_id} error={exc}; fallback={fallback_exc}", source="backend")
                         emit(Error(turn_id=turn_id, message=f"Generation failed: {exc}; fallback failed: {fallback_exc}"))
                         return
 
@@ -253,10 +401,68 @@ def _sampling_kwargs_for_retry():
                 emit(AnswerDelta(turn_id=turn_id, text=text))
 
         ended = time.time()
+        completion_tokens = _count_tokens("".join(raw_parts))
+        if self.prompt_token_counter is not None:
+            try:
+                prompt_tokens = self.prompt_token_counter(working_messages)
+            except Exception:
+                prompt_tokens = None
+        if prompt_tokens is not None:
+            emit(Meta(turn_id=turn_id, key="prompt_tokens", value=int(prompt_tokens)))
+        emit(Meta(turn_id=turn_id, key="completion_tokens", value=int(completion_tokens)))
+        total_tokens = None
+        if prompt_tokens is not None:
+            total_tokens = int(prompt_tokens) + int(completion_tokens)
+            emit(Meta(turn_id=turn_id, key="total_tokens", value=total_tokens))
+        elapsed = max(0.0, ended - started)
+        throughput = None
+        if completion_tokens > 0 and elapsed > 0:
+            throughput = {"tokens_per_s": completion_tokens / elapsed}
+        if context_report is None:
+            context_report = build_retry_report(
+                messages,
+                working_messages,
+                strategy="overflow_retry",
+                context_window=int(self.args.n_ctx),
+                reserved_generation_tokens=reserved_generation,
+                overflow_retries=overflow_retries,
+                fit=True,
+                prompt_tokens=prompt_tokens,
+                dropped_roles=dropped_roles,
+            ).to_dict()
+        token_counts = {"completion_tokens": int(completion_tokens)}
+        if prompt_tokens is not None:
+            token_counts["prompt_tokens"] = int(prompt_tokens)
+        if total_tokens is not None:
+            token_counts["total_tokens"] = int(total_tokens)
+        knob_sent = {
+            "max_new_tokens": int(max_tokens),
+            "temperature": self.args.temperature,
+            "top_p": self.args.top_p,
+        }
+        if self.args.top_k is not None:
+            knob_sent["top_k"] = self.args.top_k
+        if self.args.min_p is not None:
+            knob_sent["min_p"] = self.args.min_p
+        if self.args.typical_p is not None:
+            knob_sent["typical_p"] = self.args.typical_p
+        if self.args.repetition_penalty not in (None, 1.0):
+            knob_sent["repetition_penalty"] = self.args.repetition_penalty
+        if stop is not None:
+            knob_sent["stop_strings"] = list(stop) if isinstance(stop, list) else stop
+        elif used_mode == "plain":
+            knob_sent["stop_strings"] = ["\nUser:", "\nSystem:"]
+        knob_report = finalize_knob_report(
+            sent=knob_sent,
+            supported=SUPPORTED_KNOBS["gguf"],
+            ignored=unsupported_user_set(self.args, "gguf"),
+            notes=knob_notes,
+        )
+        answer_text = "".join(answer_parts)
         record = TurnRecord(
             raw="".join(raw_parts),
             think="".join(think_parts),
-            answer="".join(answer_parts).strip(),
+            answer=answer_text,
             ended_in_think=(router.mode == "think"),
             backend=self.backend_name,
             model_id=self.resolved_model_id,
@@ -271,10 +477,25 @@ def _sampling_kwargs_for_retry():
                 "prompt_mode": self.args.prompt_mode,
                 "chat_template": self.args.chat_template,
             },
-            timing={"start": started, "end": ended, "elapsed": max(0.0, ended - started)},
-            trimmed_messages=working_messages,
+            timing={"start": started, "end": ended, "elapsed": elapsed},
+            token_counts=token_counts,
+            throughput=throughput,
+            knobs=knob_report,
+            context=context_report,
+            trimmed_messages=append_assistant_history(
+                list(working_messages),
+                think="".join(think_parts),
+                answer=answer_text,
+                strip_think=bool(self.args.history_strip_think),
+            ),
         )
         emit(Finish(turn_id=turn_id, record=record))
+        if self.logger is not None:
+            self.logger.log(
+                f"turn_finish id={turn_id} elapsed_s={record.timing.get('elapsed', 0):.3f} "
+                f"think_chars={len(record.think)} answer_chars={len(record.answer)}",
+                source="backend",
+            )
 
 
 def create_session(args: argparse.Namespace) -> GGUFSession:
@@ -284,6 +505,11 @@ def create_session(args: argparse.Namespace) -> GGUFSession:
     if not model_path.lower().endswith(".gguf"):
         raise RuntimeError(f"Expected a .gguf file, got: {model_path}")
 
+    logger = FileLogger.from_value(
+        getattr(args, "gguf_log_file", ""),
+        "backend",
+        config_path=getattr(args, "_config_path", None),
+    )
     try:
         from llama_cpp import Llama, _internals
 
@@ -308,6 +534,8 @@ def safe_close(self):
         ) from exc
 
     print(f"Loading GGUF model: {model_path}")
+    if logger is not None:
+        logger.log(f"session_init model={model_path} n_ctx={args.n_ctx} n_gpu_layers={args.n_gpu_layers}", source="app")
     llm = Llama(
         model_path=model_path,
         n_ctx=args.n_ctx,
@@ -316,8 +544,43 @@ def safe_close(self):
     )
     template_kind, template_value = resolve_gguf_chat_template_spec(args, config_path=args._config_path)
     template_status = "auto"
+    requested_template = (args.chat_template or "").strip()
+    template_requested_value = requested_template
+    if requested_template:
+        try:
+            candidate = resolve_path_maybe_relative(requested_template, config_path=args._config_path)
+            if os.path.isfile(candidate):
+                template_requested_value = candidate
+        except Exception:
+            pass
+    prompt_token_counter: Callable[[list[dict[str, str]]], int | None] | None = None
+
+    def _tokenize_prompt_text(prompt_text: str) -> int:
+        data = prompt_text.encode("utf-8", "ignore")
+        try:
+            return len(llm.tokenize(data, add_bos=False, special=True))
+        except TypeError:
+            try:
+                return len(llm.tokenize(data, add_bos=False))
+            except TypeError:
+                return len(llm.tokenize(data))
+
+    def _fallback_plain_prompt(messages: list[dict[str, str]]) -> str:
+        system = args.system or "You are a helpful assistant."
+        parts = [f"System: {system}"]
+        for msg in messages:
+            role = msg.get("role", "message").capitalize()
+            parts.append(f"{role}: {msg.get('content', '')}")
+        parts.append("Assistant:")
+        return "\n".join(parts)
+
+    def _plain_prompt_tokens(messages: list[dict[str, str]]) -> int:
+        prompt = _fallback_plain_prompt(messages)
+        return _tokenize_prompt_text(prompt)
+
     if args.prompt_mode == "plain":
         template_status = "auto (plain mode)"
+        prompt_token_counter = _plain_prompt_tokens
     else:
         if template_kind == "file":
             try:
@@ -346,9 +609,31 @@ def safe_close(self):
             llm.chat_handler = chat_formatter_to_chat_completion_handler(formatter)
             llm.chat_format = None
             template_status = f"file:{template_value}"
+
+            def _file_template_prompt_tokens(messages: list[dict[str, str]]) -> int:
+                rendered = formatter(messages=messages)
+                return _tokenize_prompt_text(rendered.prompt)
+
+            prompt_token_counter = _file_template_prompt_tokens
         elif template_kind == "format":
             llm.chat_handler = None
             llm.chat_format = template_value
             template_status = f"format:{template_value}"
     print(f"GGUF chat template: {template_status}")
-    return GGUFSession(llm=llm, args=args, resolved_model_id=model_path)
+    if logger is not None:
+        logger.log(f"chat_template={template_status}", source="app")
+    template_info = {
+        "chat_template_requested": template_requested_value,
+        "chat_template_applied": bool(requested_template and args.prompt_mode != "plain"),
+        "chat_template_reason": (
+            "applied" if requested_template and args.prompt_mode != "plain" else ("ignored_prompt_mode" if requested_template else "empty_default")
+        ),
+    }
+    return GGUFSession(
+        llm=llm,
+        args=args,
+        resolved_model_id=model_path,
+        logger=logger,
+        prompt_token_counter=prompt_token_counter,
+        template_info=template_info,
+    )
diff --git a/tui_app/backends/hf.py b/tui_app/backends/hf.py
index e1baada..fc7280d 100644
--- a/tui_app/backends/hf.py
+++ b/tui_app/backends/hf.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import argparse
+import importlib.util
 import json
 import os
 import queue
@@ -9,11 +10,29 @@
 import time
 
 import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
+from transformers import AutoModelForCausalLM, AutoProcessor, AutoTokenizer
+try:
+    from transformers import BitsAndBytesConfig
+except Exception:
+    BitsAndBytesConfig = None  # type: ignore
 from transformers.generation.streamers import BaseStreamer
 
+try:
+    from transformers import AutoModelForMultimodalLM  # type: ignore
+except Exception:
+    AutoModelForMultimodalLM = None  # type: ignore
+
+try:
+    from transformers import AutoModelForImageTextToText  # type: ignore
+except Exception:
+    AutoModelForImageTextToText = None  # type: ignore
+
 from tui_app.backends.base import EventEmitter
+from tui_app.context_policy import build_context_limit_error, reserve_generation_tokens, trim_messages_to_budget
 from tui_app.events import AnswerDelta, Error, Finish, Meta, ThinkDelta, TurnRecord, TurnStart
+from tui_app.history_control import append_assistant_history
+from tui_app.knobs import SUPPORTED_KNOBS, finalize_knob_report, unsupported_user_set
+from tui_app.log_file import FileLogger
 from tui_app.think_router import ThinkRouter
 
 
@@ -36,6 +55,20 @@ def resolve_dtype(dtype_name: str, device: str):
     return parse_dtype(dtype_name)
 
 
+def _parse_cuda_index(device_str: str | None) -> int | None:
+    if not device_str:
+        return None
+    raw = str(device_str)
+    if raw == "cuda":
+        return 0
+    if raw.startswith("cuda:"):
+        try:
+            return int(raw.split(":", 1)[1])
+        except Exception:
+            return None
+    return None
+
+
 def resolve_model_id(model_id: str) -> str:
     raw = model_id.strip()
     expanded = os.path.expanduser(raw)
@@ -69,6 +102,26 @@ def read_model_type(model_id: str):
     return None
 
 
+def is_vision_checkpoint(model_id: str) -> bool:
+    if not os.path.isdir(model_id):
+        return False
+    config_path = os.path.join(model_id, "config.json")
+    if not os.path.isfile(config_path):
+        return False
+    try:
+        with open(config_path, "r", encoding="utf-8") as fh:
+            data = json.load(fh)
+    except Exception:
+        return False
+    # Common patterns: vision token IDs and/or a vision_config sub-config.
+    if "vision_start_token_id" in data or "vision_end_token_id" in data:
+        return True
+    vision_cfg = data.get("vision_config")
+    if isinstance(vision_cfg, dict) and vision_cfg:
+        return True
+    return False
+
+
 def load_tokenizer(model_id: str):
     try:
         return AutoTokenizer.from_pretrained(model_id)
@@ -131,7 +184,9 @@ def render_plain_prompt(messages):
     parts = []
     for msg in messages:
         role = msg.get("role", "")
-        content = (msg.get("content", "") or "").strip()
+        content_obj = msg.get("content", "")
+        content = content_obj if isinstance(content_obj, str) else str(content_obj)
+        content = content.strip()
         if not content:
             continue
         if role == "system":
@@ -148,13 +203,33 @@ def render_plain_prompt(messages):
     return "\n".join(parts)
 
 
+def _parse_hf_max_memory(raw: str):
+    value = (raw or "").strip()
+    if not value:
+        return None
+    try:
+        parsed = json.loads(value)
+    except Exception:
+        return {0: value}
+    if isinstance(parsed, dict):
+        return parsed
+    return {0: value}
+
+
 def build_model_inputs(tokenizer, messages, prompt_mode):
     if prompt_mode == "plain":
         prompt = render_plain_prompt(messages)
         return tokenizer(prompt, return_tensors="pt")
 
+    # Drop non-standard keys (e.g. "images") so apply_chat_template sees a plain chat history.
+    sanitized = []
+    for msg in messages:
+        content_obj = msg.get("content", "")
+        content = content_obj if isinstance(content_obj, str) else str(content_obj)
+        sanitized.append({"role": msg.get("role", ""), "content": content})
+
     templated = tokenizer.apply_chat_template(
-        messages,
+        sanitized,
         tokenize=True,
         add_generation_prompt=True,
         return_tensors="pt",
@@ -165,26 +240,132 @@ def build_model_inputs(tokenizer, messages, prompt_mode):
     return dict(templated)
 
 
-def apply_context_limit(tokenizer, messages, max_context_tokens, prompt_mode):
-    if not max_context_tokens:
-        return build_model_inputs(tokenizer=tokenizer, messages=messages, prompt_mode=prompt_mode), messages
+def _open_images(image_paths: list[str]):
+    from PIL import Image
+
+    images = []
+    for path in image_paths:
+        img = Image.open(path)
+        images.append(img.convert("RGB"))
+    return images
 
-    trimmed = list(messages)
-    while True:
-        candidate_inputs = build_model_inputs(tokenizer=tokenizer, messages=trimmed, prompt_mode=prompt_mode)
-        input_len = candidate_inputs["input_ids"].shape[-1]
-        if input_len <= max_context_tokens:
-            return candidate_inputs, trimmed
 
-        drop_idx = None
-        start_idx = 1 if trimmed and trimmed[0].get("role") == "system" else 0
-        for idx in range(start_idx, len(trimmed)):
-            if trimmed[idx].get("role") in {"user", "assistant", "tool"}:
-                drop_idx = idx
-                break
-        if drop_idx is None:
-            return candidate_inputs, trimmed
-        trimmed.pop(drop_idx)
+def _build_multimodal_messages(messages: list[dict[str, object]]):
+    """
+    Convert our internal message shape (role/content + optional images=[...paths...])
+    into the multimodal message format expected by Qwen-style processor chat templates.
+    Returns (messages_mm, image_paths_in_order).
+    """
+    messages_mm: list[dict[str, object]] = []
+    image_paths: list[str] = []
+    for msg in messages:
+        role = str(msg.get("role", ""))
+        content_obj = msg.get("content", "")
+        text = content_obj if isinstance(content_obj, str) else str(content_obj)
+        images = msg.get("images")
+        if isinstance(images, list) and role == "user":
+            segments: list[dict[str, object]] = []
+            for path in images:
+                if not isinstance(path, str):
+                    continue
+                image_paths.append(path)
+                # The Qwen chat template only checks type; the actual image tensor is supplied via processor(..., images=...).
+                segments.append({"type": "image", "image": path})
+            if text:
+                segments.append({"type": "text", "text": text})
+            messages_mm.append({"role": role, "content": segments})
+        else:
+            messages_mm.append({"role": role, "content": text})
+    return messages_mm, image_paths
+
+
+def build_model_inputs_multimodal(processor, messages: list[dict[str, object]]):
+    messages_mm, image_paths = _build_multimodal_messages(messages)
+    prompt = processor.apply_chat_template(messages_mm, tokenize=False, add_generation_prompt=True)
+    if image_paths:
+        images = _open_images(image_paths)
+        return processor(text=prompt, images=images, return_tensors="pt"), messages_mm
+    return processor(text=prompt, return_tensors="pt"), messages_mm
+
+
+def _infer_context_window(model, tokenizer) -> int | None:
+    candidates = [
+        getattr(getattr(model, "config", None), "max_position_embeddings", None),
+        getattr(getattr(model, "config", None), "n_positions", None),
+        getattr(getattr(model, "config", None), "max_seq_len", None),
+        getattr(getattr(model, "config", None), "seq_length", None),
+        getattr(getattr(getattr(model, "config", None), "text_config", None), "max_position_embeddings", None),
+        getattr(tokenizer, "model_max_length", None),
+    ]
+    for value in candidates:
+        if isinstance(value, int) and 0 < value < 1_000_000:
+            return int(value)
+    return None
+
+
+def _normalize_eos_token_ids(eos_token_id) -> set[int]:
+    if isinstance(eos_token_id, int):
+        return {int(eos_token_id)}
+    if isinstance(eos_token_id, (list, tuple, set)):
+        return {int(value) for value in eos_token_id if isinstance(value, int)}
+    return set()
+
+
+def _infer_hf_finish_reason(
+    *,
+    generated_token_ids: list[int],
+    completion_tokens: int,
+    max_new_tokens: int | None,
+    eos_token_id,
+) -> tuple[str | None, str | None]:
+    if isinstance(max_new_tokens, int) and max_new_tokens > 0 and completion_tokens >= max_new_tokens:
+        return "length", "local_max_new_tokens_cap"
+    eos_token_ids = _normalize_eos_token_ids(eos_token_id)
+    if generated_token_ids and eos_token_ids and int(generated_token_ids[-1]) in eos_token_ids:
+        return "stop", "local_eos_token"
+    if completion_tokens > 0:
+        return "stop", "local_hf_stopping_criteria"
+    return None, None
+
+
+def apply_context_limit(
+    tokenizer,
+    messages,
+    max_context_tokens,
+    prompt_mode,
+    *,
+    max_new_tokens: int | None,
+    model=None,
+    processor=None,
+    multimodal: bool = False,
+):
+    context_window = int(max_context_tokens) if max_context_tokens else _infer_context_window(model, tokenizer)
+    if not context_window:
+        if multimodal and processor is not None:
+            inputs, _ = build_model_inputs_multimodal(processor=processor, messages=messages)
+            return inputs, messages, None
+        return build_model_inputs(tokenizer=tokenizer, messages=messages, prompt_mode=prompt_mode), messages, None
+
+    reserved = reserve_generation_tokens(context_window, max_new_tokens)
+
+    def _measure(trimmed):
+        if multimodal and processor is not None:
+            candidate_inputs, _ = build_model_inputs_multimodal(processor=processor, messages=trimmed)
+        else:
+            candidate_inputs = build_model_inputs(tokenizer=tokenizer, messages=trimmed, prompt_mode=prompt_mode)
+        input_len = candidate_inputs["input_ids"].shape[-1]
+        return int(input_len), candidate_inputs
+
+    trimmed, _prompt_tokens, model_inputs, report = trim_messages_to_budget(
+        list(messages),
+        measure_fn=_measure,
+        context_window=context_window,
+        reserved_generation_tokens=reserved,
+        strategy="exact_preflight",
+    )
+    if not report.fit:
+        raise RuntimeError(build_context_limit_error(report))
+    return model_inputs, trimmed, report.to_dict()
 
 
 class TokenCountingTextIteratorStreamer(BaseStreamer):
@@ -203,6 +384,8 @@ def __init__(
         self.token_cache = []
         self.print_len = 0
         self.next_tokens_are_prompt = True
+        self.generated_token_count = 0
+        self.generated_token_ids = []
         self.mode = "think" if assume_think else "answer"
         self.start_marker_ids = self._single_token_marker_ids(
             ["<think>", "<|begin_of_thought|>", "<｜begin_of_thought｜>", "<｜begin▁of▁thought｜>"]
@@ -244,6 +427,8 @@ def put(self, value):
             return
 
         token_ids = value.tolist()
+        self.generated_token_count += len(token_ids)
+        self.generated_token_ids.extend(int(token_id) for token_id in token_ids)
         think_inc = 0
         for token_id in token_ids:
             if token_id in self.start_marker_ids:
@@ -308,14 +493,144 @@ def __next__(self):
 class HFSession:
     backend_name = "hf"
 
-    def __init__(self, model, tokenizer, args: argparse.Namespace, input_device: str, resolved_model_id: str):
+    def __init__(
+        self,
+        model,
+        tokenizer,
+        args: argparse.Namespace,
+        input_device: str,
+        resolved_model_id: str,
+        *,
+        processor=None,
+        supports_images: bool = False,
+        template_info: dict[str, object] | None = None,
+        logger: FileLogger | None = None,
+    ):
         self.model = model
         self.tokenizer = tokenizer
+        self.processor = processor
         self.args = args
         self.input_device = input_device
         self.resolved_model_id = resolved_model_id
+        self.supports_images = supports_images
+        self.template_info = dict(template_info or {})
+        self.logger = logger
+
+    def close(self) -> None:
+        if self.logger is not None:
+            self.logger.close()
+
+    def get_recent_logs(self, n: int = 80, sources: list[str] | None = None) -> list[str]:
+        if self.logger is None:
+            return []
+        return self.logger.get_recent_logs(n=n, sources=sources)
+
+    def list_log_sources(self) -> list[str]:
+        if self.logger is None:
+            return []
+        return self.logger.list_log_sources()
+
+    def describe(self) -> dict[str, object]:
+        weights_quantization = "8bit" if bool(getattr(self.args, "use_8bit", False)) else "4bit" if bool(getattr(self.args, "use_4bit", False)) else "none"
+        model = self.model
+        context_length_effective = _infer_context_window(model, self.tokenizer)
+        runtime_attn = getattr(getattr(model, "config", None), "_attn_implementation", None)
+        runtime_dtype = None
+        runtime_device = None
+        try:
+            first_param = next(model.parameters())
+            runtime_dtype = str(first_param.dtype).replace("torch.", "")
+            runtime_device = str(first_param.device)
+        except Exception:
+            runtime_dtype = str(getattr(self.args, "dtype", "auto"))
+            runtime_device = self.input_device
+
+        raw_device_map = getattr(model, "hf_device_map", None)
+        requested_device_map = getattr(self.args, "hf_device_map", "") or ("auto" if self.input_device == "cuda" else "none")
+        if isinstance(raw_device_map, dict):
+            device_map_repr = dict(raw_device_map)
+            map_values = [str(v) for v in raw_device_map.values()]
+            modules_on_cpu = sum(1 for v in map_values if v == "cpu")
+            modules_on_disk = sum(1 for v in map_values if v == "disk")
+            gpu_targets = sorted({v for v in map_values if v.startswith("cuda") or v.isdigit()})
+            fully_on_single_gpu = modules_on_cpu == 0 and modules_on_disk == 0 and len(gpu_targets) == 1
+        else:
+            device_map_repr = requested_device_map
+            normalized_target = str(runtime_device)
+            fully_on_single_gpu = normalized_target.startswith("cuda")
+            modules_on_cpu = 0 if fully_on_single_gpu else None
+            modules_on_disk = 0
+
+        memory_footprint_bytes = None
+        try:
+            memory_footprint_bytes = int(model.get_memory_footprint())
+        except Exception:
+            memory_footprint_bytes = None
 
-    def generate_turn(self, turn_id: int, messages: list[dict[str, str]], emit: EventEmitter) -> None:
+        if memory_footprint_bytes is None:
+            memory_footprint = "unavailable"
+        else:
+            memory_footprint = f"{memory_footprint_bytes / (1024 ** 3):.2f} GiB"
+
+        cuda_allocated = None
+        cuda_reserved = None
+        cuda_max_allocated = None
+        cuda_max_reserved = None
+        cuda_index = _parse_cuda_index(runtime_device)
+        if cuda_index is not None and torch.cuda.is_available():
+            try:
+                cuda_allocated = int(torch.cuda.memory_allocated(cuda_index))
+                cuda_reserved = int(torch.cuda.memory_reserved(cuda_index))
+                cuda_max_allocated = int(torch.cuda.max_memory_allocated(cuda_index))
+                cuda_max_reserved = int(torch.cuda.max_memory_reserved(cuda_index))
+            except Exception:
+                pass
+
+        def _fmt_bytes(value: int | None) -> str:
+            if value is None:
+                return "unavailable"
+            return f"{value / (1024 ** 3):.2f} GiB"
+
+        max_memory_raw = getattr(self.args, "hf_max_memory", "") or "(unset)"
+        max_memory_effective = bool(str(requested_device_map).lower() in {"auto", "balanced", "balanced_low_0", "sequential"})
+
+        qwen_fast_path_available = None
+        if read_model_type(self.resolved_model_id) == "qwen3_5":
+            has_fla = importlib.util.find_spec("fla") is not None
+            has_causal_conv1d = importlib.util.find_spec("causal_conv1d") is not None
+            qwen_fast_path_available = bool(has_fla and has_causal_conv1d)
+
+        return {
+            "template_control_level": "local_template",
+            "supports_images": self.supports_images,
+            "weights_quantization": weights_quantization,
+            "kv_cache_quantization": "none",
+            "torch_dtype": str(getattr(self.args, "dtype", "auto")),
+            "torch_dtype_effective": runtime_dtype,
+            "hf_attn_implementation": getattr(self.args, "hf_attn_implementation", None) or "default",
+            "attention_backend_effective": runtime_attn or "unknown",
+            "hf_device_map": device_map_repr,
+            "hf_max_memory": max_memory_raw,
+            "hf_max_memory_effective": max_memory_effective,
+            "hf_low_cpu_mem_usage": getattr(self.args, "hf_low_cpu_mem_usage", None),
+            "runtime_device": runtime_device,
+            "context_length_effective": context_length_effective,
+            "modules_on_cpu": modules_on_cpu,
+            "modules_on_disk": modules_on_disk,
+            "fully_on_single_gpu": fully_on_single_gpu,
+            "memory_footprint": memory_footprint,
+            "memory_footprint_bytes": memory_footprint_bytes,
+            "cuda_memory_allocated": _fmt_bytes(cuda_allocated),
+            "cuda_memory_reserved": _fmt_bytes(cuda_reserved),
+            "cuda_max_memory_allocated": _fmt_bytes(cuda_max_allocated),
+            "cuda_max_memory_reserved": _fmt_bytes(cuda_max_reserved),
+            "qwen_fast_path_available": qwen_fast_path_available,
+            "context_allocation": "grows_with_sequence",
+            "text_only_mode": bool(getattr(self.args, "hf_text_only", False)),
+            **self.template_info,
+        }
+
+    def generate_turn(self, turn_id: int, messages: list[dict[str, object]], emit: EventEmitter) -> None:
         args = self.args
         tokenizer = self.tokenizer
         model = self.model
@@ -328,16 +643,34 @@ def generate_turn(self, turn_id: int, messages: list[dict[str, str]], emit: Even
         answer_parts = []
 
         try:
-            model_inputs, trimmed = apply_context_limit(
+            if self.logger is not None:
+                self.logger.log(
+                    f"turn_start id={turn_id} messages={len(messages)} stream={bool(args.stream)} "
+                    f"max_new_tokens={args.max_new_tokens}",
+                    source="backend",
+                )
+            multimodal = bool(self.supports_images and any(msg.get("images") for msg in messages))
+            if multimodal and self.processor is None:
+                raise RuntimeError("Images were attached but this HF session has no processor loaded.")
+            if multimodal and args.prompt_mode != "chat":
+                raise RuntimeError("Images require --prompt-mode chat.")
+
+            model_inputs, trimmed, context_report = apply_context_limit(
                 tokenizer=tokenizer,
                 messages=messages,
                 max_context_tokens=args.max_context_tokens,
                 prompt_mode=args.prompt_mode,
+                max_new_tokens=args.max_new_tokens,
+                model=model,
+                processor=self.processor,
+                multimodal=multimodal,
             )
             model_inputs = {
                 key: value.to(self.input_device) if hasattr(value, "to") else value
                 for key, value in model_inputs.items()
             }
+            prompt_tokens = int(model_inputs["input_ids"].shape[-1])
+            emit(Meta(turn_id=turn_id, key="prompt_tokens", value=prompt_tokens))
 
             pad_token_id = tokenizer.eos_token_id
             if pad_token_id is None and tokenizer.pad_token_id is not None:
@@ -366,6 +699,30 @@ def generate_turn(self, turn_id: int, messages: list[dict[str, str]], emit: Even
                 generate_kwargs["stop_strings"] = args.stop_strings
                 generate_kwargs["tokenizer"] = tokenizer
 
+            knob_sent = {
+                "max_new_tokens": args.max_new_tokens,
+                "temperature": args.temperature,
+                "top_p": args.top_p,
+                "repetition_penalty": args.repetition_penalty,
+                "num_beams": args.num_beams,
+                "no_repeat_ngram_size": args.no_repeat_ngram_size,
+            }
+            if "top_k" in generate_kwargs:
+                knob_sent["top_k"] = args.top_k
+            if "typical_p" in generate_kwargs:
+                knob_sent["typical_p"] = args.typical_p
+            if "min_p" in generate_kwargs:
+                knob_sent["min_p"] = args.min_p
+            if "max_time" in generate_kwargs:
+                knob_sent["max_time"] = args.max_time
+            if "stop_strings" in generate_kwargs:
+                knob_sent["stop_strings"] = args.stop_strings
+            knob_report = finalize_knob_report(
+                sent=knob_sent,
+                supported=SUPPORTED_KNOBS["hf"],
+                ignored=unsupported_user_set(args, "hf"),
+            )
+
             if args.stream:
                 streamer = TokenCountingTextIteratorStreamer(
                     tokenizer,
@@ -390,15 +747,13 @@ def _generate():
                 gen_thread = threading.Thread(target=_generate, daemon=True)
                 gen_thread.start()
 
+                emitted_generated_tokens = 0
                 for piece in streamer:
-                    while True:
-                        try:
-                            count = streamer.think_token_queue.get_nowait()
-                        except queue.Empty:
-                            break
-                        if count is None:
-                            break
-                        emit(Meta(turn_id=turn_id, key="think_tokens_inc", value=int(count)))
+                    current_generated_tokens = int(getattr(streamer, "generated_token_count", 0))
+                    token_inc = current_generated_tokens - emitted_generated_tokens
+                    if token_inc > 0:
+                        emit(Meta(turn_id=turn_id, key="generated_tokens_inc", value=token_inc))
+                        emitted_generated_tokens = current_generated_tokens
 
                     raw_parts.append(piece)
                     for channel, text in router.feed(piece):
@@ -412,21 +767,22 @@ def _generate():
                 gen_thread.join()
                 if gen_error:
                     raise RuntimeError(str(gen_error[0]))
+                completion_tokens = int(getattr(streamer, "generated_token_count", 0))
+                generated_token_ids = [int(token_id) for token_id in getattr(streamer, "generated_token_ids", [])]
             else:
                 input_len = model_inputs["input_ids"].shape[-1]
                 with torch.no_grad():
                     outputs = model.generate(**model_inputs, **generate_kwargs)
                 new_tokens = outputs[0, input_len:].tolist()
+                completion_tokens = len(new_tokens)
+                generated_token_ids = [int(token_id) for token_id in new_tokens]
                 for token_id in new_tokens:
+                    emit(Meta(turn_id=turn_id, key="generated_tokens_inc", value=1))
                     piece = tokenizer.decode(
                         [token_id],
                         skip_special_tokens=True,
                         clean_up_tokenization_spaces=False,
                     )
-                    pre_mode = router.mode
-                    is_marker = piece in router.start_markers or piece in router.end_markers
-                    if pre_mode == "think" and not is_marker:
-                        emit(Meta(turn_id=turn_id, key="think_tokens_inc", value=1))
                     raw_parts.append(piece)
                     for channel, text in router.feed(piece):
                         if channel == "think":
@@ -436,6 +792,10 @@ def _generate():
                             answer_parts.append(text)
                             emit(AnswerDelta(turn_id=turn_id, text=text))
 
+            total_tokens = prompt_tokens + int(completion_tokens)
+            emit(Meta(turn_id=turn_id, key="completion_tokens", value=int(completion_tokens)))
+            emit(Meta(turn_id=turn_id, key="total_tokens", value=total_tokens))
+
             for channel, text in router.flush():
                 if channel == "think":
                     think_parts.append(text)
@@ -445,25 +805,62 @@ def _generate():
                     emit(AnswerDelta(turn_id=turn_id, text=text))
 
             ended = time.time()
+            elapsed = max(0.0, ended - started)
+            throughput = None
+            if completion_tokens > 0 and elapsed > 0:
+                throughput = {"tokens_per_s": completion_tokens / elapsed}
+            finish_reason, finish_reason_source = _infer_hf_finish_reason(
+                generated_token_ids=generated_token_ids,
+                completion_tokens=int(completion_tokens),
+                max_new_tokens=args.max_new_tokens,
+                eos_token_id=tokenizer.eos_token_id,
+            )
+            answer_text = "".join(answer_parts)
+            gen = {
+                "max_new_tokens": args.max_new_tokens,
+                "temperature": args.temperature,
+                "top_p": args.top_p,
+                "top_k": args.top_k,
+                "repetition_penalty": args.repetition_penalty,
+            }
+            if finish_reason is not None:
+                gen["finish_reason"] = finish_reason
+            if finish_reason_source is not None:
+                gen["finish_reason_source"] = finish_reason_source
             record = TurnRecord(
                 raw="".join(raw_parts),
                 think="".join(think_parts),
-                answer="".join(answer_parts).strip(),
+                answer=answer_text,
                 ended_in_think=(router.mode == "think"),
                 backend=self.backend_name,
                 model_id=self.resolved_model_id,
-                gen={
-                    "max_new_tokens": args.max_new_tokens,
-                    "temperature": args.temperature,
-                    "top_p": args.top_p,
-                    "top_k": args.top_k,
-                    "repetition_penalty": args.repetition_penalty,
+                gen=gen,
+                timing={"start": started, "end": ended, "elapsed": elapsed},
+                token_counts={
+                    "prompt_tokens": prompt_tokens,
+                    "completion_tokens": int(completion_tokens),
+                    "total_tokens": total_tokens,
                 },
-                timing={"start": started, "end": ended, "elapsed": max(0.0, ended - started)},
-                trimmed_messages=trimmed,
+                throughput=throughput,
+                knobs=knob_report,
+                context=context_report,
+                trimmed_messages=append_assistant_history(
+                    list(trimmed),
+                    think="".join(think_parts),
+                    answer=answer_text,
+                    strip_think=bool(args.history_strip_think),
+                ),
             )
             emit(Finish(turn_id=turn_id, record=record))
+            if self.logger is not None:
+                self.logger.log(
+                    f"turn_finish id={turn_id} elapsed_s={record.timing.get('elapsed', 0):.3f} "
+                    f"think_chars={len(record.think)} answer_chars={len(record.answer)}",
+                    source="backend",
+                )
         except Exception as exc:
+            if self.logger is not None:
+                self.logger.log(f"turn_error id={turn_id} error={exc}", source="backend")
             emit(Error(turn_id=turn_id, message=str(exc)))
 
 
@@ -472,8 +869,11 @@ def create_session(args: argparse.Namespace) -> HFSession:
     dtype = resolve_dtype(args.dtype, device)
 
     resolved_model_id = resolve_model_id(args.model_id)
+    logger = FileLogger.from_value(getattr(args, "hf_log_file", ""), "backend", config_path=getattr(args, "_config_path", None))
     print(f"Loading model: {resolved_model_id}")
     print(f"Using device={device}, dtype={dtype}")
+    if logger is not None:
+        logger.log(f"session_init model={resolved_model_id} device={device} dtype={dtype}", source="app")
 
     model_type = read_model_type(resolved_model_id)
     if model_type == "personaplex":
@@ -482,36 +882,128 @@ def create_session(args: argparse.Namespace) -> HFSession:
         )
 
     tokenizer = load_tokenizer(resolved_model_id)
+    supports_images = is_vision_checkpoint(resolved_model_id) and not bool(getattr(args, "hf_text_only", False))
+    processor = None
+    requested_template = (args.chat_template or "").strip()
+    template_requested_value = requested_template
+    if requested_template:
+        try:
+            candidate = resolve_path_maybe_relative(requested_template, config_path=args._config_path)
+            if os.path.isfile(candidate):
+                template_requested_value = candidate
+        except Exception:
+            pass
+    template_info = {
+        "chat_template_requested": template_requested_value,
+        "chat_template_applied": False,
+        "chat_template_reason": "empty_default" if not requested_template else "ignored_prompt_mode",
+    }
+    if is_vision_checkpoint(resolved_model_id) and bool(getattr(args, "hf_text_only", False)):
+        template_info["text_only_mode"] = True
+    else:
+        template_info["text_only_mode"] = False
+    if supports_images:
+        try:
+            processor = AutoProcessor.from_pretrained(resolved_model_id)
+        except Exception as exc:
+            raise RuntimeError(f"Failed to load processor for vision checkpoint: {exc}") from exc
     if args.prompt_mode == "chat":
         template_override = resolve_chat_template(args.chat_template, resolved_model_id, config_path=args._config_path)
         if template_override is not None:
             tokenizer.chat_template = template_override
+            if processor is not None and hasattr(processor, "tokenizer") and getattr(processor, "tokenizer", None) is not None:
+                try:
+                    processor.tokenizer.chat_template = template_override
+                except Exception:
+                    pass
             print(f"Chat template override: {args.chat_template}")
+            template_info = {
+                "chat_template_requested": template_requested_value,
+                "chat_template_applied": True,
+                "chat_template_reason": "applied",
+            }
+        elif not requested_template:
+            template_info = {
+                "chat_template_requested": template_requested_value,
+                "chat_template_applied": False,
+                "chat_template_reason": "empty_default",
+            }
         if tokenizer.chat_template is None:
             raise RuntimeError("Tokenizer has no chat template. Use --prompt-mode plain or set --chat-template.")
+    elif requested_template:
+        template_info = {
+            "chat_template_requested": template_requested_value,
+            "chat_template_applied": False,
+            "chat_template_reason": "ignored_prompt_mode",
+        }
 
     model_kwargs = {}
     input_device = device
+    explicit_device_map = (getattr(args, "hf_device_map", "") or "").strip()
+    parsed_max_memory = _parse_hf_max_memory(getattr(args, "hf_max_memory", ""))
+    explicit_low_cpu_mem_usage = getattr(args, "hf_low_cpu_mem_usage", None)
 
     if args.use_8bit or args.use_4bit:
         if device != "cuda":
             raise RuntimeError("4-bit/8-bit quantization requires CUDA.")
-        model_kwargs["device_map"] = "auto"
+        if BitsAndBytesConfig is None:
+            raise RuntimeError("BitsAndBytesConfig is unavailable in this transformers build.")
+        model_kwargs["device_map"] = explicit_device_map or "auto"
         model_kwargs["torch_dtype"] = dtype
+        if parsed_max_memory is not None:
+            model_kwargs["max_memory"] = parsed_max_memory
+        if explicit_low_cpu_mem_usage is not None:
+            model_kwargs["low_cpu_mem_usage"] = bool(explicit_low_cpu_mem_usage)
         if args.use_8bit:
-            model_kwargs["load_in_8bit"] = True
+            model_kwargs["quantization_config"] = BitsAndBytesConfig(load_in_8bit=True)
             print("Quantization: 8-bit")
         else:
-            model_kwargs["load_in_4bit"] = True
-            model_kwargs["bnb_4bit_compute_dtype"] = dtype
+            model_kwargs["quantization_config"] = BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_compute_dtype=dtype,
+            )
             print("Quantization: 4-bit")
         input_device = "cuda"
     else:
         model_kwargs["torch_dtype"] = dtype
-        model_kwargs["device_map"] = "auto" if device == "cuda" else None
-
-    model = AutoModelForCausalLM.from_pretrained(resolved_model_id, **model_kwargs)
-    if not (args.use_8bit or args.use_4bit):
+        model_kwargs["device_map"] = explicit_device_map or ("auto" if device == "cuda" else None)
+        if parsed_max_memory is not None:
+            model_kwargs["max_memory"] = parsed_max_memory
+        if explicit_low_cpu_mem_usage is not None:
+            model_kwargs["low_cpu_mem_usage"] = bool(explicit_low_cpu_mem_usage)
+    if args.hf_attn_implementation:
+        model_kwargs["attn_implementation"] = args.hf_attn_implementation
+        print(f"HF attention implementation override: {args.hf_attn_implementation}")
+
+    if supports_images:
+        load_errors = []
+        model = None
+        if AutoModelForMultimodalLM is not None:
+            try:
+                model = AutoModelForMultimodalLM.from_pretrained(resolved_model_id, **model_kwargs)
+            except Exception as exc:
+                load_errors.append(f"AutoModelForMultimodalLM: {exc}")
+        if model is None and AutoModelForImageTextToText is not None:
+            try:
+                model = AutoModelForImageTextToText.from_pretrained(resolved_model_id, **model_kwargs)
+            except Exception as exc:
+                load_errors.append(f"AutoModelForImageTextToText: {exc}")
+        if model is None:
+            detail = "; ".join(load_errors) if load_errors else "no compatible multimodal auto model class available"
+            raise RuntimeError(f"Failed to load vision model with installed transformers version: {detail}")
+    else:
+        model = AutoModelForCausalLM.from_pretrained(resolved_model_id, **model_kwargs)
+    if not (args.use_8bit or args.use_4bit) and not model_kwargs.get("device_map"):
         model.to(device)
     model.eval()
-    return HFSession(model=model, tokenizer=tokenizer, args=args, input_device=input_device, resolved_model_id=resolved_model_id)
+    return HFSession(
+        model=model,
+        tokenizer=tokenizer,
+        args=args,
+        input_device=input_device,
+        resolved_model_id=resolved_model_id,
+        processor=processor,
+        supports_images=supports_images,
+        template_info=template_info,
+        logger=logger,
+    )
diff --git a/tui_app/backends/ollama.py b/tui_app/backends/ollama.py
index 8273607..c3af3aa 100644
--- a/tui_app/backends/ollama.py
+++ b/tui_app/backends/ollama.py
@@ -10,9 +10,42 @@
 import urllib.request
 
 from tui_app.backends.base import EventEmitter
+from tui_app.context_policy import build_context_limit_error, build_retry_report, drop_oldest_history_message, is_context_overflow_text
 from tui_app.events import AnswerDelta, Error, Finish, Meta, ThinkDelta, TurnRecord, TurnStart
+from tui_app.history_control import append_assistant_history
+from tui_app.knobs import SUPPORTED_KNOBS, finalize_knob_report, unsupported_user_set
+from tui_app.log_file import FileLogger
 from tui_app.think_router import ThinkRouter
 
+MAX_CAPTURE_BYTES = 256 * 1024
+
+
+def _sanitize_for_capture(obj):
+    if isinstance(obj, dict):
+        out = {}
+        for key, value in obj.items():
+            key_l = str(key).lower()
+            if key_l in {"authorization", "api_key"}:
+                out[key] = "***"
+                continue
+            out[key] = _sanitize_for_capture(value)
+        return out
+    if isinstance(obj, list):
+        return [_sanitize_for_capture(x) for x in obj]
+    if isinstance(obj, str) and obj.startswith("data:"):
+        return "(data-url omitted)"
+    return obj
+
+
+def _truncate_capture(data: dict) -> dict:
+    raw = json.dumps(data, ensure_ascii=False, default=str)
+    if len(raw.encode("utf-8")) <= MAX_CAPTURE_BYTES:
+        return data
+    marker = "...(truncated)"
+    keep_bytes = max(1024, MAX_CAPTURE_BYTES - len(marker.encode("utf-8")) - 64)
+    trimmed = raw.encode("utf-8")[:keep_bytes].decode("utf-8", errors="ignore")
+    return {"truncated": True, "max_bytes": MAX_CAPTURE_BYTES, "data": trimmed + marker}
+
 
 def can_reach_ollama_host(host: str, timeout: int) -> bool:
     url = host.rstrip("/") + "/api/tags"
@@ -69,14 +102,55 @@ def resolve_host(cli_host: str | None, timeout: int) -> str:
 class OllamaSession:
     backend_name = "ollama"
 
-    def __init__(self, args: argparse.Namespace, resolved_model_id: str, host: str):
+    def __init__(
+        self,
+        args: argparse.Namespace,
+        resolved_model_id: str,
+        host: str,
+        template_info: dict[str, object] | None = None,
+        logger: FileLogger | None = None,
+    ):
         self.args = args
         self.resolved_model_id = resolved_model_id
         self.host = host
+        self.template_info = dict(template_info or {})
+        self.logger = logger
+        self._last_request: dict | None = None
+
+    def close(self) -> None:
+        if self.logger is not None:
+            self.logger.close()
+
+    def get_recent_logs(self, n: int = 80, sources: list[str] | None = None) -> list[str]:
+        if self.logger is None:
+            return []
+        return self.logger.get_recent_logs(n=n, sources=sources)
+
+    def list_log_sources(self) -> list[str]:
+        if self.logger is None:
+            return []
+        return self.logger.list_log_sources()
+
+    def get_last_request(self) -> dict | None:
+        return self._last_request
+
+    def describe(self) -> dict[str, object]:
+        return {
+            "host": self.host,
+            "model_id": self.resolved_model_id,
+            "template_control_level": "server_owned_template",
+            **self.template_info,
+        }
 
     def generate_turn(self, turn_id: int, messages: list[dict[str, str]], emit: EventEmitter) -> None:
         emit(TurnStart(turn_id=turn_id))
         started = time.time()
+        if self.logger is not None:
+            self.logger.log(
+                f"turn_start id={turn_id} messages={len(messages)} model={self.resolved_model_id} "
+                f"max_new_tokens={self.args.max_new_tokens}",
+                source="backend",
+            )
 
         cli_overrides = set(getattr(self.args, "_cli_overrides", set()) or set())
         config_keys = set(getattr(self.args, "_config_keys", set()) or set())
@@ -96,30 +170,50 @@ def _is_user_set(name: str) -> bool:
         if _is_user_set("stop_strings") and self.args.stop_strings is not None:
             options["stop"] = self.args.stop_strings
 
-        payload = {
-            "model": self.resolved_model_id,
-            "messages": messages,
-            "stream": True,
-        }
-        if options:
-            payload["options"] = options
-        if self.args.ollama_think in {"true", "false"}:
-            payload["think"] = self.args.ollama_think == "true"
+        knob_sent: dict[str, object] = {}
+        if "temperature" in options:
+            knob_sent["temperature"] = options["temperature"]
+        if "top_p" in options:
+            knob_sent["top_p"] = options["top_p"]
+        if "top_k" in options:
+            knob_sent["top_k"] = options["top_k"]
+        if "num_predict" in options:
+            knob_sent["max_new_tokens"] = options["num_predict"]
+        if "stop" in options:
+            knob_sent["stop_strings"] = options["stop"]
+        knob_report = finalize_knob_report(
+            sent=knob_sent,
+            supported=SUPPORTED_KNOBS["ollama"],
+            ignored=unsupported_user_set(self.args, "ollama"),
+        )
 
         router = ThinkRouter(assume_think=self.args.assume_think)
+        working_messages = list(messages)
+        overflow_retries = 0
+        dropped_roles: list[str] = []
         raw_parts: list[str] = []
         think_parts: list[str] = []
         answer_parts: list[str] = []
 
+        def _emit_generated_text(text: str) -> None:
+            if not text:
+                return
+            token_inc = len(re.findall(r"\S+", text))
+            if token_inc > 0:
+                emit(Meta(turn_id=turn_id, key="generated_tokens_inc", value=token_inc))
+
         def _emit_think_text(text: str) -> None:
             if not text:
                 return
             think_parts.append(text)
             emit(ThinkDelta(turn_id=turn_id, text=text))
-            # Approximate token count for non-HF backends.
-            token_inc = len(re.findall(r"\S+", text))
-            if token_inc > 0:
-                emit(Meta(turn_id=turn_id, key="think_tokens_inc", value=token_inc))
+
+        def _drop_oldest_turn() -> bool:
+            dropped_chunk = drop_oldest_history_message(working_messages)
+            if dropped_chunk is None:
+                return False
+            dropped_roles.extend(dropped_chunk)
+            return True
 
         def _stream_chat(request_payload: dict):
             req = urllib.request.Request(
@@ -147,10 +241,12 @@ def _consume_stream(request_payload: dict) -> None:
                     content = str(content)
 
                 if thinking:
+                    _emit_generated_text(thinking)
                     raw_parts.append(thinking)
                     _emit_think_text(thinking)
 
                 if content:
+                    _emit_generated_text(content)
                     raw_parts.append(content)
                     if thinking:
                         answer_parts.append(content)
@@ -166,43 +262,120 @@ def _consume_stream(request_payload: dict) -> None:
                 if obj.get("done"):
                     break
 
-        try:
+        while True:
+            payload = {
+                "model": self.resolved_model_id,
+                "messages": working_messages,
+                "stream": True,
+            }
+            if options:
+                payload["options"] = options
+            if self.args.ollama_think in {"true", "false"}:
+                payload["think"] = self.args.ollama_think == "true"
+            if getattr(self.args, "capture_last_request", False):
+                self._last_request = _truncate_capture(
+                    _sanitize_for_capture({"backend": "ollama", "url": self.host.rstrip("/") + "/api/chat", "payload": payload})
+                )
             try:
-                _consume_stream(payload)
-            except urllib.error.HTTPError as exc:
-                body = exc.read().decode("utf-8", errors="ignore").strip()
-                if exc.code == 400 and "think" in payload:
-                    retry_payload = dict(payload)
-                    retry_payload.pop("think", None)
-                    try:
-                        _consume_stream(retry_payload)
-                    except urllib.error.HTTPError as retry_exc:
-                        retry_body = retry_exc.read().decode("utf-8", errors="ignore").strip()
-                        detail = f"Ollama API request failed: HTTP {retry_exc.code} {retry_exc.reason}"
-                        if retry_body:
-                            detail += f" | body: {retry_body}"
-                        detail += " | retry_without_think=true"
-                        emit(Error(turn_id=turn_id, message=detail))
-                        return
-                else:
+                try:
+                    _consume_stream(payload)
+                    break
+                except urllib.error.HTTPError as exc:
+                    body = exc.read().decode("utf-8", errors="ignore").strip()
+                    if exc.code == 400 and "think" in payload:
+                        retry_payload = dict(payload)
+                        retry_payload.pop("think", None)
+                        try:
+                            _consume_stream(retry_payload)
+                            break
+                        except urllib.error.HTTPError as retry_exc:
+                            retry_body = retry_exc.read().decode("utf-8", errors="ignore").strip()
+                            detail = f"Ollama API request failed: HTTP {retry_exc.code} {retry_exc.reason}"
+                            if retry_body:
+                                detail += f" | body: {retry_body}"
+                            detail += " | retry_without_think=true"
+                            if not raw_parts and not think_parts and not answer_parts and is_context_overflow_text(detail):
+                                if _drop_oldest_turn():
+                                    overflow_retries += 1
+                                    continue
+                                detail = build_context_limit_error(
+                                    build_retry_report(
+                                        messages,
+                                        working_messages,
+                                        strategy="overflow_retry",
+                                        context_window=None,
+                                        reserved_generation_tokens=None,
+                                        overflow_retries=overflow_retries,
+                                        fit=False,
+                                        dropped_roles=dropped_roles,
+                                    )
+                                )
+                            if self.logger is not None:
+                                self.logger.log(f"turn_error id={turn_id} {detail}", source="backend")
+                            emit(Error(turn_id=turn_id, message=detail))
+                            return
                     detail = f"Ollama API request failed: HTTP {exc.code} {exc.reason}"
                     if body:
                         detail += f" | body: {body}"
+                    if not raw_parts and not think_parts and not answer_parts and is_context_overflow_text(detail):
+                        if _drop_oldest_turn():
+                            overflow_retries += 1
+                            continue
+                        detail = build_context_limit_error(
+                            build_retry_report(
+                                messages,
+                                working_messages,
+                                strategy="overflow_retry",
+                                context_window=None,
+                                reserved_generation_tokens=None,
+                                overflow_retries=overflow_retries,
+                                fit=False,
+                                dropped_roles=dropped_roles,
+                            )
+                        )
+                    if self.logger is not None:
+                        self.logger.log(f"turn_error id={turn_id} {detail}", source="backend")
+                    emit(Error(turn_id=turn_id, message=detail))
+                    return
+            except urllib.error.HTTPError as exc:
+                body = exc.read().decode("utf-8", errors="ignore").strip()
+                detail = f"Ollama API request failed: HTTP {exc.code} {exc.reason}"
+                if body:
+                    detail += f" | body: {body}"
+                if self.logger is not None:
+                    self.logger.log(f"turn_error id={turn_id} {detail}", source="backend")
+                emit(Error(turn_id=turn_id, message=detail))
+                return
+            except urllib.error.URLError as exc:
+                if self.logger is not None:
+                    self.logger.log(f"turn_error id={turn_id} Ollama API request failed: {exc}", source="backend")
+                emit(Error(turn_id=turn_id, message=f"Ollama API request failed: {exc}"))
+                return
+            except Exception as exc:
+                if not raw_parts and not think_parts and not answer_parts and is_context_overflow_text(str(exc)):
+                    if _drop_oldest_turn():
+                        overflow_retries += 1
+                        continue
+                    detail = build_context_limit_error(
+                        build_retry_report(
+                            messages,
+                            working_messages,
+                            strategy="overflow_retry",
+                            context_window=None,
+                            reserved_generation_tokens=None,
+                            overflow_retries=overflow_retries,
+                            fit=False,
+                            dropped_roles=dropped_roles,
+                        )
+                    )
+                    if self.logger is not None:
+                        self.logger.log(f"turn_error id={turn_id} {detail}", source="backend")
                     emit(Error(turn_id=turn_id, message=detail))
                     return
-        except urllib.error.HTTPError as exc:
-            body = exc.read().decode("utf-8", errors="ignore").strip()
-            detail = f"Ollama API request failed: HTTP {exc.code} {exc.reason}"
-            if body:
-                detail += f" | body: {body}"
-            emit(Error(turn_id=turn_id, message=detail))
-            return
-        except urllib.error.URLError as exc:
-            emit(Error(turn_id=turn_id, message=f"Ollama API request failed: {exc}"))
-            return
-        except Exception as exc:
-            emit(Error(turn_id=turn_id, message=str(exc)))
-            return
+                if self.logger is not None:
+                    self.logger.log(f"turn_error id={turn_id} {exc}", source="backend")
+                emit(Error(turn_id=turn_id, message=str(exc)))
+                return
 
         for channel, text in router.flush():
             if channel == "think":
@@ -212,10 +385,11 @@ def _consume_stream(request_payload: dict) -> None:
                 emit(AnswerDelta(turn_id=turn_id, text=text))
 
         ended = time.time()
+        answer_text = "".join(answer_parts)
         record = TurnRecord(
             raw="".join(raw_parts),
             think="".join(think_parts),
-            answer="".join(answer_parts).strip(),
+            answer=answer_text,
             ended_in_think=(router.mode == "think"),
             backend=self.backend_name,
             model_id=self.resolved_model_id,
@@ -227,9 +401,31 @@ def _consume_stream(request_payload: dict) -> None:
                 "ollama_think": self.args.ollama_think,
             },
             timing={"start": started, "end": ended, "elapsed": max(0.0, ended - started)},
-            trimmed_messages=messages,
+            knobs=knob_report,
+            context=build_retry_report(
+                messages,
+                working_messages,
+                strategy="overflow_retry",
+                context_window=None,
+                reserved_generation_tokens=None,
+                overflow_retries=overflow_retries,
+                fit=True,
+                dropped_roles=dropped_roles,
+            ).to_dict(),
+            trimmed_messages=append_assistant_history(
+                list(working_messages),
+                think="".join(think_parts),
+                answer=answer_text,
+                strip_think=bool(self.args.history_strip_think),
+            ),
         )
         emit(Finish(turn_id=turn_id, record=record))
+        if self.logger is not None:
+            self.logger.log(
+                f"turn_finish id={turn_id} elapsed_s={record.timing.get('elapsed', 0):.3f} "
+                f"think_chars={len(record.think)} answer_chars={len(record.answer)}",
+                source="backend",
+            )
 
 
 def create_session(args: argparse.Namespace) -> OllamaSession:
@@ -238,4 +434,22 @@ def create_session(args: argparse.Namespace) -> OllamaSession:
         model_name = model_name.split(":", 1)[1]
     host = resolve_host(args.ollama_host, args.ollama_timeout)
     print(f"Using Ollama host: {host}")
-    return OllamaSession(args=args, resolved_model_id=model_name, host=host)
+    logger = FileLogger.from_value(
+        getattr(args, "ollama_log_file", ""),
+        "backend",
+        config_path=getattr(args, "_config_path", None),
+    )
+    if logger is not None:
+        logger.log(f"session_init model={model_name} host={host}", source="app")
+    requested_template = (args.chat_template or "").strip()
+    return OllamaSession(
+        args=args,
+        resolved_model_id=model_name,
+        host=host,
+        template_info={
+            "chat_template_requested": requested_template,
+            "chat_template_applied": False,
+            "chat_template_reason": "ignored_server_owned" if requested_template else "empty_default",
+        },
+        logger=logger,
+    )
diff --git a/tui_app/backends/openai.py b/tui_app/backends/openai.py
new file mode 100644
index 0000000..9c455c0
--- /dev/null
+++ b/tui_app/backends/openai.py
@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import argparse
+import os
+
+from tui_app.log_file import FileLogger
+from tui_app.transports.openai_http import OpenAIHTTPSession, normalize_openai_base_url, resolve_model_once
+
+
+def _resolve_api_key(args: argparse.Namespace) -> str:
+    cli_overrides = set(getattr(args, "_cli_overrides", set()) or set())
+    if "openai_api_key" in cli_overrides:
+        return (args.openai_api_key or "").strip()
+    env_key = os.environ.get("OPENAI_API_KEY", "").strip()
+    if env_key:
+        return env_key
+    return (args.openai_api_key or "").strip()
+
+
+def create_session(args: argparse.Namespace) -> OpenAIHTTPSession:
+    base_url = normalize_openai_base_url((args.openai_base_url or "").strip())
+    if not base_url:
+        raise RuntimeError("OpenAI backend requires base_url (--openai-base-url or config [backend.openai].base_url).")
+
+    api_key = _resolve_api_key(args)
+
+    logger = FileLogger.from_value(
+        getattr(args, "openai_log_file", ""),
+        "backend",
+        config_path=getattr(args, "_config_path", None),
+    )
+    resolved_model_id = (args.model_id or "").strip()
+    if resolved_model_id and os.path.isabs(resolved_model_id):
+        resolved_model_id = ""
+    if resolved_model_id.startswith("openai:"):
+        resolved_model_id = resolved_model_id.split(":", 1)[1].strip()
+    if not resolved_model_id:
+        resolved_model_id = resolve_model_once(
+            base_url,
+            timeout_s=float(args.openai_timeout_s),
+            api_key=api_key,
+        )
+    if logger is not None:
+        logger.log(
+            f"session_init base_url={base_url} model={resolved_model_id} timeout_s={float(args.openai_timeout_s)}",
+            source="app",
+        )
+        logger.log("backend_ready openai session attached", source="backend")
+    requested_template = (args.chat_template or "").strip()
+
+    return OpenAIHTTPSession(
+        args=args,
+        resolved_model_id=resolved_model_id,
+        base_url=base_url,
+        api_key=api_key,
+        timeout_s=float(args.openai_timeout_s),
+        backend_name="openai",
+        template_info={
+            "template_control_level": "server_owned_template",
+            "chat_template_requested": requested_template,
+            "chat_template_applied": False,
+            "chat_template_reason": "ignored_server_owned" if requested_template else "empty_default",
+        },
+        logger=logger,
+    )
diff --git a/tui_app/backends/vllm.py b/tui_app/backends/vllm.py
new file mode 100644
index 0000000..c2a455d
--- /dev/null
+++ b/tui_app/backends/vllm.py
@@ -0,0 +1,1248 @@
+from __future__ import annotations
+
+import argparse
+import glob
+import json
+import os
+import re
+import shlex
+import shutil
+import signal
+import socket
+import subprocess
+import sys
+import threading
+import time
+import urllib.error
+import urllib.request
+from urllib.parse import urlparse
+from typing import Any
+
+from config_utils import apply_machine_model_root, get_runtime_scope, load_config_layers
+from tui_app.backends.base import EventEmitter
+from tui_app.context_policy import build_context_limit_error, reserve_generation_tokens, trim_messages_to_budget
+from tui_app.events import Error, Finish, TurnStart
+from tui_app.log_file import FileLogger
+from tui_app.transports.openai_http import OpenAIHTTPSession, normalize_openai_base_url
+
+try:
+    from transformers import AutoTokenizer
+except Exception:  # pragma: no cover - transformers is a required runtime elsewhere in this repo
+    AutoTokenizer = None  # type: ignore
+
+
+def _resolve_api_key(args: argparse.Namespace) -> str:
+    cli_overrides = set(getattr(args, "_cli_overrides", set()) or set())
+    if "vllm_api_key" in cli_overrides:
+        return (args.vllm_api_key or "").strip()
+    env_key = os.environ.get("OPENAI_API_KEY", "").strip()
+    if env_key:
+        return env_key
+    return (args.vllm_api_key or "").strip()
+
+
+def _pick_free_port(host: str) -> int:
+    bind_host = host if host not in {"0.0.0.0", "::"} else "127.0.0.1"
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.bind((bind_host, 0))
+        return int(sock.getsockname()[1])
+
+
+def _join_url(base_url: str, path: str) -> str:
+    return base_url.rstrip("/") + path
+
+
+def _json_get(url: str, *, timeout_s: float, api_key: str = "") -> dict:
+    headers = {"Content-Type": "application/json"}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    req = urllib.request.Request(url, method="GET", headers=headers)
+    with urllib.request.urlopen(req, timeout=timeout_s) as resp:
+        raw = resp.read().decode("utf-8", errors="replace")
+    import json
+
+    return json.loads(raw)
+
+
+def _http_get_ok(url: str, *, timeout_s: float, api_key: str = "") -> None:
+    headers = {"Content-Type": "application/json"}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    req = urllib.request.Request(url, method="GET", headers=headers)
+    with urllib.request.urlopen(req, timeout=timeout_s) as resp:
+        if int(getattr(resp, "status", 200)) >= 400:
+            raise RuntimeError(f"HTTP {getattr(resp, 'status', 'error')}")
+        resp.read(1)
+
+
+def _resolve_model_from_models_endpoint(base_url: str, *, timeout_s: float, api_key: str, served_model_name: str) -> str:
+    if served_model_name:
+        return served_model_name
+    data = _json_get(_join_url(base_url, "/models"), timeout_s=max(1.0, min(10.0, timeout_s)), api_key=api_key)
+    models = data.get("data")
+    ids: list[str] = []
+    if isinstance(models, list):
+        for item in models:
+            if isinstance(item, dict) and isinstance(item.get("id"), str) and item["id"].strip():
+                ids.append(item["id"].strip())
+    if len(ids) == 1:
+        return ids[0]
+    if not ids:
+        raise RuntimeError("vLLM model resolution failed: /v1/models returned no models.")
+    raise RuntimeError(
+        "vLLM model resolution failed: server returned multiple models. "
+        f"Set backend.vllm.served_model_name. Available: {', '.join(ids)}"
+    )
+
+
+def _supports_chat_template_flag(cmd_argv: list[str]) -> bool:
+    probe = list(cmd_argv)
+    if "serve" in probe:
+        probe = probe[: probe.index("serve") + 1]
+    else:
+        probe.append("serve")
+    for help_flag in ("--help", "--help=all"):
+        try:
+            out = subprocess.check_output(probe + [help_flag], text=True, stderr=subprocess.STDOUT, timeout=8)
+        except Exception:
+            continue
+        if "--chat-template" in out:
+            return True
+    return False
+
+
+def _slugify(value: str) -> str:
+    text = "".join(ch if ch.isalnum() else "-" for ch in (value or "").strip().lower())
+    text = "-".join(part for part in text.split("-") if part)
+    return text or "vllm"
+
+
+def _backend_repo_root() -> str:
+    return os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+
+
+def _resolve_sidecar_path(args: argparse.Namespace, filename: str) -> str:
+    scope = get_runtime_scope(
+        config_path=(getattr(args, "_config_path", "") or "").strip() or None,
+        backend="vllm",
+        model_ref=(getattr(args, "vllm_served_model_name", "") or getattr(args, "model_id", "") or "").strip(),
+        profile=(getattr(args, "_config_profile", "") or "").strip(),
+    )
+    base_dir = os.path.join(scope["run_root"], "state", scope["backend"], scope["model"], scope["slot"])
+    return os.path.abspath(os.path.join(base_dir, filename))
+
+
+def _resolve_engine_log_paths(args: argparse.Namespace) -> tuple[str, str]:
+    scope = get_runtime_scope(
+        config_path=(getattr(args, "_config_path", "") or "").strip() or None,
+        backend="vllm",
+        model_ref=(getattr(args, "vllm_served_model_name", "") or getattr(args, "model_id", "") or "").strip(),
+        profile=(getattr(args, "_config_profile", "") or "").strip(),
+    )
+    base_dir = os.path.join(scope["run_root"], "logs", scope["backend"], scope["model"], scope["slot"])
+    return (
+        os.path.abspath(os.path.join(base_dir, "vllm-engine.stdout.log")),
+        os.path.abspath(os.path.join(base_dir, "vllm-engine.stderr.log")),
+    )
+
+
+def _ensure_parent_dir(path: str) -> None:
+    parent = os.path.dirname(path)
+    if parent:
+        os.makedirs(parent, exist_ok=True)
+
+
+def _pid_alive(pid: int) -> bool:
+    if pid <= 0:
+        return False
+    proc_stat = f"/proc/{pid}/stat"
+    try:
+        with open(proc_stat, "r", encoding="utf-8", errors="replace") as fh:
+            stat = fh.read().strip()
+        if stat:
+            parts = stat.split()
+            if len(parts) >= 3 and parts[2] == "Z":
+                return False
+    except Exception:
+        pass
+    try:
+        os.kill(pid, 0)
+        return True
+    except OSError:
+        return False
+
+
+def _stop_pid_group(pid: int, pgid: int | None = None) -> None:
+    if pid <= 0:
+        return
+    target_pgid = pgid
+    if target_pgid is None:
+        try:
+            target_pgid = os.getpgid(pid)
+        except Exception:
+            target_pgid = None
+    if target_pgid is not None:
+        try:
+            os.killpg(target_pgid, signal.SIGTERM)
+        except Exception:
+            pass
+        deadline = time.time() + 5.0
+        while time.time() < deadline:
+            if not _pid_alive(pid):
+                return
+            time.sleep(0.1)
+        try:
+            os.killpg(target_pgid, signal.SIGKILL)
+        except Exception:
+            pass
+        return
+    try:
+        os.kill(pid, signal.SIGTERM)
+    except Exception:
+        return
+
+
+def _resolve_requested_template(args: argparse.Namespace) -> str:
+    requested_template = (args.chat_template or "").strip()
+    if not requested_template:
+        return ""
+    config_path = (getattr(args, "_config_path", "") or "").strip()
+    candidate = os.path.abspath(os.path.expanduser(requested_template))
+    if config_path and not os.path.isabs(os.path.expanduser(requested_template)):
+        candidate = os.path.abspath(os.path.join(os.path.dirname(config_path), requested_template))
+    if os.path.isfile(candidate):
+        return candidate
+    return requested_template
+
+
+def _build_signature(args: argparse.Namespace, model_id: str, template_requested_value: str) -> dict[str, Any]:
+    extra = args.vllm_extra_args or []
+    if isinstance(extra, str):
+        extra = shlex.split(extra)
+    return {
+        "backend": "vllm",
+        "mode": str(args.vllm_mode or "managed"),
+        "model_id": model_id,
+        "host": str(args.vllm_host or "127.0.0.1"),
+        "requested_port": int(args.vllm_port),
+        "cmd": str(args.vllm_cmd or "vllm"),
+        "served_model_name": str(args.vllm_served_model_name or ""),
+        "tensor_parallel_size": int(args.vllm_tensor_parallel_size or 0),
+        "gpu_memory_utilization": float(args.vllm_gpu_memory_utilization or 0),
+        "max_model_len": int(args.vllm_max_model_len or 0),
+        "generation_config": str(args.vllm_generation_config or ""),
+        "attention_backend": str(args.vllm_attention_backend or ""),
+        "dtype": str(args.vllm_dtype or ""),
+        "enable_auto_tool_choice": bool(args.vllm_enable_auto_tool_choice is True),
+        "tool_call_parser": str(args.vllm_tool_call_parser or ""),
+        "extra_args": [str(x) for x in extra if str(x).strip()],
+        "chat_template_requested": template_requested_value,
+    }
+
+
+def _load_control_file(path: str) -> dict[str, Any] | None:
+    if not os.path.isfile(path):
+        return None
+    try:
+        with open(path, "r", encoding="utf-8") as fh:
+            data = json.load(fh)
+    except Exception:
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def _write_control_file(path: str, data: dict[str, Any]) -> None:
+    _ensure_parent_dir(path)
+    tmp = path + ".tmp"
+    with open(tmp, "w", encoding="utf-8") as fh:
+        json.dump(data, fh, indent=2, ensure_ascii=False)
+    os.replace(tmp, path)
+
+
+def _remove_control_file(path: str) -> None:
+    try:
+        os.remove(path)
+    except FileNotFoundError:
+        return
+    except Exception:
+        return
+
+
+def _control_file_candidates() -> list[str]:
+    paths: list[str] = []
+    repo_models_dir = os.path.join(_backend_repo_root(), "models")
+    if os.path.isdir(repo_models_dir):
+        for root, _, files in os.walk(repo_models_dir):
+            if "vllm-managed.json" in files:
+                paths.append(os.path.join(root, "vllm-managed.json"))
+    paths.extend(glob.glob("/tmp/model-runner-*-vllm-managed.json"))
+    deduped = []
+    seen: set[str] = set()
+    for raw in paths:
+        path = os.path.abspath(raw)
+        if path in seen:
+            continue
+        seen.add(path)
+        deduped.append(path)
+    return deduped
+
+
+def _attach_selector(entry: dict[str, Any]) -> str:
+    model = str(entry.get("resolved_model_id") or entry.get("model_id") or "vllm").strip()
+    pid = int(entry.get("pid") or 0)
+    port = entry.get("port")
+    port_text = str(port) if port not in (None, "", 0) else "na"
+    return f"attach:{_slugify(model)}-{port_text}-{pid}"
+
+
+def _entry_from_control_file(path: str) -> dict[str, Any] | None:
+    data = _load_control_file(path)
+    if not data:
+        return None
+    pid = int(data.get("pid") or 0)
+    if not _pid_alive(pid):
+        return None
+    base_url = normalize_openai_base_url(str(data.get("base_url") or "").strip())
+    signature = dict(data.get("signature") or {})
+    parsed = urlparse(base_url) if base_url else None
+    model_id = str(signature.get("model_id") or "").strip()
+    resolved_model_id = str(data.get("resolved_model_id") or "").strip() or model_id
+    created_at = float(data.get("created_at") or 0.0)
+    repo_root = _backend_repo_root()
+    display_path = path
+    try:
+        repo_prefix = repo_root + os.sep
+        if path.startswith(repo_prefix):
+            display_path = os.path.relpath(path, repo_root)
+        else:
+            display_path = path
+    except Exception:
+        display_path = path
+    return {
+        "backend": "vllm",
+        "control_file": path,
+        "display_path": display_path,
+        "pid": pid,
+        "pgid": int(data.get("pgid") or 0) or None,
+        "base_url": base_url,
+        "host": parsed.hostname if parsed else "",
+        "port": parsed.port if parsed else None,
+        "model_id": model_id,
+        "resolved_model_id": resolved_model_id,
+        "served_model_name": str(signature.get("served_model_name") or "").strip(),
+        "created_at": created_at,
+        "selector": _attach_selector(
+            {
+                "resolved_model_id": resolved_model_id,
+                "model_id": model_id,
+                "pid": pid,
+                "port": parsed.port if parsed else None,
+            }
+        ),
+    }
+
+
+def list_managed_servers() -> list[dict[str, Any]]:
+    entries: list[dict[str, Any]] = []
+    for path in _control_file_candidates():
+        entry = _entry_from_control_file(path)
+        if entry:
+            entries.append(entry)
+    entries.sort(key=lambda item: (float(item.get("created_at") or 0.0), int(item.get("pid") or 0)), reverse=True)
+    return entries
+
+
+def resolve_attach_selector(selector: str) -> dict[str, Any] | None:
+    normalized = (selector or "").strip()
+    if normalized.startswith("vllm:"):
+        normalized = normalized.split(":", 1)[1].strip()
+    for entry in list_managed_servers():
+        if entry.get("selector") == normalized:
+            return entry
+    return None
+
+
+def _iter_local_vllm_config_paths() -> list[str]:
+    pattern = os.path.join(_backend_repo_root(), "models", "*", "vllm", "config", "default.toml")
+    return sorted(glob.glob(pattern))
+
+
+def _discover_live_local_vllm_servers() -> list[dict[str, Any]]:
+    entries: list[dict[str, Any]] = []
+    seen_urls: set[str] = set()
+    for cfg_path in _iter_local_vllm_config_paths():
+        try:
+            merged, meta = load_config_layers(cfg_path, backend="vllm", include_machine=True)
+        except Exception:
+            continue
+        host = str(merged.get("vllm_host") or "127.0.0.1").strip()
+        port = int(merged.get("vllm_port") or 0)
+        base_url = ""
+        if port > 0:
+            base_url = f"http://{host}:{port}"
+        else:
+            base_url = str(merged.get("vllm_base_url") or "").strip()
+        base_url = normalize_openai_base_url(base_url)
+        if not base_url or base_url in seen_urls:
+            continue
+        try:
+            resolved_model_id = _resolve_model_from_models_endpoint(
+                base_url,
+                timeout_s=2.0,
+                api_key="",
+                served_model_name="",
+            )
+        except Exception:
+            continue
+        seen_urls.add(base_url)
+        parsed = urlparse(base_url)
+        entries.append(
+            {
+                "backend": "vllm",
+                "base_url": base_url,
+                "host": parsed.hostname if parsed else "",
+                "port": parsed.port if parsed else None,
+                "resolved_model_id": resolved_model_id,
+                "config_path": str(meta.get("base") or cfg_path),
+            }
+        )
+    entries.sort(key=lambda item: (str(item.get("resolved_model_id") or ""), str(item.get("base_url") or "")))
+    return entries
+
+
+def _listener_pid_for_port(port: int) -> int | None:
+    if int(port or 0) <= 0:
+        return None
+    try:
+        out = subprocess.check_output(["ss", "-ltnp"], text=True, stderr=subprocess.DEVNULL)
+    except Exception:
+        return None
+    needle = f":{int(port)}"
+    for line in out.splitlines():
+        if needle not in line:
+            continue
+        match = re.search(r'users:\(\(".*?",pid=(\d+),fd=', line)
+        if match:
+            try:
+                return int(match.group(1))
+            except Exception:
+                return None
+    return None
+
+
+class _FileTail:
+    def __init__(
+        self,
+        logger: FileLogger,
+        source: str,
+        path: str,
+        start_offset: int,
+        stop_event: threading.Event,
+        *,
+        ready_event: threading.Event | None = None,
+        echo_target=None,
+        echo_stop_event: threading.Event | None = None,
+    ):
+        self.logger = logger
+        self.source = source
+        self.path = path
+        self.start_offset = max(0, int(start_offset))
+        self.stop_event = stop_event
+        self.echo_target = echo_target
+        self.echo_stop_event = echo_stop_event
+
+    def pump(self) -> None:
+        try:
+            with open(self.path, "r", encoding="utf-8", errors="replace") as stream:
+                stream.seek(self.start_offset)
+                while not self.stop_event.is_set():
+                    line = stream.readline()
+                    if line:
+                        trimmed = line.rstrip()
+                        self.logger.log(trimmed, source=self.source)
+                        if (
+                            self.echo_target is not None
+                            and self.echo_stop_event is not None
+                            and not self.echo_stop_event.is_set()
+                        ):
+                            try:
+                                print(trimmed, file=self.echo_target, flush=True)
+                            except Exception:
+                                pass
+                        continue
+                    time.sleep(0.15)
+        except Exception:
+            return
+
+
+class VLLMSession:
+    backend_name = "vllm"
+
+    def __init__(
+        self,
+        args: argparse.Namespace,
+        process: subprocess.Popen,
+        launch_argv: list[str],
+        base_url: str,
+        resolved_model_id: str,
+        api_key: str,
+        template_info: dict[str, object],
+        logger: FileLogger,
+        control_file_path: str,
+        managed_pid: int,
+        managed_pgid: int | None,
+        attached_existing: bool,
+        engine_stdout_start: int = 0,
+        engine_stderr_start: int = 0,
+        tail_stop_event: threading.Event | None = None,
+        tail_threads: list[threading.Thread] | None = None,
+        tokenizer=None,
+    ):
+        self.args = args
+        self._process = process
+        self._managed_pid = int(managed_pid)
+        self._managed_pgid = managed_pgid
+        self._launch_argv = launch_argv
+        self._base_url = base_url
+        self.logger = logger
+        self._control_file_path = control_file_path
+        self._engine_stdout_path = ""
+        self._engine_stderr_path = ""
+        self._engine_stdout_start = max(0, int(engine_stdout_start))
+        self._engine_stderr_start = max(0, int(engine_stderr_start))
+        self._attached_existing = bool(attached_existing)
+        self._tail_stop_event = tail_stop_event
+        self._tail_threads = list(tail_threads or [])
+        self._shutdown_on_close = True
+        self._closed = False
+        self._tokenizer = tokenizer
+        self._tokenizer_load_attempted = tokenizer is not None
+        self._tokenizer_lock = threading.Lock()
+        self._tokenizer_model_id = resolved_model_id
+        self._template_info = dict(template_info or {})
+        self._transport = OpenAIHTTPSession(
+            args=args,
+            resolved_model_id=resolved_model_id,
+            base_url=base_url,
+            api_key=api_key,
+            timeout_s=float(args.vllm_timeout_s),
+            backend_name="vllm",
+            template_info=template_info,
+            logger=logger,
+        )
+        self.resolved_model_id = resolved_model_id
+
+    def describe(self) -> dict[str, object]:
+        info = dict(self._transport.describe())
+        info["managed_mode"] = True
+        info["pid"] = self._managed_pid
+        info["launch_argv"] = " ".join(shlex.quote(part) for part in self._launch_argv)
+        info["enable_auto_tool_choice"] = self.args.vllm_enable_auto_tool_choice
+        info["tool_call_parser"] = self.args.vllm_tool_call_parser or ""
+        info["control_file"] = self._control_file_path
+        info["engine_stdout_path"] = self._engine_stdout_path
+        info["engine_stderr_path"] = self._engine_stderr_path
+        info["engine_stdout_start"] = self._engine_stdout_start
+        info["engine_stderr_start"] = self._engine_stderr_start
+        info["attached_existing"] = self._attached_existing
+        return info
+
+    def get_recent_logs(self, n: int = 80, sources: list[str] | None = None) -> list[str]:
+        return self.logger.get_recent_logs(n=n, sources=sources)
+
+    def list_log_sources(self) -> list[str]:
+        return self.logger.list_log_sources()
+
+    def get_last_request(self) -> dict | None:
+        getter = getattr(self._transport, "get_last_request", None)
+        if callable(getter):
+            return getter()
+        return None
+
+    def detach(self) -> None:
+        self._shutdown_on_close = False
+
+    @staticmethod
+    def _sanitize_messages_for_preflight(messages: list[dict[str, object]]) -> list[dict[str, object]] | None:
+        clean: list[dict[str, object]] = []
+        for msg in messages:
+            role = str(msg.get("role", "") or "").strip()
+            if role not in {"system", "user", "assistant", "tool"}:
+                continue
+            images = msg.get("images")
+            if isinstance(images, list) and images:
+                return None
+            content_obj = msg.get("content")
+            clean_msg: dict[str, object] = {
+                "role": role,
+                "content": content_obj if content_obj is None or isinstance(content_obj, str) else str(content_obj),
+            }
+            tool_calls = msg.get("tool_calls")
+            if role == "assistant" and isinstance(tool_calls, list):
+                clean_msg["tool_calls"] = tool_calls
+            tool_call_id = msg.get("tool_call_id")
+            if role == "tool" and isinstance(tool_call_id, str) and tool_call_id.strip():
+                clean_msg["tool_call_id"] = tool_call_id.strip()
+            clean.append(clean_msg)
+        return clean
+
+    def _ensure_tokenizer(self):
+        if self._tokenizer_load_attempted:
+            return self._tokenizer
+        with self._tokenizer_lock:
+            if self._tokenizer_load_attempted:
+                return self._tokenizer
+            self._tokenizer_load_attempted = True
+            if AutoTokenizer is None:
+                return None
+            model_id = (self._tokenizer_model_id or "").strip()
+            if not model_id:
+                return None
+            tokenizer = None
+            try:
+                tokenizer = AutoTokenizer.from_pretrained(model_id)
+            except Exception:
+                try:
+                    tokenizer = AutoTokenizer.from_pretrained(model_id, use_fast=False)
+                except Exception:
+                    tokenizer = None
+            if tokenizer is not None and bool(self._template_info.get("chat_template_applied")):
+                template_path = str(self._template_info.get("chat_template_requested") or "").strip()
+                if template_path and os.path.isfile(template_path):
+                    try:
+                        with open(template_path, "r", encoding="utf-8") as fh:
+                            tokenizer.chat_template = fh.read()
+                    except Exception:
+                        pass
+            self._tokenizer = tokenizer
+            return self._tokenizer
+
+    def _preflight_context(self, messages: list[dict[str, object]]) -> tuple[list[dict[str, object]], dict[str, object] | None]:
+        tokenizer = self._ensure_tokenizer()
+        if tokenizer is None or getattr(tokenizer, "chat_template", None) is None:
+            return list(messages), None
+        clean = self._sanitize_messages_for_preflight(messages)
+        if clean is None:
+            return list(messages), None
+
+        context_window = int(self.args.vllm_max_model_len or 0) or None
+        if context_window is None:
+            value = getattr(tokenizer, "model_max_length", None)
+            if isinstance(value, int) and 0 < value < 1_000_000:
+                context_window = int(value)
+        if context_window is None:
+            return list(messages), None
+
+        def _measure(trimmed: list[dict[str, object]]):
+            token_ids = tokenizer.apply_chat_template(
+                trimmed,
+                tokenize=True,
+                add_generation_prompt=True,
+            )
+            return int(len(token_ids)), None
+
+        reserved = reserve_generation_tokens(context_window, self.args.max_new_tokens)
+
+        trimmed, _prompt_tokens, _unused, report = trim_messages_to_budget(
+            clean,
+            measure_fn=_measure,
+            context_window=context_window,
+            reserved_generation_tokens=reserved,
+            strategy="exact_preflight",
+        )
+        if not report.fit:
+            raise RuntimeError(build_context_limit_error(report))
+        return list(trimmed), report.to_dict()
+
+    @staticmethod
+    def _merge_context_reports(
+        preflight: dict[str, object] | None,
+        fallback: dict[str, object] | None,
+        *,
+        token_counts: dict[str, int] | None,
+    ) -> dict[str, object] | None:
+        if preflight is None:
+            return fallback
+        if fallback is None:
+            return preflight
+        pre = dict(preflight)
+        post = dict(fallback)
+        combined_roles = list(pre.get("dropped_roles") or []) + list(post.get("dropped_roles") or [])
+        prompt_tokens = post.get("prompt_tokens")
+        if prompt_tokens is None and isinstance(token_counts, dict):
+            prompt_tokens = token_counts.get("prompt_tokens")
+        strategy = str(pre.get("strategy") or "exact_preflight")
+        post_dropped = int(post.get("dropped_messages") or 0)
+        if post_dropped > 0 or int(post.get("overflow_retries") or 0) > 0:
+            strategy = f"{strategy}+overflow_retry"
+        return {
+            "strategy": strategy,
+            "original_messages": pre.get("original_messages", post.get("original_messages")),
+            "kept_messages": post.get("kept_messages", pre.get("kept_messages")),
+            "dropped_messages": int(pre.get("dropped_messages") or 0) + post_dropped,
+            "dropped_roles": combined_roles,
+            "fit": post.get("fit", pre.get("fit")),
+            "context_window": pre.get("context_window", post.get("context_window")),
+            "reserved_generation_tokens": pre.get("reserved_generation_tokens", post.get("reserved_generation_tokens")),
+            "prompt_budget_tokens": pre.get("prompt_budget_tokens", post.get("prompt_budget_tokens")),
+            "prompt_tokens": prompt_tokens if prompt_tokens is not None else pre.get("prompt_tokens"),
+            "overflow_retries": post.get("overflow_retries", 0),
+            "system_message_present": pre.get("system_message_present", post.get("system_message_present")),
+            "system_message_preserved": bool(pre.get("system_message_preserved", True))
+            and bool(post.get("system_message_preserved", True)),
+            "system_drop_required": bool(pre.get("system_drop_required", False))
+            or bool(post.get("system_drop_required", False)),
+        }
+
+    def generate_turn(self, turn_id: int, messages: list[dict[str, object]], emit: EventEmitter) -> None:
+        process_dead = False
+        if self._process is not None:
+            process_dead = self._process.poll() is not None
+        else:
+            process_dead = not _pid_alive(self._managed_pid)
+        if process_dead:
+            tail_rows = self.logger.get_recent_logs(40)
+            tail = "\n".join(tail_rows) if tail_rows else "(no captured logs)"
+            emit(
+                Error(
+                    turn_id=turn_id,
+                    message=(
+                        "vLLM managed server exited unexpectedly before generation.\n"
+                        f"launch_argv: {' '.join(shlex.quote(p) for p in self._launch_argv)}\n"
+                        f"log_tail:\n{tail}"
+                    ),
+                )
+            )
+            return
+        emit(TurnStart(turn_id=turn_id))
+        try:
+            working_messages, preflight_context = self._preflight_context(messages)
+        except Exception as exc:
+            emit(Error(turn_id=turn_id, message=str(exc)))
+            return
+
+        def _forward(ev):
+            if isinstance(ev, TurnStart):
+                return
+            if isinstance(ev, Finish):
+                ev.record.context = self._merge_context_reports(
+                    preflight_context,
+                    ev.record.context,
+                    token_counts=ev.record.token_counts,
+                )
+            emit(ev)
+
+        self._transport.generate_turn(
+            turn_id=turn_id,
+            messages=working_messages,
+            emit=_forward,
+            emit_turn_start=False,
+        )
+
+    def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        if self._tail_stop_event is not None:
+            self._tail_stop_event.set()
+        for thread in self._tail_threads:
+            try:
+                thread.join(timeout=0.5)
+            except Exception:
+                pass
+        if self._shutdown_on_close:
+            _stop_pid_group(self._managed_pid, self._managed_pgid)
+            _remove_control_file(self._control_file_path)
+        self.logger.close()
+
+
+def _build_launch_argv(args: argparse.Namespace, host: str, port: int, model_id: str) -> list[str]:
+    cmd_raw = (args.vllm_cmd or "vllm").strip()
+    cmd_argv = shlex.split(cmd_raw) if cmd_raw else []
+    if not cmd_argv:
+        cmd_argv = ["vllm"]
+    # Robust default: if plain `vllm` is unavailable on PATH, use current interpreter.
+    if cmd_argv == ["vllm"] and shutil.which("vllm") is None:
+        cmd_argv = [sys.executable, "-m", "vllm.entrypoints.cli.main"]
+    if not cmd_argv:
+        raise RuntimeError("vLLM command is empty (backend.vllm.cmd / --vllm-cmd).")
+
+    launch = list(cmd_argv)
+    if "serve" not in launch:
+        launch.append("serve")
+    launch.extend([model_id, "--host", host, "--port", str(port)])
+
+    if args.vllm_served_model_name:
+        launch.extend(["--served-model-name", str(args.vllm_served_model_name)])
+    if int(args.vllm_tensor_parallel_size or 0) > 0:
+        launch.extend(["--tensor-parallel-size", str(args.vllm_tensor_parallel_size)])
+    if float(args.vllm_gpu_memory_utilization or 0) > 0:
+        launch.extend(["--gpu-memory-utilization", str(args.vllm_gpu_memory_utilization)])
+    if int(args.vllm_max_model_len or 0) > 0:
+        launch.extend(["--max-model-len", str(args.vllm_max_model_len)])
+    generation_config = (args.vllm_generation_config or "").strip() or "auto"
+    if generation_config == "hf":
+        generation_config = "auto"
+    if generation_config:
+        launch.extend(["--generation-config", generation_config])
+    if (args.vllm_attention_backend or "").strip():
+        launch.extend(["--attention-backend", str(args.vllm_attention_backend).strip()])
+    if (args.vllm_dtype or "").strip():
+        launch.extend(["--dtype", str(args.vllm_dtype).strip()])
+    if args.vllm_enable_auto_tool_choice is True:
+        launch.append("--enable-auto-tool-choice")
+    parser_name = str(args.vllm_tool_call_parser or "").strip()
+    if parser_name:
+        launch.extend(["--tool-call-parser", parser_name])
+
+    extra = args.vllm_extra_args or []
+    if isinstance(extra, str):
+        extra = shlex.split(extra)
+    if isinstance(extra, list):
+        launch.extend([str(x) for x in extra if str(x).strip()])
+    if "--enable-force-include-usage" not in launch:
+        launch.append("--enable-force-include-usage")
+    return launch
+
+
+def _split_env_prefixed_argv(argv: list[str]) -> tuple[dict[str, str], list[str]]:
+    env_updates: dict[str, str] = {}
+    out = list(argv)
+    if not out or out[0] != "env":
+        return env_updates, out
+
+    idx = 1
+    while idx < len(out):
+        token = str(out[idx])
+        if "=" not in token:
+            break
+        key, value = token.split("=", 1)
+        if key:
+            env_updates[key] = value
+        idx += 1
+    return env_updates, out[idx:]
+
+
+def _wait_until_ready(
+    process: subprocess.Popen | None,
+    *,
+    base_url: str,
+    timeout_s: float,
+    api_key: str,
+    ready_event: threading.Event | None = None,
+) -> None:
+    err_last = ""
+    while True:
+        if process is not None and process.poll() is not None:
+            raise RuntimeError("vLLM process exited before readiness probe succeeded.")
+        try:
+            _http_get_ok(_join_url(base_url, "/models"), timeout_s=2.0, api_key=api_key)
+            return
+        except urllib.error.HTTPError as exc:
+            err_last = f"HTTP {exc.code} {exc.reason}"
+        except Exception as exc:
+            err_last = str(exc)
+        time.sleep(0.4)
+
+
+def create_session(args: argparse.Namespace) -> VLLMSession:
+    mode = (args.vllm_mode or "managed").strip().lower()
+    if mode != "managed":
+        raise RuntimeError(f"Unsupported vLLM mode: {mode}. v1 supports managed mode only.")
+
+    attach_entry = None
+    model_id = (args.model_id or "").strip()
+    if model_id.startswith("attach:"):
+        attach_entry = resolve_attach_selector(model_id)
+        if attach_entry is None:
+            raise RuntimeError(
+                f"Unknown managed vLLM attach selector: {model_id}. "
+                "Run `tui --list` to see active managed backends."
+            )
+    # Safety net: resolve local stems even if positional precedence bypasses
+    # config-layer model_id rewriting.
+    if model_id and attach_entry is None:
+        rewritten = apply_machine_model_root(model_id)
+        if rewritten:
+            model_id = rewritten
+    # Secondary fallback: reload merged config and honor model_id from it.
+    cfg_path = (getattr(args, "_config_path", "") or "").strip()
+    if cfg_path:
+        try:
+            merged, _meta = load_config_layers(
+                cfg_path,
+                backend="vllm",
+                profile=(getattr(args, "_config_profile", "") or ""),
+                include_machine=True,
+            )
+            cfg_model_id = (merged.get("model_id") or "").strip() if isinstance(merged, dict) else ""
+            if not model_id and cfg_model_id:
+                model_id = apply_machine_model_root(cfg_model_id)
+        except Exception:
+            pass
+    if not model_id:
+        raise RuntimeError("vLLM managed mode requires model_id (path or model name).")
+
+    host = (args.vllm_host or "127.0.0.1").strip()
+    requested_port = int(args.vllm_port)
+    if requested_port < 0:
+        raise RuntimeError("vLLM port must be >= 0.")
+    api_key = _resolve_api_key(args)
+    template_requested_value = _resolve_requested_template(args)
+    signature = _build_signature(args, model_id, template_requested_value)
+    control_file_path = (
+        str(attach_entry.get("control_file") or "").strip()
+        if attach_entry is not None
+        else _resolve_sidecar_path(args, "vllm-managed.json")
+    )
+    existing = _load_control_file(control_file_path)
+    if existing:
+        existing_pid = int(existing.get("pid") or 0)
+        if not _pid_alive(existing_pid):
+            _remove_control_file(control_file_path)
+            existing = None
+        elif attach_entry is None and existing.get("signature") != signature:
+            raise RuntimeError(
+                "Detached managed vLLM is already running for this config slot with different settings. "
+                f"Stop it first with: python tui.py --config {shlex.quote((getattr(args, '_config_path', '') or getattr(args, 'model_id', '') or '').strip())} --backend vllm --shutdown-backend"
+            )
+    if existing:
+        base_url = normalize_openai_base_url(str(existing.get("base_url") or "").strip())
+        if not base_url:
+            raise RuntimeError(f"Detached vLLM control file is missing base_url: {control_file_path}")
+        _wait_until_ready(process=None, base_url=base_url, timeout_s=float(args.vllm_timeout_s), api_key=api_key)
+        resolved_model_id = _resolve_model_from_models_endpoint(
+            base_url,
+            timeout_s=float(args.vllm_timeout_s),
+            api_key=api_key,
+            served_model_name=(args.vllm_served_model_name or "").strip(),
+        )
+        logger = FileLogger.from_value(
+            getattr(args, "vllm_log_file", ""),
+            "backend",
+            config_path=getattr(args, "_config_path", None),
+        )
+        tail_stop_event = threading.Event()
+        tail_threads: list[threading.Thread] = []
+        for source_key, source_name in (("engine_stdout_path", "engine_stdout"), ("engine_stderr_path", "engine_stderr")):
+            path = str(existing.get(source_key) or "").strip()
+            if not path or not os.path.isfile(path):
+                continue
+            start_offset = os.path.getsize(path)
+            thread = threading.Thread(
+                target=_FileTail(logger, source_name, path, start_offset, tail_stop_event).pump,
+                daemon=True,
+            )
+            thread.start()
+            tail_threads.append(thread)
+        template_info = dict(existing.get("template_info") or {})
+        session = VLLMSession(
+            args=args,
+            process=None,
+            launch_argv=list(existing.get("launch_argv") or []),
+            base_url=base_url,
+            resolved_model_id=resolved_model_id,
+            tokenizer=None,
+            api_key=api_key,
+            template_info=template_info,
+            logger=logger,
+            control_file_path=control_file_path,
+            managed_pid=existing_pid,
+            managed_pgid=int(existing.get("pgid") or 0) or None,
+            attached_existing=True,
+            engine_stdout_start=os.path.getsize(str(existing.get("engine_stdout_path") or "")) if str(existing.get("engine_stdout_path") or "") and os.path.isfile(str(existing.get("engine_stdout_path") or "")) else 0,
+            engine_stderr_start=os.path.getsize(str(existing.get("engine_stderr_path") or "")) if str(existing.get("engine_stderr_path") or "") and os.path.isfile(str(existing.get("engine_stderr_path") or "")) else 0,
+            tail_stop_event=tail_stop_event,
+            tail_threads=tail_threads,
+        )
+        session._engine_stdout_path = str(existing.get("engine_stdout_path") or "")
+        session._engine_stderr_path = str(existing.get("engine_stderr_path") or "")
+        return session
+
+    port = requested_port
+    if port == 0:
+        port = _pick_free_port(host)
+    # Managed vLLM launches its own local server, so the session must track the
+    # actual launched host/port rather than any machine-level OpenAI default.
+    base_url = normalize_openai_base_url(f"http://{host}:{port}")
+
+    launch_argv = _build_launch_argv(args, host=host, port=port, model_id=model_id)
+    launch_env_updates, launch_argv = _split_env_prefixed_argv(launch_argv)
+    if launch_argv == ["vllm"] and shutil.which("vllm") is None:
+        launch_argv = [sys.executable, "-m", "vllm.entrypoints.cli.main"]
+    elif launch_argv and launch_argv[0] == "vllm" and shutil.which("vllm") is None:
+        launch_argv = [sys.executable, "-m", "vllm.entrypoints.cli.main", *launch_argv[1:]]
+    requested_template = (args.chat_template or "").strip()
+    template_requested_value = requested_template
+    template_applied = False
+    template_reason = "empty_default" if not requested_template else "unsupported_flag"
+    if requested_template:
+        cfg_path = (getattr(args, "_config_path", "") or "").strip()
+        candidate = os.path.abspath(os.path.expanduser(requested_template))
+        if cfg_path and not os.path.isabs(os.path.expanduser(requested_template)):
+            candidate = os.path.abspath(os.path.join(os.path.dirname(cfg_path), requested_template))
+        if os.path.isfile(candidate):
+            template_requested_value = candidate
+        if os.path.isfile(template_requested_value) and _supports_chat_template_flag(launch_argv):
+            launch_argv.extend(["--chat-template", template_requested_value])
+            template_applied = True
+            template_reason = "applied"
+    logger = FileLogger.from_value(
+        getattr(args, "vllm_log_file", ""),
+        "backend",
+        config_path=getattr(args, "_config_path", None),
+    )
+    logger.log(f"launch_argv: {' '.join(shlex.quote(p) for p in launch_argv)}", source="app")
+    if launch_env_updates:
+        logger.log(
+            "launch_env: " + " ".join(f"{k}={v}" for k, v in sorted(launch_env_updates.items())),
+            source="app",
+        )
+
+    stdout_path, stderr_path = _resolve_engine_log_paths(args)
+    _ensure_parent_dir(stdout_path)
+    _ensure_parent_dir(stderr_path)
+    stdout_start = 0
+    stderr_start = 0
+    stdout_fh = open(stdout_path, "w", encoding="utf-8")
+    stderr_fh = open(stderr_path, "w", encoding="utf-8")
+    try:
+        child_env = os.environ.copy()
+        child_env.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
+        if launch_env_updates:
+            child_env.update(launch_env_updates)
+        process = subprocess.Popen(
+            launch_argv,
+            shell=False,
+            stdout=stdout_fh,
+            stderr=stderr_fh,
+            text=True,
+            bufsize=1,
+            preexec_fn=os.setsid,
+            env=child_env,
+        )
+    except OSError as exc:
+        stdout_fh.close()
+        stderr_fh.close()
+        if port != 0 and ("address already in use" in str(exc).lower() or "98" in str(exc)):
+            raise RuntimeError(
+                f"Failed to launch vLLM on {host}:{port} (port busy). "
+                f"Check: ss -ltnp | rg :{port}"
+            ) from exc
+        raise RuntimeError(f"Failed to launch vLLM process: {exc}") from exc
+    finally:
+        try:
+            stdout_fh.close()
+        except Exception:
+            pass
+        try:
+            stderr_fh.close()
+        except Exception:
+            pass
+
+    tail_stop_event = threading.Event()
+    startup_echo_stop_event = threading.Event()
+    tail_threads: list[threading.Thread] = []
+    for path, start_offset, source in (
+        (stdout_path, stdout_start, "engine_stdout"),
+        (stderr_path, stderr_start, "engine_stderr"),
+    ):
+        echo_target = None
+        if source == "engine_stdout" and sys.stdout.isatty():
+            echo_target = sys.stdout
+        elif source == "engine_stderr" and sys.stderr.isatty():
+            echo_target = sys.stderr
+        thread = threading.Thread(
+            target=_FileTail(
+                logger,
+                source,
+                path,
+                start_offset,
+                tail_stop_event,
+                echo_target=echo_target,
+                echo_stop_event=startup_echo_stop_event,
+            ).pump,
+            daemon=True,
+        )
+        thread.start()
+        tail_threads.append(thread)
+
+    try:
+        _wait_until_ready(
+            process,
+            base_url=base_url,
+            timeout_s=float(args.vllm_timeout_s),
+            api_key=api_key,
+        )
+        startup_echo_stop_event.set()
+        resolved_model_id = _resolve_model_from_models_endpoint(
+            base_url,
+            timeout_s=float(args.vllm_timeout_s),
+            api_key=api_key,
+            served_model_name=(args.vllm_served_model_name or "").strip(),
+        )
+    except Exception as exc:
+        startup_echo_stop_event.set()
+        tail_rows = logger.get_recent_logs(40)
+        tail = "\n".join(tail_rows) if tail_rows else "(no captured logs)"
+        lowered_tail = tail.lower()
+        if process.poll() is not None and port != 0:
+            if "address already in use" in lowered_tail or "already in use" in lowered_tail:
+                raise RuntimeError(
+                    f"Failed to launch vLLM on {host}:{port} (port busy). Check: ss -ltnp | rg :{port}"
+                ) from exc
+        try:
+            pgid = os.getpgid(process.pid)
+            os.killpg(pgid, signal.SIGTERM)
+        except Exception:
+            try:
+                process.terminate()
+            except Exception:
+                pass
+        raise RuntimeError(
+            f"Failed to initialize vLLM managed server: {exc}\n"
+            f"launch_argv: {' '.join(shlex.quote(p) for p in launch_argv)}\n"
+            f"log_tail:\n{tail}"
+        ) from exc
+
+    try:
+        pgid = os.getpgid(process.pid)
+    except Exception:
+        pgid = None
+    template_info = {
+        "template_control_level": "managed_server_template",
+        "chat_template_requested": template_requested_value,
+        "chat_template_applied": template_applied,
+        "chat_template_reason": template_reason,
+    }
+    _write_control_file(
+        control_file_path,
+        {
+            "backend": "vllm",
+            "pid": process.pid,
+            "pgid": pgid,
+            "base_url": base_url,
+            "resolved_model_id": resolved_model_id,
+            "launch_argv": launch_argv,
+            "signature": signature,
+            "engine_stdout_path": stdout_path,
+            "engine_stderr_path": stderr_path,
+            "template_info": template_info,
+            "created_at": time.time(),
+        },
+    )
+
+    session = VLLMSession(
+        args=args,
+        process=process,
+        launch_argv=launch_argv,
+        base_url=base_url,
+        resolved_model_id=resolved_model_id,
+        tokenizer=None,
+        api_key=api_key,
+        template_info=template_info,
+        logger=logger,
+        control_file_path=control_file_path,
+        managed_pid=process.pid,
+        managed_pgid=pgid,
+        attached_existing=False,
+        engine_stdout_start=stdout_start,
+        engine_stderr_start=stderr_start,
+        tail_stop_event=tail_stop_event,
+        tail_threads=tail_threads,
+    )
+    session._engine_stdout_path = stdout_path
+    session._engine_stderr_path = stderr_path
+    return session
+
+
+def shutdown_managed_server(args: argparse.Namespace) -> dict[str, object]:
+    control_file_path = ""
+    existing = None
+    has_explicit_target = bool((getattr(args, "_config_path", "") or "").strip() or (getattr(args, "model_id", "") or "").strip())
+    if has_explicit_target:
+        control_file_path = _resolve_sidecar_path(args, "vllm-managed.json")
+        existing = _load_control_file(control_file_path)
+        if not existing:
+            return {"stopped": False, "reason": "not_found", "control_file": control_file_path}
+    else:
+        managed = list_managed_servers()
+        if len(managed) == 1:
+            only = managed[0]
+            control_file_path = str(only.get("control_file") or "")
+            existing = _load_control_file(control_file_path) if control_file_path else None
+        elif len(managed) > 1:
+            return {
+                "stopped": False,
+                "reason": "ambiguous",
+                "control_file": "",
+                "candidates": [
+                    {
+                        "control_file": str(entry.get("control_file") or ""),
+                        "base_url": str(entry.get("base_url") or ""),
+                        "resolved_model_id": str(entry.get("resolved_model_id") or entry.get("model_id") or ""),
+                        "pid": int(entry.get("pid") or 0),
+                    }
+                    for entry in managed
+                ],
+            }
+        else:
+            live = _discover_live_local_vllm_servers()
+            if len(live) == 1:
+                only = live[0]
+                pid = _listener_pid_for_port(int(only.get("port") or 0))
+                if not pid:
+                    return {
+                        "stopped": False,
+                        "reason": "pid_not_found",
+                        "control_file": "",
+                        "base_url": str(only.get("base_url") or ""),
+                        "resolved_model_id": str(only.get("resolved_model_id") or ""),
+                    }
+                pgid = None
+                try:
+                    pgid = os.getpgid(pid)
+                except Exception:
+                    pgid = None
+                _stop_pid_group(pid, pgid)
+                return {
+                    "stopped": True,
+                    "reason": "terminated_unmanaged",
+                    "control_file": "",
+                    "pid": pid,
+                    "base_url": only.get("base_url"),
+                    "resolved_model_id": only.get("resolved_model_id"),
+                }
+            if len(live) > 1:
+                return {
+                    "stopped": False,
+                    "reason": "ambiguous",
+                    "control_file": "",
+                    "candidates": [
+                        {
+                            "control_file": "",
+                            "base_url": str(entry.get("base_url") or ""),
+                            "resolved_model_id": str(entry.get("resolved_model_id") or ""),
+                            "pid": _listener_pid_for_port(int(entry.get("port") or 0)) or 0,
+                        }
+                        for entry in live
+                    ],
+                }
+            return {"stopped": False, "reason": "not_found", "control_file": ""}
+    if not existing:
+        return {"stopped": False, "reason": "not_found", "control_file": control_file_path}
+    pid = int(existing.get("pid") or 0)
+    pgid = int(existing.get("pgid") or 0) or None
+    if not _pid_alive(pid):
+        _remove_control_file(control_file_path)
+        return {"stopped": False, "reason": "stale", "control_file": control_file_path, "pid": pid}
+    _stop_pid_group(pid, pgid)
+    _remove_control_file(control_file_path)
+    return {
+        "stopped": True,
+        "reason": "terminated",
+        "control_file": control_file_path,
+        "pid": pid,
+        "base_url": existing.get("base_url"),
+    }
diff --git a/tui_app/context_policy.py b/tui_app/context_policy.py
new file mode 100644
index 0000000..70bf0d7
--- /dev/null
+++ b/tui_app/context_policy.py
@@ -0,0 +1,274 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+
+MeasureFn = Callable[[list[dict[str, object]]], tuple[int, Any]]
+
+
+@dataclass
+class ContextReport:
+    strategy: str
+    original_messages: int
+    kept_messages: int
+    dropped_messages: int
+    dropped_roles: list[str] = field(default_factory=list)
+    fit: bool = True
+    context_window: int | None = None
+    reserved_generation_tokens: int | None = None
+    prompt_budget_tokens: int | None = None
+    prompt_tokens: int | None = None
+    overflow_retries: int = 0
+    system_message_present: bool = False
+    system_message_preserved: bool = True
+    system_drop_required: bool = False
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "strategy": self.strategy,
+            "original_messages": self.original_messages,
+            "kept_messages": self.kept_messages,
+            "dropped_messages": self.dropped_messages,
+            "dropped_roles": list(self.dropped_roles),
+            "fit": self.fit,
+            "context_window": self.context_window,
+            "reserved_generation_tokens": self.reserved_generation_tokens,
+            "prompt_budget_tokens": self.prompt_budget_tokens,
+            "prompt_tokens": self.prompt_tokens,
+            "overflow_retries": self.overflow_retries,
+            "system_message_present": self.system_message_present,
+            "system_message_preserved": self.system_message_preserved,
+            "system_drop_required": self.system_drop_required,
+        }
+
+
+def reserve_generation_tokens(context_window: int | None, requested_max_new_tokens: int | None) -> int | None:
+    if context_window is None or context_window <= 1:
+        return None
+    if requested_max_new_tokens is None or int(requested_max_new_tokens) <= 0:
+        return 0
+    return max(1, min(int(requested_max_new_tokens), int(context_window) - 1))
+
+
+def _protected_suffix_start(messages: list[dict[str, object]]) -> int:
+    last_user_idx = -1
+    for idx in range(len(messages) - 1, -1, -1):
+        if messages[idx].get("role") == "user":
+            last_user_idx = idx
+            break
+    if last_user_idx != -1:
+        return last_user_idx
+    return max(0, len(messages) - 1)
+
+
+def _tool_call_id_set(message: dict[str, object]) -> set[str]:
+    tool_calls = message.get("tool_calls")
+    if not isinstance(tool_calls, list):
+        return set()
+    ids: set[str] = set()
+    for item in tool_calls:
+        if not isinstance(item, dict):
+            continue
+        call_id = item.get("id")
+        if isinstance(call_id, str) and call_id.strip():
+            ids.add(call_id.strip())
+    return ids
+
+
+def _drop_tool_exchange(messages: list[dict[str, object]], idx: int) -> list[str]:
+    assistant = messages[idx]
+    call_ids = _tool_call_id_set(assistant)
+    if not call_ids:
+        role = str(assistant.get("role", "") or "") or "assistant"
+        messages.pop(idx)
+        return [role]
+
+    dropped_roles = [str(assistant.get("role", "") or "") or "assistant"]
+    end = idx + 1
+    while end < len(messages):
+        message = messages[end]
+        role = str(message.get("role", "") or "")
+        if role != "tool":
+            break
+        tool_call_id = str(message.get("tool_call_id", "") or "").strip()
+        if tool_call_id not in call_ids:
+            break
+        dropped_roles.append("tool")
+        end += 1
+    del messages[idx:end]
+    return dropped_roles
+
+
+def _turn_bundle_end(messages: list[dict[str, object]], start: int, protected_suffix_start: int) -> int:
+    end = start + 1
+    while end < protected_suffix_start:
+        role = str(messages[end].get("role", "") or "")
+        if role == "user":
+            break
+        if role == "assistant" and _tool_call_id_set(messages[end]):
+            call_ids = _tool_call_id_set(messages[end])
+            end += 1
+            while end < protected_suffix_start:
+                next_role = str(messages[end].get("role", "") or "")
+                if next_role != "tool":
+                    break
+                tool_call_id = str(messages[end].get("tool_call_id", "") or "").strip()
+                if tool_call_id not in call_ids:
+                    break
+                end += 1
+            continue
+        end += 1
+    return end
+
+
+def drop_oldest_history_message(messages: list[dict[str, object]]) -> list[str] | None:
+    if not messages:
+        return None
+    protected_suffix_start = _protected_suffix_start(messages)
+    for idx, item in enumerate(messages):
+        if idx >= protected_suffix_start:
+            break
+        role = str(item.get("role", "") or "")
+        if role == "system":
+            continue
+        if role == "user":
+            end = _turn_bundle_end(messages, idx, protected_suffix_start)
+            dropped_roles = [str(msg.get("role", "") or "") or "message" for msg in messages[idx:end]]
+            del messages[idx:end]
+            return dropped_roles
+        if role == "assistant" and _tool_call_id_set(item):
+            return _drop_tool_exchange(messages, idx)
+        if role in {"user", "assistant", "tool"}:
+            messages.pop(idx)
+            return [role]
+    return None
+
+
+def trim_messages_to_budget(
+    messages: list[dict[str, object]],
+    *,
+    measure_fn: MeasureFn,
+    context_window: int,
+    reserved_generation_tokens: int | None,
+    strategy: str,
+) -> tuple[list[dict[str, object]], int, Any, ContextReport]:
+    working = list(messages)
+    budget = max(1, int(context_window) - int(reserved_generation_tokens or 0))
+    dropped_roles: list[str] = []
+    last_count = 0
+    last_value: Any = None
+    system_present = any(str(msg.get("role", "") or "") == "system" for msg in messages)
+
+    while True:
+        last_count, last_value = measure_fn(working)
+        if last_count <= budget:
+            break
+        dropped_roles_chunk = drop_oldest_history_message(working)
+        if dropped_roles_chunk is None:
+            report = ContextReport(
+                strategy=strategy,
+                original_messages=len(messages),
+                kept_messages=len(working),
+                dropped_messages=len(dropped_roles),
+                dropped_roles=dropped_roles,
+                fit=False,
+                context_window=int(context_window),
+                reserved_generation_tokens=reserved_generation_tokens,
+                prompt_budget_tokens=budget,
+                prompt_tokens=last_count,
+                system_message_present=system_present,
+                system_message_preserved=system_present,
+                system_drop_required=system_present,
+            )
+            return working, last_count, last_value, report
+        dropped_roles.extend(dropped_roles_chunk)
+
+    report = ContextReport(
+        strategy=strategy,
+        original_messages=len(messages),
+        kept_messages=len(working),
+        dropped_messages=len(dropped_roles),
+        dropped_roles=dropped_roles,
+        fit=True,
+        context_window=int(context_window),
+        reserved_generation_tokens=reserved_generation_tokens,
+        prompt_budget_tokens=budget,
+        prompt_tokens=last_count,
+        system_message_present=system_present,
+        system_message_preserved=system_present,
+        system_drop_required=False,
+    )
+    return working, last_count, last_value, report
+
+
+def build_retry_report(
+    original_messages: list[dict[str, object]],
+    kept_messages: list[dict[str, object]],
+    *,
+    strategy: str,
+    context_window: int | None,
+    reserved_generation_tokens: int | None,
+    overflow_retries: int,
+    fit: bool,
+    prompt_tokens: int | None = None,
+    dropped_roles: list[str] | None = None,
+) -> ContextReport:
+    roles = list(dropped_roles or [])
+    system_present = any(str(msg.get("role", "") or "") == "system" for msg in original_messages)
+    prompt_budget = None
+    if context_window is not None:
+        prompt_budget = max(1, int(context_window) - int(reserved_generation_tokens or 0))
+    return ContextReport(
+        strategy=strategy,
+        original_messages=len(original_messages),
+        kept_messages=len(kept_messages),
+        dropped_messages=len(roles),
+        dropped_roles=roles,
+        fit=fit,
+        context_window=context_window,
+        reserved_generation_tokens=reserved_generation_tokens,
+        prompt_budget_tokens=prompt_budget,
+        prompt_tokens=prompt_tokens,
+        overflow_retries=int(overflow_retries),
+        system_message_present=system_present,
+        system_message_preserved=system_present,
+        system_drop_required=bool(system_present and not fit),
+    )
+
+
+def build_context_limit_error(report: ContextReport) -> str:
+    parts = ["Input is too large even after history trimming."]
+    if report.context_window is not None:
+        parts.append(f"context_window={report.context_window}")
+    if report.prompt_budget_tokens is not None:
+        parts.append(f"prompt_budget_tokens={report.prompt_budget_tokens}")
+    if report.prompt_tokens is not None:
+        parts.append(f"prompt_tokens={report.prompt_tokens}")
+    parts.append(f"dropped_history_messages={report.dropped_messages}")
+    if report.system_message_present:
+        parts.append(f"system_message_preserved={report.system_message_preserved}")
+    parts.append("Reduce the current prompt/system prompt or lower max_new_tokens.")
+    return " ".join(parts)
+
+
+def is_context_overflow_text(text: str) -> bool:
+    lowered = (text or "").lower()
+    patterns = [
+        "context window",
+        "context length",
+        "maximum context length",
+        "requested tokens",
+        "requested token",
+        "too many tokens",
+        "max_model_len",
+        "input too long",
+        "prompt is too long",
+        "exceeds the model's context length",
+        "exceed the model's context length",
+        "exceeds context window",
+        "reduce the length",
+    ]
+    if any(pattern in lowered for pattern in patterns):
+        return True
+    return "exceed" in lowered and "token" in lowered
diff --git a/tui_app/events.py b/tui_app/events.py
index 2c57744..92331d8 100644
--- a/tui_app/events.py
+++ b/tui_app/events.py
@@ -14,7 +14,12 @@ class TurnRecord:
     model_id: str
     gen: dict[str, Any] = field(default_factory=dict)
     timing: dict[str, Any] = field(default_factory=dict)
-    trimmed_messages: list[dict[str, str]] | None = None
+    token_counts: dict[str, int] | None = None
+    throughput: dict[str, float] | None = None
+    knobs: dict[str, Any] | None = None
+    context: dict[str, Any] | None = None
+    tool_activity: list[dict[str, Any]] | None = None
+    trimmed_messages: list[dict[str, object]] | None = None
 
 
 @dataclass
diff --git a/tui_app/history_control.py b/tui_app/history_control.py
new file mode 100644
index 0000000..0dc2f1a
--- /dev/null
+++ b/tui_app/history_control.py
@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+
+def build_assistant_history_content(*, think: str, answer: str, strip_think: bool) -> str | None:
+    think_text = think or ""
+    answer_text = answer or ""
+    think_has_content = bool(think_text.strip())
+    answer_has_content = bool(answer_text.strip())
+    if strip_think:
+        return answer_text if answer_has_content else None
+    if think_has_content and answer_has_content:
+        return f"<think>{think_text}</think>{answer_text}"
+    if think_has_content:
+        return f"<think>{think_text}</think>"
+    return answer_text if answer_has_content else None
+
+
+def append_assistant_history(
+    messages: list[dict[str, object]],
+    *,
+    think: str,
+    answer: str,
+    strip_think: bool,
+) -> list[dict[str, object]]:
+    out = list(messages)
+    content = build_assistant_history_content(think=think, answer=answer, strip_think=strip_think)
+    if content is not None and content.strip():
+        out.append({"role": "assistant", "content": content})
+    return out
diff --git a/tui_app/knobs.py b/tui_app/knobs.py
new file mode 100644
index 0000000..2f32593
--- /dev/null
+++ b/tui_app/knobs.py
@@ -0,0 +1,276 @@
+from __future__ import annotations
+
+from collections import OrderedDict
+
+ALL_GEN_KNOBS = [
+    "allowed_token_ids",
+    "best_of",
+    "frequency_penalty",
+    "ignore_eos",
+    "include_stop_str_in_output",
+    "length_penalty",
+    "max_new_tokens",
+    "max_time",
+    "min_p",
+    "min_tokens",
+    "no_repeat_ngram_size",
+    "num_beams",
+    "presence_penalty",
+    "prompt_logprobs",
+    "repetition_penalty",
+    "seed",
+    "skip_special_tokens",
+    "spaces_between_special_tokens",
+    "stop_strings",
+    "stop_token_ids",
+    "temperature",
+    "top_k",
+    "top_p",
+    "truncate_prompt_tokens",
+    "typical_p",
+    "use_beam_search",
+]
+
+SUPPORTED_KNOBS = {
+    "hf": {
+        "max_new_tokens",
+        "max_time",
+        "min_p",
+        "no_repeat_ngram_size",
+        "num_beams",
+        "repetition_penalty",
+        "stop_strings",
+        "temperature",
+        "top_k",
+        "top_p",
+        "typical_p",
+    },
+    "gguf": {
+        "max_new_tokens",
+        "min_p",
+        "repetition_penalty",
+        "stop_strings",
+        "temperature",
+        "top_k",
+        "top_p",
+        "typical_p",
+    },
+    "exl2": {
+        "frequency_penalty",
+        "max_new_tokens",
+        "min_p",
+        "presence_penalty",
+        "repetition_penalty",
+        "stop_strings",
+        "temperature",
+        "top_k",
+        "top_p",
+        "typical_p",
+    },
+    "openai": {
+        "max_new_tokens",
+        "seed",
+        "stop_strings",
+        "temperature",
+        "top_p",
+    },
+    "vllm": {
+        "allowed_token_ids",
+        "best_of",
+        "frequency_penalty",
+        "ignore_eos",
+        "include_stop_str_in_output",
+        "length_penalty",
+        "max_new_tokens",
+        "min_p",
+        "min_tokens",
+        "presence_penalty",
+        "prompt_logprobs",
+        "repetition_penalty",
+        "seed",
+        "skip_special_tokens",
+        "spaces_between_special_tokens",
+        "stop_strings",
+        "stop_token_ids",
+        "temperature",
+        "top_k",
+        "top_p",
+        "truncate_prompt_tokens",
+        "use_beam_search",
+    },
+    "ollama": {
+        "max_new_tokens",
+        "stop_strings",
+        "temperature",
+        "top_k",
+        "top_p",
+    },
+}
+
+
+def user_set_keys(args) -> set[str]:
+    cli_overrides = set(getattr(args, "_cli_overrides", set()) or set())
+    config_keys = set(getattr(args, "_config_keys", set()) or set())
+    return cli_overrides | config_keys
+
+
+def unsupported_user_set(args, backend: str) -> list[str]:
+    supported = SUPPORTED_KNOBS.get(backend, set())
+    keys = user_set_keys(args)
+    return sorted(k for k in keys if k in ALL_GEN_KNOBS and k not in supported)
+
+
+def finalize_knob_report(
+    *,
+    sent: dict[str, object],
+    supported: set[str],
+    ignored: list[str] | None = None,
+    notes: list[str] | None = None,
+    mode: str | None = None,
+) -> dict[str, object]:
+    ignored_sorted = sorted(set(ignored or []))
+    sent_sorted = OrderedDict((key, sent[key]) for key in sorted(sent.keys()))
+    deferred_sorted = sorted(key for key in supported if key not in sent_sorted and key not in ignored_sorted)
+    out: dict[str, object] = {
+        "sent": dict(sent_sorted),
+        "deferred": deferred_sorted,
+        "ignored": ignored_sorted,
+    }
+    if mode:
+        out["mode"] = mode
+    note_rows = [str(note) for note in (notes or []) if str(note).strip()]
+    if note_rows:
+        out["notes"] = note_rows
+    return out
+
+
+def build_intent_knobs(args, backend: str) -> dict[str, object]:
+    sent: dict[str, object] = {}
+    if backend == "hf":
+        sent = {
+            "max_new_tokens": args.max_new_tokens,
+            "temperature": args.temperature,
+            "top_p": args.top_p,
+            "repetition_penalty": args.repetition_penalty,
+            "num_beams": args.num_beams,
+            "no_repeat_ngram_size": args.no_repeat_ngram_size,
+        }
+        if args.top_k is not None:
+            sent["top_k"] = args.top_k
+        if args.stop_strings is not None:
+            sent["stop_strings"] = args.stop_strings
+        if args.typical_p is not None:
+            sent["typical_p"] = args.typical_p
+        if args.min_p is not None:
+            sent["min_p"] = args.min_p
+        if args.max_time is not None:
+            sent["max_time"] = args.max_time
+    elif backend == "gguf":
+        sent = {
+            "max_new_tokens": args.max_new_tokens,
+            "temperature": args.temperature,
+            "top_p": args.top_p,
+        }
+        if args.top_k is not None:
+            sent["top_k"] = args.top_k
+        if args.min_p is not None:
+            sent["min_p"] = args.min_p
+        if args.typical_p is not None:
+            sent["typical_p"] = args.typical_p
+        if args.repetition_penalty not in (None, 1.0):
+            sent["repetition_penalty"] = args.repetition_penalty
+        if args.stop_strings is not None:
+            sent["stop_strings"] = args.stop_strings
+    elif backend == "exl2":
+        sent = {
+            "max_new_tokens": args.max_new_tokens,
+            "temperature": args.temperature,
+            "top_p": args.top_p,
+        }
+        if args.top_k is not None:
+            sent["top_k"] = args.top_k
+        if args.min_p is not None:
+            sent["min_p"] = args.min_p
+        if args.typical_p is not None:
+            sent["typical_p"] = args.typical_p
+        if args.repetition_penalty is not None:
+            sent["repetition_penalty"] = args.repetition_penalty
+        if args.frequency_penalty is not None:
+            sent["frequency_penalty"] = args.frequency_penalty
+        if args.presence_penalty is not None:
+            sent["presence_penalty"] = args.presence_penalty
+        if args.stop_strings:
+            sent["stop_strings"] = args.stop_strings
+    elif backend == "openai":
+        user_set = user_set_keys(args)
+        if "max_new_tokens" in user_set and args.max_new_tokens is not None:
+            sent["max_new_tokens"] = args.max_new_tokens
+        if "temperature" in user_set and args.temperature is not None:
+            sent["temperature"] = args.temperature
+        if "top_p" in user_set and args.top_p is not None:
+            sent["top_p"] = args.top_p
+        if args.stop_strings:
+            sent["stop_strings"] = args.stop_strings
+        if args.seed is not None:
+            sent["seed"] = args.seed
+    elif backend == "vllm":
+        user_set = user_set_keys(args)
+        if "max_new_tokens" in user_set and args.max_new_tokens is not None:
+            sent["max_new_tokens"] = args.max_new_tokens
+        if "temperature" in user_set and args.temperature is not None:
+            sent["temperature"] = args.temperature
+        if "top_p" in user_set and args.top_p is not None:
+            sent["top_p"] = args.top_p
+        for key in (
+            "top_k",
+            "min_p",
+            "stop_strings",
+            "stop_token_ids",
+            "repetition_penalty",
+            "presence_penalty",
+            "frequency_penalty",
+            "seed",
+            "truncate_prompt_tokens",
+            "allowed_token_ids",
+            "prompt_logprobs",
+        ):
+            if key not in user_set:
+                continue
+            value = getattr(args, key, None)
+            if value not in (None, [], 0, 0.0):
+                sent[key] = value
+        if args.ignore_eos is True:
+            sent["ignore_eos"] = True
+        if args.min_tokens not in (None, 0):
+            sent["min_tokens"] = args.min_tokens
+        if args.best_of not in (None, 1):
+            sent["best_of"] = args.best_of
+        if args.use_beam_search is True:
+            sent["use_beam_search"] = True
+        if args.length_penalty not in (None, 1.0):
+            sent["length_penalty"] = args.length_penalty
+        if args.include_stop_str_in_output is True:
+            sent["include_stop_str_in_output"] = True
+        if args.skip_special_tokens is False:
+            sent["skip_special_tokens"] = False
+        if args.spaces_between_special_tokens is False:
+            sent["spaces_between_special_tokens"] = False
+    elif backend == "ollama":
+        user_set = user_set_keys(args)
+        if "temperature" in user_set and args.temperature is not None:
+            sent["temperature"] = args.temperature
+        if "top_p" in user_set and args.top_p is not None:
+            sent["top_p"] = args.top_p
+        if "top_k" in user_set and args.top_k is not None:
+            sent["top_k"] = args.top_k
+        if "max_new_tokens" in user_set and args.max_new_tokens is not None:
+            sent["max_new_tokens"] = args.max_new_tokens
+        if "stop_strings" in user_set and args.stop_strings is not None:
+            sent["stop_strings"] = args.stop_strings
+
+    return finalize_knob_report(
+        sent=sent,
+        supported=SUPPORTED_KNOBS.get(backend, set()),
+        ignored=unsupported_user_set(args, backend),
+        mode="intent",
+    )
diff --git a/tui_app/log_file.py b/tui_app/log_file.py
new file mode 100644
index 0000000..84a2ef1
--- /dev/null
+++ b/tui_app/log_file.py
@@ -0,0 +1,229 @@
+from __future__ import annotations
+
+import collections
+import os
+import re
+import threading
+from datetime import datetime, timezone
+from typing import Callable
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+from config_utils import get_machine_run_root, get_runtime_scope
+
+
+_QUERY_SECRET_KEYS = {
+    "access_token",
+    "api_key",
+    "apikey",
+    "auth",
+    "authorization",
+    "bearer",
+    "key",
+    "password",
+    "sig",
+    "signature",
+    "token",
+}
+
+
+class FileLogger:
+    def __init__(
+        self,
+        path: str | None,
+        default_source: str,
+        *,
+        config_path: str | None = None,
+        max_tail: int = 500,
+        max_line_bytes: int = 8 * 1024,
+    ):
+        raw = (path or "").strip()
+        self.path = self._resolve_path(raw, config_path=config_path) if raw else ""
+        self.default_source = (default_source or "backend").strip() or "backend"
+        self.max_line_bytes = max(256, int(max_line_bytes))
+        self._fh = None
+        self._sink_failed = False
+        self._warned_keys: set[str] = set()
+        self._lock = threading.Lock()
+        self._tail: collections.deque[tuple[str, str]] = collections.deque(maxlen=max(1, int(max_tail)))
+        self._subscribers: list[Callable[[str, str], None]] = []
+        self._open_sink()
+
+    @classmethod
+    def from_value(
+        cls,
+        path: str | None,
+        label: str,
+        *,
+        config_path: str | None = None,
+        max_tail: int = 500,
+    ) -> FileLogger:
+        return cls(path, label, config_path=config_path, max_tail=max_tail)
+
+    @staticmethod
+    def _resolve_path(path: str, *, config_path: str | None = None) -> str:
+        expanded = os.path.expanduser(path)
+        if os.path.isabs(expanded):
+            return expanded
+        if config_path:
+            cfg_dir = os.path.dirname(os.path.abspath(config_path))
+            repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+            repo_prefix = repo_root + os.sep
+            if cfg_dir.startswith(repo_prefix):
+                scope = get_runtime_scope(config_path=config_path)
+                return os.path.abspath(
+                    os.path.join(
+                        get_machine_run_root(),
+                        "logs",
+                        scope["backend"],
+                        scope["model"],
+                        scope["slot"],
+                        expanded,
+                    )
+                )
+            if cfg_dir:
+                return os.path.abspath(os.path.join(cfg_dir, expanded))
+        return os.path.abspath(expanded)
+
+    @staticmethod
+    def _ts_utc() -> str:
+        return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+
+    @staticmethod
+    def _normalize_single_line(message: str) -> str:
+        return str(message).replace("\r\n", "\n").replace("\r", "\n").replace("\n", "\\n").strip()
+
+    @staticmethod
+    def _redact_query_secrets(text: str) -> str:
+        def _replace_url(match: re.Match[str]) -> str:
+            raw = match.group(0)
+            try:
+                parts = urlsplit(raw)
+            except Exception:
+                return raw
+            if not parts.query:
+                return raw
+            changed = False
+            query = []
+            for key, value in parse_qsl(parts.query, keep_blank_values=True):
+                if key.lower() in _QUERY_SECRET_KEYS:
+                    query.append((key, "***"))
+                    changed = True
+                else:
+                    query.append((key, value))
+            if not changed:
+                return raw
+            return urlunsplit((parts.scheme, parts.netloc, parts.path, urlencode(query), parts.fragment))
+
+        return re.sub(r"https?://[^\s]+", _replace_url, text)
+
+    @classmethod
+    def _redact(cls, message: str) -> str:
+        text = message
+        text = re.sub(r"data:image/[^;]+;base64,[A-Za-z0-9+/=\s]+", "<image:data_url omitted>", text, flags=re.IGNORECASE)
+        text = re.sub(r"(?i)(authorization\s*[:=]\s*)(bearer\s+)?([^\s,;]+)", r"\1***", text)
+        text = re.sub(
+            r"(?i)\b(openai_api_key|vllm_api_key|api[_-]?key|access_token|token)\b(\s*[:=]\s*)(['\"]?)([^'\"\s,]+)(\3)",
+            r"\1\2\3***\5",
+            text,
+        )
+        text = re.sub(
+            r"(?i)([?&](?:access_token|api[_-]?key|apikey|auth|authorization|bearer|key|password|sig|signature|token)=)([^&#\s]+)",
+            r"\1***",
+            text,
+        )
+        text = cls._redact_query_secrets(text)
+        return text
+
+    def _truncate(self, message: str) -> str:
+        data = message.encode("utf-8", errors="ignore")
+        if len(data) <= self.max_line_bytes:
+            return message
+        marker = "...<truncated>"
+        keep = max(64, self.max_line_bytes - len(marker.encode("utf-8")))
+        trimmed = data[:keep].decode("utf-8", errors="ignore")
+        return trimmed + marker
+
+    def _canonical_message(self, message: str) -> str:
+        normalized = self._normalize_single_line(message)
+        redacted = self._redact(normalized)
+        return self._truncate(redacted)
+
+    def _render_line(self, source: str, message: str) -> str:
+        return f"{self._ts_utc()} [{source}] {message}"
+
+    def _open_sink(self) -> None:
+        if not self.path:
+            return
+        try:
+            parent = os.path.dirname(self.path)
+            if parent:
+                os.makedirs(parent, exist_ok=True)
+            self._fh = open(self.path, "a", encoding="utf-8")
+        except Exception as exc:
+            self._fh = None
+            self._sink_failed = True
+            self.warn_once("sink_open_failed", f"Log file sink disabled: {exc}")
+
+    def log(self, message: str, *, source: str | None = None) -> None:
+        src = (source or self.default_source or "backend").strip() or "backend"
+        canonical_message = self._canonical_message(message)
+        line = self._render_line(src, canonical_message)
+        warn_message = ""
+        subscribers: list[Callable[[str, str], None]] = []
+        with self._lock:
+            self._tail.append((src, line))
+            subscribers = list(self._subscribers)
+            if self._fh is not None:
+                try:
+                    self._fh.write(line + "\n")
+                    self._fh.flush()
+                except Exception as exc:
+                    try:
+                        self._fh.close()
+                    except Exception:
+                        pass
+                    self._fh = None
+                    self._sink_failed = True
+                    warn_message = f"Log file sink disabled after write failure: {exc}"
+        for subscriber in subscribers:
+            try:
+                subscriber(src, canonical_message)
+            except Exception:
+                continue
+        if warn_message:
+            self.warn_once("sink_write_failed", warn_message)
+
+    def subscribe(self, callback: Callable[[str, str], None]) -> None:
+        with self._lock:
+            self._subscribers.append(callback)
+
+    def warn_once(self, key: str, message: str, *, source: str = "app") -> None:
+        with self._lock:
+            if key in self._warned_keys:
+                return
+            self._warned_keys.add(key)
+        self.log(message, source=source)
+
+    def get_recent_logs(self, n: int = 80, sources: list[str] | None = None) -> list[str]:
+        size = max(1, int(n))
+        allowed = {s.strip() for s in (sources or []) if str(s).strip()}
+        with self._lock:
+            data = list(self._tail)
+        if allowed:
+            rows = [line for src, line in data if src in allowed]
+        else:
+            rows = [line for _, line in data]
+        if size >= len(rows):
+            return rows
+        return rows[-size:]
+
+    def list_log_sources(self) -> list[str]:
+        with self._lock:
+            sources = {src for src, _ in self._tail}
+        return sorted(sources)
+
+    def close(self) -> None:
+        with self._lock:
+            if self._fh is not None:
+                self._fh.close()
+                self._fh = None
diff --git a/tui_app/telemetry.py b/tui_app/telemetry.py
new file mode 100644
index 0000000..f8ed9b0
--- /dev/null
+++ b/tui_app/telemetry.py
@@ -0,0 +1,860 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+import threading
+import uuid
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any, Callable
+
+from tui_app.events import TurnRecord
+
+
+def _utc_now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+
+
+def _resolve_path(path: str, *, config_path: str | None = None) -> str:
+    expanded = os.path.expanduser(path)
+    if os.path.isabs(expanded):
+        return expanded
+    if config_path:
+        cfg_dir = os.path.dirname(config_path)
+        if cfg_dir:
+            return os.path.abspath(os.path.join(cfg_dir, expanded))
+    return os.path.abspath(expanded)
+
+
+def _event_id() -> str:
+    return f"evt_{uuid.uuid4().hex}"
+
+
+def _session_id() -> str:
+    return f"sess_{uuid.uuid4().hex}"
+
+
+_WINDOWS_ABS_PATH = re.compile(r"^[A-Za-z]:[\\/]")
+_NVML_LOCK = threading.Lock()
+_NVML_MODULE: Any | None = None
+_NVML_READY = False
+_NVML_INIT_ATTEMPTED = False
+
+
+class TelemetryPublisher:
+    def publish(self, envelope: dict[str, Any]) -> None:
+        raise NotImplementedError
+
+    def close(self) -> None:
+        return None
+
+
+class NoOpTelemetryPublisher(TelemetryPublisher):
+    def publish(self, envelope: dict[str, Any]) -> None:
+        del envelope
+
+
+class JsonlTelemetryPublisher(TelemetryPublisher):
+    def __init__(self, path: str):
+        self.path = path
+        self._lock = threading.Lock()
+        parent = os.path.dirname(path)
+        if parent:
+            os.makedirs(parent, exist_ok=True)
+
+    def publish(self, envelope: dict[str, Any]) -> None:
+        # JSONL framing: one complete event envelope per line, append-only.
+        line = json.dumps(envelope, ensure_ascii=False, separators=(",", ":"), default=str)
+        with self._lock:
+            with open(self.path, "a", encoding="utf-8") as fh:
+                fh.write(line + "\n")
+
+
+def build_publisher(args: Any) -> TelemetryPublisher:
+    path = str(getattr(args, "telemetry_jsonl", "") or "").strip()
+    if not path:
+        return NoOpTelemetryPublisher()
+    return JsonlTelemetryPublisher(_resolve_path(path, config_path=getattr(args, "_config_path", None)))
+
+
+@dataclass
+class TelemetryContext:
+    session_id: str
+    started_at: str
+    backend_name: str
+    resolved_model_id: str
+    resolved_model_id_kind: str
+    model_display_name: str
+    model_display_name_source: str
+    model_path: str | None
+    transport_name: str
+    config_path: str | None
+    profile_name: str
+    publisher: TelemetryPublisher
+    experiment_id: str | None = None
+
+    @property
+    def enabled(self) -> bool:
+        return not isinstance(self.publisher, NoOpTelemetryPublisher)
+
+    @classmethod
+    def create(cls, args: Any, session: Any) -> "TelemetryContext":
+        backend_name = str(getattr(session, "backend_name", getattr(args, "backend", "")) or "")
+        identity = resolve_model_identity(args=args, session=session)
+        transport_name = _transport_name_for_backend(backend_name)
+        return cls(
+            session_id=_session_id(),
+            started_at=_utc_now_iso(),
+            backend_name=backend_name,
+            resolved_model_id=identity.resolved_model_id,
+            resolved_model_id_kind=identity.resolved_model_id_kind,
+            model_display_name=identity.model_display_name,
+            model_display_name_source=identity.model_display_name_source,
+            model_path=identity.model_path,
+            transport_name=transport_name,
+            config_path=getattr(args, "_config_path", None),
+            profile_name=str(getattr(args, "_config_profile", "") or ""),
+            publisher=build_publisher(args),
+        )
+
+    def close(self) -> None:
+        self.publisher.close()
+
+    def publish_event(self, event_type: str, payload: dict[str, Any]) -> None:
+        envelope = {
+            "schema_version": "v1",
+            "event_type": event_type,
+            "event_id": _event_id(),
+            "ts": _utc_now_iso(),
+            "session_id": self.session_id,
+            "payload": payload,
+        }
+        if self.experiment_id:
+            envelope["experiment_id"] = self.experiment_id
+        if self.backend_name:
+            envelope["backend_name"] = self.backend_name
+        if self.resolved_model_id:
+            envelope["resolved_model_id"] = self.resolved_model_id
+        if self.resolved_model_id_kind:
+            envelope["resolved_model_id_kind"] = self.resolved_model_id_kind
+        if self.model_display_name:
+            envelope["model_display_name"] = self.model_display_name
+        if self.model_display_name_source:
+            envelope["model_display_name_source"] = self.model_display_name_source
+        if self.model_path:
+            envelope["model_path"] = self.model_path
+        try:
+            self.publisher.publish(envelope)
+        except Exception:
+            return
+
+    def publish_session_started(self) -> None:
+        payload = {
+            "session_id": self.session_id,
+            "started_at": self.started_at,
+            "ended_at": None,
+            "status": "running",
+            "activity_state": "idle",
+            "activity_state_reason": "session_open_no_request_in_flight",
+            "backend_name": self.backend_name,
+            "transport_name": self.transport_name,
+            "resolved_model_id": self.resolved_model_id,
+            "resolved_model_id_kind": self.resolved_model_id_kind,
+            "model_display_name": self.model_display_name,
+            "model_display_name_source": self.model_display_name_source,
+            "model_path": self.model_path,
+            "config_path": self.config_path,
+            "profile_name": self.profile_name or "",
+        }
+        self.publish_event("session_started", payload)
+
+    def publish_session_finished(self, *, status: str = "finished") -> None:
+        activity_state = "error" if status == "error" else "finished"
+        payload = {
+            "session_id": self.session_id,
+            "started_at": self.started_at,
+            "ended_at": _utc_now_iso(),
+            "status": status,
+            "activity_state": activity_state,
+            "activity_state_reason": f"session_terminal_status_{status or 'finished'}",
+            "backend_name": self.backend_name,
+            "transport_name": self.transport_name,
+            "resolved_model_id": self.resolved_model_id,
+            "resolved_model_id_kind": self.resolved_model_id_kind,
+            "model_display_name": self.model_display_name,
+            "model_display_name_source": self.model_display_name_source,
+            "model_path": self.model_path,
+            "config_path": self.config_path,
+            "profile_name": self.profile_name or "",
+        }
+        self.publish_event("session_finished", payload)
+
+    def publish_error(self, *, scope: str, message: str) -> None:
+        payload = {
+            "session_id": self.session_id,
+            "ts": _utc_now_iso(),
+            "scope": str(scope or "session"),
+            "message": str(message or ""),
+        }
+        self.publish_event("error_reported", payload)
+
+    def publish_log_record(self, *, source: str, message: str) -> None:
+        payload = {
+            "session_id": self.session_id,
+            "ts": _utc_now_iso(),
+            "source": str(source or ""),
+            "message": str(message or ""),
+        }
+        self.publish_event("log_recorded", payload)
+
+    def publish_load_report(self, session: Any, args: Any) -> None:
+        payload = build_load_report_payload(session=session, args=args)
+        if payload:
+            self.publish_event("load_reported", payload)
+
+    def publish_turn_finished(self, *, turn_id: int, record: TurnRecord) -> None:
+        token_counts = dict(record.token_counts or {})
+        timing = dict(record.timing or {})
+        throughput = dict(record.throughput or {})
+        completion_tokens = token_counts.get("completion_tokens")
+        payload: dict[str, Any] = {
+            "session_id": self.session_id,
+            "turn_id": int(turn_id),
+            "started_at": _as_iso(timing.get("start")),
+            "ended_at": _as_iso(timing.get("end")),
+            "streaming_enabled": True,
+        }
+        if isinstance(token_counts.get("prompt_tokens"), int):
+            payload["prompt_tokens"] = int(token_counts["prompt_tokens"])
+        if isinstance(token_counts.get("completion_tokens"), int):
+            payload["completion_tokens"] = int(token_counts["completion_tokens"])
+        if isinstance(token_counts.get("total_tokens"), int):
+            payload["total_tokens"] = int(token_counts["total_tokens"])
+        request_latency = None
+        decode_latency = None
+        if isinstance(timing.get("elapsed"), (int, float)):
+            request_latency = max(0.0, float(timing["elapsed"]))
+            payload["request_latency_seconds"] = request_latency
+        ttft = timing.get("time_to_first_token")
+        if isinstance(ttft, (int, float)):
+            ttft_value = max(0.0, float(ttft))
+            payload["time_to_first_token_seconds"] = ttft_value
+            if request_latency is not None:
+                decode_latency = max(0.0, request_latency - ttft_value)
+                payload["decode_latency_seconds"] = decode_latency
+        stop_reason = record.gen.get("finish_reason") if isinstance(record.gen, dict) else None
+        if stop_reason not in (None, ""):
+            payload["stop_reason"] = stop_reason
+        stop_reason_source = record.gen.get("finish_reason_source") if isinstance(record.gen, dict) else None
+        if stop_reason_source not in (None, ""):
+            payload["stop_reason_source"] = stop_reason_source
+        if record.knobs is not None:
+            payload["knobs"] = record.knobs
+        turn_throughput = _build_turn_throughput_extension(
+            throughput=throughput,
+            completion_tokens=completion_tokens,
+            request_latency=request_latency,
+            decode_latency=decode_latency,
+        )
+        if turn_throughput:
+            payload.setdefault("extension", {})["throughput"] = turn_throughput
+        self.publish_event("turn_finished", payload)
+
+    def publish_runtime_sample(self, payload: dict[str, Any]) -> None:
+        if payload:
+            self.publish_event("runtime_sample", payload)
+
+
+def _transport_name_for_backend(backend_name: str) -> str:
+    if backend_name in {"openai", "vllm"}:
+        return "openai_http"
+    if backend_name == "ollama":
+        return "ollama_http"
+    return "inproc"
+
+
+def _as_iso(value: Any) -> str | None:
+    if isinstance(value, (int, float)):
+        return datetime.fromtimestamp(float(value), tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+    if isinstance(value, str) and value:
+        return value
+    return None
+
+
+def build_load_report_payload(*, session: Any, args: Any) -> dict[str, Any]:
+    describe = getattr(session, "describe", None)
+    info = describe() if callable(describe) else {}
+    if not isinstance(info, dict):
+        info = {}
+    backend_name = str(getattr(session, "backend_name", getattr(args, "backend", "")) or "")
+    identity = resolve_model_identity(args=args, session=session)
+    payload: dict[str, Any] = {
+        "engine_name": backend_name,
+        "model_identifier": identity.resolved_model_id,
+        "model_identifier_kind": identity.resolved_model_id_kind,
+        "model_display_name": identity.model_display_name,
+    }
+    if identity.model_path:
+        payload["model_path"] = identity.model_path
+
+    requested_runtime = _requested_load_runtime_fields(args=args, backend_name=backend_name)
+    confirmed_runtime = _confirmed_load_runtime_fields(info=info)
+    for field_name in (
+        "model_dtype",
+        "kv_cache_dtype",
+        "quantization_type",
+        "attention_backend",
+        "tensor_parallelism",
+        "context_length",
+    ):
+        value = confirmed_runtime.get(field_name)
+        if value not in (None, "", "unknown"):
+            payload[field_name] = value
+
+    memory_footprint = info.get("memory_footprint_bytes")
+    if isinstance(memory_footprint, int):
+        payload["model_weight_bytes"] = int(memory_footprint)
+
+    extension: dict[str, Any] = {}
+    runtime_truth_extension = _build_runtime_truth_extension(
+        requested=requested_runtime,
+        confirmed=confirmed_runtime,
+    )
+    if runtime_truth_extension:
+        extension["runtime_truth"] = runtime_truth_extension
+    if backend_name == "hf":
+        extension["hf"] = {
+            "runtime_device": info.get("runtime_device"),
+            "fully_on_single_gpu": info.get("fully_on_single_gpu"),
+            "modules_on_cpu": info.get("modules_on_cpu"),
+            "modules_on_disk": info.get("modules_on_disk"),
+            "text_only_mode": info.get("text_only_mode"),
+        }
+    elif backend_name == "vllm":
+        extension["vllm"] = {
+            "managed_mode": info.get("managed_mode"),
+            "pid": info.get("pid"),
+            "enable_auto_tool_choice": info.get("enable_auto_tool_choice"),
+            "tool_call_parser": info.get("tool_call_parser"),
+        }
+    elif backend_name == "exl2":
+        extension["exl2"] = dict(info)
+    elif backend_name == "gguf":
+        extension["gguf"] = dict(info)
+    elif backend_name == "ollama":
+        extension["ollama"] = {"host": info.get("host")}
+    elif backend_name == "openai":
+        extension["openai"] = {"base_url": info.get("base_url")}
+    if extension:
+        payload["extension"] = extension
+    return payload
+
+
+def _requested_load_runtime_fields(*, args: Any, backend_name: str) -> dict[str, Any]:
+    payload: dict[str, Any] = {}
+    if backend_name == "hf":
+        dtype = str(getattr(args, "dtype", "") or "").strip()
+        if dtype:
+            payload["model_dtype"] = dtype
+        payload["kv_cache_dtype"] = "none"
+        payload["quantization_type"] = (
+            "8bit"
+            if bool(getattr(args, "use_8bit", False))
+            else "4bit"
+            if bool(getattr(args, "use_4bit", False))
+            else "none"
+        )
+        payload["attention_backend"] = str(getattr(args, "hf_attn_implementation", "") or "default")
+        value = getattr(args, "max_context_tokens", None)
+        if isinstance(value, int) and value > 0:
+            payload["context_length"] = int(value)
+        return payload
+    if backend_name == "vllm":
+        dtype = str(getattr(args, "vllm_dtype", "") or "").strip()
+        if dtype:
+            payload["model_dtype"] = dtype
+        payload["attention_backend"] = str(getattr(args, "vllm_attention_backend", "") or "auto")
+        value = int(getattr(args, "vllm_tensor_parallel_size", 0) or 0)
+        if value > 0:
+            payload["tensor_parallelism"] = value
+        value = int(getattr(args, "vllm_max_model_len", 0) or 0)
+        if value > 0:
+            payload["context_length"] = value
+        return payload
+    if backend_name == "gguf":
+        payload["quantization_type"] = "gguf"
+        payload["kv_cache_dtype"] = "none"
+        value = int(getattr(args, "n_ctx", 0) or 0)
+        if value > 0:
+            payload["context_length"] = value
+        return payload
+    if backend_name == "exl2":
+        payload["quantization_type"] = "exl2"
+        payload["kv_cache_dtype"] = str(getattr(args, "cache_type", "") or "").strip() or "fp16"
+        value = int(getattr(args, "max_seq_len", 0) or 0)
+        if value > 0:
+            payload["context_length"] = value
+        return payload
+    return payload
+
+
+def _confirmed_load_runtime_fields(*, info: dict[str, Any]) -> dict[str, Any]:
+    payload: dict[str, Any] = {}
+
+    model_dtype = _first_known(
+        info.get("torch_dtype_effective"),
+        info.get("model_dtype_effective"),
+        info.get("model_dtype"),
+        info.get("vllm_dtype_effective"),
+    )
+    if model_dtype is not None:
+        payload["model_dtype"] = model_dtype
+
+    kv_dtype = _first_known(
+        info.get("kv_cache_dtype_effective"),
+        info.get("kv_cache_quantization_effective"),
+        info.get("kv_cache_quantization"),
+    )
+    if kv_dtype is not None:
+        payload["kv_cache_dtype"] = kv_dtype
+
+    quantization = _first_known(
+        info.get("weights_quantization_effective"),
+        info.get("weights_quantization"),
+        info.get("quantization_type"),
+    )
+    if quantization is not None:
+        payload["quantization_type"] = quantization
+
+    attention_backend = _first_known(
+        info.get("attention_backend_effective"),
+        info.get("attention_backend_runtime"),
+        info.get("attention_backend"),
+    )
+    if attention_backend is not None:
+        payload["attention_backend"] = attention_backend
+
+    tensor_parallelism = _first_positive_int(
+        info.get("tensor_parallelism_effective"),
+        info.get("tensor_parallel_size_effective"),
+        info.get("tensor_parallelism"),
+        info.get("tensor_parallel_size"),
+    )
+    if tensor_parallelism is not None:
+        payload["tensor_parallelism"] = tensor_parallelism
+
+    context_length = _first_positive_int(
+        info.get("context_length_effective"),
+        info.get("max_model_len_effective"),
+        info.get("max_seq_len_effective"),
+        info.get("context_window"),
+    )
+    if context_length is not None:
+        payload["context_length"] = context_length
+
+    return payload
+
+
+def _build_runtime_truth_extension(*, requested: dict[str, Any], confirmed: dict[str, Any]) -> dict[str, Any]:
+    payload: dict[str, Any] = {}
+    if requested:
+        payload["requested"] = requested
+    if confirmed:
+        payload["confirmed"] = confirmed
+    mismatches: dict[str, dict[str, Any]] = {}
+    unconfirmed_requested: list[str] = []
+    for key, requested_value in requested.items():
+        if not _is_concrete_requested_value(requested_value):
+            continue
+        confirmed_value = confirmed.get(key)
+        if confirmed_value is None:
+            unconfirmed_requested.append(key)
+            continue
+        if confirmed_value != requested_value:
+            mismatches[key] = {
+                "requested": requested_value,
+                "confirmed": confirmed_value,
+            }
+    if mismatches:
+        payload["mismatches"] = mismatches
+    if unconfirmed_requested:
+        payload["unconfirmed_requested"] = sorted(unconfirmed_requested)
+    return payload
+
+
+def _is_concrete_requested_value(value: Any) -> bool:
+    if value in (None, "", "auto", "default", "model_default", "server_default", "server_managed", "(unset)"):
+        return False
+    return True
+
+
+def _first_known(*values: Any) -> Any | None:
+    for value in values:
+        if value not in (None, "", "unknown"):
+            return value
+    return None
+
+
+def _first_positive_int(*values: Any) -> int | None:
+    for value in values:
+        if isinstance(value, bool):
+            continue
+        if isinstance(value, int) and value > 0:
+            return int(value)
+        if isinstance(value, str) and value.isdigit():
+            parsed = int(value)
+            if parsed > 0:
+                return parsed
+    return None
+
+
+def _build_turn_throughput_extension(
+    *,
+    throughput: dict[str, Any],
+    completion_tokens: Any,
+    request_latency: float | None,
+    decode_latency: float | None,
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {}
+    completion_token_count = int(completion_tokens) if isinstance(completion_tokens, int) and completion_tokens >= 0 else None
+    legacy_tokens_per_second = throughput.get("tokens_per_s")
+    if isinstance(legacy_tokens_per_second, (int, float)):
+        payload["legacy_tokens_per_second"] = float(legacy_tokens_per_second)
+        if completion_token_count is not None and request_latency is not None and request_latency > 0:
+            payload["legacy_measurement_basis"] = "completion_tokens_div_request_latency_seconds"
+    if completion_token_count is not None and decode_latency is not None and decode_latency > 0:
+        payload["raw_completion_tokens_per_second"] = float(completion_token_count / decode_latency)
+        payload["raw_measurement_basis"] = "completion_tokens_div_decode_latency_seconds"
+    else:
+        payload["raw_measurement_state"] = "unavailable"
+        payload["raw_unavailable_reason"] = "decode_latency_missing"
+    if completion_token_count is not None and request_latency is not None and request_latency > 0:
+        payload["effective_completion_tokens_per_second"] = float(completion_token_count / request_latency)
+        payload["effective_measurement_basis"] = "completion_tokens_div_request_latency_seconds"
+    else:
+        payload["effective_measurement_state"] = "unavailable"
+        payload["effective_unavailable_reason"] = "request_latency_or_completion_tokens_missing"
+    return payload
+
+
+def build_runtime_sample_payload(
+    *,
+    telemetry: TelemetryContext,
+    session: Any,
+    generated_tokens: int,
+    elapsed_s: float,
+    requests_completed_total: int,
+    requests_in_flight: int,
+) -> dict[str, Any]:
+    requests_in_flight_count = int(max(0, requests_in_flight))
+    payload: dict[str, Any] = {
+        "session_id": telemetry.session_id,
+        "ts": _utc_now_iso(),
+        "activity_state": _activity_state_for_requests(requests_in_flight_count),
+        "activity_state_reason": _activity_state_reason_for_requests(requests_in_flight_count),
+    }
+    groups: dict[str, Any] = {}
+
+    describe = getattr(session, "describe", None)
+    info = describe() if callable(describe) else {}
+    if not isinstance(info, dict):
+        info = {}
+
+    gpu_group: dict[str, Any] = {}
+    memory_group: dict[str, Any] = {}
+    runtime_device = str(info.get("runtime_device") or "")
+    try:
+        import torch  # type: ignore
+
+        cuda_index = None
+        if runtime_device.startswith("cuda:"):
+            cuda_index = int(runtime_device.split(":", 1)[1])
+        elif runtime_device == "cuda" and torch.cuda.is_available():
+            cuda_index = int(torch.cuda.current_device())
+        if cuda_index is not None and torch.cuda.is_available():
+            free_bytes, total_bytes = torch.cuda.mem_get_info(cuda_index)
+            used_bytes = int(total_bytes - free_bytes)
+            gpu_group.update(
+                {
+                    "vram_total_bytes": int(total_bytes),
+                    "vram_used_bytes": used_bytes,
+                    "vram_free_bytes": int(free_bytes),
+                }
+            )
+            gpu_group.update(_read_nvml_gpu_metrics(cuda_index))
+            try:
+                memory_group["torch_cuda_memory_allocated_bytes"] = int(torch.cuda.memory_allocated(cuda_index))
+                memory_group["torch_cuda_memory_reserved_bytes"] = int(torch.cuda.memory_reserved(cuda_index))
+                memory_group["torch_cuda_max_allocated_bytes"] = int(torch.cuda.max_memory_allocated(cuda_index))
+            except Exception:
+                pass
+    except Exception:
+        pass
+
+    groups["gpu"] = _finalize_gpu_group(gpu_metrics=gpu_group, runtime_device=runtime_device)
+    if memory_group:
+        groups["memory"] = memory_group
+
+    groups["kv_cache"] = _build_kv_cache_group(info)
+    groups["throughput"] = _build_throughput_group(
+        requests_in_flight=requests_in_flight_count,
+        generated_tokens=generated_tokens,
+        elapsed_s=elapsed_s,
+    )
+    groups["requests"] = {
+        "requests_completed_total": int(max(0, requests_completed_total)),
+        "requests_in_flight": requests_in_flight_count,
+        "activity_state": "in_flight" if requests_in_flight_count > 0 else "idle",
+    }
+    payload.update(groups)
+    return payload
+
+
+def attach_log_subscribers(session: Any, callback: Callable[[str, str], None]) -> None:
+    seen: set[int] = set()
+
+    def _attach(logger: Any) -> None:
+        if logger is None:
+            return
+        marker = id(logger)
+        if marker in seen:
+            return
+        seen.add(marker)
+        subscribe = getattr(logger, "subscribe", None)
+        if callable(subscribe):
+            subscribe(callback)
+
+    _attach(getattr(session, "logger", None))
+    transport = getattr(session, "_transport", None)
+    if transport is not None:
+        _attach(getattr(transport, "logger", None))
+
+
+@dataclass(frozen=True)
+class ModelIdentity:
+    resolved_model_id: str
+    resolved_model_id_kind: str
+    model_display_name: str
+    model_display_name_source: str
+    model_path: str | None = None
+
+
+def resolve_model_identity(*, args: Any, session: Any) -> ModelIdentity:
+    resolved_model_id = str(getattr(session, "resolved_model_id", getattr(args, "model_id", "")) or "").strip()
+    model_path = _normalize_model_path(resolved_model_id) if _looks_like_local_path(resolved_model_id) else None
+    display_name = ""
+    display_name_source = ""
+
+    configured_display_name = str(getattr(args, "display_name", "") or "").strip()
+    if configured_display_name:
+        display_name = configured_display_name
+        display_name_source = "config_display_name"
+    else:
+        config_model_name = _model_name_from_config_path(getattr(args, "_config_path", None))
+        if config_model_name:
+            display_name = config_model_name
+            display_name_source = "config_model_dir"
+        elif resolved_model_id and not model_path:
+            display_name = resolved_model_id
+            display_name_source = "resolved_model_id"
+        elif model_path:
+            display_name = os.path.basename(model_path.rstrip("/\\")) or model_path
+            display_name_source = "path_basename"
+
+    return ModelIdentity(
+        resolved_model_id=resolved_model_id,
+        resolved_model_id_kind="path" if model_path else "model_id",
+        model_display_name=display_name,
+        model_display_name_source=display_name_source,
+        model_path=model_path,
+    )
+
+
+def _model_name_from_config_path(config_path: str | None) -> str:
+    if not config_path:
+        return ""
+    parts = os.path.normpath(str(config_path)).split(os.sep)
+    try:
+        idx = parts.index("models")
+    except ValueError:
+        return ""
+    if idx + 1 >= len(parts):
+        return ""
+    return str(parts[idx + 1] or "")
+
+
+def _normalize_model_path(value: str) -> str:
+    expanded = os.path.expanduser(value.strip())
+    if _WINDOWS_ABS_PATH.match(expanded):
+        drive = expanded[0].lower()
+        rest = expanded[2:].lstrip("\\/").replace("\\", "/")
+        expanded = f"/mnt/{drive}/{rest}"
+    if os.path.isabs(expanded) or os.path.exists(expanded):
+        return os.path.abspath(expanded)
+    return expanded
+
+
+def _looks_like_local_path(value: str) -> bool:
+    text = str(value or "").strip()
+    if not text:
+        return False
+    expanded = os.path.expanduser(text)
+    return bool(
+        os.path.isabs(expanded)
+        or expanded.startswith((".", "~"))
+        or _WINDOWS_ABS_PATH.match(expanded)
+        or expanded.lower().endswith(".gguf")
+        or os.path.exists(expanded)
+    )
+
+
+def _build_throughput_group(*, requests_in_flight: int, generated_tokens: int, elapsed_s: float) -> dict[str, Any]:
+    if int(max(0, requests_in_flight)) <= 0:
+        return {
+            "reported_speed_type": "raw_completion",
+            "measurement_state": "idle",
+            "trust_level": "unavailable",
+            "trust_reason": "no_active_generation",
+            "effective_measurement_state": "unavailable",
+            "effective_unavailable_reason": "end_to_end_request_speed_not_available_without_active_generation",
+        }
+
+    payload: dict[str, Any] = {
+        "reported_speed_type": "raw_completion",
+        "measurement_state": "active_generation",
+        "measurement_basis": "current_turn_completion_tokens_div_elapsed_seconds",
+        "trust_level": "provisional",
+        "trust_reason": "derived_from_streamed_completion_tokens_and_local_elapsed_time",
+        "effective_measurement_state": "unavailable",
+        "effective_unavailable_reason": "end_to_end_request_speed_not_known_until_turn_completion",
+        "tokens_generated_total": int(max(0, generated_tokens)),
+    }
+    if elapsed_s > 0:
+        payload["sample_window_seconds"] = float(elapsed_s)
+        payload["tokens_generated_per_second"] = float(generated_tokens / elapsed_s)
+    return payload
+
+
+def _build_kv_cache_group(info: dict[str, Any]) -> dict[str, Any]:
+    payload: dict[str, Any] = {}
+    numeric_fields = {
+        "total_bytes": info.get("kv_cache_total_bytes"),
+        "used_bytes": info.get("kv_cache_used_bytes"),
+        "utilization_ratio": info.get("kv_cache_utilization_ratio"),
+        "block_size": info.get("kv_cache_block_size"),
+        "sequence_count": info.get("kv_cache_sequence_count"),
+    }
+    for key, value in numeric_fields.items():
+        if isinstance(value, bool):
+            continue
+        if isinstance(value, int):
+            payload[key] = int(value)
+        elif isinstance(value, float):
+            payload[key] = float(value)
+    if "utilization_ratio" not in payload:
+        total_bytes = payload.get("total_bytes")
+        used_bytes = payload.get("used_bytes")
+        if isinstance(total_bytes, int) and total_bytes > 0 and isinstance(used_bytes, int) and used_bytes >= 0:
+            payload["utilization_ratio"] = float(used_bytes / total_bytes)
+    if payload:
+        payload["measurement_state"] = "available"
+        return payload
+    return {
+        "measurement_state": "unavailable",
+        "unavailable_reason": "backend_does_not_report_kv_cache_runtime_usage",
+    }
+
+
+def _activity_state_for_requests(requests_in_flight: int) -> str:
+    return "generating" if int(max(0, requests_in_flight)) > 0 else "idle"
+
+
+def _activity_state_reason_for_requests(requests_in_flight: int) -> str:
+    if int(max(0, requests_in_flight)) > 0:
+        return "requests_in_flight_positive"
+    return "no_requests_in_flight"
+
+
+def _finalize_gpu_group(*, gpu_metrics: dict[str, Any], runtime_device: str) -> dict[str, Any]:
+    if not runtime_device or not (runtime_device == "cuda" or runtime_device.startswith("cuda:")):
+        return {
+            "measurement_state": "unavailable",
+            "unavailable_reason": "session_not_running_on_cuda",
+            "diagnosis_state": "unavailable",
+            "diagnosis_reason": "gpu_not_active_for_this_session",
+        }
+
+    payload = dict(gpu_metrics)
+    if not payload:
+        return {
+            "measurement_state": "unavailable",
+            "unavailable_reason": "cuda_metrics_collection_failed",
+            "diagnosis_state": "incomplete",
+            "diagnosis_reason": "gpu_runtime_metrics_unavailable_for_operator_diagnosis",
+        }
+
+    has_memory_view = all(key in payload for key in ("vram_total_bytes", "vram_used_bytes", "vram_free_bytes"))
+    has_utilization_view = "utilization_percent" in payload
+    payload["measurement_state"] = "available" if has_memory_view and has_utilization_view else "partial"
+    payload["diagnosis_state"] = "incomplete"
+    payload["diagnosis_reason"] = "gpu_runtime_metrics_do_not_cover_compute_memory_queue_interpretation"
+    return payload
+
+
+def _read_nvml_gpu_metrics(cuda_index: int) -> dict[str, Any]:
+    metrics: dict[str, Any] = {}
+    pynvml = _load_pynvml()
+    if pynvml is None:
+        return metrics
+    try:
+        handle = pynvml.nvmlDeviceGetHandleByIndex(int(cuda_index))
+    except Exception:
+        return metrics
+
+    try:
+        utilization = pynvml.nvmlDeviceGetUtilizationRates(handle)
+        gpu_util = getattr(utilization, "gpu", None)
+        if gpu_util is not None:
+            metrics["utilization_percent"] = float(gpu_util)
+    except Exception:
+        pass
+
+    try:
+        power_mw = pynvml.nvmlDeviceGetPowerUsage(handle)
+        metrics["power_usage_watts"] = float(power_mw) / 1000.0
+    except Exception:
+        pass
+
+    try:
+        temp_c = pynvml.nvmlDeviceGetTemperature(handle, pynvml.NVML_TEMPERATURE_GPU)
+        metrics["temperature_celsius"] = int(temp_c)
+    except Exception:
+        pass
+
+    return metrics
+
+
+def _load_pynvml() -> Any | None:
+    global _NVML_MODULE, _NVML_READY, _NVML_INIT_ATTEMPTED
+    if _NVML_READY:
+        return _NVML_MODULE
+    if _NVML_INIT_ATTEMPTED:
+        return None
+    with _NVML_LOCK:
+        if _NVML_READY:
+            return _NVML_MODULE
+        if _NVML_INIT_ATTEMPTED:
+            return None
+        _NVML_INIT_ATTEMPTED = True
+        try:
+            import pynvml  # type: ignore
+
+            pynvml.nvmlInit()
+            _NVML_MODULE = pynvml
+            _NVML_READY = True
+            return _NVML_MODULE
+        except Exception:
+            _NVML_MODULE = None
+            _NVML_READY = False
+            return None
diff --git a/tui_app/tools/__init__.py b/tui_app/tools/__init__.py
new file mode 100644
index 0000000..cb2fe1e
--- /dev/null
+++ b/tui_app/tools/__init__.py
@@ -0,0 +1,3 @@
+from .runtime import ToolRuntime, build_tool_runtime
+
+__all__ = ["ToolRuntime", "build_tool_runtime"]
diff --git a/tui_app/tools/runtime.py b/tui_app/tools/runtime.py
new file mode 100644
index 0000000..cda8b98
--- /dev/null
+++ b/tui_app/tools/runtime.py
@@ -0,0 +1,391 @@
+from __future__ import annotations
+
+import ast
+import json
+import math
+import os
+from concurrent.futures import ThreadPoolExecutor, TimeoutError as FutureTimeoutError
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Callable
+from zoneinfo import ZoneInfo
+
+
+def _resolve_path(path: str, config_path: str | None = None) -> str:
+    expanded = os.path.expanduser(path)
+    if os.path.isabs(expanded):
+        return expanded
+    if config_path:
+        cfg_dir = os.path.dirname(config_path)
+        candidate = os.path.abspath(os.path.join(cfg_dir, expanded))
+        if os.path.exists(candidate):
+            return candidate
+    return os.path.abspath(expanded)
+
+
+def _truncate_text(text: str, max_chars: int) -> str:
+    limit = max(1, int(max_chars))
+    if len(text) <= limit:
+        return text
+    marker = "...(truncated)"
+    keep = max(1, limit - len(marker))
+    return text[:keep] + marker
+
+
+class _SafeCalcEvaluator:
+    _MAX_EXPR_LEN = 200
+    _MAX_DEPTH = 32
+    _MAX_ABS_EXPONENT = 12
+    _MAX_ABS_NUMBER = 10**12
+
+    def eval(self, expression: str) -> str:
+        expr = (expression or "").strip()
+        if not expr:
+            raise ValueError("expression is required")
+        if len(expr) > self._MAX_EXPR_LEN:
+            raise ValueError(f"expression too long (max {self._MAX_EXPR_LEN} chars)")
+        tree = ast.parse(expr, mode="eval")
+        value = self._visit(tree.body, depth=0)
+        if isinstance(value, float) and value.is_integer():
+            return str(int(value))
+        return str(value)
+
+    def _visit(self, node: ast.AST, *, depth: int) -> float | int:
+        if depth > self._MAX_DEPTH:
+            raise ValueError("expression too deep")
+
+        if isinstance(node, ast.Constant):
+            if not isinstance(node.value, (int, float)) or isinstance(node.value, bool):
+                raise ValueError("only numeric literals are allowed")
+            return self._validate_number(node.value)
+
+        if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.UAdd, ast.USub)):
+            value = self._visit(node.operand, depth=depth + 1)
+            out = +value if isinstance(node.op, ast.UAdd) else -value
+            return self._validate_number(out)
+
+        if isinstance(node, ast.BinOp) and isinstance(
+            node.op,
+            (ast.Add, ast.Sub, ast.Mult, ast.Div, ast.FloorDiv, ast.Mod, ast.Pow),
+        ):
+            left = self._visit(node.left, depth=depth + 1)
+            right = self._visit(node.right, depth=depth + 1)
+            if isinstance(node.op, ast.Add):
+                return self._validate_number(left + right)
+            if isinstance(node.op, ast.Sub):
+                return self._validate_number(left - right)
+            if isinstance(node.op, ast.Mult):
+                return self._validate_number(left * right)
+            if isinstance(node.op, ast.Div):
+                return self._validate_number(left / right)
+            if isinstance(node.op, ast.FloorDiv):
+                return self._validate_number(left // right)
+            if isinstance(node.op, ast.Mod):
+                return self._validate_number(left % right)
+            if isinstance(node.op, ast.Pow):
+                if abs(right) > self._MAX_ABS_EXPONENT:
+                    raise ValueError("exponent too large")
+                return self._validate_number(left**right)
+
+        raise ValueError("unsupported expression")
+
+    def _validate_number(self, value: float | int) -> float | int:
+        if isinstance(value, bool):
+            raise ValueError("unsupported value")
+        if not math.isfinite(float(value)):
+            raise ValueError("non-finite result")
+        if abs(float(value)) > self._MAX_ABS_NUMBER:
+            raise ValueError("result too large")
+        return value
+
+
+_SAFE_CALC = _SafeCalcEvaluator()
+
+
+@dataclass
+class ToolDefinition:
+    name: str
+    schema: dict[str, object]
+    handler: Callable[[dict[str, object]], str] | None
+    source: str
+
+
+@dataclass
+class ToolRuntime:
+    backend_name: str
+    enabled: bool
+    mode: str
+    schema_file: str
+    tool_choice: str
+    allow: list[str]
+    deny: list[str]
+    max_calls_per_turn: int
+    timeout_s: float
+    max_result_chars: int
+    supported_backend: bool
+    available_tools: dict[str, ToolDefinition]
+    exposed_tools: dict[str, ToolDefinition]
+
+    def exposed_schema(self) -> list[dict[str, object]]:
+        return [tool.schema for tool in self.exposed_tools.values()]
+
+    def tool_names(self) -> list[str]:
+        return list(self.exposed_tools.keys())
+
+    def get_tool(self, name: str) -> ToolDefinition | None:
+        return self.exposed_tools.get((name or "").strip())
+
+    def describe(self, *, verbose: bool = False) -> dict[str, object]:
+        data: dict[str, object] = {
+            "backend": self.backend_name,
+            "supported_backend": self.supported_backend,
+            "enabled": self.enabled,
+            "mode": self.mode,
+            "schema_file": self.schema_file or "",
+            "tool_choice": self.tool_choice or "",
+            "allow": list(self.allow),
+            "deny": list(self.deny),
+            "max_calls_per_turn": self.max_calls_per_turn,
+            "timeout_s": self.timeout_s,
+            "max_result_chars": self.max_result_chars,
+            "tool_names": self.tool_names(),
+        }
+        if verbose:
+            data["available_tools"] = {
+                name: {
+                    "source": tool.source,
+                    "executable": bool(tool.handler),
+                }
+                for name, tool in self.available_tools.items()
+            }
+        return data
+
+    def execute(
+        self,
+        *,
+        name: str,
+        arguments_raw: str,
+        denied_by_policy: bool = False,
+    ) -> dict[str, object]:
+        item: dict[str, object] = {
+            "name": name,
+            "arguments_raw": arguments_raw,
+            "arguments_json": None,
+            "status": "received",
+            "result": None,
+            "error": None,
+        }
+        if denied_by_policy:
+            item["status"] = "denied_by_policy"
+            item["error"] = "Tool call denied by policy."
+            item["result"] = _truncate_text(str(item["error"]), self.max_result_chars)
+            return item
+
+        tool = self.get_tool(name)
+        if tool is None:
+            item["status"] = "tool_unavailable"
+            item["error"] = f"Tool '{name}' is unavailable."
+            item["result"] = _truncate_text(str(item["error"]), self.max_result_chars)
+            return item
+
+        try:
+            parsed = json.loads(arguments_raw or "{}")
+        except Exception as exc:
+            item["status"] = "invalid_arguments"
+            item["error"] = f"Invalid tool arguments JSON: {exc}"
+            item["result"] = _truncate_text(str(item["error"]), self.max_result_chars)
+            return item
+
+        if not isinstance(parsed, dict):
+            item["status"] = "invalid_arguments"
+            item["error"] = "Tool arguments must decode to a JSON object."
+            item["result"] = _truncate_text(str(item["error"]), self.max_result_chars)
+            return item
+
+        item["arguments_json"] = parsed
+        if self.mode != "execute":
+            item["status"] = "dry_run"
+            return item
+
+        if tool.handler is None:
+            item["status"] = "tool_unavailable"
+            item["error"] = f"Tool '{name}' is not executable in this repo."
+            item["result"] = _truncate_text(str(item["error"]), self.max_result_chars)
+            return item
+
+        def _call() -> str:
+            return str(tool.handler(parsed))
+
+        with ThreadPoolExecutor(max_workers=1) as pool:
+            future = pool.submit(_call)
+            try:
+                raw_result = future.result(timeout=max(0.1, self.timeout_s))
+            except FutureTimeoutError:
+                future.cancel()
+                item["status"] = "timeout"
+                item["error"] = f"Tool '{name}' timed out after {self.timeout_s:.1f}s."
+                item["result"] = _truncate_text(str(item["error"]), self.max_result_chars)
+                return item
+            except Exception as exc:
+                item["status"] = "execute_error"
+                item["error"] = str(exc)
+                item["result"] = _truncate_text(str(exc), self.max_result_chars)
+                return item
+
+        item["status"] = "executed"
+        item["result"] = _truncate_text(raw_result, self.max_result_chars)
+        return item
+
+
+def _builtin_tool_schemas() -> list[ToolDefinition]:
+    def calc_tool(arguments: dict[str, object]) -> str:
+        return _SAFE_CALC.eval(str(arguments.get("expression", "") or ""))
+
+    def get_time_tool(arguments: dict[str, object]) -> str:
+        tz = str(arguments.get("tz", "America/Denver") or "America/Denver")
+        now = datetime.now(ZoneInfo(tz))
+        return now.isoformat()
+
+    def echo_tool(arguments: dict[str, object]) -> str:
+        return str(arguments.get("text", "") or "")
+
+    return [
+        ToolDefinition(
+            name="calc",
+            source="builtin",
+            handler=calc_tool,
+            schema={
+                "type": "function",
+                "function": {
+                    "name": "calc",
+                    "description": "Evaluate a simple arithmetic expression safely.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "expression": {"type": "string", "description": "Arithmetic expression to evaluate."}
+                        },
+                        "required": ["expression"],
+                        "additionalProperties": False,
+                    },
+                },
+            },
+        ),
+        ToolDefinition(
+            name="get_time",
+            source="builtin",
+            handler=get_time_tool,
+            schema={
+                "type": "function",
+                "function": {
+                    "name": "get_time",
+                    "description": "Return the current time for an IANA timezone.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "tz": {
+                                "type": "string",
+                                "description": "IANA timezone name like America/Denver.",
+                                "default": "America/Denver",
+                            }
+                        },
+                        "additionalProperties": False,
+                    },
+                },
+            },
+        ),
+        ToolDefinition(
+            name="echo",
+            source="builtin",
+            handler=echo_tool,
+            schema={
+                "type": "function",
+                "function": {
+                    "name": "echo",
+                    "description": "Return the provided text unchanged.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {"text": {"type": "string"}},
+                        "required": ["text"],
+                        "additionalProperties": False,
+                    },
+                },
+            },
+        ),
+    ]
+
+
+def _load_schema_file(schema_file: str, *, config_path: str | None) -> list[ToolDefinition]:
+    if not schema_file:
+        return []
+    resolved = _resolve_path(schema_file, config_path=config_path)
+    with open(resolved, "rb") as fh:
+        data = json.loads(fh.read().decode("utf-8"))
+    tools_obj = data.get("tools") if isinstance(data, dict) else data
+    if not isinstance(tools_obj, list):
+        raise RuntimeError(f"Tool schema file must contain a tools list: {resolved}")
+    out: list[ToolDefinition] = []
+    for item in tools_obj:
+        if not isinstance(item, dict):
+            raise RuntimeError(f"Invalid tool schema entry in {resolved}: expected object")
+        if item.get("type") != "function":
+            raise RuntimeError(f"Unsupported tool schema type in {resolved}: {item.get('type')!r}")
+        function = item.get("function")
+        if not isinstance(function, dict):
+            raise RuntimeError(f"Invalid function tool schema in {resolved}")
+        name = str(function.get("name", "") or "").strip()
+        if not name:
+            raise RuntimeError(f"Function tool missing name in {resolved}")
+        out.append(ToolDefinition(name=name, schema=item, handler=None, source=resolved))
+    return out
+
+
+def build_tool_runtime(args, backend_name: str) -> ToolRuntime:
+    mode = str(getattr(args, "tools_mode", "dry_run") or "dry_run").strip().lower()
+    if mode not in {"off", "dry_run", "execute"}:
+        raise RuntimeError(f"Invalid tools.mode: {mode!r}")
+    enabled = bool(getattr(args, "tools_enabled", False)) and mode != "off"
+    supported_backend = backend_name in {"openai", "vllm"}
+    schema_file = str(getattr(args, "tools_schema_file", "") or "").strip()
+    allow = [str(x).strip() for x in (getattr(args, "tools_allow", []) or []) if str(x).strip()]
+    deny = [str(x).strip() for x in (getattr(args, "tools_deny", []) or []) if str(x).strip()]
+
+    tool_defs = _builtin_tool_schemas() + _load_schema_file(
+        schema_file,
+        config_path=getattr(args, "_config_path", None),
+    )
+
+    collisions: dict[str, list[str]] = {}
+    for tool in tool_defs:
+        collisions.setdefault(tool.name, []).append(tool.source)
+    dupes = sorted(name for name, sources in collisions.items() if len(sources) > 1)
+    if dupes:
+        parts = [f"{name} ({', '.join(collisions[name])})" for name in dupes]
+        raise RuntimeError("Tool schema name collision(s): " + "; ".join(parts))
+
+    available = {tool.name: tool for tool in sorted(tool_defs, key=lambda item: item.name)}
+    allow_lower = {name.lower() for name in allow}
+    deny_lower = {name.lower() for name in deny}
+    exposed: dict[str, ToolDefinition] = {}
+    for name, tool in available.items():
+        lowered = name.lower()
+        if allow_lower and lowered not in allow_lower:
+            continue
+        if lowered in deny_lower:
+            continue
+        exposed[name] = tool
+
+    return ToolRuntime(
+        backend_name=backend_name,
+        enabled=enabled,
+        mode=mode,
+        schema_file=_resolve_path(schema_file, config_path=getattr(args, "_config_path", None)) if schema_file else "",
+        tool_choice=str(getattr(args, "tools_tool_choice", "") or "").strip(),
+        allow=allow,
+        deny=deny,
+        max_calls_per_turn=max(1, int(getattr(args, "tools_max_calls_per_turn", 3) or 3)),
+        timeout_s=float(getattr(args, "tools_timeout_s", 10) or 10),
+        max_result_chars=max(1, int(getattr(args, "tools_max_result_chars", 8000) or 8000)),
+        supported_backend=supported_backend,
+        available_tools=available,
+        exposed_tools=exposed,
+    )
diff --git a/tui_app/transports/__init__.py b/tui_app/transports/__init__.py
new file mode 100644
index 0000000..dbd9389
--- /dev/null
+++ b/tui_app/transports/__init__.py
@@ -0,0 +1,3 @@
+from tui_app.transports.openai_http import OpenAIHTTPSession, normalize_openai_base_url, resolve_model_once
+
+__all__ = ["OpenAIHTTPSession", "normalize_openai_base_url", "resolve_model_once"]
diff --git a/tui_app/transports/openai_http.py b/tui_app/transports/openai_http.py
new file mode 100644
index 0000000..893c98a
--- /dev/null
+++ b/tui_app/transports/openai_http.py
@@ -0,0 +1,1164 @@
+from __future__ import annotations
+
+import argparse
+import base64
+import json
+import mimetypes
+import os
+import re
+import time
+import urllib.error
+import urllib.request
+from copy import deepcopy
+
+from tui_app.backends.base import EventEmitter
+from tui_app.context_policy import (
+    build_context_limit_error,
+    build_retry_report,
+    drop_oldest_history_message,
+    is_context_overflow_text,
+    reserve_generation_tokens,
+)
+from tui_app.events import AnswerDelta, Error, Finish, Meta, ThinkDelta, TurnRecord, TurnStart
+from tui_app.history_control import append_assistant_history
+from tui_app.knobs import SUPPORTED_KNOBS, finalize_knob_report, unsupported_user_set
+from tui_app.log_file import FileLogger
+from tui_app.think_router import ThinkRouter
+from tui_app.tools import build_tool_runtime
+
+MAX_IMAGE_BYTES = 10 * 1024 * 1024
+MAX_TOTAL_IMAGE_BYTES = 20 * 1024 * 1024
+MAX_CAPTURE_BYTES = 256 * 1024
+
+
+def _safe_json_snippet(value: object, limit: int = 4096) -> str:
+    try:
+        text = json.dumps(value, ensure_ascii=False, default=str)
+    except Exception:
+        text = str(value)
+    if len(text) <= limit:
+        return text
+    return text[: max(1, limit - len("...(truncated)"))] + "...(truncated)"
+
+
+def normalize_openai_base_url(base_url: str) -> str:
+    raw = (base_url or "").strip().rstrip("/")
+    if not raw:
+        return ""
+    if raw.endswith("/v1"):
+        return raw
+    return raw + "/v1"
+
+
+def _looks_like_url(value: str) -> bool:
+    lowered = value.lower()
+    return lowered.startswith("http://") or lowered.startswith("https://") or lowered.startswith("data:")
+
+
+def _build_data_url(path: str) -> tuple[str, int]:
+    with open(path, "rb") as fh:
+        raw = fh.read()
+    size = len(raw)
+    if size > MAX_IMAGE_BYTES:
+        raise RuntimeError(
+            f"Image too large: {path} ({size} bytes). Limit is {MAX_IMAGE_BYTES} bytes per image. "
+            "Resize the image or use a hosted URL."
+        )
+    mime, _ = mimetypes.guess_type(path)
+    if not mime:
+        mime = "application/octet-stream"
+    encoded = base64.b64encode(raw).decode("ascii")
+    return f"data:{mime};base64,{encoded}", size
+
+
+def _sanitize_messages(messages: list[dict[str, object]]) -> list[dict[str, object]]:
+    clean: list[dict[str, object]] = []
+    total_image_bytes = 0
+    for msg in messages:
+        role_obj = msg.get("role", "")
+        role = str(role_obj).strip()
+        if role not in {"system", "user", "assistant", "tool"}:
+            continue
+
+        content_obj = msg.get("content")
+        text: str | None
+        if content_obj is None:
+            text = None
+        elif isinstance(content_obj, list):
+            text = None
+        else:
+            text = content_obj if isinstance(content_obj, str) else str(content_obj)
+        images_obj = msg.get("images")
+        if not isinstance(images_obj, list) or not images_obj:
+            out_content = deepcopy(content_obj) if isinstance(content_obj, list) else text
+            out: dict[str, object] = {"role": role, "content": out_content}
+            tool_calls = msg.get("tool_calls")
+            if role == "assistant" and isinstance(tool_calls, list):
+                out["tool_calls"] = deepcopy(tool_calls)
+            tool_call_id = msg.get("tool_call_id")
+            if role == "tool" and isinstance(tool_call_id, str) and tool_call_id.strip():
+                out["tool_call_id"] = tool_call_id.strip()
+            tool_name = msg.get("name")
+            if role == "tool" and isinstance(tool_name, str) and tool_name.strip():
+                out["name"] = tool_name.strip()
+            clean.append(out)
+            continue
+
+        parts: list[dict[str, object]] = []
+        if text:
+            parts.append({"type": "text", "text": text})
+        for entry in images_obj:
+            if not isinstance(entry, str) or not entry.strip():
+                continue
+            value = entry.strip()
+            if _looks_like_url(value):
+                url = value
+                size = 0
+            else:
+                if not os.path.isfile(value):
+                    raise RuntimeError(f"Image path not found: {value}")
+                url, size = _build_data_url(value)
+            total_image_bytes += size
+            if total_image_bytes > MAX_TOTAL_IMAGE_BYTES:
+                raise RuntimeError(
+                    f"Image payload too large ({total_image_bytes} bytes). Limit is {MAX_TOTAL_IMAGE_BYTES} bytes. "
+                    "Attach fewer images, resize them, or use hosted URLs."
+                )
+            parts.append({"type": "image_url", "image_url": {"url": url}})
+        out = {"role": role, "content": parts if parts else text}
+        clean.append(out)
+    return clean
+
+
+def _join_url(base_url: str, path: str) -> str:
+    return base_url.rstrip("/") + path
+
+
+def _sanitize_for_capture(obj):
+    if isinstance(obj, dict):
+        out = {}
+        for key, value in obj.items():
+            key_l = str(key).lower()
+            if key_l in {"authorization", "api_key", "openai_api_key", "vllm_api_key"}:
+                out[key] = "***"
+                continue
+            out[key] = _sanitize_for_capture(value)
+        return out
+    if isinstance(obj, list):
+        return [_sanitize_for_capture(x) for x in obj]
+    if isinstance(obj, str):
+        if obj.startswith("data:"):
+            mime = "unknown"
+            if ";" in obj and obj.startswith("data:"):
+                mime = obj[5 : obj.find(";")] or "unknown"
+            approx_bytes = int((len(obj) - obj.find(",") - 1) * 0.75) if "," in obj else 0
+            return {"url": "(data-url omitted)", "mime": mime, "bytes": approx_bytes}
+        if "bearer " in obj.lower():
+            return "***"
+    return obj
+
+
+def _truncate_capture(data: dict) -> dict:
+    raw = json.dumps(data, ensure_ascii=False, default=str)
+    if len(raw.encode("utf-8")) <= MAX_CAPTURE_BYTES:
+        return data
+    marker = "...(truncated)"
+    keep_bytes = max(1024, MAX_CAPTURE_BYTES - len(marker.encode("utf-8")) - 64)
+    trimmed = raw.encode("utf-8")[:keep_bytes].decode("utf-8", errors="ignore")
+    return {"truncated": True, "max_bytes": MAX_CAPTURE_BYTES, "data": trimmed + marker}
+
+
+def _normalize_tool_choice(raw: object) -> object | None:
+    if raw in (None, "", False):
+        return None
+    if isinstance(raw, dict):
+        return deepcopy(raw)
+    if isinstance(raw, str):
+        value = raw.strip()
+        if not value:
+            return None
+        lowered = value.lower()
+        if lowered in {"auto", "none", "required"}:
+            return lowered
+        if value.startswith("{"):
+            parsed = json.loads(value)
+            if not isinstance(parsed, dict):
+                raise ValueError("tool_choice JSON must decode to an object")
+            return parsed
+        return {"type": "function", "function": {"name": value}}
+    raise ValueError("tool_choice must be empty, a string, or an object")
+
+
+def _parse_usage_counts(payload: object) -> dict[str, int]:
+    if not isinstance(payload, dict):
+        return {}
+    prompt_tokens = payload.get("prompt_tokens")
+    completion_tokens = payload.get("completion_tokens")
+    total_tokens = payload.get("total_tokens")
+    counts: dict[str, int] = {}
+    if isinstance(prompt_tokens, int):
+        counts["prompt_tokens"] = int(prompt_tokens)
+    if isinstance(completion_tokens, int):
+        counts["completion_tokens"] = int(completion_tokens)
+    if isinstance(total_tokens, int):
+        counts["total_tokens"] = int(total_tokens)
+    if "total_tokens" not in counts and "prompt_tokens" in counts and "completion_tokens" in counts:
+        counts["total_tokens"] = counts["prompt_tokens"] + counts["completion_tokens"]
+    return counts
+
+
+def _extract_server_error_text(payload: object, *, event_name: str | None = None) -> str | None:
+    if isinstance(payload, dict):
+        error = payload.get("error")
+        if isinstance(error, dict):
+            message = error.get("message")
+            if isinstance(message, str) and message.strip():
+                return message.strip()
+            return _safe_json_snippet(error)
+        if event_name == "error":
+            message = payload.get("message")
+            if isinstance(message, str) and message.strip():
+                return message.strip()
+            return _safe_json_snippet(payload)
+    elif event_name == "error" and isinstance(payload, str) and payload.strip():
+        return payload.strip()
+    return None
+
+
+def _parse_nonstream_chat_response(frame: dict[str, object]) -> dict[str, object]:
+    usage_counts = _parse_usage_counts(frame.get("usage"))
+    choices = frame.get("choices")
+    if not isinstance(choices, list) or not choices:
+        raise RuntimeError("Non-stream chat completion response missing choices[0].")
+    choice0 = choices[0]
+    if not isinstance(choice0, dict):
+        raise RuntimeError("Non-stream chat completion response has invalid choices[0].")
+    finish_reason = choice0.get("finish_reason") if isinstance(choice0.get("finish_reason"), str) else None
+    message = choice0.get("message")
+    if not isinstance(message, dict):
+        raise RuntimeError("Non-stream chat completion response missing choices[0].message.")
+    content = message.get("content")
+    if content is None:
+        content_text = ""
+    elif isinstance(content, str):
+        content_text = content
+    else:
+        content_text = _safe_json_snippet(content)
+    tool_calls = message.get("tool_calls")
+    out_tool_calls: list[dict[str, object]] = []
+    if isinstance(tool_calls, list):
+        for index, item in enumerate(tool_calls):
+            if not isinstance(item, dict):
+                continue
+            fn = item.get("function") if isinstance(item.get("function"), dict) else {}
+            out_tool_calls.append(
+                {
+                    "index": index,
+                    "id": str(item.get("id") or ""),
+                    "type": str(item.get("type") or "function"),
+                    "name": str(fn.get("name") or ""),
+                    "arguments": str(fn.get("arguments") or ""),
+                }
+            )
+    return {
+        "content": content_text,
+        "tool_calls": out_tool_calls,
+        "finish_reason": finish_reason,
+        "usage": usage_counts,
+        "raw": frame,
+    }
+
+
+def _iter_sse_events(resp) -> object:
+    event_name = "message"
+    data_lines: list[str] = []
+    for raw_line in resp:
+        line = raw_line.decode("utf-8", errors="replace")
+        if line.endswith("\r\n"):
+            line = line[:-2]
+        elif line.endswith("\n"):
+            line = line[:-1]
+        elif line.endswith("\r"):
+            line = line[:-1]
+
+        if line == "":
+            if not data_lines:
+                event_name = "message"
+                continue
+            data_text = "\n".join(data_lines)
+            yield {"event": event_name, "data": data_text}
+            event_name = "message"
+            data_lines = []
+            continue
+        if line.startswith(":"):
+            continue
+        field, sep, value = line.partition(":")
+        if not sep:
+            continue
+        value = value[1:] if value.startswith(" ") else value
+        if field == "event":
+            event_name = value or "message"
+        elif field == "data":
+            data_lines.append(value)
+        else:
+            continue
+    if data_lines:
+        yield {"event": event_name, "data": "\n".join(data_lines)}
+
+
+def compat_chat_completion_request(
+    *,
+    base_url: str,
+    payload: dict[str, object],
+    timeout_s: float,
+    api_key: str = "",
+) -> dict[str, object]:
+    url = _join_url(normalize_openai_base_url(base_url), "/chat/completions")
+    stream = bool(payload.get("stream"))
+    if not stream:
+        with _json_request("POST", url, timeout=max(1.0, timeout_s), api_key=api_key, payload=payload) as resp:
+            raw = resp.read().decode("utf-8", errors="replace")
+        frame = json.loads(raw)
+        err_text = _extract_server_error_text(frame)
+        if err_text:
+            raise RuntimeError(f"server error frame: {err_text}")
+        return {
+            "mode": "nonstream",
+            **_parse_nonstream_chat_response(frame),
+        }
+
+    events: list[dict[str, object]] = []
+    aggregated_tool_calls: dict[str, dict[str, object]] = {}
+    finish_reason: str | None = None
+    usage: dict[str, int] = {}
+    with _json_request("POST", url, timeout=max(1.0, timeout_s), api_key=api_key, payload=payload) as resp:
+        for event in _iter_sse_events(resp):
+            if not isinstance(event, dict):
+                continue
+            data_text = str(event.get("data") or "")
+            event_name = str(event.get("event") or "message")
+            if not data_text:
+                continue
+            if data_text.strip() == "[DONE]":
+                break
+            frame = json.loads(data_text)
+            err_text = _extract_server_error_text(frame, event_name=event_name)
+            if err_text:
+                raise RuntimeError(f"server error frame: {err_text}")
+            events.append(frame)
+            counts = _parse_usage_counts(frame.get("usage"))
+            if counts:
+                usage = counts
+            choices = frame.get("choices")
+            if not isinstance(choices, list) or not choices:
+                continue
+            choice0 = choices[0]
+            if not isinstance(choice0, dict):
+                continue
+            if isinstance(choice0.get("finish_reason"), str) and choice0.get("finish_reason"):
+                finish_reason = str(choice0["finish_reason"])
+            delta = choice0.get("delta")
+            if not isinstance(delta, dict):
+                continue
+            tcs = delta.get("tool_calls")
+            if isinstance(tcs, list):
+                for tc in tcs:
+                    if not isinstance(tc, dict):
+                        continue
+                    idx = str(tc.get("index", 0))
+                    rec = aggregated_tool_calls.setdefault(
+                        idx,
+                        {"index": tc.get("index", 0), "id": "", "type": "function", "name": "", "arguments": ""},
+                    )
+                    if isinstance(tc.get("id"), str) and tc["id"]:
+                        rec["id"] = tc["id"]
+                    if isinstance(tc.get("type"), str) and tc["type"]:
+                        rec["type"] = tc["type"]
+                    fn = tc.get("function")
+                    if isinstance(fn, dict):
+                        if isinstance(fn.get("name"), str) and fn["name"]:
+                            rec["name"] = fn["name"]
+                        if isinstance(fn.get("arguments"), str) and fn["arguments"]:
+                            rec["arguments"] = str(rec.get("arguments", "")) + fn["arguments"]
+    return {
+        "mode": "stream",
+        "finish_reason": finish_reason,
+        "usage": usage,
+        "events": events,
+        "tool_calls": [aggregated_tool_calls[key] for key in sorted(aggregated_tool_calls.keys(), key=int)],
+    }
+
+
+def _json_request(
+    method: str,
+    url: str,
+    *,
+    timeout: float,
+    api_key: str = "",
+    payload: dict | None = None,
+):
+    headers = {"Content-Type": "application/json"}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    data = None
+    if payload is not None:
+        data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(url, method=method, data=data, headers=headers)
+    return urllib.request.urlopen(req, timeout=timeout)
+
+
+def resolve_model_once(base_url: str, *, timeout_s: float, api_key: str) -> str:
+    resolved_base = normalize_openai_base_url(base_url)
+    url = _join_url(resolved_base, "/models")
+    with _json_request("GET", url, timeout=max(1.0, min(10.0, timeout_s)), api_key=api_key) as resp:
+        raw = resp.read().decode("utf-8", errors="replace")
+    data = json.loads(raw)
+    models = data.get("data")
+    if not isinstance(models, list):
+        raise RuntimeError("Model resolution failed: /v1/models response missing data[]")
+    ids: list[str] = []
+    for item in models:
+        if isinstance(item, dict) and isinstance(item.get("id"), str) and item["id"].strip():
+            ids.append(item["id"].strip())
+    if len(ids) == 1:
+        return ids[0]
+    if not ids:
+        raise RuntimeError("Model resolution failed: /v1/models returned no models")
+    raise RuntimeError(
+        "Model resolution failed: server returned multiple models. "
+        f"Set model_id explicitly. Available: {', '.join(ids)}"
+    )
+
+
+class OpenAIHTTPSession:
+    def __init__(
+        self,
+        *,
+        args: argparse.Namespace,
+        resolved_model_id: str,
+        base_url: str,
+        api_key: str,
+        timeout_s: float,
+        backend_name: str,
+        template_info: dict[str, object] | None = None,
+        logger: FileLogger | None = None,
+    ):
+        self.args = args
+        self.resolved_model_id = resolved_model_id
+        self.base_url = normalize_openai_base_url(base_url)
+        self.api_key = api_key
+        self.timeout_s = float(timeout_s)
+        self.backend_name = backend_name
+        self._ignored_knobs_once = False
+        self.template_info = dict(template_info or {})
+        self.logger = logger
+        self._last_request: dict | None = None
+        self._tool_runtime = build_tool_runtime(args, backend_name)
+
+    def close(self) -> None:
+        if self.logger is not None:
+            self.logger.close()
+
+    def get_recent_logs(self, n: int = 80, sources: list[str] | None = None) -> list[str]:
+        if self.logger is None:
+            return []
+        return self.logger.get_recent_logs(n=n, sources=sources)
+
+    def list_log_sources(self) -> list[str]:
+        if self.logger is None:
+            return []
+        return self.logger.list_log_sources()
+
+    def get_last_request(self) -> dict | None:
+        return self._last_request
+
+    def describe(self) -> dict[str, object]:
+        return {
+            "base_url": self.base_url,
+            "model_id": self.resolved_model_id,
+            "api_key": "(set)" if self.api_key else "(unset)",
+            "timeout_s": self.timeout_s,
+            **self.template_info,
+        }
+
+    def _capture_request(self, *, url: str, payload: dict[str, object]) -> None:
+        if not getattr(self.args, "capture_last_request", False):
+            return
+        captured = {
+            "backend": self.backend_name,
+            "url": url,
+            "payload": _sanitize_for_capture(payload),
+            "api_key": "***" if self.api_key else "(unset)",
+        }
+        self._last_request = _truncate_capture(captured)
+
+    def _capture_response_snippet(self, *, key: str, value: object) -> None:
+        if not getattr(self.args, "capture_last_request", False):
+            return
+        if not isinstance(self._last_request, dict):
+            return
+        data = deepcopy(self._last_request)
+        data[key] = _sanitize_for_capture(value)
+        self._last_request = _truncate_capture(data)
+
+    def _emit_ignored_knobs_once(self, emit: EventEmitter, turn_id: int) -> None:
+        if self._ignored_knobs_once:
+            return
+        ignored: list[str] = []
+        if self.backend_name != "vllm" and self.args.top_k is not None:
+            ignored.append("top_k")
+        if self.backend_name != "vllm" and self.args.min_p is not None:
+            ignored.append("min_p")
+        if self.args.typical_p is not None:
+            ignored.append("typical_p")
+        if self.backend_name != "vllm" and self.args.repetition_penalty not in (None, 1.0):
+            ignored.append("repetition_penalty")
+        if self.backend_name != "vllm" and self.args.presence_penalty is not None:
+            ignored.append("presence_penalty")
+        if self.backend_name != "vllm" and self.args.frequency_penalty is not None:
+            ignored.append("frequency_penalty")
+        if ignored:
+            emit(Meta(turn_id=turn_id, key="ignored_knobs", value=ignored))
+        self._ignored_knobs_once = True
+
+    def generate_turn(
+        self,
+        turn_id: int,
+        messages: list[dict[str, object]],
+        emit: EventEmitter,
+        *,
+        emit_turn_start: bool = True,
+    ) -> None:
+        class _ContextOverflow(RuntimeError):
+            pass
+
+        if emit_turn_start:
+            emit(TurnStart(turn_id=turn_id))
+        started = time.time()
+        deadline = started + max(1.0, self.timeout_s)
+        self._emit_ignored_knobs_once(emit, turn_id)
+        if self.logger is not None:
+            self.logger.log(
+                f"turn_start id={turn_id} messages={len(messages)} model={self.resolved_model_id} "
+                f"max_new_tokens={self.args.max_new_tokens}",
+                source="transport",
+            )
+
+        context_window = None
+        if self.backend_name == "vllm" and int(self.args.vllm_max_model_len or 0) > 0:
+            context_window = int(self.args.vllm_max_model_len)
+        reserved_generation = reserve_generation_tokens(context_window, self.args.max_new_tokens)
+        working_messages = list(messages)
+        overflow_retries = 0
+        dropped_roles: list[str] = []
+        tool_runtime = self._tool_runtime
+        tools_active = (
+            tool_runtime.enabled
+            and tool_runtime.supported_backend
+            and bool(tool_runtime.tool_names())
+        )
+        tool_activity: list[dict[str, object]] = []
+        all_tool_calls_for_gen: list[dict[str, object]] = []
+        aggregate_prompt_tokens = 0
+        aggregate_completion_tokens = 0
+        aggregate_total_tokens = 0
+        aggregate_estimated_completion_tokens = 0
+        final_finish_reason: str | None = None
+        final_knob_report: dict[str, object] | None = None
+        final_context_prompt_tokens: int | None = None
+        final_answer_text = ""
+        final_think_text = ""
+        ended_in_think = False
+        aggregate_raw_parts: list[str] = []
+        aggregate_think_parts: list[str] = []
+        aggregate_answer_parts: list[str] = []
+
+        def _drop_oldest_turn() -> bool:
+            dropped_chunk = drop_oldest_history_message(working_messages)
+            if dropped_chunk is None:
+                return False
+            dropped_roles.extend(dropped_chunk)
+            return True
+
+        config_origins = dict(getattr(self.args, "_config_origins", {}) or {})
+        cli_overrides = set(getattr(self.args, "_cli_overrides", set()) or set())
+
+        def _is_explicit(name: str) -> bool:
+            return name in config_origins or name in cli_overrides
+
+        def _run_attempt(*, include_tools: bool):
+            router = ThinkRouter(assume_think=self.args.assume_think)
+            raw_parts: list[str] = []
+            think_parts: list[str] = []
+            answer_parts: list[str] = []
+            tool_calls: dict[str, dict[str, str | int]] = {}
+            usage_totals: dict[str, int] | None = None
+            finish_reason: str | None = None
+            generated_token_total = 0
+            stage = "build_payload"
+
+            def _emit_generated_text(text: str) -> None:
+                nonlocal generated_token_total
+                if not text:
+                    return
+                token_inc = len(re.findall(r"\S+", text))
+                if token_inc > 0:
+                    generated_token_total += token_inc
+                    emit(Meta(turn_id=turn_id, key="generated_tokens_inc", value=token_inc))
+
+            def _emit_think(text: str) -> None:
+                if not text:
+                    return
+                think_parts.append(text)
+                emit(ThinkDelta(turn_id=turn_id, text=text))
+
+            payload_messages = _sanitize_messages(working_messages)
+            payload: dict[str, object] = {
+                "messages": payload_messages,
+                "stream": True,
+                "stream_options": {"include_usage": True},
+            }
+            if _is_explicit("max_new_tokens"):
+                payload["max_tokens"] = self.args.max_new_tokens
+            if _is_explicit("temperature"):
+                payload["temperature"] = self.args.temperature
+            if _is_explicit("top_p"):
+                payload["top_p"] = self.args.top_p
+            if self.resolved_model_id:
+                payload["model"] = self.resolved_model_id
+            if self.args.stop_strings:
+                payload["stop"] = self.args.stop_strings
+            if self.args.seed is not None:
+                payload["seed"] = self.args.seed
+            if include_tools:
+                payload["tools"] = tool_runtime.exposed_schema()
+                tool_choice = _normalize_tool_choice(getattr(self.args, "tools_tool_choice", ""))
+                if tool_choice is not None:
+                    payload["tool_choice"] = tool_choice
+            if self.backend_name == "vllm":
+                if self.args.presence_penalty not in (None, 0.0):
+                    payload["presence_penalty"] = self.args.presence_penalty
+                if self.args.frequency_penalty not in (None, 0.0):
+                    payload["frequency_penalty"] = self.args.frequency_penalty
+                if self.args.top_k not in (None, -1):
+                    payload["top_k"] = self.args.top_k
+                if self.args.min_p not in (None, 0.0):
+                    payload["min_p"] = self.args.min_p
+                if self.args.repetition_penalty not in (None, 1.0):
+                    payload["repetition_penalty"] = self.args.repetition_penalty
+                if self.args.stop_token_ids:
+                    payload["stop_token_ids"] = self.args.stop_token_ids
+                if self.args.ignore_eos is True:
+                    payload["ignore_eos"] = self.args.ignore_eos
+                if self.args.min_tokens not in (None, 0):
+                    payload["min_tokens"] = self.args.min_tokens
+                if self.args.best_of not in (None, 1):
+                    payload["best_of"] = self.args.best_of
+                if self.args.use_beam_search is True:
+                    payload["use_beam_search"] = self.args.use_beam_search
+                if self.args.length_penalty not in (None, 1.0):
+                    payload["length_penalty"] = self.args.length_penalty
+                if self.args.include_stop_str_in_output is True:
+                    payload["include_stop_str_in_output"] = self.args.include_stop_str_in_output
+                if self.args.skip_special_tokens is False:
+                    payload["skip_special_tokens"] = self.args.skip_special_tokens
+                if self.args.spaces_between_special_tokens is False:
+                    payload["spaces_between_special_tokens"] = self.args.spaces_between_special_tokens
+                if self.args.truncate_prompt_tokens not in (None, 0):
+                    payload["truncate_prompt_tokens"] = self.args.truncate_prompt_tokens
+                if self.args.allowed_token_ids:
+                    payload["allowed_token_ids"] = self.args.allowed_token_ids
+                if self.args.prompt_logprobs not in (None, 0):
+                    payload["prompt_logprobs"] = self.args.prompt_logprobs
+
+            knob_sent: dict[str, object] = {}
+            if "max_tokens" in payload:
+                knob_sent["max_new_tokens"] = payload["max_tokens"]
+            if "temperature" in payload:
+                knob_sent["temperature"] = payload["temperature"]
+            if "top_p" in payload:
+                knob_sent["top_p"] = payload["top_p"]
+            if "stop" in payload:
+                knob_sent["stop_strings"] = payload["stop"]
+            if "seed" in payload:
+                knob_sent["seed"] = payload["seed"]
+            if self.backend_name == "vllm":
+                payload_to_knob = {
+                    "top_k": "top_k",
+                    "min_p": "min_p",
+                    "repetition_penalty": "repetition_penalty",
+                    "presence_penalty": "presence_penalty",
+                    "frequency_penalty": "frequency_penalty",
+                    "stop_token_ids": "stop_token_ids",
+                    "ignore_eos": "ignore_eos",
+                    "min_tokens": "min_tokens",
+                    "best_of": "best_of",
+                    "use_beam_search": "use_beam_search",
+                    "length_penalty": "length_penalty",
+                    "include_stop_str_in_output": "include_stop_str_in_output",
+                    "skip_special_tokens": "skip_special_tokens",
+                    "spaces_between_special_tokens": "spaces_between_special_tokens",
+                    "truncate_prompt_tokens": "truncate_prompt_tokens",
+                    "allowed_token_ids": "allowed_token_ids",
+                    "prompt_logprobs": "prompt_logprobs",
+                }
+                for payload_key, knob_key in payload_to_knob.items():
+                    if payload_key in payload:
+                        knob_sent[knob_key] = payload[payload_key]
+            knob_report = finalize_knob_report(
+                sent=knob_sent,
+                supported=SUPPORTED_KNOBS[self.backend_name],
+                ignored=unsupported_user_set(self.args, self.backend_name),
+            )
+
+            stage = "request_open"
+            url = _join_url(self.base_url, "/chat/completions")
+            self._capture_request(url=url, payload=payload)
+            req_timeout = max(1.0, self.timeout_s)
+
+            def _transport_error(detail: str, *, snippet: object | None = None) -> RuntimeError:
+                elapsed = max(0.0, time.time() - started)
+                message = (
+                    f"{self.backend_name} OpenAI-compatible request failed: {detail} "
+                    f"(url={url}, elapsed={elapsed:.2f}s)"
+                )
+                if snippet not in (None, "", {}):
+                    message += f" | last={_safe_json_snippet(snippet)}"
+                return RuntimeError(message)
+
+            try:
+                with _json_request("POST", url, timeout=req_timeout, api_key=self.api_key, payload=payload) as resp:
+                    stage = "stream_parse"
+                    last_event_snippet: object | None = None
+                    for event in _iter_sse_events(resp):
+                        if time.time() > deadline:
+                            raise _transport_error(f"timeout after {self.timeout_s}s", snippet=last_event_snippet)
+                        if not isinstance(event, dict):
+                            continue
+                        data_part = str(event.get("data") or "")
+                        event_name = str(event.get("event") or "message")
+                        if not data_part:
+                            continue
+                        if data_part.strip() == "[DONE]":
+                            raise StopIteration
+                        try:
+                            frame = json.loads(data_part)
+                            last_event_snippet = frame
+                            self._capture_response_snippet(key="response_event", value=frame)
+                        except Exception:
+                            last_event_snippet = {"event": event_name, "data": data_part}
+                            self._capture_response_snippet(key="response_event", value=last_event_snippet)
+                            err_text = _extract_server_error_text(data_part, event_name=event_name)
+                            if err_text:
+                                self._capture_response_snippet(key="response_error", value=last_event_snippet)
+                                if not raw_parts and not think_parts and not answer_parts and is_context_overflow_text(err_text):
+                                    raise _ContextOverflow(str(err_text))
+                                raise _transport_error(f"server error event: {err_text}", snippet=last_event_snippet)
+                            continue
+
+                        err_text = _extract_server_error_text(frame, event_name=event_name)
+                        if err_text:
+                            self._capture_response_snippet(key="response_error", value=frame)
+                            if not raw_parts and not think_parts and not answer_parts and is_context_overflow_text(err_text):
+                                raise _ContextOverflow(str(err_text))
+                            raise _transport_error(f"server error frame: {err_text}", snippet=frame)
+
+                        counts = _parse_usage_counts(frame.get("usage"))
+                        if counts:
+                            usage_totals = counts
+                            for key, value in counts.items():
+                                emit(Meta(turn_id=turn_id, key=key, value=value))
+
+                        choices = frame.get("choices")
+                        if not isinstance(choices, list) or not choices:
+                            continue
+                        choice0 = choices[0]
+                        if not isinstance(choice0, dict):
+                            continue
+                        choice_finish_reason = choice0.get("finish_reason")
+                        if isinstance(choice_finish_reason, str) and choice_finish_reason:
+                            finish_reason = choice_finish_reason
+                        delta = choice0.get("delta") or {}
+                        if not isinstance(delta, dict):
+                            continue
+
+                        reasoning = delta.get("reasoning")
+                        if not isinstance(reasoning, str):
+                            reasoning = delta.get("reasoning_content")
+                        if isinstance(reasoning, str) and reasoning:
+                            _emit_generated_text(reasoning)
+                            raw_parts.append(reasoning)
+                            _emit_think(reasoning)
+
+                        content = delta.get("content")
+                        if isinstance(content, str) and content:
+                            _emit_generated_text(content)
+                            raw_parts.append(content)
+                            if isinstance(reasoning, str) and reasoning:
+                                answer_parts.append(content)
+                                emit(AnswerDelta(turn_id=turn_id, text=content))
+                            else:
+                                for channel, text in router.feed(content):
+                                    if channel == "think":
+                                        _emit_think(text)
+                                    else:
+                                        answer_parts.append(text)
+                                        emit(AnswerDelta(turn_id=turn_id, text=text))
+
+                        tcs = delta.get("tool_calls")
+                        if isinstance(tcs, list):
+                            for tc in tcs:
+                                if not isinstance(tc, dict):
+                                    continue
+                                idx = tc.get("index", 0)
+                                idx_key = str(idx)
+                                rec = tool_calls.setdefault(
+                                    idx_key,
+                                    {"index": idx, "id": "", "type": "function", "name": "", "arguments": ""},
+                                )
+                                tc_id = tc.get("id")
+                                if isinstance(tc_id, str) and tc_id:
+                                    rec["id"] = tc_id
+                                tc_type = tc.get("type")
+                                if isinstance(tc_type, str) and tc_type:
+                                    rec["type"] = tc_type
+                                fn = tc.get("function")
+                                if isinstance(fn, dict):
+                                    name = fn.get("name")
+                                    if isinstance(name, str) and name:
+                                        rec["name"] = name
+                                    args_part = fn.get("arguments")
+                                    if isinstance(args_part, str) and args_part:
+                                        rec["arguments"] = str(rec.get("arguments", "")) + args_part
+            except StopIteration:
+                pass
+            except urllib.error.HTTPError as exc:
+                body = exc.read().decode("utf-8", errors="ignore").strip()
+                body_snippet = body[:4096] if body else ""
+                if body_snippet:
+                    self._capture_response_snippet(key="response_error", value={"http_status": exc.code, "body": body_snippet})
+                detail = f"HTTP {exc.code} {exc.reason}"
+                if not raw_parts and not think_parts and not answer_parts and is_context_overflow_text(detail):
+                    raise _ContextOverflow(detail)
+                raise _transport_error(detail, snippet=body_snippet or None) from exc
+            except urllib.error.URLError as exc:
+                raise _transport_error(str(exc)) from exc
+            except _ContextOverflow:
+                raise
+            except Exception as exc:
+                if not raw_parts and not think_parts and not answer_parts and is_context_overflow_text(str(exc)):
+                    raise _ContextOverflow(str(exc)) from exc
+                snippet = None
+                if isinstance(self._last_request, dict):
+                    snippet = self._last_request.get("response_error") or self._last_request.get("response_event")
+                raise _transport_error(f"{stage}: {exc}", snippet=snippet) from exc
+
+            for channel, text in router.flush():
+                if channel == "think":
+                    _emit_think(text)
+                else:
+                    answer_parts.append(text)
+                    emit(AnswerDelta(turn_id=turn_id, text=text))
+
+            tool_calls_out: list[dict[str, object]] = []
+            assistant_tool_calls: list[dict[str, object]] = []
+            if tool_calls:
+                for key in sorted(tool_calls.keys(), key=lambda x: int(x)):
+                    item = tool_calls[key]
+                    tool_calls_out.append(
+                        {
+                            "index": item.get("index"),
+                            "id": item.get("id") or "",
+                            "name": item.get("name") or "",
+                            "arguments": item.get("arguments") or "",
+                        }
+                    )
+                    assistant_tool_calls.append(
+                        {
+                            "id": item.get("id") or "",
+                            "type": item.get("type") or "function",
+                            "function": {
+                                "name": item.get("name") or "",
+                                "arguments": item.get("arguments") or "",
+                            },
+                        }
+                    )
+            self._capture_response_snippet(
+                key="response_summary",
+                value={
+                    "finish_reason": finish_reason,
+                    "usage": usage_totals or {},
+                    "tool_calls": tool_calls_out,
+                },
+            )
+            answer_text = "".join(answer_parts)
+            assistant_message: dict[str, object] | None = None
+            if assistant_tool_calls:
+                assistant_message = {
+                    "role": "assistant",
+                    "content": answer_text if answer_text else None,
+                    "tool_calls": assistant_tool_calls,
+                }
+            return (
+                payload,
+                knob_report,
+                raw_parts,
+                think_parts,
+                answer_parts,
+                usage_totals,
+                finish_reason,
+                tool_calls_out,
+                assistant_message,
+                router.mode == "think",
+                generated_token_total,
+            )
+
+        while True:
+            try:
+                (
+                    payload,
+                    knob_report,
+                    raw_parts,
+                    think_parts,
+                    answer_parts,
+                    usage_totals,
+                    finish_reason,
+                    tool_calls_out,
+                    assistant_message,
+                    ended_in_think,
+                    generated_token_total,
+                ) = _run_attempt(include_tools=tools_active and tool_runtime.max_calls_per_turn > len(all_tool_calls_for_gen))
+            except _ContextOverflow:
+                if _drop_oldest_turn():
+                    overflow_retries += 1
+                    continue
+                detail = build_context_limit_error(
+                    build_retry_report(
+                        messages,
+                        working_messages,
+                        strategy="overflow_retry",
+                        context_window=context_window,
+                        reserved_generation_tokens=reserved_generation,
+                        overflow_retries=overflow_retries,
+                        fit=False,
+                        prompt_tokens=None,
+                        dropped_roles=dropped_roles,
+                    )
+                )
+                if self.logger is not None:
+                    self.logger.log(f"turn_error id={turn_id} error={detail}", source="transport")
+                emit(Error(turn_id=turn_id, message=detail))
+                return
+            except Exception as exc:
+                if self.logger is not None:
+                    self.logger.log(f"turn_error id={turn_id} error={exc}", source="transport")
+                emit(Error(turn_id=turn_id, message=str(exc)))
+                return
+
+            final_knob_report = knob_report
+            final_finish_reason = finish_reason
+            final_answer_text = "".join(answer_parts)
+            final_think_text = "".join(think_parts)
+            aggregate_raw_parts.extend(raw_parts)
+            aggregate_think_parts.extend(think_parts)
+            aggregate_answer_parts.extend(answer_parts)
+            aggregate_estimated_completion_tokens += int(generated_token_total)
+            if isinstance(usage_totals, dict):
+                prompt_tokens = usage_totals.get("prompt_tokens")
+                completion_tokens = usage_totals.get("completion_tokens")
+                total_tokens = usage_totals.get("total_tokens")
+                if isinstance(prompt_tokens, int):
+                    aggregate_prompt_tokens += prompt_tokens
+                    final_context_prompt_tokens = prompt_tokens
+                if isinstance(completion_tokens, int):
+                    aggregate_completion_tokens += completion_tokens
+                if isinstance(total_tokens, int):
+                    aggregate_total_tokens += total_tokens
+                elif isinstance(prompt_tokens, int) and isinstance(completion_tokens, int):
+                    aggregate_total_tokens += prompt_tokens + completion_tokens
+
+            if tool_calls_out:
+                all_tool_calls_for_gen.extend(tool_calls_out)
+
+            if not (tools_active and tool_calls_out):
+                break
+
+            if assistant_message is not None:
+                working_messages.append(assistant_message)
+
+            remaining_calls = max(0, tool_runtime.max_calls_per_turn - len(tool_activity))
+            for index, call in enumerate(tool_calls_out):
+                tool_call_id = str(call.get("id", "") or "").strip() or f"tool_call_{len(tool_activity) + 1}"
+                name = str(call.get("name", "") or "").strip()
+                arguments_raw = str(call.get("arguments", "") or "")
+                denied_by_policy = False
+                if name in tool_runtime.available_tools and name not in tool_runtime.exposed_tools:
+                    denied_by_policy = True
+
+                activity: dict[str, object]
+                if tool_runtime.mode == "dry_run":
+                    activity = tool_runtime.execute(
+                        name=name,
+                        arguments_raw=arguments_raw,
+                        denied_by_policy=denied_by_policy,
+                    )
+                    activity["tool_call_id"] = tool_call_id
+                elif index >= remaining_calls:
+                    limit_msg = "Tool execution limit reached for this turn."
+                    activity = {
+                        "tool_call_id": tool_call_id,
+                        "name": name,
+                        "arguments_raw": arguments_raw,
+                        "arguments_json": None,
+                        "status": "max_calls_exceeded",
+                        "result": limit_msg,
+                        "error": limit_msg,
+                    }
+                    activity["result"] = str(activity["result"])[: tool_runtime.max_result_chars]
+                else:
+                    if self.logger is not None:
+                        self.logger.log(
+                            f"tool_call_execute_start id={turn_id} tool_call_id={tool_call_id} name={name}",
+                            source="app",
+                        )
+                    activity = tool_runtime.execute(
+                        name=name,
+                        arguments_raw=arguments_raw,
+                        denied_by_policy=denied_by_policy,
+                    )
+                    activity["tool_call_id"] = tool_call_id
+
+                if self.logger is not None:
+                    self.logger.log(
+                        f"tool_call_received id={turn_id} tool_call_id={tool_call_id} name={name} "
+                        f"status={activity.get('status')} args_len={len(arguments_raw)}",
+                        source="app",
+                    )
+                    if activity.get("status") == "executed":
+                        result = str(activity.get("result") or "")
+                        self.logger.log(
+                            f"tool_call_execute_success id={turn_id} tool_call_id={tool_call_id} "
+                            f"name={name} output_len={len(result)}",
+                            source="app",
+                        )
+                    elif activity.get("status") not in {"dry_run", "denied_by_policy"}:
+                        self.logger.log(
+                            f"tool_call_execute_error id={turn_id} tool_call_id={tool_call_id} "
+                            f"name={name} error={activity.get('error')}",
+                            source="app",
+                        )
+
+                tool_activity.append(activity)
+
+                if tool_runtime.mode != "dry_run":
+                    result_text = str(activity.get("result") or activity.get("error") or "")
+                    working_messages.append(
+                        {
+                            "role": "tool",
+                            "tool_call_id": tool_call_id,
+                            "content": result_text,
+                        }
+                    )
+                    if self.logger is not None:
+                        self.logger.log(
+                            f"tool_call_result_injected id={turn_id} tool_call_id={tool_call_id} "
+                            f"name={name} content_len={len(result_text)}",
+                            source="app",
+                        )
+
+            if tool_runtime.mode == "dry_run":
+                final_answer_text = "".join(answer_parts)
+                final_think_text = "".join(think_parts)
+                break
+
+        ended = time.time()
+        elapsed = max(0.0, ended - started)
+        throughput = None
+        token_counts = None
+        if aggregate_prompt_tokens or aggregate_completion_tokens or aggregate_total_tokens:
+            if aggregate_total_tokens <= 0:
+                aggregate_total_tokens = aggregate_prompt_tokens + aggregate_completion_tokens
+            token_counts = {
+                "prompt_tokens": aggregate_prompt_tokens,
+                "completion_tokens": aggregate_completion_tokens,
+                "total_tokens": aggregate_total_tokens,
+            }
+        elif aggregate_estimated_completion_tokens > 0:
+            token_counts = {
+                "completion_tokens": aggregate_estimated_completion_tokens,
+            }
+        if token_counts is not None and token_counts.get("completion_tokens", 0) > 0 and elapsed > 0:
+            throughput = {"tokens_per_s": token_counts["completion_tokens"] / elapsed}
+        gen = {
+            "max_tokens": self.args.max_new_tokens,
+            "temperature": self.args.temperature,
+            "top_p": self.args.top_p,
+            "stop": self.args.stop_strings,
+            "seed": self.args.seed,
+        }
+        if self.backend_name == "vllm":
+            gen["top_k"] = self.args.top_k
+            gen["min_p"] = self.args.min_p
+            gen["repetition_penalty"] = self.args.repetition_penalty
+            gen["presence_penalty"] = self.args.presence_penalty
+            gen["frequency_penalty"] = self.args.frequency_penalty
+            gen["stop_token_ids"] = self.args.stop_token_ids
+            gen["ignore_eos"] = self.args.ignore_eos
+            gen["min_tokens"] = self.args.min_tokens
+            gen["best_of"] = self.args.best_of
+            gen["use_beam_search"] = self.args.use_beam_search
+            gen["length_penalty"] = self.args.length_penalty
+            gen["include_stop_str_in_output"] = self.args.include_stop_str_in_output
+            gen["skip_special_tokens"] = self.args.skip_special_tokens
+            gen["spaces_between_special_tokens"] = self.args.spaces_between_special_tokens
+            gen["truncate_prompt_tokens"] = self.args.truncate_prompt_tokens
+            gen["allowed_token_ids"] = self.args.allowed_token_ids
+            gen["prompt_logprobs"] = self.args.prompt_logprobs
+        if all_tool_calls_for_gen:
+            gen["tool_calls"] = all_tool_calls_for_gen
+        if final_finish_reason is not None:
+            gen["finish_reason"] = final_finish_reason
+        context_report = build_retry_report(
+            messages,
+            working_messages,
+            strategy="overflow_retry",
+            context_window=context_window,
+            reserved_generation_tokens=reserved_generation,
+            overflow_retries=overflow_retries,
+            fit=True,
+            prompt_tokens=final_context_prompt_tokens,
+            dropped_roles=dropped_roles,
+        ).to_dict()
+        trimmed_messages = None
+        if tool_runtime.mode == "dry_run" and tool_activity:
+            trimmed_messages = list(working_messages)
+        else:
+            trimmed_messages = append_assistant_history(
+                list(working_messages),
+                think=final_think_text,
+                answer=final_answer_text,
+                strip_think=bool(self.args.history_strip_think),
+            )
+        record = TurnRecord(
+            raw="".join(aggregate_raw_parts),
+            think="".join(aggregate_think_parts),
+            answer="".join(aggregate_answer_parts),
+            ended_in_think=ended_in_think,
+            backend=self.backend_name,
+            model_id=self.resolved_model_id,
+            gen=gen,
+            timing={"start": started, "end": ended, "elapsed": elapsed},
+            token_counts=token_counts,
+            throughput=throughput,
+            knobs=final_knob_report,
+            context=context_report,
+            tool_activity=tool_activity or None,
+            trimmed_messages=trimmed_messages,
+        )
+        emit(Finish(turn_id=turn_id, record=record))
+        if self.logger is not None:
+            self.logger.log(
+                f"turn_finish id={turn_id} elapsed_s={record.timing.get('elapsed', 0):.3f} "
+                f"think_chars={len(record.think)} answer_chars={len(record.answer)}",
+                source="transport",
+            )
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 0000000..54ed2b0
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,2662 @@
+version = 1
+revision = 3
+requires-python = "==3.12.*"
+resolution-markers = [
+    "sys_platform == 'linux'",
+]
+supported-markers = [
+    "sys_platform == 'linux'",
+]
+
+[manifest]
+overrides = [{ name = "transformers", specifier = "==5.5.3" }]
+
+[[package]]
+name = "aiohappyeyeballs"
+version = "2.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558", size = 22760, upload-time = "2025-03-12T01:42:48.764Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265, upload-time = "2025-03-12T01:42:47.083Z" },
+]
+
+[[package]]
+name = "aiohttp"
+version = "3.13.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohappyeyeballs", marker = "sys_platform == 'linux'" },
+    { name = "aiosignal", marker = "sys_platform == 'linux'" },
+    { name = "attrs", marker = "sys_platform == 'linux'" },
+    { name = "frozenlist", marker = "sys_platform == 'linux'" },
+    { name = "multidict", marker = "sys_platform == 'linux'" },
+    { name = "propcache", marker = "sys_platform == 'linux'" },
+    { name = "yarl", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/50/42/32cf8e7704ceb4481406eb87161349abb46a57fee3f008ba9cb610968646/aiohttp-3.13.3.tar.gz", hash = "sha256:a949eee43d3782f2daae4f4a2819b2cb9b0c5d3b7f7a927067cc84dafdbb9f88", size = 7844556, upload-time = "2026-01-03T17:33:05.204Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8d/a8/5a35dc56a06a2c90d4742cbf35294396907027f80eea696637945a106f25/aiohttp-3.13.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d32764c6c9aafb7fb55366a224756387cd50bfa720f32b88e0e6fa45b27dcf29", size = 1737839, upload-time = "2026-01-03T17:30:19.422Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/62/4b9eeb331da56530bf2e198a297e5303e1c1ebdceeb00fe9b568a65c5a0c/aiohttp-3.13.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b1a6102b4d3ebc07dad44fbf07b45bb600300f15b552ddf1851b5390202ea2e3", size = 1703932, upload-time = "2026-01-03T17:30:21.756Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f6/af16887b5d419e6a367095994c0b1332d154f647e7dc2bd50e61876e8e3d/aiohttp-3.13.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c014c7ea7fb775dd015b2d3137378b7be0249a448a1612268b5a90c2d81de04d", size = 1771906, upload-time = "2026-01-03T17:30:23.932Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/83/397c634b1bcc24292fa1e0c7822800f9f6569e32934bdeef09dae7992dfb/aiohttp-3.13.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2b8d8ddba8f95ba17582226f80e2de99c7a7948e66490ef8d947e272a93e9463", size = 1871020, upload-time = "2026-01-03T17:30:26Z" },
+    { url = "https://files.pythonhosted.org/packages/86/f6/a62cbbf13f0ac80a70f71b1672feba90fdb21fd7abd8dbf25c0105fb6fa3/aiohttp-3.13.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ae8dd55c8e6c4257eae3a20fd2c8f41edaea5992ed67156642493b8daf3cecc", size = 1755181, upload-time = "2026-01-03T17:30:27.554Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/87/20a35ad487efdd3fba93d5843efdfaa62d2f1479eaafa7453398a44faf13/aiohttp-3.13.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:01ad2529d4b5035578f5081606a465f3b814c542882804e2e8cda61adf5c71bf", size = 1561794, upload-time = "2026-01-03T17:30:29.254Z" },
+    { url = "https://files.pythonhosted.org/packages/de/95/8fd69a66682012f6716e1bc09ef8a1a2a91922c5725cb904689f112309c4/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bb4f7475e359992b580559e008c598091c45b5088f28614e855e42d39c2f1033", size = 1697900, upload-time = "2026-01-03T17:30:31.033Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/66/7b94b3b5ba70e955ff597672dad1691333080e37f50280178967aff68657/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:c19b90316ad3b24c69cd78d5c9b4f3aa4497643685901185b65166293d36a00f", size = 1728239, upload-time = "2026-01-03T17:30:32.703Z" },
+    { url = "https://files.pythonhosted.org/packages/47/71/6f72f77f9f7d74719692ab65a2a0252584bf8d5f301e2ecb4c0da734530a/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:96d604498a7c782cb15a51c406acaea70d8c027ee6b90c569baa6e7b93073679", size = 1740527, upload-time = "2026-01-03T17:30:34.695Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/b4/75ec16cbbd5c01bdaf4a05b19e103e78d7ce1ef7c80867eb0ace42ff4488/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:084911a532763e9d3dd95adf78a78f4096cd5f58cdc18e6fdbc1b58417a45423", size = 1554489, upload-time = "2026-01-03T17:30:36.864Z" },
+    { url = "https://files.pythonhosted.org/packages/52/8f/bc518c0eea29f8406dcf7ed1f96c9b48e3bc3995a96159b3fc11f9e08321/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7a4a94eb787e606d0a09404b9c38c113d3b099d508021faa615d70a0131907ce", size = 1767852, upload-time = "2026-01-03T17:30:39.433Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/f2/a07a75173124f31f11ea6f863dc44e6f09afe2bca45dd4e64979490deab1/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:87797e645d9d8e222e04160ee32aa06bc5c163e8499f24db719e7852ec23093a", size = 1722379, upload-time = "2026-01-03T17:30:41.081Z" },
+]
+
+[[package]]
+name = "aiosignal"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "frozenlist", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" },
+]
+
+[[package]]
+name = "annotated-doc"
+version = "0.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anthropic"
+version = "0.86.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio", marker = "sys_platform == 'linux'" },
+    { name = "distro", marker = "sys_platform == 'linux'" },
+    { name = "docstring-parser", marker = "sys_platform == 'linux'" },
+    { name = "httpx", marker = "sys_platform == 'linux'" },
+    { name = "jiter", marker = "sys_platform == 'linux'" },
+    { name = "pydantic", marker = "sys_platform == 'linux'" },
+    { name = "sniffio", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/37/7a/8b390dc47945d3169875d342847431e5f7d5fa716b2e37494d57cfc1db10/anthropic-0.86.0.tar.gz", hash = "sha256:60023a7e879aa4fbb1fed99d487fe407b2ebf6569603e5047cfe304cebdaa0e5", size = 583820, upload-time = "2026-03-18T18:43:08.017Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/5f/67db29c6e5d16c8c9c4652d3efb934d89cb750cad201539141781d8eae14/anthropic-0.86.0-py3-none-any.whl", hash = "sha256:9d2bbd339446acce98858c5627d33056efe01f70435b22b63546fe7edae0cd57", size = 469400, upload-time = "2026-03-18T18:43:06.526Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" },
+]
+
+[[package]]
+name = "apache-tvm-ffi"
+version = "0.1.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6f/60/1e787a0b5ebf318483235be2a689ee367173983067e441b8379564f667c0/apache_tvm_ffi-0.1.9.tar.gz", hash = "sha256:d2d402587e8906de0a07f4746aa78f3d452c7efe3625d4bb39ac2ad693bce530", size = 2513731, upload-time = "2026-02-27T19:28:06.602Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a7/c0/6d3d54f50012255b41bc3e24944c086f63c4707c8686c7c6780e9283eb96/apache_tvm_ffi-0.1.9-cp312-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7d503029e66c43b1a1cb1a42a1e9bb428c8a28dcbdec31c28e705472ca648a3a", size = 2203712, upload-time = "2026-02-27T19:27:25.867Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/dd/2bab4c6cd86257dbf99e93452a1af833113f8dc3e25a25579f6e4e4c8a94/apache_tvm_ffi-0.1.9-cp312-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28241371934ea8af10d5067087ba1229ebddded7b2c02d33a258ec2a96df8c46", size = 2299704, upload-time = "2026-02-27T19:27:27.477Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/4a/b469bcb2e1014cb84d336d2a59f42958a058251c577a4c2680cacad346e2/apache_tvm_ffi-0.1.9-cp312-abi3-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:87cacce81df55685fc6a76e1e3c5db1200e85e87bf5974b692c59d131b7bc622", size = 2130865, upload-time = "2026-02-27T19:27:29.092Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ef/5402da5d37f5270fd88ea0348acca78dba9be8bdbf6c2bcae0935eb03ef1/apache_tvm_ffi-0.1.9-cp312-abi3-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f45eb43499acac45ff6c93564f0ff2d3ca27b69656d540fd56ce59d51c0b4c65", size = 2278991, upload-time = "2026-02-27T19:27:30.729Z" },
+]
+
+[[package]]
+name = "astor"
+version = "0.8.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5a/21/75b771132fee241dfe601d39ade629548a9626d1d39f333fde31bc46febe/astor-0.8.1.tar.gz", hash = "sha256:6a6effda93f4e1ce9f618779b2dd1d9d84f1e32812c23a29b3fff6fd7f63fa5e", size = 35090, upload-time = "2019-12-10T01:50:35.51Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c3/88/97eef84f48fa04fbd6750e62dcceafba6c63c81b7ac1420856c8dcc0a3f9/astor-0.8.1-py2.py3-none-any.whl", hash = "sha256:070a54e890cefb5b3739d19f30f5a5ec840ffc9c50ffa7d23cc9fc1a38ebbfc5", size = 27488, upload-time = "2019-12-10T01:50:33.628Z" },
+]
+
+[[package]]
+name = "attrs"
+version = "26.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" },
+]
+
+[[package]]
+name = "blake3"
+version = "1.0.8"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/75/aa/abcd75e9600987a0bc6cfe9b6b2ff3f0e2cb08c170addc6e76035b5c4cb3/blake3-1.0.8.tar.gz", hash = "sha256:513cc7f0f5a7c035812604c2c852a0c1468311345573de647e310aca4ab165ba", size = 117308, upload-time = "2025-10-14T06:47:48.83Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ee/7d/85a4c0782f613de23d114a7a78fcce270f75b193b3ff3493a0de24ba104a/blake3-1.0.8-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:269f255b110840e52b6ce9db02217e39660ebad3e34ddd5bca8b8d378a77e4e1", size = 371296, upload-time = "2025-10-14T06:45:49.674Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/20/488475254976ed93fab57c67aa80d3b40df77f7d9db6528c9274bff53e08/blake3-1.0.8-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:66ca28a673025c40db3eba21a9cac52f559f83637efa675b3f6bd8683f0415f3", size = 374516, upload-time = "2025-10-14T06:45:51.23Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/21/2a1c47fedb77fb396512677ec6d46caf42ac6e9a897db77edd0a2a46f7bb/blake3-1.0.8-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bcb04966537777af56c1f399b35525aa70a1225816e121ff95071c33c0f7abca", size = 447911, upload-time = "2025-10-14T06:45:52.637Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/7d/db0626df16029713e7e61b67314c4835e85c296d82bd907c21c6ea271da2/blake3-1.0.8-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e5b5da177d62cc4b7edf0cea08fe4dec960c9ac27f916131efa890a01f747b93", size = 505420, upload-time = "2025-10-14T06:45:54.445Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/55/6e737850c2d58a6d9de8a76dad2ae0f75b852a23eb4ecb07a0b165e6e436/blake3-1.0.8-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:38209b10482c97e151681ea3e91cc7141f56adbbf4820a7d701a923124b41e6a", size = 394189, upload-time = "2025-10-14T06:45:55.719Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/94/eafaa5cdddadc0c9c603a6a6d8339433475e1a9f60c8bb9c2eed2d8736b6/blake3-1.0.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:504d1399b7fb91dfe5c25722d2807990493185faa1917456455480c36867adb5", size = 388001, upload-time = "2025-10-14T06:45:57.067Z" },
+    { url = "https://files.pythonhosted.org/packages/17/81/735fa00d13de7f68b25e1b9cb36ff08c6f165e688d85d8ec2cbfcdedccc5/blake3-1.0.8-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c84af132aa09abeadf9a0118c8fb26f4528f3f42c10ef8be0fcf31c478774ec4", size = 550302, upload-time = "2025-10-14T06:45:58.657Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/c6/d1fe8bdea4a6088bd54b5a58bc40aed89a4e784cd796af7722a06f74bae7/blake3-1.0.8-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a25db3d36b55f5ed6a86470155cc749fc9c5b91c949b8d14f48658f9d960d9ec", size = 554211, upload-time = "2025-10-14T06:46:00.269Z" },
+]
+
+[[package]]
+name = "cachetools"
+version = "7.0.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/dd/57fe3fdb6e65b25a5987fd2cdc7e22db0aef508b91634d2e57d22928d41b/cachetools-7.0.5.tar.gz", hash = "sha256:0cd042c24377200c1dcd225f8b7b12b0ca53cc2c961b43757e774ebe190fd990", size = 37367, upload-time = "2026-03-09T20:51:29.451Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/06/f3/39cf3367b8107baa44f861dc802cbf16263c945b62d8265d36034fc07bea/cachetools-7.0.5-py3-none-any.whl", hash = "sha256:46bc8ebefbe485407621d0a4264b23c080cedd913921bad7ac3ed2f26c183114", size = 13918, upload-time = "2026-03-09T20:51:27.33Z" },
+]
+
+[[package]]
+name = "cbor2"
+version = "5.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/bd/cb/09939728be094d155b5d4ac262e39877875f5f7e36eea66beb359f647bd0/cbor2-5.9.0.tar.gz", hash = "sha256:85c7a46279ac8f226e1059275221e6b3d0e370d2bb6bd0500f9780781615bcea", size = 111231, upload-time = "2026-03-22T15:56:50.638Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/09/fd/7ddf3d3153b54c69c3be77172b8d9aa3a9d74f62a7fbde614d53eaeed9a4/cbor2-5.9.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ae6c706ac1d85a0b3cb3395308fd0c4d55e3202b4760773675957e93cdff45fc", size = 287865, upload-time = "2026-03-22T15:56:14.813Z" },
+    { url = "https://files.pythonhosted.org/packages/db/9d/7ede2cc42f9bb4260492e7d29d2aab781eacbbcfb09d983de1e695077199/cbor2-5.9.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4cd43d8fc374b31643b2830910f28177a606a7bc84975a62675dd3f2e320fc7b", size = 288246, upload-time = "2026-03-22T15:56:16.113Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/9d/588ebc7c5bc5843f609b05fe07be8575c7dec987735b0bbc908ac9c1264a/cbor2-5.9.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4aa07b392cc3d76fb31c08a46a226b58c320d1c172ff3073e864409ced7bc50f", size = 280214, upload-time = "2026-03-22T15:56:17.519Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/a1/6fc8f4b15c6a27e7fbb7966c30c2b4b18c274a3221fa2f5e6235502d34bc/cbor2-5.9.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:971d425b3a23b75953d8853d5f9911bdeefa09d759ee3b5e6b07b5ff3cbd9073", size = 282162, upload-time = "2026-03-22T15:56:18.975Z" },
+    { url = "https://files.pythonhosted.org/packages/42/ff/b83492b096fbef26e9cb62c1a4bf2d3cef579ea7b33138c6c37c4ae66f67/cbor2-5.9.0-py3-none-any.whl", hash = "sha256:27695cbd70c90b8de5c4a284642c2836449b14e2c2e07e3ffe0744cb7669a01b", size = 24627, upload-time = "2026-03-22T15:56:48.847Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.2.25"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
+]
+
+[[package]]
+name = "cffi"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser", marker = "implementation_name != 'PyPy' and sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" },
+    { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" },
+    { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7b/60/e3bec1881450851b087e301bedc3daa9377a4d45f1c26aa90b0b235e38aa/charset_normalizer-3.4.6.tar.gz", hash = "sha256:1ae6b62897110aa7c79ea2f5dd38d1abca6db663687c0b1ad9aed6f6bae3d9d6", size = 143363, upload-time = "2026-03-15T18:53:25.478Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a8/37/bdca6613c2e3c58c7421891d80cc3efa1d32e882f7c4a7ee6039c3fc951a/charset_normalizer-3.4.6-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a4ea868bc28109052790eb2b52a9ab33f3aa7adc02f96673526ff47419490e21", size = 199191, upload-time = "2026-03-15T18:50:52.658Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/92/9934d1bbd69f7f398b38c5dae1cbf9cc672e7c34a4adf7b17c0a9c17d15d/charset_normalizer-3.4.6-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:836ab36280f21fc1a03c99cd05c6b7af70d2697e374c7af0b61ed271401a72a2", size = 218674, upload-time = "2026-03-15T18:50:54.102Z" },
+    { url = "https://files.pythonhosted.org/packages/af/90/25f6ab406659286be929fd89ab0e78e38aa183fc374e03aa3c12d730af8a/charset_normalizer-3.4.6-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f1ce721c8a7dfec21fcbdfe04e8f68174183cf4e8188e0645e92aa23985c57ff", size = 215259, upload-time = "2026-03-15T18:50:55.616Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/ef/79a463eb0fff7f96afa04c1d4c51f8fc85426f918db467854bfb6a569ce3/charset_normalizer-3.4.6-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e28d62a8fc7a1fa411c43bd65e346f3bce9716dc51b897fbe930c5987b402d5", size = 207276, upload-time = "2026-03-15T18:50:57.054Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/72/d0426afec4b71dc159fa6b4e68f868cd5a3ecd918fec5813a15d292a7d10/charset_normalizer-3.4.6-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:530d548084c4a9f7a16ed4a294d459b4f229db50df689bfe92027452452943a0", size = 195161, upload-time = "2026-03-15T18:50:58.686Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/18/c82b06a68bfcb6ce55e508225d210c7e6a4ea122bfc0748892f3dc4e8e11/charset_normalizer-3.4.6-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:30f445ae60aad5e1f8bdbb3108e39f6fbc09f4ea16c815c66578878325f8f15a", size = 203452, upload-time = "2026-03-15T18:51:00.196Z" },
+    { url = "https://files.pythonhosted.org/packages/44/d6/0c25979b92f8adafdbb946160348d8d44aa60ce99afdc27df524379875cb/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ac2393c73378fea4e52aa56285a3d64be50f1a12395afef9cce47772f60334c2", size = 202272, upload-time = "2026-03-15T18:51:01.703Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/3d/7fea3e8fe84136bebbac715dd1221cc25c173c57a699c030ab9b8900cbb7/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:90ca27cd8da8118b18a52d5f547859cc1f8354a00cd1e8e5120df3e30d6279e5", size = 195622, upload-time = "2026-03-15T18:51:03.526Z" },
+    { url = "https://files.pythonhosted.org/packages/57/8a/d6f7fd5cb96c58ef2f681424fbca01264461336d2a7fc875e4446b1f1346/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8e5a94886bedca0f9b78fecd6afb6629142fd2605aa70a125d49f4edc6037ee6", size = 220056, upload-time = "2026-03-15T18:51:05.269Z" },
+    { url = "https://files.pythonhosted.org/packages/16/50/478cdda782c8c9c3fb5da3cc72dd7f331f031e7f1363a893cdd6ca0f8de0/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:695f5c2823691a25f17bc5d5ffe79fa90972cc34b002ac6c843bb8a1720e950d", size = 203751, upload-time = "2026-03-15T18:51:06.858Z" },
+    { url = "https://files.pythonhosted.org/packages/75/fc/cc2fcac943939c8e4d8791abfa139f685e5150cae9f94b60f12520feaa9b/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:231d4da14bcd9301310faf492051bee27df11f2bc7549bc0bb41fef11b82daa2", size = 216563, upload-time = "2026-03-15T18:51:08.564Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/b7/a4add1d9a5f68f3d037261aecca83abdb0ab15960a3591d340e829b37298/charset_normalizer-3.4.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a056d1ad2633548ca18ffa2f85c202cfb48b68615129143915b8dc72a806a923", size = 209265, upload-time = "2026-03-15T18:51:10.312Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/68/687187c7e26cb24ccbd88e5069f5ef00eba804d36dde11d99aad0838ab45/charset_normalizer-3.4.6-py3-none-any.whl", hash = "sha256:947cf925bc916d90adba35a64c82aace04fa39b46b52d4630ece166655905a69", size = 61455, upload-time = "2026-03-15T18:53:23.833Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
+]
+
+[[package]]
+name = "cloudpickle"
+version = "3.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/27/fb/576f067976d320f5f0114a8d9fa1215425441bb35627b1993e5afd8111e5/cloudpickle-3.1.2.tar.gz", hash = "sha256:7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414", size = 22330, upload-time = "2025-11-03T09:25:26.604Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl", hash = "sha256:9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a", size = 22228, upload-time = "2025-11-03T09:25:25.534Z" },
+]
+
+[[package]]
+name = "compressed-tensors"
+version = "0.14.0.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "loguru", marker = "sys_platform == 'linux'" },
+    { name = "pydantic", marker = "sys_platform == 'linux'" },
+    { name = "torch", marker = "sys_platform == 'linux'" },
+    { name = "transformers", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/f1/4c9b01ceaf82ad58ad00919223e09b8e74d4073a2ba8e3ab2f97521ef65c/compressed_tensors-0.14.0.1.tar.gz", hash = "sha256:5ad3841184b6f5020e06059b2463191c5c57a144bb97cab9159978d8118839b1", size = 226393, upload-time = "2026-03-11T17:04:35.57Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0a/26/16a13993ecf4fdc9c39d63b3a6daabafd32a452cf68b81aa9eb3b8170913/compressed_tensors-0.14.0.1-py3-none-any.whl", hash = "sha256:46c4940a3a779d3d97108c294bfcd9acf4bd0491f7c6737c320f0e815ec732e4", size = 196454, upload-time = "2026-03-11T17:04:33.2Z" },
+]
+
+[[package]]
+name = "cramjam"
+version = "2.11.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/14/12/34bf6e840a79130dfd0da7badfb6f7810b8fcfd60e75b0539372667b41b6/cramjam-2.11.0.tar.gz", hash = "sha256:5c82500ed91605c2d9781380b378397012e25127e89d64f460fea6aeac4389b4", size = 99100, upload-time = "2025-07-27T21:25:07.559Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/52/0851a16a62447532e30ba95a80e638926fdea869a34b4b5b9d0a020083ba/cramjam-2.11.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:4f8d82081ed7d8fe52c982bd1f06e4c7631a73fe1fb6d4b3b3f2404f87dc40fe", size = 2025285, upload-time = "2025-07-27T21:22:32.954Z" },
+    { url = "https://files.pythonhosted.org/packages/98/76/122e444f59dbc216451d8e3d8282c9665dc79eaf822f5f1470066be1b695/cramjam-2.11.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:092a3ec26e0a679305018380e4f652eae1b6dfe3fc3b154ee76aa6b92221a17c", size = 1761327, upload-time = "2025-07-27T21:22:34.484Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/bc/3a0189aef1af2b29632c039c19a7a1b752bc21a4053582a5464183a0ad3d/cramjam-2.11.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:529d6d667c65fd105d10bd83d1cd3f9869f8fd6c66efac9415c1812281196a92", size = 1854075, upload-time = "2025-07-27T21:22:36.157Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/80/8a6343b13778ce52d94bb8d5365a30c3aa951276b1857201fe79d7e2ad25/cramjam-2.11.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:555eb9c90c450e0f76e27d9ff064e64a8b8c6478ab1a5594c91b7bc5c82fd9f0", size = 2032710, upload-time = "2025-07-27T21:22:38.17Z" },
+    { url = "https://files.pythonhosted.org/packages/df/6b/cd1778a207c29eda10791e3dfa018b588001928086e179fc71254793c625/cramjam-2.11.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5edf4c9e32493035b514cf2ba0c969d81ccb31de63bd05490cc8bfe3b431674e", size = 2068353, upload-time = "2025-07-27T21:22:39.615Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/f0/5c2a5cd5711032f3b191ca50cb786c17689b4a9255f9f768866e6c9f04d9/cramjam-2.11.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2fa2fe41f48c4d58d923803383b0737f048918b5a0d10390de9628bb6272b107", size = 1978104, upload-time = "2025-07-27T21:22:41.106Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/8b/b363a5fb2c3347504fe9a64f8d0f1e276844f0e532aa7162c061cd1ffee4/cramjam-2.11.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:9ca14cf1cabdb0b77d606db1bb9e9ca593b1dbd421fcaf251ec9a5431ec449f3", size = 2030779, upload-time = "2025-07-27T21:22:42.969Z" },
+    { url = "https://files.pythonhosted.org/packages/78/7b/d83dad46adb6c988a74361f81ad9c5c22642be53ad88616a19baedd06243/cramjam-2.11.0-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:309e95bf898829476bccf4fd2c358ec00e7ff73a12f95a3cdeeba4bb1d3683d5", size = 2155297, upload-time = "2025-07-27T21:22:44.6Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/be/60d9be4cb33d8740a4aa94c7513f2ef3c4eba4fd13536f086facbafade71/cramjam-2.11.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:86dca35d2f15ef22922411496c220f3c9e315d5512f316fe417461971cc1648d", size = 2169255, upload-time = "2025-07-27T21:22:46.534Z" },
+    { url = "https://files.pythonhosted.org/packages/11/b0/4a595f01a243aec8ad272b160b161c44351190c35d98d7787919d962e9e5/cramjam-2.11.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:193c6488bd2f514cbc0bef5c18fad61a5f9c8d059dd56edf773b3b37f0e85496", size = 2155651, upload-time = "2025-07-27T21:22:48.46Z" },
+]
+
+[[package]]
+name = "cryptography"
+version = "46.0.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "platform_python_implementation != 'PyPy' and sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a4/ba/04b1bd4218cbc58dc90ce967106d51582371b898690f3ae0402876cc4f34/cryptography-46.0.6.tar.gz", hash = "sha256:27550628a518c5c6c903d84f637fbecf287f6cb9ced3804838a1295dc1fd0759", size = 750542, upload-time = "2026-03-25T23:34:53.396Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/60/f8/e61f8f13950ab6195b31913b42d39f0f9afc7d93f76710f299b5ec286ae6/cryptography-46.0.6-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:26031f1e5ca62fcb9d1fcb34b2b60b390d1aacaa15dc8b895a9ed00968b97b30", size = 4275275, upload-time = "2026-03-25T23:33:23.844Z" },
+    { url = "https://files.pythonhosted.org/packages/19/69/732a736d12c2631e140be2348b4ad3d226302df63ef64d30dfdb8db7ad1c/cryptography-46.0.6-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9a693028b9cbe51b5a1136232ee8f2bc242e4e19d456ded3fa7c86e43c713b4a", size = 4425320, upload-time = "2026-03-25T23:33:25.703Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/12/123be7292674abf76b21ac1fc0e1af50661f0e5b8f0ec8285faac18eb99e/cryptography-46.0.6-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:67177e8a9f421aa2d3a170c3e56eca4e0128883cf52a071a7cbf53297f18b175", size = 4278082, upload-time = "2026-03-25T23:33:27.423Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/ba/d5e27f8d68c24951b0a484924a84c7cdaed7502bac9f18601cd357f8b1d2/cryptography-46.0.6-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:d9528b535a6c4f8ff37847144b8986a9a143585f0540fbcb1a98115b543aa463", size = 4926514, upload-time = "2026-03-25T23:33:29.206Z" },
+    { url = "https://files.pythonhosted.org/packages/34/71/1ea5a7352ae516d5512d17babe7e1b87d9db5150b21f794b1377eac1edc0/cryptography-46.0.6-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:22259338084d6ae497a19bae5d4c66b7ca1387d3264d1c2c0e72d9e9b6a77b97", size = 4457766, upload-time = "2026-03-25T23:33:30.834Z" },
+    { url = "https://files.pythonhosted.org/packages/01/59/562be1e653accee4fdad92c7a2e88fced26b3fdfce144047519bbebc299e/cryptography-46.0.6-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:760997a4b950ff00d418398ad73fbc91aa2894b5c1db7ccb45b4f68b42a63b3c", size = 3986535, upload-time = "2026-03-25T23:33:33.02Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/8b/b1ebfeb788bf4624d36e45ed2662b8bd43a05ff62157093c1539c1288a18/cryptography-46.0.6-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:3dfa6567f2e9e4c5dceb8ccb5a708158a2a871052fa75c8b78cb0977063f1507", size = 4277618, upload-time = "2026-03-25T23:33:34.567Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/52/a005f8eabdb28df57c20f84c44d397a755782d6ff6d455f05baa2785bd91/cryptography-46.0.6-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:cdcd3edcbc5d55757e5f5f3d330dd00007ae463a7e7aa5bf132d1f22a4b62b19", size = 4890802, upload-time = "2026-03-25T23:33:37.034Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/4d/8e7d7245c79c617d08724e2efa397737715ca0ec830ecb3c91e547302555/cryptography-46.0.6-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:d4e4aadb7fc1f88687f47ca20bb7227981b03afaae69287029da08096853b738", size = 4457425, upload-time = "2026-03-25T23:33:38.904Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/5c/f6c3596a1430cec6f949085f0e1a970638d76f81c3ea56d93d564d04c340/cryptography-46.0.6-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:2b417edbe8877cda9022dde3a008e2deb50be9c407eef034aeeb3a8b11d9db3c", size = 4405530, upload-time = "2026-03-25T23:33:40.842Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/c9/9f9cea13ee2dbde070424e0c4f621c091a91ffcc504ffea5e74f0e1daeff/cryptography-46.0.6-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:380343e0653b1c9d7e1f55b52aaa2dbb2fdf2730088d48c43ca1c7c0abb7cc2f", size = 4667896, upload-time = "2026-03-25T23:33:42.781Z" },
+    { url = "https://files.pythonhosted.org/packages/49/b3/dc27efd8dcc4bff583b3f01d4a3943cd8b5821777a58b3a6a5f054d61b79/cryptography-46.0.6-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:639301950939d844a9e1c4464d7e07f902fe9a7f6b215bb0d4f28584729935d8", size = 4270529, upload-time = "2026-03-25T23:34:15.019Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/05/e8d0e6eb4f0d83365b3cb0e00eb3c484f7348db0266652ccd84632a3d58d/cryptography-46.0.6-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ed3775295fb91f70b4027aeba878d79b3e55c0b3e97eaa4de71f8f23a9f2eb77", size = 4414827, upload-time = "2026-03-25T23:34:16.604Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/97/daba0f5d2dc6d855e2dcb70733c812558a7977a55dd4a6722756628c44d1/cryptography-46.0.6-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:8927ccfbe967c7df312ade694f987e7e9e22b2425976ddbf28271d7e58845290", size = 4271265, upload-time = "2026-03-25T23:34:18.586Z" },
+    { url = "https://files.pythonhosted.org/packages/89/06/fe1fce39a37ac452e58d04b43b0855261dac320a2ebf8f5260dd55b201a9/cryptography-46.0.6-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:b12c6b1e1651e42ab5de8b1e00dc3b6354fdfd778e7fa60541ddacc27cd21410", size = 4916800, upload-time = "2026-03-25T23:34:20.561Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/8a/b14f3101fe9c3592603339eb5d94046c3ce5f7fc76d6512a2d40efd9724e/cryptography-46.0.6-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:063b67749f338ca9c5a0b7fe438a52c25f9526b851e24e6c9310e7195aad3b4d", size = 4448771, upload-time = "2026-03-25T23:34:22.406Z" },
+    { url = "https://files.pythonhosted.org/packages/01/b3/0796998056a66d1973fd52ee89dc1bb3b6581960a91ad4ac705f182d398f/cryptography-46.0.6-cp38-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:02fad249cb0e090b574e30b276a3da6a149e04ee2f049725b1f69e7b8351ec70", size = 3978333, upload-time = "2026-03-25T23:34:24.281Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/3d/db200af5a4ffd08918cd55c08399dc6c9c50b0bc72c00a3246e099d3a849/cryptography-46.0.6-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:7e6142674f2a9291463e5e150090b95a8519b2fb6e6aaec8917dd8d094ce750d", size = 4271069, upload-time = "2026-03-25T23:34:25.895Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/18/61acfd5b414309d74ee838be321c636fe71815436f53c9f0334bf19064fa/cryptography-46.0.6-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:456b3215172aeefb9284550b162801d62f5f264a081049a3e94307fe20792cfa", size = 4878358, upload-time = "2026-03-25T23:34:27.67Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/65/5bf43286d566f8171917cae23ac6add941654ccf085d739195a4eacf1674/cryptography-46.0.6-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:341359d6c9e68834e204ceaf25936dffeafea3829ab80e9503860dcc4f4dac58", size = 4448061, upload-time = "2026-03-25T23:34:29.375Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/25/7e49c0fa7205cf3597e525d156a6bce5b5c9de1fd7e8cb01120e459f205a/cryptography-46.0.6-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9a9c42a2723999a710445bc0d974e345c32adfd8d2fac6d8a251fa829ad31cfb", size = 4399103, upload-time = "2026-03-25T23:34:32.036Z" },
+    { url = "https://files.pythonhosted.org/packages/44/46/466269e833f1c4718d6cd496ffe20c56c9c8d013486ff66b4f69c302a68d/cryptography-46.0.6-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6617f67b1606dfd9fe4dbfa354a9508d4a6d37afe30306fe6c101b7ce3274b72", size = 4659255, upload-time = "2026-03-25T23:34:33.679Z" },
+]
+
+[[package]]
+name = "cuda-bindings"
+version = "13.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cuda-pathfinder", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/61/3c/c33fd3aa5fcc89aa1c135e477a0561f29142ab5fe028ca425fc87f7f0a74/cuda_bindings-13.0.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b899e5a513c11eaa18648f9bf5265d8de2a93f76ef66a6bfca0a2887303965cd", size = 11709086, upload-time = "2025-10-21T15:09:00.005Z" },
+    { url = "https://files.pythonhosted.org/packages/21/ac/6b34452a3836c9fbabcd360689a353409d15f500dd9d9ced7f837549e383/cuda_bindings-13.0.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cf41d9e69019939aa15296fa66ea7d3fdb8d2c6383f729f4b1156c8b37808a06", size = 12128303, upload-time = "2025-10-21T15:09:02.889Z" },
+]
+
+[[package]]
+name = "cuda-pathfinder"
+version = "1.5.0"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/93/66/0c02bd330e7d976f83fa68583d6198d76f23581bcbb5c0e98a6148f326e5/cuda_pathfinder-1.5.0-py3-none-any.whl", hash = "sha256:498f90a9e9de36044a7924742aecce11c50c49f735f1bc53e05aa46de9ea4110", size = 49739, upload-time = "2026-03-24T21:14:30.869Z" },
+]
+
+[[package]]
+name = "cuda-python"
+version = "13.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cuda-bindings", marker = "sys_platform == 'linux'" },
+    { name = "cuda-pathfinder", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/31/5f/beaa12a11b051027eec0b041df01c6690db4f02e3b2e8fadd5a0eeb4df52/cuda_python-13.0.3-py3-none-any.whl", hash = "sha256:914cd7e2dd075bd06a2d5121c1d9ccdd3d0c94b03ea5a44dbd98d24d8ed93bab", size = 7605, upload-time = "2025-10-21T15:48:59.222Z" },
+]
+
+[[package]]
+name = "depyf"
+version = "0.20.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "astor", marker = "sys_platform == 'linux'" },
+    { name = "dill", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/88/35/83fb0178212279aa0af031031905804c6de5618435d229f41ed21bb9ad2c/depyf-0.20.0.tar.gz", hash = "sha256:fb7683bd72c44f67b56029df2c47721e9a02ffa4d7b19095f1c54c4ebf797a98", size = 6168761, upload-time = "2025-10-13T12:33:38.589Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cf/65/4df6936130b56e1429114e663e7c1576cf845f3aef1b2dd200c0a5d19dba/depyf-0.20.0-py3-none-any.whl", hash = "sha256:d31effad4261cebecb58955d832e448ace88f432328f95f82fd99c30fd9308d4", size = 39381, upload-time = "2025-10-13T12:33:33.647Z" },
+]
+
+[[package]]
+name = "dill"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/81/e1/56027a71e31b02ddc53c7d65b01e68edf64dea2932122fe7746a516f75d5/dill-0.4.1.tar.gz", hash = "sha256:423092df4182177d4d8ba8290c8a5b640c66ab35ec7da59ccfa00f6fa3eea5fa", size = 187315, upload-time = "2026-01-19T02:36:56.85Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/77/dc8c558f7593132cf8fefec57c4f60c83b16941c574ac5f619abb3ae7933/dill-0.4.1-py3-none-any.whl", hash = "sha256:1e1ce33e978ae97fcfcff5638477032b801c46c7c65cf717f95fbc2248f79a9d", size = 120019, upload-time = "2026-01-19T02:36:55.663Z" },
+]
+
+[[package]]
+name = "diskcache"
+version = "5.6.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/3f/21/1c1ffc1a039ddcc459db43cc108658f32c57d271d7289a2794e401d0fdb6/diskcache-5.6.3.tar.gz", hash = "sha256:2c3a3fa2743d8535d832ec61c2054a1641f41775aa7c556758a109941e33e4fc", size = 67916, upload-time = "2023-08-31T06:12:00.316Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3f/27/4570e78fc0bf5ea0ca45eb1de3818a23787af9b390c0b0a0033a1b8236f9/diskcache-5.6.3-py3-none-any.whl", hash = "sha256:5e31b2d5fbad117cc363ebaf6b689474db18a1f6438bc82358b024abd4c2ca19", size = 45550, upload-time = "2023-08-31T06:11:58.822Z" },
+]
+
+[[package]]
+name = "distro"
+version = "1.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed", size = 60722, upload-time = "2023-12-24T09:54:32.31Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" },
+]
+
+[[package]]
+name = "dnspython"
+version = "2.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/8b/57666417c0f90f08bcafa776861060426765fdb422eb10212086fb811d26/dnspython-2.8.0.tar.gz", hash = "sha256:181d3c6996452cb1189c4046c61599b84a5a86e099562ffde77d26984ff26d0f", size = 368251, upload-time = "2025-09-07T18:58:00.022Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ba/5a/18ad964b0086c6e62e2e7500f7edc89e3faa45033c71c1893d34eed2b2de/dnspython-2.8.0-py3-none-any.whl", hash = "sha256:01d9bbc4a2d76bf0db7c1f729812ded6d912bd318d3b1cf81d30c0f845dbf3af", size = 331094, upload-time = "2025-09-07T18:57:58.071Z" },
+]
+
+[[package]]
+name = "docstring-parser"
+version = "0.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b2/9d/c3b43da9515bd270df0f80548d9944e389870713cc1fe2b8fb35fe2bcefd/docstring_parser-0.17.0.tar.gz", hash = "sha256:583de4a309722b3315439bb31d64ba3eebada841f2e2cee23b99df001434c912", size = 27442, upload-time = "2025-07-21T07:35:01.868Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/55/e2/2537ebcff11c1ee1ff17d8d0b6f4db75873e3b0fb32c2d4a2ee31ecb310a/docstring_parser-0.17.0-py3-none-any.whl", hash = "sha256:cf2569abd23dce8099b300f9b4fa8191e9582dda731fd533daf54c4551658708", size = 36896, upload-time = "2025-07-21T07:35:00.684Z" },
+]
+
+[[package]]
+name = "einops"
+version = "0.8.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2c/77/850bef8d72ffb9219f0b1aac23fbc1bf7d038ee6ea666f331fa273031aa2/einops-0.8.2.tar.gz", hash = "sha256:609da665570e5e265e27283aab09e7f279ade90c4f01bcfca111f3d3e13f2827", size = 56261, upload-time = "2026-01-26T04:13:17.638Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/09/f8d8f8f31e4483c10a906437b4ce31bdf3d6d417b73fe33f1a8b59e34228/einops-0.8.2-py3-none-any.whl", hash = "sha256:54058201ac7087911181bfec4af6091bb59380360f069276601256a76af08193", size = 65638, upload-time = "2026-01-26T04:13:18.546Z" },
+]
+
+[[package]]
+name = "email-validator"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "dnspython", marker = "sys_platform == 'linux'" },
+    { name = "idna", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f5/22/900cb125c76b7aaa450ce02fd727f452243f2e91a61af068b40adba60ea9/email_validator-2.3.0.tar.gz", hash = "sha256:9fc05c37f2f6cf439ff414f8fc46d917929974a82244c20eb10231ba60c54426", size = 51238, upload-time = "2025-08-26T13:09:06.831Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/15/545e2b6cf2e3be84bc1ed85613edd75b8aea69807a71c26f4ca6a9258e82/email_validator-2.3.0-py3-none-any.whl", hash = "sha256:80f13f623413e6b197ae73bb10bf4eb0908faf509ad8362c5edeb0be7fd450b4", size = 35604, upload-time = "2025-08-26T13:09:05.858Z" },
+]
+
+[[package]]
+name = "exllamav2"
+version = "0.3.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "fastparquet", marker = "sys_platform == 'linux'" },
+    { name = "ninja", marker = "sys_platform == 'linux'" },
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "pandas", marker = "sys_platform == 'linux'" },
+    { name = "pillow", marker = "sys_platform == 'linux'" },
+    { name = "pygments", marker = "sys_platform == 'linux'" },
+    { name = "regex", marker = "sys_platform == 'linux'" },
+    { name = "rich", marker = "sys_platform == 'linux'" },
+    { name = "safetensors", marker = "sys_platform == 'linux'" },
+    { name = "torch", marker = "sys_platform == 'linux'" },
+    { name = "websockets", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/25/6f/dd7fac30c1e93d6a58a4a8d96cea6597710cdd114e7cc4fdc0476ad61d03/exllamav2-0.3.2-py3-none-any.whl", hash = "sha256:7cd61ae4bf1d8d12034595ab9731f0f43bac415d6394fbb273d4383293d6079e", size = 1519385, upload-time = "2025-07-14T06:31:21.277Z" },
+]
+
+[[package]]
+name = "fastapi"
+version = "0.135.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc", marker = "sys_platform == 'linux'" },
+    { name = "pydantic", marker = "sys_platform == 'linux'" },
+    { name = "starlette", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+    { name = "typing-inspection", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c4/73/5903c4b13beae98618d64eb9870c3fac4f605523dd0312ca5c80dadbd5b9/fastapi-0.135.2.tar.gz", hash = "sha256:88a832095359755527b7f63bb4c6bc9edb8329a026189eed83d6c1afcf419d56", size = 395833, upload-time = "2026-03-23T14:12:41.697Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8f/ea/18f6d0457f9efb2fc6fa594857f92810cadb03024975726db6546b3d6fcf/fastapi-0.135.2-py3-none-any.whl", hash = "sha256:0af0447d541867e8db2a6a25c23a8c4bd80e2394ac5529bd87501bbb9e240ca5", size = 117407, upload-time = "2026-03-23T14:12:43.284Z" },
+]
+
+[package.optional-dependencies]
+standard = [
+    { name = "email-validator", marker = "sys_platform == 'linux'" },
+    { name = "fastapi-cli", extra = ["standard"], marker = "sys_platform == 'linux'" },
+    { name = "httpx", marker = "sys_platform == 'linux'" },
+    { name = "jinja2", marker = "sys_platform == 'linux'" },
+    { name = "pydantic-extra-types", marker = "sys_platform == 'linux'" },
+    { name = "pydantic-settings", marker = "sys_platform == 'linux'" },
+    { name = "python-multipart", marker = "sys_platform == 'linux'" },
+    { name = "uvicorn", extra = ["standard"], marker = "sys_platform == 'linux'" },
+]
+
+[[package]]
+name = "fastapi-cli"
+version = "0.0.24"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "rich-toolkit", marker = "sys_platform == 'linux'" },
+    { name = "typer", marker = "sys_platform == 'linux'" },
+    { name = "uvicorn", extra = ["standard"], marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6e/58/74797ae9e4610cfa0c6b34c8309096d3b20bb29be3b8b5fbf1004d10fa5f/fastapi_cli-0.0.24.tar.gz", hash = "sha256:1afc9c9e21d7ebc8a3ca5e31790cd8d837742be7e4f8b9236e99cb3451f0de00", size = 19043, upload-time = "2026-02-24T10:45:10.476Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/4b/68f9fe268e535d79c76910519530026a4f994ce07189ac0dded45c6af825/fastapi_cli-0.0.24-py3-none-any.whl", hash = "sha256:4a1f78ed798f106b4fee85ca93b85d8fe33c0a3570f775964d37edb80b8f0edc", size = 12304, upload-time = "2026-02-24T10:45:09.552Z" },
+]
+
+[package.optional-dependencies]
+standard = [
+    { name = "fastapi-cloud-cli", marker = "sys_platform == 'linux'" },
+    { name = "uvicorn", extra = ["standard"], marker = "sys_platform == 'linux'" },
+]
+
+[[package]]
+name = "fastapi-cloud-cli"
+version = "0.15.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "fastar", marker = "sys_platform == 'linux'" },
+    { name = "httpx", marker = "sys_platform == 'linux'" },
+    { name = "pydantic", extra = ["email"], marker = "sys_platform == 'linux'" },
+    { name = "rich-toolkit", marker = "sys_platform == 'linux'" },
+    { name = "rignore", marker = "sys_platform == 'linux'" },
+    { name = "sentry-sdk", marker = "sys_platform == 'linux'" },
+    { name = "typer", marker = "sys_platform == 'linux'" },
+    { name = "uvicorn", extra = ["standard"], marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7f/f2/fcd66ce245b7e3c3d84ca8717eda8896945fbc17c87a9b03f490ff06ace7/fastapi_cloud_cli-0.15.1.tar.gz", hash = "sha256:71a46f8a1d9fea295544113d6b79f620dc5768b24012887887306d151165745d", size = 43851, upload-time = "2026-03-26T10:23:12.932Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b2/11/ecb0d5e1d114e8aaec1cdc8ee2d7b0f54292585067effe2756bde7e7a4b0/fastapi_cloud_cli-0.15.1-py3-none-any.whl", hash = "sha256:b1e8b3b26dc314e180fc0ab67dfd39d7d9fe160d3951081d09184eafaacf5649", size = 32284, upload-time = "2026-03-26T10:23:14.151Z" },
+]
+
+[[package]]
+name = "fastar"
+version = "0.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/dd/00/dab9ca274cf1fde19223fea7104631bea254751026e75bf99f2b6d0d1568/fastar-0.9.0.tar.gz", hash = "sha256:d49114d5f0b76c5cc242875d90fa4706de45e0456ddedf416608ecd0787fb410", size = 70124, upload-time = "2026-03-20T14:26:34.503Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a9/ad/e2499d136e24c2d896f2ec58183c91c6f8185d758177537724ed2f3e1b54/fastar-0.9.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:ad46bc23040142e9be4b4005ea366834dbf0f1b6a90b8ecdc3ec96c42dec4adf", size = 865265, upload-time = "2026-03-20T14:24:55.418Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/cf/b6ad68b2ab1d7b74b0d38725d817418016bdd64880b36108be80d2460b4d/fastar-0.9.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:de264da9e8ef6407aa0b23c7c47ed4e34fde867e7c1f6e3cb98945a93e5f89f2", size = 760583, upload-time = "2026-03-20T14:23:50.447Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/96/086116ad46e3b98f6c217919d680e619f2857ffa6b5cc0d7e46e4f214b83/fastar-0.9.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:75c70be3a7da3ff9342f64c15ec3749c13ef56bc28e69075d82d03768532a8d0", size = 758000, upload-time = "2026-03-20T14:24:03.471Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/e6/ea642ea61eea98d609343080399a296a9ff132bd0492a6638d6e0d9e41a7/fastar-0.9.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4a734506b071d2a8844771fe735fbd6d67dd0eec80eef5f189bbe763ebe7a0b8", size = 923647, upload-time = "2026-03-20T14:24:16.875Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/3e/53874aad61e4a664af555a2aa7a52fe46cfadd423db0e592fa0cfe0fa668/fastar-0.9.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8eac084ab215aaf65fa406c9b9da1ac4e697c3d3a1a183e09c488e555802f62d", size = 816528, upload-time = "2026-03-20T14:24:42.048Z" },
+    { url = "https://files.pythonhosted.org/packages/41/df/d663214d35380b07a24a796c48d7d7d4dc3a28ec0756edbcb7e2a81dc572/fastar-0.9.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:acb62e2369834fb23d26327157f0a2dbec40b230c709fa85b1ce96cf010e6fbf", size = 819050, upload-time = "2026-03-20T14:25:08.352Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/5a/455b53f11527568100ba6d5847635430645bad62d676f0bae4173fc85c90/fastar-0.9.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:f2f399fffb74bcd9e9d4507e253ace2430b5ccf61000596bda41e90414bcf4f2", size = 885257, upload-time = "2026-03-20T14:24:28.86Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/dd/0a8ea7b910293b07f8c82ef4e6451262ccf2a6f2020e880f184dc4abd6c2/fastar-0.9.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:87006c8770dfc558aefe927590bbcdaf9648ca4472a9ee6d10dfb7c0bda4ce5b", size = 968135, upload-time = "2026-03-20T14:25:45.614Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/cb/5c7e9231d6ba00e225623947068db09ddd4e401800b0afaf39eece14bfee/fastar-0.9.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:4d012644421d669d9746157193f4eafd371e8ae56ff7aef97612a4922418664c", size = 1034940, upload-time = "2026-03-20T14:25:58.893Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/b4/eccfcf7fe9d2a0cea6d71630acc48a762404058c9b3ae1323f74abcda005/fastar-0.9.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:094fd03b2e41b20a2602d340e2b52ad10051d82caa1263411cf247c1b1bc139f", size = 1073807, upload-time = "2026-03-20T14:26:11.694Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/53/6ddda28545b428d54c42f341d797046467c689616a36eae9a43ba56f2545/fastar-0.9.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:59bc500d7b6bdaf2ffb2b632bc6b0f97ddfb3bb7d31b54d61ceb00b5698d6484", size = 1025314, upload-time = "2026-03-20T14:26:24.624Z" },
+]
+
+[[package]]
+name = "fastparquet"
+version = "2026.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cramjam", marker = "sys_platform == 'linux'" },
+    { name = "fsspec", marker = "sys_platform == 'linux'" },
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "packaging", marker = "sys_platform == 'linux'" },
+    { name = "pandas", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/ef/78a5db203e2e1d19249286f52ecb5531b8863e56a346d9d193633c3030fd/fastparquet-2026.3.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:41def5d94abf44830e58b4c2ed137b71f2f0e068c6241a1d2524595178880851", size = 1763256, upload-time = "2026-03-17T21:20:48.875Z" },
+    { url = "https://files.pythonhosted.org/packages/61/99/e43283ac6cc83269c8214b8ee57e7773ea5f39016a8e8fcfe4529fa2cc30/fastparquet-2026.3.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6a5ddb40b58b62ef660ea9f0774d3b3cfe6d0b88c20b44b986e500439290de81", size = 1810605, upload-time = "2026-03-17T21:20:50.846Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/9a/f5aada3af89dcd3027e543fa39756f67790daef0c31f03973bb97c6171c9/fastparquet-2026.3.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f6cc397aa8ca5bb2e84670270b46a89e6d6e426f8bfce5437d028a90cd2d8b3d", size = 1819611, upload-time = "2026-03-20T17:17:43.306Z" },
+    { url = "https://files.pythonhosted.org/packages/07/92/bdd4d8dfd59a6ae92b33eab0f583fd5099188c8065d875d22782f26b79e0/fastparquet-2026.3.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:46c60acc4b5752cd883bd0cc9076a01698b1b5f28cb7f94449fba68f40758316", size = 1783750, upload-time = "2026-03-17T21:20:52.819Z" },
+    { url = "https://files.pythonhosted.org/packages/70/7d/d46abd9713f53d90ebc47c373d78ddb34c24e5fa6a02c5a974370f8a57b0/fastparquet-2026.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c61d734cff4d29f16bf1c813b4d1725dec3676cb82a2f617713a894b4e97546d", size = 1816343, upload-time = "2026-03-20T17:17:46.005Z" },
+]
+
+[[package]]
+name = "filelock"
+version = "3.25.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/b8/00651a0f559862f3bb7d6f7477b192afe3f583cc5e26403b44e59a55ab34/filelock-3.25.2.tar.gz", hash = "sha256:b64ece2b38f4ca29dd3e810287aa8c48182bbecd1ae6e9ae126c9b35f1382694", size = 40480, upload-time = "2026-03-11T20:45:38.487Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/a5/842ae8f0c08b61d6484b52f99a03510a3a72d23141942d216ebe81fefbce/filelock-3.25.2-py3-none-any.whl", hash = "sha256:ca8afb0da15f229774c9ad1b455ed96e85a81373065fb10446672f64444ddf70", size = 26759, upload-time = "2026-03-11T20:45:37.437Z" },
+]
+
+[[package]]
+name = "flashinfer-cubin"
+version = "0.6.6"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/e8/826f9452bc5f76b94d7eb025f03dcaf1b51b9ed7790386c0285191e69be4/flashinfer_cubin-0.6.6-py3-none-any.whl", hash = "sha256:36508dfc792eb5ecfb15d2c140a7702812e1fa1ab0fb03929b2ed55e3e8191f3", size = 267661457, upload-time = "2026-03-11T01:36:36.538Z" },
+]
+
+[[package]]
+name = "flashinfer-python"
+version = "0.6.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "apache-tvm-ffi", marker = "sys_platform == 'linux'" },
+    { name = "click", marker = "sys_platform == 'linux'" },
+    { name = "einops", marker = "sys_platform == 'linux'" },
+    { name = "ninja", marker = "sys_platform == 'linux'" },
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cudnn-frontend", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cutlass-dsl", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-ml-py", marker = "sys_platform == 'linux'" },
+    { name = "packaging", marker = "sys_platform == 'linux'" },
+    { name = "requests", marker = "sys_platform == 'linux'" },
+    { name = "tabulate", marker = "sys_platform == 'linux'" },
+    { name = "torch", marker = "sys_platform == 'linux'" },
+    { name = "tqdm", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/03/70/c5a235297351021f5d3d3233523a85f5a6468495587489ad2f257e8eafe2/flashinfer_python-0.6.6.tar.gz", hash = "sha256:0730ba7c7aad332961933bcebc5119762797161ede57d955f6fd199818ed1d92", size = 5344156, upload-time = "2026-03-11T01:36:21.434Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/61/385d06755f3ab66333018285657adf0daf8a90a129448231fd09e315bd2e/flashinfer_python-0.6.6-py3-none-any.whl", hash = "sha256:078f158636969eec1a0d3dea19c3ca90b426b66df89bbf7b7b8276ce2ec08148", size = 7817047, upload-time = "2026-03-11T01:36:19.198Z" },
+]
+
+[[package]]
+name = "frozenlist"
+version = "1.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" },
+    { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" },
+    { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" },
+]
+
+[[package]]
+name = "fsspec"
+version = "2026.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e1/cf/b50ddf667c15276a9ab15a70ef5f257564de271957933ffea49d2cdbcdfb/fsspec-2026.3.0.tar.gz", hash = "sha256:1ee6a0e28677557f8c2f994e3eea77db6392b4de9cd1f5d7a9e87a0ae9d01b41", size = 313547, upload-time = "2026-03-27T19:11:14.892Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d5/1f/5f4a3cd9e4440e9d9bc78ad0a91a1c8d46b4d429d5239ebe6793c9fe5c41/fsspec-2026.3.0-py3-none-any.whl", hash = "sha256:d2ceafaad1b3457968ed14efa28798162f1638dbb5d2a6868a2db002a5ee39a4", size = 202595, upload-time = "2026-03-27T19:11:13.595Z" },
+]
+
+[[package]]
+name = "gguf"
+version = "0.18.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "pyyaml", marker = "sys_platform == 'linux'" },
+    { name = "requests", marker = "sys_platform == 'linux'" },
+    { name = "tqdm", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3f/26/7622a41c39db9d7090225a4bf8368550e59694dcf7313b44f9a82b501209/gguf-0.18.0.tar.gz", hash = "sha256:b4659093d5d0dccdb5902a904d54b327f4052879fe5e90946ad5fce9f8018c2e", size = 107170, upload-time = "2026-02-27T15:05:39.254Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5e/0c/e0f1eae7535a97476fb903f65301e35da2a66182b8161066b7eb312b2cb8/gguf-0.18.0-py3-none-any.whl", hash = "sha256:af93f7ef198a265cbde5fa6a6b3101528bca285903949ab0a3e591cd993a1864", size = 114244, upload-time = "2026-02-27T15:05:37.991Z" },
+]
+
+[[package]]
+name = "googleapis-common-protos"
+version = "1.73.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "protobuf", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a1/c0/4a54c386282c13449eca8bbe2ddb518181dc113e78d240458a68856b4d69/googleapis_common_protos-1.73.1.tar.gz", hash = "sha256:13114f0e9d2391756a0194c3a8131974ed7bffb06086569ba193364af59163b6", size = 147506, upload-time = "2026-03-26T22:17:38.451Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/82/fcb6520612bec0c39b973a6c0954b6a0d948aadfe8f7e9487f60ceb8bfa6/googleapis_common_protos-1.73.1-py3-none-any.whl", hash = "sha256:e51f09eb0a43a8602f5a915870972e6b4a394088415c79d79605a46d8e826ee8", size = 297556, upload-time = "2026-03-26T22:15:58.455Z" },
+]
+
+[[package]]
+name = "grpcio"
+version = "1.78.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/8a/3d098f35c143a89520e568e6539cc098fcd294495910e359889ce8741c84/grpcio-1.78.0.tar.gz", hash = "sha256:7382b95189546f375c174f53a5fa873cef91c4b8005faa05cc5b3beea9c4f1c5", size = 12852416, upload-time = "2026-02-06T09:57:18.093Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4e/f4/7384ed0178203d6074446b3c4f46c90a22ddf7ae0b3aee521627f54cfc2a/grpcio-1.78.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:f9ab915a267fc47c7e88c387a3a28325b58c898e23d4995f765728f4e3dedb97", size = 5913985, upload-time = "2026-02-06T09:55:26.832Z" },
+    { url = "https://files.pythonhosted.org/packages/24/a7/f06d151afc4e64b7e3cc3e872d331d011c279aaab02831e40a81c691fb65/grpcio-1.78.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:859b13906ce098c0b493af92142ad051bf64c7870fa58a123911c88606714996", size = 6475766, upload-time = "2026-02-06T09:55:31.825Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/a8/4482922da832ec0082d0f2cc3a10976d84a7424707f25780b82814aafc0a/grpcio-1.78.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:b2342d87af32790f934a79c3112641e7b27d63c261b8b4395350dad43eff1dc7", size = 7170027, upload-time = "2026-02-06T09:55:34.7Z" },
+    { url = "https://files.pythonhosted.org/packages/54/bf/f4a3b9693e35d25b24b0b39fa46d7d8a3c439e0a3036c3451764678fec20/grpcio-1.78.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:12a771591ae40bc65ba67048fa52ef4f0e6db8279e595fd349f9dfddeef571f9", size = 6690766, upload-time = "2026-02-06T09:55:36.902Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/b9/521875265cc99fe5ad4c5a17010018085cae2810a928bf15ebe7d8bcd9cc/grpcio-1.78.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:185dea0d5260cbb2d224c507bf2a5444d5abbb1fa3594c1ed7e4c709d5eb8383", size = 7266161, upload-time = "2026-02-06T09:55:39.824Z" },
+    { url = "https://files.pythonhosted.org/packages/05/86/296a82844fd40a4ad4a95f100b55044b4f817dece732bf686aea1a284147/grpcio-1.78.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:51b13f9aed9d59ee389ad666b8c2214cc87b5de258fa712f9ab05f922e3896c6", size = 8253303, upload-time = "2026-02-06T09:55:42.353Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/e4/ea3c0caf5468537f27ad5aab92b681ed7cc0ef5f8c9196d3fd42c8c2286b/grpcio-1.78.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fd5f135b1bd58ab088930b3c613455796dfa0393626a6972663ccdda5b4ac6ce", size = 7698222, upload-time = "2026-02-06T09:55:44.629Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "hf-xet"
+version = "1.4.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/09/08/23c84a26716382c89151b5b447b4beb19e3345f3a93d3b73009a71a57ad3/hf_xet-1.4.2.tar.gz", hash = "sha256:b7457b6b482d9e0743bd116363239b1fa904a5e65deede350fbc0c4ea67c71ea", size = 672357, upload-time = "2026-03-13T06:58:51.077Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3c/4c/781267da3188db679e601de18112021a5cb16506fe86b246e22c5401a9c4/hf_xet-1.4.2-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:77e8c180b7ef12d8a96739a4e1e558847002afe9ea63b6f6358b2271a8bdda1c", size = 4217422, upload-time = "2026-03-13T06:58:27.472Z" },
+    { url = "https://files.pythonhosted.org/packages/68/47/d6cf4a39ecf6c7705f887a46f6ef5c8455b44ad9eb0d391aa7e8a2ff7fea/hf_xet-1.4.2-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:c3b3c6a882016b94b6c210957502ff7877802d0dbda8ad142c8595db8b944271", size = 3992847, upload-time = "2026-03-13T06:58:25.989Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/ef/e80815061abff54697239803948abc665c6b1d237102c174f4f7a9a5ffc5/hf_xet-1.4.2-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9d9a634cc929cfbaf2e1a50c0e532ae8c78fa98618426769480c58501e8c8ac2", size = 4193843, upload-time = "2026-03-13T06:58:44.59Z" },
+    { url = "https://files.pythonhosted.org/packages/54/75/07f6aa680575d9646c4167db6407c41340cbe2357f5654c4e72a1b01ca14/hf_xet-1.4.2-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6b0932eb8b10317ea78b7da6bab172b17be03bbcd7809383d8d5abd6a2233e04", size = 4432751, upload-time = "2026-03-13T06:58:46.533Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi", marker = "sys_platform == 'linux'" },
+    { name = "h11", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httptools"
+version = "0.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b5/46/120a669232c7bdedb9d52d4aeae7e6c7dfe151e99dc70802e2fc7a5e1993/httptools-0.7.1.tar.gz", hash = "sha256:abd72556974f8e7c74a259655924a717a2365b236c882c3f6f8a45fe94703ac9", size = 258961, upload-time = "2025-10-10T03:55:08.559Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/84/a6/b3965e1e146ef5762870bbe76117876ceba51a201e18cc31f5703e454596/httptools-0.7.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c15f37ef679ab9ecc06bfc4e6e8628c32a8e4b305459de7cf6785acd57e4d03", size = 517655, upload-time = "2025-10-10T03:54:41.347Z" },
+    { url = "https://files.pythonhosted.org/packages/11/7d/71fee6f1844e6fa378f2eddde6c3e41ce3a1fb4b2d81118dd544e3441ec0/httptools-0.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7fe6e96090df46b36ccfaf746f03034e5ab723162bc51b0a4cf58305324036f2", size = 511440, upload-time = "2025-10-10T03:54:42.452Z" },
+    { url = "https://files.pythonhosted.org/packages/22/a5/079d216712a4f3ffa24af4a0381b108aa9c45b7a5cc6eb141f81726b1823/httptools-0.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f72fdbae2dbc6e68b8239defb48e6a5937b12218e6ffc2c7846cc37befa84362", size = 495186, upload-time = "2025-10-10T03:54:43.937Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/9e/025ad7b65278745dee3bd0ebf9314934c4592560878308a6121f7f812084/httptools-0.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e99c7b90a29fd82fea9ef57943d501a16f3404d7b9ee81799d41639bdaae412c", size = 499192, upload-time = "2025-10-10T03:54:45.003Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio", marker = "sys_platform == 'linux'" },
+    { name = "certifi", marker = "sys_platform == 'linux'" },
+    { name = "httpcore", marker = "sys_platform == 'linux'" },
+    { name = "idna", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "httpx-sse"
+version = "0.4.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/4c/751061ffa58615a32c31b2d82e8482be8dd4a89154f003147acee90f2be9/httpx_sse-0.4.3.tar.gz", hash = "sha256:9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d", size = 15943, upload-time = "2025-10-10T21:48:22.271Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc", size = 8960, upload-time = "2025-10-10T21:48:21.158Z" },
+]
+
+[[package]]
+name = "huggingface-hub"
+version = "1.7.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "filelock", marker = "sys_platform == 'linux'" },
+    { name = "fsspec", marker = "sys_platform == 'linux'" },
+    { name = "hf-xet", marker = "(platform_machine == 'AMD64' and sys_platform == 'linux') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'amd64' and sys_platform == 'linux') or (platform_machine == 'arm64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+    { name = "httpx", marker = "sys_platform == 'linux'" },
+    { name = "packaging", marker = "sys_platform == 'linux'" },
+    { name = "pyyaml", marker = "sys_platform == 'linux'" },
+    { name = "tqdm", marker = "sys_platform == 'linux'" },
+    { name = "typer", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/15/eafc1c57bf0f8afffb243dcd4c0cceb785e956acc17bba4d9bf2ae21fc9c/huggingface_hub-1.7.2.tar.gz", hash = "sha256:7f7e294e9bbb822e025bdb2ada025fa4344d978175a7f78e824d86e35f7ab43b", size = 724684, upload-time = "2026-03-20T10:36:08.767Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/08/de/3ad061a05f74728927ded48c90b73521b9a9328c85d841bdefb30e01fb85/huggingface_hub-1.7.2-py3-none-any.whl", hash = "sha256:288f33a0a17b2a73a1359e2a5fd28d1becb2c121748c6173ab8643fb342c850e", size = 618036, upload-time = "2026-03-20T10:36:06.824Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "ijson"
+version = "3.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f4/57/60d1a6a512f2f0508d0bc8b4f1cc5616fd3196619b66bd6a01f9155a1292/ijson-3.5.0.tar.gz", hash = "sha256:94688760720e3f5212731b3cb8d30267f9a045fb38fb3870254e7b9504246f31", size = 68658, upload-time = "2026-02-24T03:58:30.974Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/31/76/6f91bdb019dd978fce1bc5ea1cd620cfc096d258126c91db2c03a20a7f34/ijson-3.5.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7d48dc2984af02eb3c56edfb3f13b3f62f2f3e4fe36f058c8cfc75d93adf4fed", size = 138977, upload-time = "2026-02-24T03:57:11.932Z" },
+    { url = "https://files.pythonhosted.org/packages/11/be/bbc983059e48a54b0121ee60042979faed7674490bbe7b2c41560db3f436/ijson-3.5.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f1e73a44844d9adbca9cf2c4132cd875933e83f3d4b23881fcaf82be83644c7d", size = 149785, upload-time = "2026-02-24T03:57:13.255Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/81/2fee58f9024a3449aee83edfa7167fb5ccd7e1af2557300e28531bb68e16/ijson-3.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7389a56b8562a19948bdf1d7bae3a2edc8c7f86fb59834dcb1c4c722818e645a", size = 149729, upload-time = "2026-02-24T03:57:14.191Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/56/f1706761fcc096c9d414b3dcd000b1e6e5c24364c21cfba429837f98ee8d/ijson-3.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3176f23f8ebec83f374ed0c3b4e5a0c4db7ede54c005864efebbed46da123608", size = 150697, upload-time = "2026-02-24T03:57:15.855Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/6e/ee0d9c875a0193b632b3e9ccd1b22a50685fb510256ad57ba483b6529f77/ijson-3.5.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:6babd88e508630c6ef86c9bebaaf13bb2fb8ec1d8f8868773a03c20253f599bc", size = 142873, upload-time = "2026-02-24T03:57:16.831Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/bf/f9d4399d0e6e3fd615035290a71e97c843f17f329b43638c0a01cf112d73/ijson-3.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dc1b3836b174b6db2fa8319f1926fb5445abd195dc963368092103f8579cb8ed", size = 151583, upload-time = "2026-02-24T03:57:17.757Z" },
+]
+
+[[package]]
+name = "importlib-metadata"
+version = "8.7.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "zipp", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "interegular"
+version = "0.3.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/dc/9d/8b6dde58a028a3962ce17e84d5fe73758df61378e00ef8ac3d85da34b0ff/interegular-0.3.3.tar.gz", hash = "sha256:d9b697b21b34884711399ba0f0376914b81899ce670032486d0d048344a76600", size = 24705, upload-time = "2024-01-06T23:01:22.372Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c4/01/72d6472f80651673716d1deda2a5bbb633e563ecf94f4479da5519d69d25/interegular-0.3.3-py37-none-any.whl", hash = "sha256:b0c07007d48c89d6d19f7204972d369b2a77222722e126b6aa63aa721dc3b19c", size = 23635, upload-time = "2024-01-06T23:01:20.829Z" },
+]
+
+[[package]]
+name = "jinja2"
+version = "3.1.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markupsafe", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
+]
+
+[[package]]
+name = "jiter"
+version = "0.13.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0d/5e/4ec91646aee381d01cdb9974e30882c9cd3b8c5d1079d6b5ff4af522439a/jiter-0.13.0.tar.gz", hash = "sha256:f2839f9c2c7e2dffc1bc5929a510e14ce0a946be9365fd1219e7ef342dae14f4", size = 164847, upload-time = "2026-02-02T12:37:56.441Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cf/52/e5719a60ac5d4d7c5995461a94ad5ef962a37c8bf5b088390e6fad59b2ff/jiter-0.13.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c1e2b199f446d3e82246b4fd9236d7cb502dc2222b18698ba0d986d2fecc6152", size = 348821, upload-time = "2026-02-02T12:36:00.093Z" },
+    { url = "https://files.pythonhosted.org/packages/61/db/c1efc32b8ba4c740ab3fc2d037d8753f67685f475e26b9d6536a4322bcdd/jiter-0.13.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:04670992b576fa65bd056dbac0c39fe8bd67681c380cb2b48efa885711d9d726", size = 364163, upload-time = "2026-02-02T12:36:01.937Z" },
+    { url = "https://files.pythonhosted.org/packages/55/8a/fb75556236047c8806995671a18e4a0ad646ed255276f51a20f32dceaeec/jiter-0.13.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5a1aff1fbdb803a376d4d22a8f63f8e7ccbce0b4890c26cc7af9e501ab339ef0", size = 483709, upload-time = "2026-02-02T12:36:03.41Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/16/43512e6ee863875693a8e6f6d532e19d650779d6ba9a81593ae40a9088ff/jiter-0.13.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b3fb8c2053acaef8580809ac1d1f7481a0a0bdc012fd7f5d8b18fb696a5a089", size = 370480, upload-time = "2026-02-02T12:36:04.791Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/4c/09b93e30e984a187bc8aaa3510e1ec8dcbdcd71ca05d2f56aac0492453aa/jiter-0.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bdaba7d87e66f26a2c45d8cbadcbfc4bf7884182317907baf39cfe9775bb4d93", size = 360735, upload-time = "2026-02-02T12:36:06.994Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/1b/46c5e349019874ec5dfa508c14c37e29864ea108d376ae26d90bee238cd7/jiter-0.13.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7b88d649135aca526da172e48083da915ec086b54e8e73a425ba50999468cc08", size = 391814, upload-time = "2026-02-02T12:36:08.368Z" },
+    { url = "https://files.pythonhosted.org/packages/15/9e/26184760e85baee7162ad37b7912797d2077718476bf91517641c92b3639/jiter-0.13.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:e404ea551d35438013c64b4f357b0474c7abf9f781c06d44fcaf7a14c69ff9e2", size = 513990, upload-time = "2026-02-02T12:36:09.993Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/34/2c9355247d6debad57a0a15e76ab1566ab799388042743656e566b3b7de1/jiter-0.13.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:1f4748aad1b4a93c8bdd70f604d0f748cdc0e8744c5547798acfa52f10e79228", size = 548021, upload-time = "2026-02-02T12:36:11.376Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/10/528b439290763bff3d939268085d03382471b442f212dca4ff5f12802d43/jiter-0.13.0-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ab44b178f7981fcaea7e0a5df20e773c663d06ffda0198f1a524e91b2fde7e59", size = 337384, upload-time = "2026-02-02T12:37:53.582Z" },
+    { url = "https://files.pythonhosted.org/packages/67/8a/a342b2f0251f3dac4ca17618265d93bf244a2a4d089126e81e4c1056ac50/jiter-0.13.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7bb00b6d26db67a05fe3e12c76edc75f32077fb51deed13822dc648fa373bc19", size = 343768, upload-time = "2026-02-02T12:37:55.055Z" },
+]
+
+[[package]]
+name = "jmespath"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/59/322338183ecda247fb5d1763a6cbe46eff7222eaeebafd9fa65d4bf5cb11/jmespath-1.1.0.tar.gz", hash = "sha256:472c87d80f36026ae83c6ddd0f1d05d4e510134ed462851fd5f754c8c3cbb88d", size = 27377, upload-time = "2026-01-22T16:35:26.279Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/2f/967ba146e6d58cf6a652da73885f52fc68001525b4197effc174321d70b4/jmespath-1.1.0-py3-none-any.whl", hash = "sha256:a5663118de4908c91729bea0acadca56526eb2698e83de10cd116ae0f4e97c64", size = 20419, upload-time = "2026-01-22T16:35:24.919Z" },
+]
+
+[[package]]
+name = "jsonschema"
+version = "4.26.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs", marker = "sys_platform == 'linux'" },
+    { name = "jsonschema-specifications", marker = "sys_platform == 'linux'" },
+    { name = "referencing", marker = "sys_platform == 'linux'" },
+    { name = "rpds-py", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" },
+]
+
+[[package]]
+name = "jsonschema-specifications"
+version = "2025.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "referencing", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" },
+]
+
+[[package]]
+name = "lark"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/60/bc7622aefb2aee1c0b4ba23c1446d3e30225c8770b38d7aedbfb65ca9d5a/lark-1.2.2.tar.gz", hash = "sha256:ca807d0162cd16cef15a8feecb862d7319e7a09bdb13aef927968e45040fed80", size = 252132, upload-time = "2024-08-13T19:49:00.652Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2d/00/d90b10b962b4277f5e64a78b6609968859ff86889f5b898c1a778c06ec00/lark-1.2.2-py3-none-any.whl", hash = "sha256:c2276486b02f0f1b90be155f2c8ba4a8e194d42775786db622faccd652d8e80c", size = 111036, upload-time = "2024-08-13T19:48:58.603Z" },
+]
+
+[[package]]
+name = "linkify-it-py"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "uc-micro-py", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2e/c9/06ea13676ef354f0af6169587ae292d3e2406e212876a413bf9eece4eb23/linkify_it_py-2.1.0.tar.gz", hash = "sha256:43360231720999c10e9328dc3691160e27a718e280673d444c38d7d3aaa3b98b", size = 29158, upload-time = "2026-03-01T07:48:47.683Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b4/de/88b3be5c31b22333b3ca2f6ff1de4e863d8fe45aaea7485f591970ec1d3e/linkify_it_py-2.1.0-py3-none-any.whl", hash = "sha256:0d252c1594ecba2ecedc444053db5d3a9b7ec1b0dd929c8f1d74dce89f86c05e", size = 19878, upload-time = "2026-03-01T07:48:46.098Z" },
+]
+
+[[package]]
+name = "llama-cpp-python"
+version = "0.3.19"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "diskcache", marker = "sys_platform == 'linux'" },
+    { name = "jinja2", marker = "sys_platform == 'linux'" },
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d7/0f/b26ceec20294f5d592ac137ccc2f10e91fa1f35bb8555906b5718a625ac1/llama_cpp_python-0.3.19.tar.gz", hash = "sha256:6816e4a0a74ae9a356e7a0546e13147543f01f695c86a28d940e4b86519acf13", size = 59043951, upload-time = "2026-03-25T22:32:32.581Z" }
+
+[[package]]
+name = "llguidance"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/95/48/3f7a9d3ff1b36bba92b5107a3a21286821227afe9ea464736133994d61fb/llguidance-1.3.0.tar.gz", hash = "sha256:861249afd51dc325646834462ea827e57a5c2b2042e108e6aae7059fdad9104d", size = 1070460, upload-time = "2025-10-20T19:58:44.164Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/aa/11/44389d3d1526d7a5c38ffd587a5ebc61d7bee443ac1dea95f2089ad58f5f/llguidance-1.3.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6f6caca5d78db7f76e1fbb0fff8607b861c32d47fa3d5dee2fc49de27ee269df", size = 2835242, upload-time = "2025-10-20T19:58:34.518Z" },
+    { url = "https://files.pythonhosted.org/packages/83/a8/1ff2bedb8f9acb46a2d2d603415d272bb622c142ea86f5b95445cc6e366c/llguidance-1.3.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc17e9dd602c3879bf91664a64bf72f54c74dbfbeb24ccfab6a5fe435b12f7aa", size = 3033133, upload-time = "2025-10-20T19:58:38.721Z" },
+]
+
+[[package]]
+name = "llvmlite"
+version = "0.44.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/89/6a/95a3d3610d5c75293d5dbbb2a76480d5d4eeba641557b69fe90af6c5b84e/llvmlite-0.44.0.tar.gz", hash = "sha256:07667d66a5d150abed9157ab6c0b9393c9356f229784a4385c02f99e94fc94d4", size = 171880, upload-time = "2025-01-20T11:14:41.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/da/8341fd3056419441286c8e26bf436923021005ece0bff5f41906476ae514/llvmlite-0.44.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0143a5ef336da14deaa8ec26c5449ad5b6a2b564df82fcef4be040b9cacfea9", size = 42361901, upload-time = "2025-01-20T11:13:46.711Z" },
+    { url = "https://files.pythonhosted.org/packages/53/ad/d79349dc07b8a395a99153d7ce8b01d6fcdc9f8231355a5df55ded649b61/llvmlite-0.44.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d752f89e31b66db6f8da06df8b39f9b91e78c5feea1bf9e8c1fba1d1c24c065d", size = 41184247, upload-time = "2025-01-20T11:13:56.159Z" },
+]
+
+[[package]]
+name = "lm-format-enforcer"
+version = "0.11.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "interegular", marker = "sys_platform == 'linux'" },
+    { name = "packaging", marker = "sys_platform == 'linux'" },
+    { name = "pydantic", marker = "sys_platform == 'linux'" },
+    { name = "pyyaml", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/84/d5/41cd417ba7dfdbbcfe46cebf81fb3dfd7c591b89897560ad05bb410a465d/lm_format_enforcer-0.11.3.tar.gz", hash = "sha256:e68081c108719cce284a9bcc889709b26ffb085a1945b5eba3a12cfa96d528da", size = 40258, upload-time = "2025-08-24T19:37:47.527Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/ef/11292bb0b85cf4c93447cab5a29f64576ed14d3ab4280e35ddd23486594a/lm_format_enforcer-0.11.3-py3-none-any.whl", hash = "sha256:cf586350875def1ae7a8fba84fcbbfc8371424b6c9d05c1fcba70aa233fbf06f", size = 45418, upload-time = "2025-08-24T19:37:46.325Z" },
+]
+
+[[package]]
+name = "loguru"
+version = "0.7.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/3a/05/a1dae3dffd1116099471c643b8924f5aa6524411dc6c63fdae648c4f1aca/loguru-0.7.3.tar.gz", hash = "sha256:19480589e77d47b8d85b2c827ad95d49bf31b0dcde16593892eb51dd18706eb6", size = 63559, upload-time = "2024-12-06T11:20:56.608Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", hash = "sha256:31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c", size = 61595, upload-time = "2024-12-06T11:20:54.538Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },
+]
+
+[package.optional-dependencies]
+linkify = [
+    { name = "linkify-it-py", marker = "sys_platform == 'linux'" },
+]
+
+[[package]]
+name = "markupsafe"
+version = "3.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" },
+    { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" },
+    { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" },
+]
+
+[[package]]
+name = "mcp"
+version = "1.26.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio", marker = "sys_platform == 'linux'" },
+    { name = "httpx", marker = "sys_platform == 'linux'" },
+    { name = "httpx-sse", marker = "sys_platform == 'linux'" },
+    { name = "jsonschema", marker = "sys_platform == 'linux'" },
+    { name = "pydantic", marker = "sys_platform == 'linux'" },
+    { name = "pydantic-settings", marker = "sys_platform == 'linux'" },
+    { name = "pyjwt", extra = ["crypto"], marker = "sys_platform == 'linux'" },
+    { name = "python-multipart", marker = "sys_platform == 'linux'" },
+    { name = "sse-starlette", marker = "sys_platform == 'linux'" },
+    { name = "starlette", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+    { name = "typing-inspection", marker = "sys_platform == 'linux'" },
+    { name = "uvicorn", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fc/6d/62e76bbb8144d6ed86e202b5edd8a4cb631e7c8130f3f4893c3f90262b10/mcp-1.26.0.tar.gz", hash = "sha256:db6e2ef491eecc1a0d93711a76f28dec2e05999f93afd48795da1c1137142c66", size = 608005, upload-time = "2026-01-24T19:40:32.468Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fd/d9/eaa1f80170d2b7c5ba23f3b59f766f3a0bb41155fbc32a69adfa1adaaef9/mcp-1.26.0-py3-none-any.whl", hash = "sha256:904a21c33c25aa98ddbeb47273033c435e595bbacfdb177f4bd87f6dceebe1ca", size = 233615, upload-time = "2026-01-24T19:40:30.652Z" },
+]
+
+[[package]]
+name = "mdit-py-plugins"
+version = "0.5.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b2/fd/a756d36c0bfba5f6e39a1cdbdbfdd448dc02692467d83816dff4592a1ebc/mdit_py_plugins-0.5.0.tar.gz", hash = "sha256:f4918cb50119f50446560513a8e311d574ff6aaed72606ddae6d35716fe809c6", size = 44655, upload-time = "2025-08-11T07:25:49.083Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/86/dd6e5db36df29e76c7a7699123569a4a18c1623ce68d826ed96c62643cae/mdit_py_plugins-0.5.0-py3-none-any.whl", hash = "sha256:07a08422fc1936a5d26d146759e9155ea466e842f5ab2f7d2266dd084c8dab1f", size = 57205, upload-time = "2025-08-11T07:25:47.597Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "mistral-common"
+version = "1.10.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jsonschema", marker = "sys_platform == 'linux'" },
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "pillow", marker = "sys_platform == 'linux'" },
+    { name = "pydantic", marker = "sys_platform == 'linux'" },
+    { name = "pydantic-extra-types", extra = ["pycountry"], marker = "sys_platform == 'linux'" },
+    { name = "requests", marker = "sys_platform == 'linux'" },
+    { name = "tiktoken", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a7/22/f798c1acc3f8cf32b6201b063d96867d79aa39d31dff12478739e1a78979/mistral_common-1.10.0.tar.gz", hash = "sha256:e456ff101edbdfc094039ec6c26f7d0f73356729798d628a6e6e96c3917147bc", size = 6351515, upload-time = "2026-03-13T10:13:46.683Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/87/c6/1429a0a3ab40f8530492b62b52eb792266c261b22ed62aa7f25d61d531ae/mistral_common-1.10.0-py3-none-any.whl", hash = "sha256:c594d1a05202b61e8f0d867ec6064df4c5e5d492c2c2bdb6fd8fb4872c6afd8b", size = 6525284, upload-time = "2026-03-13T10:13:44.329Z" },
+]
+
+[package.optional-dependencies]
+image = [
+    { name = "opencv-python-headless", marker = "sys_platform == 'linux'" },
+]
+
+[[package]]
+name = "model-hosting-container-standards"
+version = "0.1.14"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "fastapi", marker = "sys_platform == 'linux'" },
+    { name = "httpx", marker = "sys_platform == 'linux'" },
+    { name = "jmespath", marker = "sys_platform == 'linux'" },
+    { name = "pydantic", marker = "sys_platform == 'linux'" },
+    { name = "setuptools", marker = "sys_platform == 'linux'" },
+    { name = "starlette", marker = "sys_platform == 'linux'" },
+    { name = "supervisor", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c6/3d/cf5c6029648cb0a116f7b5c2f74aa155ab0c6dd723a1f204a6d7ff354526/model_hosting_container_standards-0.1.14.tar.gz", hash = "sha256:b6cf4c46d88ce6acd6e543a578bb88ffd55d1179a7c09c22e61ae1d8a567c564", size = 90386, upload-time = "2026-03-18T21:25:14.513Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/48/94/052452842d39c562237a70345c57ec213a9db22bd25bba998fd2b32d70a7/model_hosting_container_standards-0.1.14-py3-none-any.whl", hash = "sha256:d678be6745899b8ba1e8246c96b101e7802a6a4ea3fb5d90ae8d6eb4204e84c6", size = 121406, upload-time = "2026-03-18T21:25:12.932Z" },
+]
+
+[[package]]
+name = "model-runner"
+version = "0.0.0"
+source = { editable = "." }
+dependencies = [
+    { name = "huggingface-hub", marker = "sys_platform == 'linux'" },
+    { name = "jinja2", marker = "sys_platform == 'linux'" },
+    { name = "pynvml", marker = "sys_platform == 'linux'" },
+    { name = "rich", marker = "sys_platform == 'linux'" },
+    { name = "textual", marker = "sys_platform == 'linux'" },
+    { name = "torch", marker = "sys_platform == 'linux'" },
+    { name = "torchaudio", marker = "sys_platform == 'linux'" },
+    { name = "torchvision", marker = "sys_platform == 'linux'" },
+    { name = "transformers", marker = "sys_platform == 'linux'" },
+    { name = "vllm", marker = "sys_platform == 'linux'" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "pytest", marker = "sys_platform == 'linux'" },
+]
+exl2 = [
+    { name = "exllamav2", marker = "sys_platform == 'linux'" },
+]
+gguf = [
+    { name = "llama-cpp-python", marker = "sys_platform == 'linux'" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "huggingface-hub", specifier = "==1.7.2" },
+    { name = "jinja2", specifier = ">=3.1,<4" },
+    { name = "pynvml", specifier = ">=13,<14" },
+    { name = "rich", specifier = ">=14,<15" },
+    { name = "textual", specifier = ">=6,<9" },
+    { name = "torch", specifier = "==2.10.0+cu130", index = "https://download.pytorch.org/whl/cu130" },
+    { name = "torchaudio", specifier = "==2.10.0+cu130", index = "https://download.pytorch.org/whl/cu130" },
+    { name = "torchvision", specifier = "==0.25.0+cu130", index = "https://download.pytorch.org/whl/cu130" },
+    { name = "transformers", specifier = "==5.5.3" },
+    { name = "vllm", specifier = "==0.19.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [{ name = "pytest", specifier = ">=8,<10" }]
+exl2 = [{ name = "exllamav2", specifier = ">=0.3.2,<0.4" }]
+gguf = [{ name = "llama-cpp-python", specifier = ">=0.3.16,<0.4" }]
+
+[[package]]
+name = "mpmath"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" },
+]
+
+[[package]]
+name = "msgspec"
+version = "0.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ea/9c/bfbd12955a49180cbd234c5d29ec6f74fe641698f0cd9df154a854fc8a15/msgspec-0.20.0.tar.gz", hash = "sha256:692349e588fde322875f8d3025ac01689fead5901e7fb18d6870a44519d62a29", size = 317862, upload-time = "2025-11-24T03:56:28.934Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/49/d6/9709ee093b7742362c2934bfb1bbe791a1e09bed3ea5d8a18ce552fbfd73/msgspec-0.20.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:558ed73315efa51b1538fa8f1d3b22c8c5ff6d9a2a62eff87d25829b94fc5054", size = 218852, upload-time = "2025-11-24T03:55:35.575Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/a2/488517a43ccf5a4b6b6eca6dd4ede0bd82b043d1539dd6bb908a19f8efd3/msgspec-0.20.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:509ac1362a1d53aa66798c9b9fd76872d7faa30fcf89b2fba3bcbfd559d56eb0", size = 224937, upload-time = "2025-11-24T03:55:36.859Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/e8/49b832808aa23b85d4f090d1d2e48a4e3834871415031ed7c5fe48723156/msgspec-0.20.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1353c2c93423602e7dea1aa4c92f3391fdfc25ff40e0bacf81d34dbc68adb870", size = 222858, upload-time = "2025-11-24T03:55:38.187Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/56/1dc2fa53685dca9c3f243a6cbecd34e856858354e455b77f47ebd76cf5bf/msgspec-0.20.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:cb33b5eb5adb3c33d749684471c6a165468395d7aa02d8867c15103b81e1da3e", size = 227248, upload-time = "2025-11-24T03:55:39.496Z" },
+]
+
+[[package]]
+name = "multidict"
+version = "6.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", hash = "sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d", size = 102010, upload-time = "2026-01-26T02:46:45.979Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cf/3b/d6bd75dc4f3ff7c73766e04e705b00ed6dbbaccf670d9e05a12b006f5a21/multidict-6.7.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53", size = 251018, upload-time = "2026-01-26T02:43:56.198Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/80/c959c5933adedb9ac15152e4067c702a808ea183a8b64cf8f31af8ad3155/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75", size = 258883, upload-time = "2026-01-26T02:43:57.499Z" },
+    { url = "https://files.pythonhosted.org/packages/86/85/7ed40adafea3d4f1c8b916e3b5cc3a8e07dfcdcb9cd72800f4ed3ca1b387/multidict-6.7.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b", size = 242413, upload-time = "2026-01-26T02:43:58.755Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/57/b8565ff533e48595503c785f8361ff9a4fde4d67de25c207cd0ba3befd03/multidict-6.7.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733", size = 268404, upload-time = "2026-01-26T02:44:00.216Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/50/9810c5c29350f7258180dfdcb2e52783a0632862eb334c4896ac717cebcb/multidict-6.7.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a", size = 269456, upload-time = "2026-01-26T02:44:02.202Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961", size = 256322, upload-time = "2026-01-26T02:44:03.56Z" },
+    { url = "https://files.pythonhosted.org/packages/31/6e/d8a26d81ac166a5592782d208dd90dfdc0a7a218adaa52b45a672b46c122/multidict-6.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582", size = 253955, upload-time = "2026-01-26T02:44:04.845Z" },
+    { url = "https://files.pythonhosted.org/packages/59/4c/7c672c8aad41534ba619bcd4ade7a0dc87ed6b8b5c06149b85d3dd03f0cd/multidict-6.7.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e", size = 251254, upload-time = "2026-01-26T02:44:06.133Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/bd/84c24de512cbafbdbc39439f74e967f19570ce7924e3007174a29c348916/multidict-6.7.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3", size = 252059, upload-time = "2026-01-26T02:44:07.518Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/ba/f5449385510825b73d01c2d4087bf6d2fccc20a2d42ac34df93191d3dd03/multidict-6.7.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6", size = 263588, upload-time = "2026-01-26T02:44:09.382Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/11/afc7c677f68f75c84a69fe37184f0f82fce13ce4b92f49f3db280b7e92b3/multidict-6.7.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a", size = 259642, upload-time = "2026-01-26T02:44:10.73Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/17/ebb9644da78c4ab36403739e0e6e0e30ebb135b9caf3440825001a0bddcb/multidict-6.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba", size = 251377, upload-time = "2026-01-26T02:44:12.042Z" },
+    { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" },
+]
+
+[[package]]
+name = "networkx"
+version = "3.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", hash = "sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509", size = 2517025, upload-time = "2025-12-08T17:02:39.908Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", hash = "sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762", size = 2068504, upload-time = "2025-12-08T17:02:38.159Z" },
+]
+
+[[package]]
+name = "ninja"
+version = "1.13.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/73/79a0b22fc731989c708068427579e840a6cf4e937fe7ae5c5d0b7356ac22/ninja-1.13.0.tar.gz", hash = "sha256:4a40ce995ded54d9dc24f8ea37ff3bf62ad192b547f6c7126e7e25045e76f978", size = 242558, upload-time = "2025-08-11T15:10:19.421Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8e/de/6e1cd6b84b412ac1ef327b76f0641aeb5dcc01e9d3f9eee0286d0c34fd93/ninja-1.13.0-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3d00c692fb717fd511abeb44b8c5d00340c36938c12d6538ba989fe764e79630", size = 177467, upload-time = "2025-08-11T15:09:52.767Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/83/49320fb6e58ae3c079381e333575fdbcf1cca3506ee160a2dcce775046fa/ninja-1.13.0-py3-none-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:be7f478ff9f96a128b599a964fc60a6a87b9fa332ee1bd44fa243ac88d50291c", size = 187834, upload-time = "2025-08-11T15:09:54.115Z" },
+    { url = "https://files.pythonhosted.org/packages/56/c7/ba22748fb59f7f896b609cd3e568d28a0a367a6d953c24c461fe04fc4433/ninja-1.13.0-py3-none-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:60056592cf495e9a6a4bea3cd178903056ecb0943e4de45a2ea825edb6dc8d3e", size = 202736, upload-time = "2025-08-11T15:09:55.745Z" },
+    { url = "https://files.pythonhosted.org/packages/79/22/d1de07632b78ac8e6b785f41fa9aad7a978ec8c0a1bf15772def36d77aac/ninja-1.13.0-py3-none-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:1c97223cdda0417f414bf864cfb73b72d8777e57ebb279c5f6de368de0062988", size = 179034, upload-time = "2025-08-11T15:09:57.394Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/de/0e6edf44d6a04dabd0318a519125ed0415ce437ad5a1ec9b9be03d9048cf/ninja-1.13.0-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fb46acf6b93b8dd0322adc3a4945452a4e774b75b91293bafcc7b7f8e6517dfa", size = 180716, upload-time = "2025-08-11T15:09:58.696Z" },
+    { url = "https://files.pythonhosted.org/packages/54/28/938b562f9057aaa4d6bfbeaa05e81899a47aebb3ba6751e36c027a7f5ff7/ninja-1.13.0-py3-none-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4be9c1b082d244b1ad7ef41eb8ab088aae8c109a9f3f0b3e56a252d3e00f42c1", size = 146843, upload-time = "2025-08-11T15:10:00.046Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/fb/d06a3838de4f8ab866e44ee52a797b5491df823901c54943b2adb0389fbb/ninja-1.13.0-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:6739d3352073341ad284246f81339a384eec091d9851a886dfa5b00a6d48b3e2", size = 154402, upload-time = "2025-08-11T15:10:01.657Z" },
+    { url = "https://files.pythonhosted.org/packages/31/bf/0d7808af695ceddc763cf251b84a9892cd7f51622dc8b4c89d5012779f06/ninja-1.13.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:11be2d22027bde06f14c343f01d31446747dbb51e72d00decca2eb99be911e2f", size = 552388, upload-time = "2025-08-11T15:10:03.349Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/70/c99d0c2c809f992752453cce312848abb3b1607e56d4cd1b6cded317351a/ninja-1.13.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:aa45b4037b313c2f698bc13306239b8b93b4680eb47e287773156ac9e9304714", size = 472501, upload-time = "2025-08-11T15:10:04.735Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/43/c217b1153f0e499652f5e0766da8523ce3480f0a951039c7af115e224d55/ninja-1.13.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:5f8e1e8a1a30835eeb51db05cf5a67151ad37542f5a4af2a438e9490915e5b72", size = 638280, upload-time = "2025-08-11T15:10:06.512Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/45/9151bba2c8d0ae2b6260f71696330590de5850e5574b7b5694dce6023e20/ninja-1.13.0-py3-none-musllinux_1_2_ppc64le.whl", hash = "sha256:3d7d7779d12cb20c6d054c61b702139fd23a7a964ec8f2c823f1ab1b084150db", size = 642420, upload-time = "2025-08-11T15:10:08.35Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/fb/95752eb635bb8ad27d101d71bef15bc63049de23f299e312878fc21cb2da/ninja-1.13.0-py3-none-musllinux_1_2_riscv64.whl", hash = "sha256:d741a5e6754e0bda767e3274a0f0deeef4807f1fec6c0d7921a0244018926ae5", size = 585106, upload-time = "2025-08-11T15:10:09.818Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/31/aa56a1a286703800c0cbe39fb4e82811c277772dc8cd084f442dd8e2938a/ninja-1.13.0-py3-none-musllinux_1_2_s390x.whl", hash = "sha256:e8bad11f8a00b64137e9b315b137d8bb6cbf3086fbdc43bf1f90fd33324d2e96", size = 707138, upload-time = "2025-08-11T15:10:11.366Z" },
+    { url = "https://files.pythonhosted.org/packages/34/6f/5f5a54a1041af945130abdb2b8529cbef0cdcbbf9bcf3f4195378319d29a/ninja-1.13.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:b4f2a072db3c0f944c32793e91532d8948d20d9ab83da9c0c7c15b5768072200", size = 581758, upload-time = "2025-08-11T15:10:13.295Z" },
+]
+
+[[package]]
+name = "numba"
+version = "0.61.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "llvmlite", marker = "sys_platform == 'linux'" },
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1c/a0/e21f57604304aa03ebb8e098429222722ad99176a4f979d34af1d1ee80da/numba-0.61.2.tar.gz", hash = "sha256:8750ee147940a6637b80ecf7f95062185ad8726c8c28a2295b8ec1160a196f7d", size = 2820615, upload-time = "2025-04-09T02:58:07.659Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/2d/e518df036feab381c23a624dac47f8445ac55686ec7f11083655eb707da3/numba-0.61.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5b1bb509d01f23d70325d3a5a0e237cbc9544dd50e50588bc581ba860c213546", size = 3885928, upload-time = "2025-04-09T02:57:55.206Z" },
+    { url = "https://files.pythonhosted.org/packages/10/0f/23cced68ead67b75d77cfcca3df4991d1855c897ee0ff3fe25a56ed82108/numba-0.61.2-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:48a53a3de8f8793526cbe330f2a39fe9a6638efcbf11bd63f3d2f9757ae345cd", size = 3577115, upload-time = "2025-04-09T02:57:56.818Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.2.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440, upload-time = "2025-05-17T22:38:04.611Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f8/35/8c80729f1ff76b3921d5c9487c7ac3de9b2a103b1cd05e905b3090513510/numpy-2.2.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87", size = 14018462, upload-time = "2025-05-17T21:35:42.174Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/3d/1e1db36cfd41f895d266b103df00ca5b3cbe965184df824dec5c08c6b803/numpy-2.2.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249", size = 16527618, upload-time = "2025-05-17T21:36:06.711Z" },
+    { url = "https://files.pythonhosted.org/packages/61/c6/03ed30992602c85aa3cd95b9070a514f8b3c33e31124694438d88809ae36/numpy-2.2.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49", size = 15505511, upload-time = "2025-05-17T21:36:29.965Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/25/5761d832a81df431e260719ec45de696414266613c9ee268394dd5ad8236/numpy-2.2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de", size = 18313783, upload-time = "2025-05-17T21:36:56.883Z" },
+]
+
+[[package]]
+name = "nvidia-cublas"
+version = "13.1.0.3"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e1/a5/fce49e2ae977e0ccc084e5adafceb4f0ac0c8333cb6863501618a7277f67/nvidia_cublas-13.1.0.3-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:c86fc7f7ae36d7528288c5d88098edcb7b02c633d262e7ddbb86b0ad91be5df2", size = 542851226, upload-time = "2025-10-09T08:59:04.818Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/44/423ac00af4dd95a5aeb27207e2c0d9b7118702149bf4704c3ddb55bb7429/nvidia_cublas-13.1.0.3-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:ee8722c1f0145ab246bccb9e452153b5e0515fd094c3678df50b2a0888b8b171", size = 423133236, upload-time = "2025-10-09T08:59:32.536Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-cupti"
+version = "13.0.85"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/2a/80353b103fc20ce05ef51e928daed4b6015db4aaa9162ed0997090fe2250/nvidia_cuda_cupti-13.0.85-py3-none-manylinux_2_25_aarch64.whl", hash = "sha256:796bd679890ee55fb14a94629b698b6db54bcfd833d391d5e94017dd9d7d3151", size = 10310827, upload-time = "2025-09-04T08:26:42.012Z" },
+    { url = "https://files.pythonhosted.org/packages/33/6d/737d164b4837a9bbd202f5ae3078975f0525a55730fe871d8ed4e3b952b0/nvidia_cuda_cupti-13.0.85-py3-none-manylinux_2_25_x86_64.whl", hash = "sha256:4eb01c08e859bf924d222250d2e8f8b8ff6d3db4721288cf35d14252a4d933c8", size = 10715597, upload-time = "2025-09-04T08:26:51.312Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-nvrtc"
+version = "13.0.88"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c3/68/483a78f5e8f31b08fb1bb671559968c0ca3a065ac7acabfc7cee55214fd6/nvidia_cuda_nvrtc-13.0.88-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:ad9b6d2ead2435f11cbb6868809d2adeeee302e9bb94bcf0539c7a40d80e8575", size = 90215200, upload-time = "2025-09-04T08:28:44.204Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/dc/6bb80850e0b7edd6588d560758f17e0550893a1feaf436807d64d2da040f/nvidia_cuda_nvrtc-13.0.88-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d27f20a0ca67a4bb34268a5e951033496c5b74870b868bacd046b1b8e0c3267b", size = 43015449, upload-time = "2025-09-04T08:28:20.239Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-runtime"
+version = "13.0.96"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/87/4f/17d7b9b8e285199c58ce28e31b5c5bbaa4d8271af06a89b6405258245de2/nvidia_cuda_runtime-13.0.96-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ef9bcbe90493a2b9d810e43d249adb3d02e98dd30200d86607d8d02687c43f55", size = 2261060, upload-time = "2025-10-09T08:55:15.78Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/24/d1558f3b68b1d26e706813b1d10aa1d785e4698c425af8db8edc3dced472/nvidia_cuda_runtime-13.0.96-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7f82250d7782aa23b6cfe765ecc7db554bd3c2870c43f3d1821f1d18aebf0548", size = 2243632, upload-time = "2025-10-09T08:55:36.117Z" },
+]
+
+[[package]]
+name = "nvidia-cudnn-cu13"
+version = "9.15.1.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-cublas", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ff/93/b3c9db2c35d6183361333d2dcfea50e094c012d012c8a4d7effbfb53ef62/nvidia_cudnn_cu13-9.15.1.9-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:44cd2ec83c3ef62a7357614bd02ce7f3dac35ffcbb04ad20999e730741f0ba17", size = 415636241, upload-time = "2025-11-12T20:22:26.582Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/d0/90f98fc55c48a7d8f5ad0a03a6321acc1a7024bdd550d96b3547a04ea6b4/nvidia_cudnn_cu13-9.15.1.9-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:ebc9a647918df0d7298d67cfaf41579fd4c78ead9aba246f5ad9414d61b9ec4c", size = 351298418, upload-time = "2025-11-12T20:23:21.455Z" },
+]
+
+[[package]]
+name = "nvidia-cudnn-frontend"
+version = "1.18.0"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e3/b4/604e230378680ee117849a4e1045baca092f93161a829291a84d5acce70c/nvidia_cudnn_frontend-1.18.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:310b417f2848a83d1437203fcaeea320a74fb7f28af20bf42bf5afc9c01f1c12", size = 2027408, upload-time = "2026-01-27T23:32:46.576Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/52/08f98262e77b1cbcc834cc1a5db494d0661ea1dbdea58c2e2d51a57fdaca/nvidia_cudnn_frontend-1.18.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c023539ca6de99234cf5102c3ec0d6af817f5396fc93028a22ba5b834a35b8a", size = 2159245, upload-time = "2026-01-27T23:07:32.664Z" },
+]
+
+[[package]]
+name = "nvidia-cufft"
+version = "12.0.0.61"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-nvjitlink", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8b/ae/f417a75c0259e85c1d2f83ca4e960289a5f814ed0cea74d18c353d3e989d/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2708c852ef8cd89d1d2068bdbece0aa188813a0c934db3779b9b1faa8442e5f5", size = 214053554, upload-time = "2025-09-04T08:31:38.196Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/2f/7b57e29836ea8714f81e9898409196f47d772d5ddedddf1592eadb8ab743/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6c44f692dce8fd5ffd3e3df134b6cdb9c2f72d99cf40b62c32dde45eea9ddad3", size = 214085489, upload-time = "2025-09-04T08:31:56.044Z" },
+]
+
+[[package]]
+name = "nvidia-cufile"
+version = "1.15.1.6"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3f/70/4f193de89a48b71714e74602ee14d04e4019ad36a5a9f20c425776e72cd6/nvidia_cufile-1.15.1.6-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:08a3ecefae5a01c7f5117351c64f17c7c62efa5fffdbe24fc7d298da19cd0b44", size = 1223672, upload-time = "2025-09-04T08:32:22.779Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/73/cc4a14c9813a8a0d509417cf5f4bdaba76e924d58beb9864f5a7baceefbf/nvidia_cufile-1.15.1.6-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:bdc0deedc61f548bddf7733bdc216456c2fdb101d020e1ab4b88d232d5e2f6d1", size = 1136992, upload-time = "2025-09-04T08:32:14.119Z" },
+]
+
+[[package]]
+name = "nvidia-curand"
+version = "10.4.0.35"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/72/7c2ae24fb6b63a32e6ae5d241cc65263ea18d08802aaae087d9f013335a2/nvidia_curand-10.4.0.35-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:133df5a7509c3e292aaa2b477afd0194f06ce4ea24d714d616ff36439cee349a", size = 61962106, upload-time = "2025-08-04T10:21:41.128Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/9f/be0a41ca4a4917abf5cb9ae0daff1a6060cc5de950aec0396de9f3b52bc5/nvidia_curand-10.4.0.35-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:1aee33a5da6e1db083fe2b90082def8915f30f3248d5896bcec36a579d941bfc", size = 59544258, upload-time = "2025-08-04T10:22:03.992Z" },
+]
+
+[[package]]
+name = "nvidia-cusolver"
+version = "12.0.4.66"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-cublas", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cusparse", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-nvjitlink", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c8/c3/b30c9e935fc01e3da443ec0116ed1b2a009bb867f5324d3f2d7e533e776b/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:02c2457eaa9e39de20f880f4bd8820e6a1cfb9f9a34f820eb12a155aa5bc92d2", size = 223467760, upload-time = "2025-09-04T08:33:04.222Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/67/cba3777620cdacb99102da4042883709c41c709f4b6323c10781a9c3aa34/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:0a759da5dea5c0ea10fd307de75cdeb59e7ea4fcb8add0924859b944babf1112", size = 200941980, upload-time = "2025-09-04T08:33:22.767Z" },
+]
+
+[[package]]
+name = "nvidia-cusparse"
+version = "12.6.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-nvjitlink", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f8/94/5c26f33738ae35276672f12615a64bd008ed5be6d1ebcb23579285d960a9/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:80bcc4662f23f1054ee334a15c72b8940402975e0eab63178fc7e670aa59472c", size = 162155568, upload-time = "2025-09-04T08:33:42.864Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/18/623c77619c31d62efd55302939756966f3ecc8d724a14dab2b75f1508850/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2b3c89c88d01ee0e477cb7f82ef60a11a4bcd57b6b87c33f789350b59759360b", size = 145942937, upload-time = "2025-09-04T08:33:58.029Z" },
+]
+
+[[package]]
+name = "nvidia-cusparselt-cu13"
+version = "0.8.0"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/46/10/8dcd1175260706a2fc92a16a52e306b71d4c1ea0b0cc4a9484183399818a/nvidia_cusparselt_cu13-0.8.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:400c6ed1cf6780fc6efedd64ec9f1345871767e6a1a0a552a1ea0578117ea77c", size = 220791277, upload-time = "2025-08-13T19:22:40.982Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/53/43b0d71f4e702fa9733f8b4571fdca50a8813f1e450b656c239beff12315/nvidia_cusparselt_cu13-0.8.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:25e30a8a7323935d4ad0340b95a0b69926eee755767e8e0b1cf8dd85b197d3fd", size = 169884119, upload-time = "2025-08-13T19:23:41.967Z" },
+]
+
+[[package]]
+name = "nvidia-cutlass-dsl"
+version = "4.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-cutlass-dsl-libs-base", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a9/03/678dab0383db1ddfc449da216220f40404189eb36eeed9d87a4fa4bdb0e6/nvidia_cutlass_dsl-4.4.2-py3-none-any.whl", hash = "sha256:7cfb9ef19062b055b9372c7a627004724e2755e4c8b16c3cc88807d64501a4ae", size = 10167, upload-time = "2026-03-16T02:18:59.043Z" },
+]
+
+[[package]]
+name = "nvidia-cutlass-dsl-libs-base"
+version = "4.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cuda-python", marker = "sys_platform == 'linux'" },
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8e/7d/0df5e38d11e52cc72095a14d6448bc1c5d0d4b00b069a1189ca417fb225b/nvidia_cutlass_dsl_libs_base-4.4.2-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:2ec8812eeadcbb6fe20bda2e295ed9c00653f8253b78e33cf0ab65a47b829e73", size = 75473821, upload-time = "2026-03-16T02:27:08.371Z" },
+    { url = "https://files.pythonhosted.org/packages/56/98/e264964741d9cc9816625d9600d17a5249fd5cbd8c2d166fb0d0c34dfe5a/nvidia_cutlass_dsl_libs_base-4.4.2-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:22e37b58f7a6f2f43bba533c4df8a088012122e0b4e9a632eca23937adeafb39", size = 74355593, upload-time = "2026-03-16T02:25:11.762Z" },
+]
+
+[[package]]
+name = "nvidia-ml-py"
+version = "13.595.45"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ce/49/c29f6e30d8662d2e94fef17739ea7309cc76aba269922ae999e4cc07f268/nvidia_ml_py-13.595.45.tar.gz", hash = "sha256:c9f34897fe0441ff35bc8f35baf80f830a20b0f4e6ce71e0a325bc0e66acf079", size = 50780, upload-time = "2026-03-19T16:59:44.956Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8a/24/fc256107d23597fa33d319505ce77160fa1a2349c096d01901ffc7cb7fc4/nvidia_ml_py-13.595.45-py3-none-any.whl", hash = "sha256:b65a7977f503d56154b14d683710125ef93594adb63fbf7e559336e3318f1376", size = 51776, upload-time = "2026-03-19T16:59:43.603Z" },
+]
+
+[[package]]
+name = "nvidia-nccl-cu13"
+version = "2.28.9"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/39/55/1920646a2e43ffd4fc958536b276197ed740e9e0c54105b4bb3521591fc7/nvidia_nccl_cu13-2.28.9-py3-none-manylinux_2_18_aarch64.whl", hash = "sha256:01c873ba1626b54caa12272ed228dc5b2781545e0ae8ba3f432a8ef1c6d78643", size = 196561677, upload-time = "2025-11-18T05:49:03.45Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/b4/878fefaad5b2bcc6fcf8d474a25e3e3774bc5133e4b58adff4d0bca238bc/nvidia_nccl_cu13-2.28.9-py3-none-manylinux_2_18_x86_64.whl", hash = "sha256:e4553a30f34195f3fa1da02a6da3d6337d28f2003943aa0a3d247bbc25fefc42", size = 196493177, upload-time = "2025-11-18T05:49:17.677Z" },
+]
+
+[[package]]
+name = "nvidia-nvjitlink"
+version = "13.0.88"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/56/7a/123e033aaff487c77107195fa5a2b8686795ca537935a24efae476c41f05/nvidia_nvjitlink-13.0.88-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:13a74f429e23b921c1109976abefacc69835f2f433ebd323d3946e11d804e47b", size = 40713933, upload-time = "2025-09-04T08:35:43.553Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/2c/93c5250e64df4f894f1cbb397c6fd71f79813f9fd79d7cd61de3f97b3c2d/nvidia_nvjitlink-13.0.88-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e931536ccc7d467a98ba1d8b89ff7fa7f1fa3b13f2b0069118cd7f47bff07d0c", size = 38768748, upload-time = "2025-09-04T08:35:20.008Z" },
+]
+
+[[package]]
+name = "nvidia-nvshmem-cu13"
+version = "3.4.5"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/0f/05cc9c720236dcd2db9c1ab97fff629e96821be2e63103569da0c9b72f19/nvidia_nvshmem_cu13-3.4.5-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6dc2a197f38e5d0376ad52cd1a2a3617d3cdc150fd5966f4aee9bcebb1d68fe9", size = 60215947, upload-time = "2025-09-06T00:32:20.022Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/35/a9bf80a609e74e3b000fef598933235c908fcefcef9026042b8e6dfde2a9/nvidia_nvshmem_cu13-3.4.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:290f0a2ee94c9f3687a02502f3b9299a9f9fe826e6d0287ee18482e78d495b80", size = 60412546, upload-time = "2025-09-06T00:32:41.564Z" },
+]
+
+[[package]]
+name = "nvidia-nvtx"
+version = "13.0.85"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c2/f3/d86c845465a2723ad7e1e5c36dcd75ddb82898b3f53be47ebd429fb2fa5d/nvidia_nvtx-13.0.85-py3-none-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4936d1d6780fbe68db454f5e72a42ff64d1fd6397df9f363ae786930fd5c1cd4", size = 148047, upload-time = "2025-09-04T08:29:01.761Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/64/3708a90d1ebe202ffdeb7185f878a3c84d15c2b2c31858da2ce0583e2def/nvidia_nvtx-13.0.85-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cb7780edb6b14107373c835bf8b72e7a178bac7367e23da7acb108f973f157a6", size = 148878, upload-time = "2025-09-04T08:28:53.627Z" },
+]
+
+[[package]]
+name = "openai"
+version = "2.24.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio", marker = "sys_platform == 'linux'" },
+    { name = "distro", marker = "sys_platform == 'linux'" },
+    { name = "httpx", marker = "sys_platform == 'linux'" },
+    { name = "jiter", marker = "sys_platform == 'linux'" },
+    { name = "pydantic", marker = "sys_platform == 'linux'" },
+    { name = "sniffio", marker = "sys_platform == 'linux'" },
+    { name = "tqdm", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/13/17e87641b89b74552ed408a92b231283786523edddc95f3545809fab673c/openai-2.24.0.tar.gz", hash = "sha256:1e5769f540dbd01cb33bc4716a23e67b9d695161a734aff9c5f925e2bf99a673", size = 658717, upload-time = "2026-02-24T20:02:07.958Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c9/30/844dc675ee6902579b8eef01ed23917cc9319a1c9c0c14ec6e39340c96d0/openai-2.24.0-py3-none-any.whl", hash = "sha256:fed30480d7d6c884303287bde864980a4b137b60553ffbcf9ab4a233b7a73d94", size = 1120122, upload-time = "2026-02-24T20:02:05.669Z" },
+]
+
+[[package]]
+name = "openai-harmony"
+version = "0.0.8"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3e/92/2d038d096f29179c7c9571b431f9e739f87a487121901725e23fe338dd9d/openai_harmony-0.0.8.tar.gz", hash = "sha256:6e43f98e6c242fa2de6f8ea12eab24af63fa2ed3e89c06341fb9d92632c5cbdf", size = 284777, upload-time = "2025-11-05T19:07:06.727Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d3/d2/ce6953ca87db9cae3e775024184da7d1c5cb88cead19a2d75b42f00a959c/openai_harmony-0.0.8-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e4f709815924ec325b9a890e6ab2bbb0ceec8e319a4e257328eb752cf36b2efc", size = 2948463, upload-time = "2025-11-05T19:06:48.17Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/4c/b553c9651662d6ce102ca7f3629d268b23df1abe5841e24bed81e8a8e949/openai_harmony-0.0.8-cp38-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5cfcfd963b50a41fc656c84d3440ca6eecdccd6c552158ce790b8f2e33dfb5a9", size = 2704083, upload-time = "2025-11-05T19:06:50.205Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/af/4eec8f9ab9c27bcdb444460c72cf43011d176fc44c79d6e113094ca1e152/openai_harmony-0.0.8-cp38-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a3a16972aa1cee38ea958470cd04ac9a2d5ac38fdcf77ab686611246220c158", size = 2959765, upload-time = "2025-11-05T19:06:53.62Z" },
+    { url = "https://files.pythonhosted.org/packages/11/3c/33f3374e4624e0e776f6b13b73c45a7ead7f9c4529f8369ed5bfcaa30cac/openai_harmony-0.0.8-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b4d5cfa168e74d08f8ba6d58a7e49bc7daef4d58951ec69b66b0d56f4927a68d", size = 3427031, upload-time = "2025-11-05T19:06:51.829Z" },
+    { url = "https://files.pythonhosted.org/packages/25/3f/1a192b93bb47c6b44cd98ba8cc1d3d2a9308f1bb700c3017e6352da11bda/openai_harmony-0.0.8-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c007d277218a50db8839e599ed78e0fffe5130f614c3f6d93ae257f282071a29", size = 2953260, upload-time = "2025-11-05T19:06:55.406Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/f8/93b582cad3531797c3db7c2db5400fd841538ccddfd9f5e3df61be99a630/openai_harmony-0.0.8-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:8565d4f5a0638da1bffde29832ed63c9e695c558611053add3b2dc0b56c92dbc", size = 3127044, upload-time = "2025-11-05T19:06:59.553Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/10/4327dbf87f75ae813405fd9a9b4a5cde63d506ffed0a096a440a4cabd89c/openai_harmony-0.0.8-cp38-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:cbaa3bda75ef0d8836e1f8cc84af62f971b1d756d740efc95c38c3e04c0bfde2", size = 2932931, upload-time = "2025-11-05T19:07:01.437Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/c8/1774eec4f6f360ef57618fb8f52e3d3af245b2491bd0297513aa09eec04b/openai_harmony-0.0.8-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:772922a9bd24e133950fad71eb1550836f415a88e8c77870e12d0c3bd688ddc2", size = 2996140, upload-time = "2025-11-05T19:07:03.438Z" },
+    { url = "https://files.pythonhosted.org/packages/60/c3/3d1e01e2dba517a91760e4a03e4f20ffc75039a6fe584d0e6f9b5c78fd15/openai_harmony-0.0.8-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:007b0476a1f331f8130783f901f1da6f5a7057af1a4891f1b6a31dec364189b5", size = 3205080, upload-time = "2025-11-05T19:07:05.078Z" },
+]
+
+[[package]]
+name = "opencv-python-headless"
+version = "4.13.0.92"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/21/76/9417a6aef9def70e467a5bf560579f816148a4c658b7d525581b356eda9e/opencv_python_headless-4.13.0.92-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c8cfc8e87ed452b5cecb9419473ee5560a989859fe1d10d1ce11ae87b09a2cb", size = 33703709, upload-time = "2026-02-05T10:24:46.469Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ce/bd17ff5772938267fd49716e94ca24f616ff4cb1ff4c6be13085108037be/opencv_python_headless-4.13.0.92-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0525a3d2c0b46c611e2130b5fdebc94cf404845d8fa64d2f3a3b679572a5bd22", size = 56016764, upload-time = "2026-02-05T10:26:48.904Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/b4/b7bcbf7c874665825a8c8e1097e93ea25d1f1d210a3e20d4451d01da30aa/opencv_python_headless-4.13.0.92-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:eb60e36b237b1ebd40a912da5384b348df8ed534f6f644d8e0b4f103e272ba7d", size = 35010236, upload-time = "2026-02-05T10:28:11.031Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/33/b5db29a6c00eb8f50708110d8d453747ca125c8b805bc437b289dbdcc057/opencv_python_headless-4.13.0.92-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:0bd48544f77c68b2941392fcdf9bcd2b9cdf00e98cb8c29b2455d194763cf99e", size = 60391106, upload-time = "2026-02-05T10:30:14.236Z" },
+]
+
+[[package]]
+name = "opentelemetry-api"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "importlib-metadata", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2c/1d/4049a9e8698361cc1a1aa03a6c59e4fa4c71e0c0f94a30f988a6876a2ae6/opentelemetry_api-1.40.0.tar.gz", hash = "sha256:159be641c0b04d11e9ecd576906462773eb97ae1b657730f0ecf64d32071569f", size = 70851, upload-time = "2026-03-04T14:17:21.555Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/bf/93795954016c522008da367da292adceed71cca6ee1717e1d64c83089099/opentelemetry_api-1.40.0-py3-none-any.whl", hash = "sha256:82dd69331ae74b06f6a874704be0cfaa49a1650e1537d4a813b86ecef7d0ecf9", size = 68676, upload-time = "2026-03-04T14:17:01.24Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-exporter-otlp-proto-grpc", marker = "sys_platform == 'linux'" },
+    { name = "opentelemetry-exporter-otlp-proto-http", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d0/37/b6708e0eff5c5fb9aba2e0ea09f7f3bcbfd12a592d2a780241b5f6014df7/opentelemetry_exporter_otlp-1.40.0.tar.gz", hash = "sha256:7caa0870b95e2fcb59d64e16e2b639ecffb07771b6cd0000b5d12e5e4fef765a", size = 6152, upload-time = "2026-03-04T14:17:23.235Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2d/fc/aea77c28d9f3ffef2fdafdc3f4a235aee4091d262ddabd25882f47ce5c5f/opentelemetry_exporter_otlp-1.40.0-py3-none-any.whl", hash = "sha256:48c87e539ec9afb30dc443775a1334cc5487de2f72a770a4c00b1610bf6c697d", size = 7023, upload-time = "2026-03-04T14:17:03.612Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-proto-common"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-proto", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/51/bc/1559d46557fe6eca0b46c88d4c2676285f1f3be2e8d06bb5d15fbffc814a/opentelemetry_exporter_otlp_proto_common-1.40.0.tar.gz", hash = "sha256:1cbee86a4064790b362a86601ee7934f368b81cd4cc2f2e163902a6e7818a0fa", size = 20416, upload-time = "2026-03-04T14:17:23.801Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8b/ca/8f122055c97a932311a3f640273f084e738008933503d0c2563cd5d591fc/opentelemetry_exporter_otlp_proto_common-1.40.0-py3-none-any.whl", hash = "sha256:7081ff453835a82417bf38dccf122c827c3cbc94f2079b03bba02a3165f25149", size = 18369, upload-time = "2026-03-04T14:17:04.796Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-proto-grpc"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "googleapis-common-protos", marker = "sys_platform == 'linux'" },
+    { name = "grpcio", marker = "sys_platform == 'linux'" },
+    { name = "opentelemetry-api", marker = "sys_platform == 'linux'" },
+    { name = "opentelemetry-exporter-otlp-proto-common", marker = "sys_platform == 'linux'" },
+    { name = "opentelemetry-proto", marker = "sys_platform == 'linux'" },
+    { name = "opentelemetry-sdk", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8f/7f/b9e60435cfcc7590fa87436edad6822240dddbc184643a2a005301cc31f4/opentelemetry_exporter_otlp_proto_grpc-1.40.0.tar.gz", hash = "sha256:bd4015183e40b635b3dab8da528b27161ba83bf4ef545776b196f0fb4ec47740", size = 25759, upload-time = "2026-03-04T14:17:24.4Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/96/6f/7ee0980afcbdcd2d40362da16f7f9796bd083bf7f0b8e038abfbc0300f5d/opentelemetry_exporter_otlp_proto_grpc-1.40.0-py3-none-any.whl", hash = "sha256:2aa0ca53483fe0cf6405087a7491472b70335bc5c7944378a0a8e72e86995c52", size = 20304, upload-time = "2026-03-04T14:17:05.942Z" },
+]
+
+[[package]]
+name = "opentelemetry-exporter-otlp-proto-http"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "googleapis-common-protos", marker = "sys_platform == 'linux'" },
+    { name = "opentelemetry-api", marker = "sys_platform == 'linux'" },
+    { name = "opentelemetry-exporter-otlp-proto-common", marker = "sys_platform == 'linux'" },
+    { name = "opentelemetry-proto", marker = "sys_platform == 'linux'" },
+    { name = "opentelemetry-sdk", marker = "sys_platform == 'linux'" },
+    { name = "requests", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2e/fa/73d50e2c15c56be4d000c98e24221d494674b0cc95524e2a8cb3856d95a4/opentelemetry_exporter_otlp_proto_http-1.40.0.tar.gz", hash = "sha256:db48f5e0f33217588bbc00274a31517ba830da576e59503507c839b38fa0869c", size = 17772, upload-time = "2026-03-04T14:17:25.324Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/3a/8865d6754e61c9fb170cdd530a124a53769ee5f740236064816eb0ca7301/opentelemetry_exporter_otlp_proto_http-1.40.0-py3-none-any.whl", hash = "sha256:a8d1dab28f504c5d96577d6509f80a8150e44e8f45f82cdbe0e34c99ab040069", size = 19960, upload-time = "2026-03-04T14:17:07.153Z" },
+]
+
+[[package]]
+name = "opentelemetry-proto"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "protobuf", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4c/77/dd38991db037fdfce45849491cb61de5ab000f49824a00230afb112a4392/opentelemetry_proto-1.40.0.tar.gz", hash = "sha256:03f639ca129ba513f5819810f5b1f42bcb371391405d99c168fe6937c62febcd", size = 45667, upload-time = "2026-03-04T14:17:31.194Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b9/b2/189b2577dde745b15625b3214302605b1353436219d42b7912e77fa8dc24/opentelemetry_proto-1.40.0-py3-none-any.whl", hash = "sha256:266c4385d88923a23d63e353e9761af0f47a6ed0d486979777fe4de59dc9b25f", size = 72073, upload-time = "2026-03-04T14:17:16.673Z" },
+]
+
+[[package]]
+name = "opentelemetry-sdk"
+version = "1.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api", marker = "sys_platform == 'linux'" },
+    { name = "opentelemetry-semantic-conventions", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/fd/3c3125b20ba18ce2155ba9ea74acb0ae5d25f8cd39cfd37455601b7955cc/opentelemetry_sdk-1.40.0.tar.gz", hash = "sha256:18e9f5ec20d859d268c7cb3c5198c8d105d073714db3de50b593b8c1345a48f2", size = 184252, upload-time = "2026-03-04T14:17:31.87Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/c5/6a852903d8bfac758c6dc6e9a68b015d3c33f2f1be5e9591e0f4b69c7e0a/opentelemetry_sdk-1.40.0-py3-none-any.whl", hash = "sha256:787d2154a71f4b3d81f20524a8ce061b7db667d24e46753f32a7bc48f1c1f3f1", size = 141951, upload-time = "2026-03-04T14:17:17.961Z" },
+]
+
+[[package]]
+name = "opentelemetry-semantic-conventions"
+version = "0.61b0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6d/c0/4ae7973f3c2cfd2b6e321f1675626f0dab0a97027cc7a297474c9c8f3d04/opentelemetry_semantic_conventions-0.61b0.tar.gz", hash = "sha256:072f65473c5d7c6dc0355b27d6c9d1a679d63b6d4b4b16a9773062cb7e31192a", size = 145755, upload-time = "2026-03-04T14:17:32.664Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b2/37/cc6a55e448deaa9b27377d087da8615a3416d8ad523d5960b78dbeadd02a/opentelemetry_semantic_conventions-0.61b0-py3-none-any.whl", hash = "sha256:fa530a96be229795f8cef353739b618148b0fe2b4b3f005e60e262926c4d38e2", size = 231621, upload-time = "2026-03-04T14:17:19.33Z" },
+]
+
+[[package]]
+name = "opentelemetry-semantic-conventions-ai"
+version = "0.5.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-sdk", marker = "sys_platform == 'linux'" },
+    { name = "opentelemetry-semantic-conventions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/24/02/10aeacc37a38a3a8fa16ff67bec1ae3bf882539f6f9efb0f70acf802ca2d/opentelemetry_semantic_conventions_ai-0.5.1.tar.gz", hash = "sha256:153906200d8c1d2f8e09bd78dbef526916023de85ac3dab35912bfafb69ff04c", size = 26533, upload-time = "2026-03-26T14:20:38.73Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/55/22/41fb05f1dc5fda2c468e05a41814c20859016c85117b66c8a257cae814f6/opentelemetry_semantic_conventions_ai-0.5.1-py3-none-any.whl", hash = "sha256:25aeb22bd261543b4898a73824026d96770e5351209c7d07a0b1314762b1f6e4", size = 11250, upload-time = "2026-03-26T14:20:37.108Z" },
+]
+
+[[package]]
+name = "outlines-core"
+version = "0.2.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1a/d3/e04e9145f8f806723dec9b9e5227ad695a3efcd3ced7794cf7c22b15df5e/outlines_core-0.2.11.tar.gz", hash = "sha256:dfce56f717ff5083e54cbcfdb66cad243365437fccbb5509adaa7e31e030f1d8", size = 197263, upload-time = "2025-05-19T10:12:51.719Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/92/c7/a65d1fddf49830ebc41422294eacde35286d9f68994a8aa905cb14f5aade/outlines_core-0.2.11-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86df9740368866295077346440d911df4972da2b3f1f54b8125e6f329e8a8891", size = 2287677, upload-time = "2025-05-19T10:12:24.24Z" },
+    { url = "https://files.pythonhosted.org/packages/23/79/8795aed8be9b77dd69d78e7cfbfcf28c179e6b08da6e56bbbf48a09fe55f/outlines_core-0.2.11-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:96ce4dd78f106799be4a0a5795cefd1352806162973756a4b6fce4bb6eddd7e4", size = 2113000, upload-time = "2025-05-19T10:12:25.446Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "pandas"
+version = "3.0.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "python-dateutil", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2e/0c/b28ed414f080ee0ad153f848586d61d1878f91689950f037f976ce15f6c8/pandas-3.0.1.tar.gz", hash = "sha256:4186a699674af418f655dbd420ed87f50d56b4cd6603784279d9eef6627823c8", size = 4641901, upload-time = "2026-02-17T22:20:16.434Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/39/327802e0b6d693182403c144edacbc27eb82907b57062f23ef5a4c4a5ea7/pandas-3.0.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b8e36891080b87823aff3640c78649b91b8ff6eea3c0d70aeabd72ea43ab069b", size = 10396030, upload-time = "2026-02-17T22:18:43.822Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/fe/89d77e424365280b79d99b3e1e7d606f5165af2f2ecfaf0c6d24c799d607/pandas-3.0.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:532527a701281b9dd371e2f582ed9094f4c12dd9ffb82c0c54ee28d8ac9520c4", size = 10876435, upload-time = "2026-02-17T22:18:45.954Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/a6/2a75320849dd154a793f69c951db759aedb8d1dd3939eeacda9bdcfa1629/pandas-3.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:356e5c055ed9b0da1580d465657bc7d00635af4fd47f30afb23025352ba764d1", size = 11405133, upload-time = "2026-02-17T22:18:48.533Z" },
+    { url = "https://files.pythonhosted.org/packages/58/53/1d68fafb2e02d7881df66aa53be4cd748d25cbe311f3b3c85c93ea5d30ca/pandas-3.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9d810036895f9ad6345b8f2a338dd6998a74e8483847403582cab67745bff821", size = 11932065, upload-time = "2026-02-17T22:18:50.837Z" },
+]
+
+[[package]]
+name = "partial-json-parser"
+version = "0.2.1.1.post7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6a/6d/eed37d7ebc1e0bcd27b831c0cf1fe94881934316187c4b30d23f29ea0bd4/partial_json_parser-0.2.1.1.post7.tar.gz", hash = "sha256:86590e1ba6bcb6739a2dfc17d2323f028cb5884f4c6ce23db376999132c9a922", size = 10296, upload-time = "2025-11-17T07:27:41.202Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/42/32/658973117bf0fd82a24abbfb94fe73a5e86216e49342985e10acce54775a/partial_json_parser-0.2.1.1.post7-py3-none-any.whl", hash = "sha256:145119e5eabcf80cbb13844a6b50a85c68bf99d376f8ed771e2a3c3b03e653ae", size = 10877, upload-time = "2025-11-17T07:27:40.457Z" },
+]
+
+[[package]]
+name = "pillow"
+version = "12.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1f/42/5c74462b4fd957fcd7b13b04fb3205ff8349236ea74c7c375766d6c82288/pillow-12.1.1.tar.gz", hash = "sha256:9ad8fa5937ab05218e2b6a4cff30295ad35afd2f83ac592e68c0d871bb0fdbc4", size = 46980264, upload-time = "2026-02-11T04:23:07.146Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b1/2e/1001613d941c67442f745aff0f7cc66dd8df9a9c084eb497e6a543ee6f7e/pillow-12.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bb66b7cc26f50977108790e2456b7921e773f23db5630261102233eb355a3b79", size = 6234995, upload-time = "2026-02-11T04:20:51.032Z" },
+    { url = "https://files.pythonhosted.org/packages/07/26/246ab11455b2549b9233dbd44d358d033a2f780fa9007b61a913c5b2d24e/pillow-12.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aee2810642b2898bb187ced9b349e95d2a7272930796e022efaf12e99dccd293", size = 8045012, upload-time = "2026-02-11T04:20:52.882Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/8b/07587069c27be7535ac1fe33874e32de118fbd34e2a73b7f83436a88368c/pillow-12.1.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a0b1cd6232e2b618adcc54d9882e4e662a089d5768cd188f7c245b4c8c44a397", size = 6349638, upload-time = "2026-02-11T04:20:54.444Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/79/6df7b2ee763d619cda2fb4fea498e5f79d984dae304d45a8999b80d6cf5c/pillow-12.1.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7aac39bcf8d4770d089588a2e1dd111cbaa42df5a94be3114222057d68336bd0", size = 7041540, upload-time = "2026-02-11T04:20:55.97Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/5e/2ba19e7e7236d7529f4d873bdaf317a318896bac289abebd4bb00ef247f0/pillow-12.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ab174cd7d29a62dd139c44bf74b698039328f45cb03b4596c43473a46656b2f3", size = 6462613, upload-time = "2026-02-11T04:20:57.542Z" },
+    { url = "https://files.pythonhosted.org/packages/03/03/31216ec124bb5c3dacd74ce8efff4cc7f52643653bad4825f8f08c697743/pillow-12.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:339ffdcb7cbeaa08221cd401d517d4b1fe7a9ed5d400e4a8039719238620ca35", size = 7166745, upload-time = "2026-02-11T04:20:59.196Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.9.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/19/56/8d4c30c8a1d07013911a8fdbd8f89440ef9f08d07a1b50ab8ca8be5a20f9/platformdirs-4.9.4.tar.gz", hash = "sha256:1ec356301b7dc906d83f371c8f487070e99d3ccf9e501686456394622a01a934", size = 28737, upload-time = "2026-03-05T18:34:13.271Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/d7/97f7e3a6abb67d8080dd406fd4df842c2be0efaf712d1c899c32a075027c/platformdirs-4.9.4-py3-none-any.whl", hash = "sha256:68a9a4619a666ea6439f2ff250c12a853cd1cbd5158d258bd824a7df6be2f868", size = 21216, upload-time = "2026-03-05T18:34:12.172Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "prometheus-client"
+version = "0.24.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/58/a794d23feb6b00fc0c72787d7e87d872a6730dd9ed7c7b3e954637d8f280/prometheus_client-0.24.1.tar.gz", hash = "sha256:7e0ced7fbbd40f7b84962d5d2ab6f17ef88a72504dcf7c0b40737b43b2a461f9", size = 85616, upload-time = "2026-01-14T15:26:26.965Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/74/c3/24a2f845e3917201628ecaba4f18bab4d18a337834c1df2a159ee9d22a42/prometheus_client-0.24.1-py3-none-any.whl", hash = "sha256:150db128af71a5c2482b36e588fc8a6b95e498750da4b17065947c16070f4055", size = 64057, upload-time = "2026-01-14T15:26:24.42Z" },
+]
+
+[[package]]
+name = "prometheus-fastapi-instrumentator"
+version = "7.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "prometheus-client", marker = "sys_platform == 'linux'" },
+    { name = "starlette", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/69/6d/24d53033cf93826aa7857699a4450c1c67e5b9c710e925b1ed2b320c04df/prometheus_fastapi_instrumentator-7.1.0.tar.gz", hash = "sha256:be7cd61eeea4e5912aeccb4261c6631b3f227d8924542d79eaf5af3f439cbe5e", size = 20220, upload-time = "2025-03-19T19:35:05.351Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/27/72/0824c18f3bc75810f55dacc2dd933f6ec829771180245ae3cc976195dec0/prometheus_fastapi_instrumentator-7.1.0-py3-none-any.whl", hash = "sha256:978130f3c0bb7b8ebcc90d35516a6fe13e02d2eb358c8f83887cdef7020c31e9", size = 19296, upload-time = "2025-03-19T19:35:04.323Z" },
+]
+
+[[package]]
+name = "propcache"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", hash = "sha256:f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d", size = 46442, upload-time = "2025-10-08T19:49:02.291Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/d3/6c7ee328b39a81ee877c962469f1e795f9db87f925251efeb0545e0020d0/propcache-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72", size = 225505, upload-time = "2025-10-08T19:46:50.055Z" },
+    { url = "https://files.pythonhosted.org/packages/01/5d/1c53f4563490b1d06a684742cc6076ef944bc6457df6051b7d1a877c057b/propcache-0.4.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:405aac25c6394ef275dee4c709be43745d36674b223ba4eb7144bf4d691b7367", size = 230242, upload-time = "2025-10-08T19:46:51.815Z" },
+    { url = "https://files.pythonhosted.org/packages/20/e1/ce4620633b0e2422207c3cb774a0ee61cac13abc6217763a7b9e2e3f4a12/propcache-0.4.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0013cb6f8dde4b2a2f66903b8ba740bdfe378c943c4377a200551ceb27f379e4", size = 238474, upload-time = "2025-10-08T19:46:53.208Z" },
+    { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf", size = 221575, upload-time = "2025-10-08T19:46:54.511Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/a5/8a5e8678bcc9d3a1a15b9a29165640d64762d424a16af543f00629c87338/propcache-0.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:031dce78b9dc099f4c29785d9cf5577a3faf9ebf74ecbd3c856a7b92768c3df3", size = 216736, upload-time = "2025-10-08T19:46:56.212Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/63/b7b215eddeac83ca1c6b934f89d09a625aa9ee4ba158338854c87210cc36/propcache-0.4.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ab08df6c9a035bee56e31af99be621526bd237bea9f32def431c656b29e41778", size = 213019, upload-time = "2025-10-08T19:46:57.595Z" },
+    { url = "https://files.pythonhosted.org/packages/57/74/f580099a58c8af587cac7ba19ee7cb418506342fbbe2d4a4401661cca886/propcache-0.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4d7af63f9f93fe593afbf104c21b3b15868efb2c21d07d8732c0c4287e66b6a6", size = 220376, upload-time = "2025-10-08T19:46:59.067Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ee/542f1313aff7eaf19c2bb758c5d0560d2683dac001a1c96d0774af799843/propcache-0.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cfc27c945f422e8b5071b6e93169679e4eb5bf73bbcbf1ba3ae3a83d2f78ebd9", size = 226988, upload-time = "2025-10-08T19:47:00.544Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/18/9c6b015dd9c6930f6ce2229e1f02fb35298b847f2087ea2b436a5bfa7287/propcache-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:35c3277624a080cc6ec6f847cbbbb5b49affa3598c4535a0a4682a697aaa5c75", size = 215615, upload-time = "2025-10-08T19:47:01.968Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload-time = "2025-10-08T19:49:00.792Z" },
+]
+
+[[package]]
+name = "protobuf"
+version = "6.33.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/66/70/e908e9c5e52ef7c3a6c7902c9dfbb34c7e29c25d2f81ade3856445fd5c94/protobuf-6.33.6.tar.gz", hash = "sha256:a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135", size = 444531, upload-time = "2026-03-18T19:05:00.988Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ee/90/b3c01fdec7d2f627b3a6884243ba328c1217ed2d978def5c12dc50d328a3/protobuf-6.33.6-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:e2afbae9b8e1825e3529f88d514754e094278bb95eadc0e199751cdd9a2e82a2", size = 324610, upload-time = "2026-03-18T19:04:53.096Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/ca/25afc144934014700c52e05103c2421997482d561f3101ff352e1292fb81/protobuf-6.33.6-cp39-abi3-manylinux2014_s390x.whl", hash = "sha256:c96c37eec15086b79762ed265d59ab204dabc53056e3443e702d2681f4b39ce3", size = 339381, upload-time = "2026-03-18T19:04:54.616Z" },
+    { url = "https://files.pythonhosted.org/packages/16/92/d1e32e3e0d894fe00b15ce28ad4944ab692713f2e7f0a99787405e43533a/protobuf-6.33.6-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:e9db7e292e0ab79dd108d7f1a94fe31601ce1ee3f7b79e0692043423020b0593", size = 323436, upload-time = "2026-03-18T19:04:55.768Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/72/02445137af02769918a93807b2b7890047c32bfb9f90371cbc12688819eb/protobuf-6.33.6-py3-none-any.whl", hash = "sha256:77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901", size = 170656, upload-time = "2026-03-18T19:04:59.826Z" },
+]
+
+[[package]]
+name = "psutil"
+version = "7.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" },
+    { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" },
+    { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" },
+]
+
+[[package]]
+name = "py-cpuinfo"
+version = "9.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/37/a8/d832f7293ebb21690860d2e01d8115e5ff6f2ae8bbdc953f0eb0fa4bd2c7/py-cpuinfo-9.0.0.tar.gz", hash = "sha256:3cdbbf3fac90dc6f118bfd64384f309edeadd902d7c8fb17f02ffa1fc3f49690", size = 104716, upload-time = "2022-10-25T20:38:06.303Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/a9/023730ba63db1e494a271cb018dcd361bd2c917ba7004c3e49d5daf795a2/py_cpuinfo-9.0.0-py3-none-any.whl", hash = "sha256:859625bc251f64e21f077d099d4162689c762b5d6a4c3c97553d56241c9674d5", size = 22335, upload-time = "2022-10-25T20:38:27.636Z" },
+]
+
+[[package]]
+name = "pybase64"
+version = "1.4.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/b8/4ed5c7ad5ec15b08d35cc79ace6145d5c1ae426e46435f4987379439dfea/pybase64-1.4.3.tar.gz", hash = "sha256:c2ed274c9e0ba9c8f9c4083cfe265e66dd679126cd9c2027965d807352f3f053", size = 137272, upload-time = "2025-12-06T13:27:04.013Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/1b/9a8cab0042b464e9a876d5c65fe5127445a2436da36fda64899b119b1a1b/pybase64-1.4.3-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:f0b3f200c3e06316f6bebabd458b4e4bcd4c2ca26af7c0c766614d91968dee27", size = 68210, upload-time = "2025-12-06T13:23:18.813Z" },
+    { url = "https://files.pythonhosted.org/packages/62/f7/965b79ff391ad208b50e412b5d3205ccce372a2d27b7218ae86d5295b105/pybase64-1.4.3-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:bb632edfd132b3eaf90c39c89aa314beec4e946e210099b57d40311f704e11d4", size = 71599, upload-time = "2025-12-06T13:23:20.195Z" },
+    { url = "https://files.pythonhosted.org/packages/03/4b/a3b5175130b3810bbb8ccfa1edaadbd3afddb9992d877c8a1e2f274b476e/pybase64-1.4.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:356ef1d74648ce997f5a777cf8f1aefecc1c0b4fe6201e0ef3ec8a08170e1b54", size = 59922, upload-time = "2025-12-06T13:23:21.487Z" },
+    { url = "https://files.pythonhosted.org/packages/da/5d/c38d1572027fc601b62d7a407721688b04b4d065d60ca489912d6893e6cf/pybase64-1.4.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:c48361f90db32bacaa5518419d4eb9066ba558013aaf0c7781620279ecddaeb9", size = 56712, upload-time = "2025-12-06T13:23:22.77Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/d4/4e04472fef485caa8f561d904d4d69210a8f8fc1608ea15ebd9012b92655/pybase64-1.4.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:702bcaa16ae02139d881aeaef5b1c8ffb4a3fae062fe601d1e3835e10310a517", size = 59300, upload-time = "2025-12-06T13:23:24.543Z" },
+    { url = "https://files.pythonhosted.org/packages/86/e7/16e29721b86734b881d09b7e23dfd7c8408ad01a4f4c7525f3b1088e25ec/pybase64-1.4.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:53d0ffe1847b16b647c6413d34d1de08942b7724273dd57e67dcbdb10c574045", size = 60278, upload-time = "2025-12-06T13:23:25.608Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/02/18515f211d7c046be32070709a8efeeef8a0203de4fd7521e6b56404731b/pybase64-1.4.3-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:9a1792e8b830a92736dae58f0c386062eb038dfe8004fb03ba33b6083d89cd43", size = 54817, upload-time = "2025-12-06T13:23:26.633Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/be/14e29d8e1a481dbff151324c96dd7b5d2688194bb65dc8a00ca0e1ad1e86/pybase64-1.4.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1d468b1b1ac5ad84875a46eaa458663c3721e8be5f155ade356406848d3701f6", size = 58611, upload-time = "2025-12-06T13:23:27.684Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/8a/a2588dfe24e1bbd742a554553778ab0d65fdf3d1c9a06d10b77047d142aa/pybase64-1.4.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:e97b7bdbd62e71898cd542a6a9e320d9da754ff3ebd02cb802d69087ee94d468", size = 52404, upload-time = "2025-12-06T13:23:28.714Z" },
+    { url = "https://files.pythonhosted.org/packages/27/fc/afcda7445bebe0cbc38cafdd7813234cdd4fc5573ff067f1abf317bb0cec/pybase64-1.4.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b33aeaa780caaa08ffda87fc584d5eab61e3d3bbb5d86ead02161dc0c20d04bc", size = 68817, upload-time = "2025-12-06T13:23:30.079Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/3a/87c3201e555ed71f73e961a787241a2438c2bbb2ca8809c29ddf938a3157/pybase64-1.4.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c0efcf78f11cf866bed49caa7b97552bc4855a892f9cc2372abcd3ed0056f0d", size = 57854, upload-time = "2025-12-06T13:23:31.17Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/7d/931c2539b31a7b375e7d595b88401eeb5bd6c5ce1059c9123f9b608aaa14/pybase64-1.4.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:66e3791f2ed725a46593f8bd2761ff37d01e2cdad065b1dceb89066f476e50c6", size = 54333, upload-time = "2025-12-06T13:23:32.422Z" },
+    { url = "https://files.pythonhosted.org/packages/de/5e/537601e02cc01f27e9d75f440f1a6095b8df44fc28b1eef2cd739aea8cec/pybase64-1.4.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:72bb0b6bddadab26e1b069bb78e83092711a111a80a0d6b9edcb08199ad7299b", size = 56492, upload-time = "2025-12-06T13:23:33.515Z" },
+    { url = "https://files.pythonhosted.org/packages/96/97/2a2e57acf8f5c9258d22aba52e71f8050e167b29ed2ee1113677c1b600c1/pybase64-1.4.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5b3365dbcbcdb0a294f0f50af0c0a16b27a232eddeeb0bceeefd844ef30d2a23", size = 70974, upload-time = "2025-12-06T13:23:36.27Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/8f/43c3bb11ca9bacf81cb0b7a71500bb65b2eda6d5fe07433c09b543de97f3/pybase64-1.4.3-graalpy312-graalpy250_312_native-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5c29a582b0ea3936d02bd6fe9bf674ab6059e6e45ab71c78404ab2c913224414", size = 43461, upload-time = "2025-12-06T13:26:28.906Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/4c/2a5258329200be57497d3972b5308558c6de42e3749c6cc2aa1cbe34b25a/pybase64-1.4.3-graalpy312-graalpy250_312_native-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b6b664758c804fa919b4f1257aa8cf68e95db76fc331de5f70bfc3a34655afe1", size = 36058, upload-time = "2025-12-06T13:26:30.092Z" },
+]
+
+[[package]]
+name = "pycountry"
+version = "26.2.16"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/de/1d/061b9e7a48b85cfd69f33c33d2ef784a531c359399ad764243399673c8f5/pycountry-26.2.16.tar.gz", hash = "sha256:5b6027d453fcd6060112b951dd010f01f168b51b4bf8a1f1fc8c95c8d94a0801", size = 7711342, upload-time = "2026-02-17T03:42:52.367Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9c/42/7703bd45b62fecd44cd7d3495423097e2f7d28bc2e99e7c1af68892ab157/pycountry-26.2.16-py3-none-any.whl", hash = "sha256:115c4baf7cceaa30f59a4694d79483c9167dbce7a9de4d3d571c5f3ea77c305a", size = 8044600, upload-time = "2026-02-17T03:42:49.777Z" },
+]
+
+[[package]]
+name = "pycparser"
+version = "3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.12.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types", marker = "sys_platform == 'linux'" },
+    { name = "pydantic-core", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+    { name = "typing-inspection", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
+]
+
+[package.optional-dependencies]
+email = [
+    { name = "email-validator", marker = "sys_platform == 'linux'" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" },
+    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" },
+    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" },
+    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
+]
+
+[[package]]
+name = "pydantic-extra-types"
+version = "2.11.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/71/dba38ee2651f84f7842206adbd2233d8bbdb59fb85e9fa14232486a8c471/pydantic_extra_types-2.11.1.tar.gz", hash = "sha256:46792d2307383859e923d8fcefa82108b1a141f8a9c0198982b3832ab5ef1049", size = 172002, upload-time = "2026-03-16T08:08:03.92Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/17/c1/3226e6d7f5a4f736f38ac11a6fbb262d701889802595cdb0f53a885ac2e0/pydantic_extra_types-2.11.1-py3-none-any.whl", hash = "sha256:1722ea2bddae5628ace25f2aa685b69978ef533123e5638cfbddb999e0100ec1", size = 79526, upload-time = "2026-03-16T08:08:02.533Z" },
+]
+
+[package.optional-dependencies]
+pycountry = [
+    { name = "pycountry", marker = "sys_platform == 'linux'" },
+]
+
+[[package]]
+name = "pydantic-settings"
+version = "2.13.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic", marker = "sys_platform == 'linux'" },
+    { name = "python-dotenv", marker = "sys_platform == 'linux'" },
+    { name = "typing-inspection", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/52/6d/fffca34caecc4a3f97bda81b2098da5e8ab7efc9a66e819074a11955d87e/pydantic_settings-2.13.1.tar.gz", hash = "sha256:b4c11847b15237fb0171e1462bf540e294affb9b86db4d9aa5c01730bdbe4025", size = 223826, upload-time = "2026-02-19T13:45:08.055Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/00/4b/ccc026168948fec4f7555b9164c724cf4125eac006e176541483d2c959be/pydantic_settings-2.13.1-py3-none-any.whl", hash = "sha256:d56fd801823dbeae7f0975e1f8c8e25c258eb75d278ea7abb5d9cebb01b56237", size = 58929, upload-time = "2026-02-19T13:45:06.034Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pyjwt"
+version = "2.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c2/27/a3b6e5bf6ff856d2509292e95c8f57f0df7017cf5394921fc4e4ef40308a/pyjwt-2.12.1.tar.gz", hash = "sha256:c74a7a2adf861c04d002db713dd85f84beb242228e671280bf709d765b03672b", size = 102564, upload-time = "2026-03-13T19:27:37.25Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/7a/8dd906bd22e79e47397a61742927f6747fe93242ef86645ee9092e610244/pyjwt-2.12.1-py3-none-any.whl", hash = "sha256:28ca37c070cad8ba8cd9790cd940535d40274d22f80ab87f3ac6a713e6e8454c", size = 29726, upload-time = "2026-03-13T19:27:35.677Z" },
+]
+
+[package.optional-dependencies]
+crypto = [
+    { name = "cryptography", marker = "sys_platform == 'linux'" },
+]
+
+[[package]]
+name = "pynvml"
+version = "13.0.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nvidia-ml-py", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5c/57/da7dc63a79f59e082e26a66ac02d87d69ea316b35b35b7a00d82f3ce3d2f/pynvml-13.0.1.tar.gz", hash = "sha256:1245991d9db786b4d2f277ce66869bd58f38ac654e38c9397d18f243c8f6e48f", size = 35226, upload-time = "2025-09-05T20:33:25.377Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/4a/cac76c174bb439a0c46c9a4413fcbea5c6cabfb01879f7bbdb9fdfaed76c/pynvml-13.0.1-py3-none-any.whl", hash = "sha256:e2b20e0a501eeec951e2455b7ab444759cf048e0e13a57b08049fa2775266aa8", size = 28810, upload-time = "2025-09-05T20:33:24.13Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "iniconfig", marker = "sys_platform == 'linux'" },
+    { name = "packaging", marker = "sys_platform == 'linux'" },
+    { name = "pluggy", marker = "sys_platform == 'linux'" },
+    { name = "pygments", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+]
+
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },
+]
+
+[[package]]
+name = "python-json-logger"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/29/bf/eca6a3d43db1dae7070f70e160ab20b807627ba953663ba07928cdd3dc58/python_json_logger-4.0.0.tar.gz", hash = "sha256:f58e68eb46e1faed27e0f574a55a0455eecd7b8a5b88b85a784519ba3cff047f", size = 17683, upload-time = "2025-10-06T04:15:18.984Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/51/e5/fecf13f06e5e5f67e8837d777d1bc43fac0ed2b77a676804df5c34744727/python_json_logger-4.0.0-py3-none-any.whl", hash = "sha256:af09c9daf6a813aa4cc7180395f50f2a9e5fa056034c9953aec92e381c5ba1e2", size = 15548, upload-time = "2025-10-06T04:15:17.553Z" },
+]
+
+[[package]]
+name = "python-multipart"
+version = "0.0.22"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/01/979e98d542a70714b0cb2b6728ed0b7c46792b695e3eaec3e20711271ca3/python_multipart-0.0.22.tar.gz", hash = "sha256:7340bef99a7e0032613f56dc36027b959fd3b30a787ed62d310e951f7c3a3a58", size = 37612, upload-time = "2026-01-25T10:15:56.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1b/d0/397f9626e711ff749a95d96b7af99b9c566a9bb5129b8e4c10fc4d100304/python_multipart-0.0.22-py3-none-any.whl", hash = "sha256:2b2cd894c83d21bf49d702499531c7bafd057d730c201782048f7945d82de155", size = 24579, upload-time = "2026-01-25T10:15:54.811Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+]
+
+[[package]]
+name = "pyzmq"
+version = "27.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "implementation_name == 'pypy' and sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/04/0b/3c9baedbdf613ecaa7aa07027780b8867f57b6293b6ee50de316c9f3222b/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540", size = 281750, upload-time = "2025-09-08T23:10:18.157Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/5e/c3c49fdd0f535ef45eefcc16934648e9e59dace4a37ee88fc53f6cd8e641/pyzmq-27.1.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1c179799b118e554b66da67d88ed66cd37a169f1f23b5d9f0a231b4e8d44a113", size = 895645, upload-time = "2025-09-08T23:08:05.301Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/e5/b0b2504cb4e903a74dcf1ebae157f9e20ebb6ea76095f6cfffea28c42ecd/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3837439b7f99e60312f0c926a6ad437b067356dc2bc2ec96eb395fd0fe804233", size = 652574, upload-time = "2025-09-08T23:08:06.828Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/9b/c108cdb55560eaf253f0cbdb61b29971e9fb34d9c3499b0e96e4e60ed8a5/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43ad9a73e3da1fab5b0e7e13402f0b2fb934ae1c876c51d0afff0e7c052eca31", size = 840995, upload-time = "2025-09-08T23:08:08.396Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/bb/b79798ca177b9eb0825b4c9998c6af8cd2a7f15a6a1a4272c1d1a21d382f/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0de3028d69d4cdc475bfe47a6128eb38d8bc0e8f4d69646adfbcd840facbac28", size = 1642070, upload-time = "2025-09-08T23:08:09.989Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/80/2df2e7977c4ede24c79ae39dcef3899bfc5f34d1ca7a5b24f182c9b7a9ca/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:cf44a7763aea9298c0aa7dbf859f87ed7012de8bda0f3977b6fb1d96745df856", size = 2021121, upload-time = "2025-09-08T23:08:11.907Z" },
+    { url = "https://files.pythonhosted.org/packages/46/bd/2d45ad24f5f5ae7e8d01525eb76786fa7557136555cac7d929880519e33a/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f30f395a9e6fbca195400ce833c731e7b64c3919aa481af4d88c3759e0cb7496", size = 1878550, upload-time = "2025-09-08T23:08:13.513Z" },
+]
+
+[[package]]
+name = "quack-kernels"
+version = "0.3.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "apache-tvm-ffi", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cutlass-dsl", marker = "sys_platform == 'linux'" },
+    { name = "torch", marker = "sys_platform == 'linux'" },
+    { name = "torch-c-dlpack-ext", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/75/af/5b77f565d4268905eb7e7fe3367f877ae98d0cae920c6d9f2d019a39f214/quack_kernels-0.3.6.tar.gz", hash = "sha256:43af5a1f31099682cb1c53aa835fcdfebeb88d917c08aa342b959af88c6e8749", size = 192593, upload-time = "2026-03-24T13:30:00.923Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8e/28/e688da97806474963b2983a8231572733de11ed48f8899410c0afc8bdf15/quack_kernels-0.3.6-py3-none-any.whl", hash = "sha256:973d974ccca816014006af8f136294ba0f15b1c324197f8b54ffc6500666e0e5", size = 198865, upload-time = "2026-03-24T13:29:59.107Z" },
+]
+
+[[package]]
+name = "referencing"
+version = "0.37.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs", marker = "sys_platform == 'linux'" },
+    { name = "rpds-py", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" },
+]
+
+[[package]]
+name = "regex"
+version = "2026.2.28"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8b/71/41455aa99a5a5ac1eaf311f5d8efd9ce6433c03ac1e0962de163350d0d97/regex-2026.2.28.tar.gz", hash = "sha256:a729e47d418ea11d03469f321aaf67cdee8954cde3ff2cf8403ab87951ad10f2", size = 415184, upload-time = "2026-02-28T02:19:42.792Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dd/c9/8cc8d850b35ab5650ff6756a1cb85286e2000b66c97520b29c1587455344/regex-2026.2.28-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e71dcecaa113eebcc96622c17692672c2d104b1d71ddf7adeda90da7ddeb26fc", size = 796765, upload-time = "2026-02-28T02:16:55.905Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/5d/57702597627fc23278ebf36fbb497ac91c0ce7fec89ac6c81e420ca3e38c/regex-2026.2.28-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:481df4623fa4969c8b11f3433ed7d5e3dc9cec0f008356c3212b3933fb77e3d8", size = 863093, upload-time = "2026-02-28T02:16:58.094Z" },
+    { url = "https://files.pythonhosted.org/packages/02/6d/f3ecad537ca2811b4d26b54ca848cf70e04fcfc138667c146a9f3157779c/regex-2026.2.28-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:64e7c6ad614573e0640f271e811a408d79a9e1fe62a46adb602f598df42a818d", size = 909455, upload-time = "2026-02-28T02:17:00.918Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/40/bb226f203caa22c1043c1ca79b36340156eca0f6a6742b46c3bb222a3a57/regex-2026.2.28-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6b08a06976ff4fb0d83077022fde3eca06c55432bb997d8c0495b9a4e9872f4", size = 802037, upload-time = "2026-02-28T02:17:02.842Z" },
+    { url = "https://files.pythonhosted.org/packages/44/7c/c6d91d8911ac6803b45ca968e8e500c46934e58c0903cbc6d760ee817a0a/regex-2026.2.28-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:864cdd1a2ef5716b0ab468af40139e62ede1b3a53386b375ec0786bb6783fc05", size = 775113, upload-time = "2026-02-28T02:17:04.506Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/8d/4a9368d168d47abd4158580b8c848709667b1cd293ff0c0c277279543bd0/regex-2026.2.28-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:511f7419f7afab475fd4d639d4aedfc54205bcb0800066753ef68a59f0f330b5", size = 784194, upload-time = "2026-02-28T02:17:06.888Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/bf/2c72ab5d8b7be462cb1651b5cc333da1d0068740342f350fcca3bca31947/regex-2026.2.28-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:b42f7466e32bf15a961cf09f35fa6323cc72e64d3d2c990b10de1274a5da0a59", size = 856846, upload-time = "2026-02-28T02:17:09.11Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f4/6b65c979bb6d09f51bb2d2a7bc85de73c01ec73335d7ddd202dcb8cd1c8f/regex-2026.2.28-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8710d61737b0c0ce6836b1da7109f20d495e49b3809f30e27e9560be67a257bf", size = 763516, upload-time = "2026-02-28T02:17:11.004Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/32/29ea5e27400ee86d2cc2b4e80aa059df04eaf78b4f0c18576ae077aeff68/regex-2026.2.28-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4390c365fd2d45278f45afd4673cb90f7285f5701607e3ad4274df08e36140ae", size = 849278, upload-time = "2026-02-28T02:17:12.693Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/91/3233d03b5f865111cd517e1c95ee8b43e8b428d61fa73764a80c9bb6f537/regex-2026.2.28-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:cb3b1db8ff6c7b8bf838ab05583ea15230cb2f678e569ab0e3a24d1e8320940b", size = 790068, upload-time = "2026-02-28T02:17:14.9Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.33.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi", marker = "sys_platform == 'linux'" },
+    { name = "charset-normalizer", marker = "sys_platform == 'linux'" },
+    { name = "idna", marker = "sys_platform == 'linux'" },
+    { name = "urllib3", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/34/64/8860370b167a9721e8956ae116825caff829224fbca0ca6e7bf8ddef8430/requests-2.33.0.tar.gz", hash = "sha256:c7ebc5e8b0f21837386ad0e1c8fe8b829fa5f544d8df3b2253bff14ef29d7652", size = 134232, upload-time = "2026-03-25T15:10:41.586Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/56/5d/c814546c2333ceea4ba42262d8c4d55763003e767fa169adc693bd524478/requests-2.33.0-py3-none-any.whl", hash = "sha256:3324635456fa185245e24865e810cecec7b4caf933d7eb133dcde67d48cee69b", size = 65017, upload-time = "2026-03-25T15:10:40.382Z" },
+]
+
+[[package]]
+name = "rich"
+version = "14.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py", marker = "sys_platform == 'linux'" },
+    { name = "pygments", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b3/c6/f3b320c27991c46f43ee9d856302c70dc2d0fb2dba4842ff739d5f46b393/rich-14.3.3.tar.gz", hash = "sha256:b8daa0b9e4eef54dd8cf7c86c03713f53241884e814f4e2f5fb342fe520f639b", size = 230582, upload-time = "2026-02-19T17:23:12.474Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/25/b208c5683343959b670dc001595f2f3737e051da617f66c31f7c4fa93abc/rich-14.3.3-py3-none-any.whl", hash = "sha256:793431c1f8619afa7d3b52b2cdec859562b950ea0d4b6b505397612db8d5362d", size = 310458, upload-time = "2026-02-19T17:23:13.732Z" },
+]
+
+[[package]]
+name = "rich-toolkit"
+version = "0.19.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click", marker = "sys_platform == 'linux'" },
+    { name = "rich", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/42/ba/dae9e3096651042754da419a4042bc1c75e07d615f9b15066d738838e4df/rich_toolkit-0.19.7.tar.gz", hash = "sha256:133c0915872da91d4c25d85342d5ec1dfacc69b63448af1a08a0d4b4f23ef46e", size = 195877, upload-time = "2026-02-24T16:06:20.555Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/3c/c923619f6d2f5fafcc96fec0aaf9550a46cd5b6481f06e0c6b66a2a4fed0/rich_toolkit-0.19.7-py3-none-any.whl", hash = "sha256:0288e9203728c47c5a4eb60fd2f0692d9df7455a65901ab6f898437a2ba5989d", size = 32963, upload-time = "2026-02-24T16:06:22.066Z" },
+]
+
+[[package]]
+name = "rignore"
+version = "0.7.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e5/f5/8bed2310abe4ae04b67a38374a4d311dd85220f5d8da56f47ae9361be0b0/rignore-0.7.6.tar.gz", hash = "sha256:00d3546cd793c30cb17921ce674d2c8f3a4b00501cb0e3dd0e82217dbeba2671", size = 57140, upload-time = "2025-11-05T21:41:21.968Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4a/c8/dea564b36dedac8de21c18e1851789545bc52a0c22ece9843444d5608a6a/rignore-0.7.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bda49950d405aa8d0ebe26af807c4e662dd281d926530f03f29690a2e07d649a", size = 897821, upload-time = "2025-11-05T20:40:52.613Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/2b/ee96db17ac1835e024c5d0742eefb7e46de60020385ac883dd3d1cde2c1f/rignore-0.7.6-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b5fd5ab3840b8c16851d327ed06e9b8be6459702a53e5ab1fc4073b684b3789e", size = 873963, upload-time = "2025-11-05T20:41:07.49Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/8c/ad5a57bbb9d14d5c7e5960f712a8a0b902472ea3f4a2138cbf70d1777b75/rignore-0.7.6-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ced2a248352636a5c77504cb755dc02c2eef9a820a44d3f33061ce1bb8a7f2d2", size = 1169216, upload-time = "2025-11-05T20:41:23.73Z" },
+    { url = "https://files.pythonhosted.org/packages/80/e6/5b00bc2a6bc1701e6878fca798cf5d9125eb3113193e33078b6fc0d99123/rignore-0.7.6-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a04a3b73b75ddc12c9c9b21efcdaab33ca3832941d6f1d67bffd860941cd448a", size = 942942, upload-time = "2025-11-05T20:41:39.393Z" },
+    { url = "https://files.pythonhosted.org/packages/85/e5/7f99bd0cc9818a91d0e8b9acc65b792e35750e3bdccd15a7ee75e64efca4/rignore-0.7.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d24321efac92140b7ec910ac7c53ab0f0c86a41133d2bb4b0e6a7c94967f44dd", size = 959787, upload-time = "2025-11-05T20:42:09.765Z" },
+    { url = "https://files.pythonhosted.org/packages/55/54/2ffea79a7c1eabcede1926347ebc2a81bc6b81f447d05b52af9af14948b9/rignore-0.7.6-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:73c7aa109d41e593785c55fdaa89ad80b10330affa9f9d3e3a51fa695f739b20", size = 984245, upload-time = "2025-11-05T20:41:54.062Z" },
+    { url = "https://files.pythonhosted.org/packages/41/f7/e80f55dfe0f35787fa482aa18689b9c8251e045076c35477deb0007b3277/rignore-0.7.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1734dc49d1e9501b07852ef44421f84d9f378da9fbeda729e77db71f49cac28b", size = 1078647, upload-time = "2025-11-05T21:40:13.463Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/cf/2c64f0b6725149f7c6e7e5a909d14354889b4beaadddaa5fff023ec71084/rignore-0.7.6-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5719ea14ea2b652c0c0894be5dfde954e1853a80dea27dd2fbaa749618d837f5", size = 1139186, upload-time = "2025-11-05T21:40:31.27Z" },
+    { url = "https://files.pythonhosted.org/packages/75/95/a86c84909ccc24af0d094b50d54697951e576c252a4d9f21b47b52af9598/rignore-0.7.6-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:8e23424fc7ce35726854f639cb7968151a792c0c3d9d082f7f67e0c362cfecca", size = 1117604, upload-time = "2025-11-05T21:40:48.07Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/5e/13b249613fd5d18d58662490ab910a9f0be758981d1797789913adb4e918/rignore-0.7.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3efdcf1dd84d45f3e2bd2f93303d9be103888f56dfa7c3349b5bf4f0657ec696", size = 1127725, upload-time = "2025-11-05T21:41:05.804Z" },
+]
+
+[[package]]
+name = "rpds-py"
+version = "0.30.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", hash = "sha256:dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84", size = 69469, upload-time = "2025-11-30T20:24:38.837Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/65/1c/ae157e83a6357eceff62ba7e52113e3ec4834a84cfe07fa4b0757a7d105f/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca28829ae5f5d569bb62a79512c842a03a12576375d5ece7d2cadf8abe96ec28", size = 390763, upload-time = "2025-11-30T20:22:21.661Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/36/eb2eb8515e2ad24c0bd43c3ee9cd74c33f7ca6430755ccdb240fd3144c44/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a1010ed9524c73b94d15919ca4d41d8780980e1765babf85f9a2f90d247153dd", size = 408951, upload-time = "2025-11-30T20:22:23.408Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/65/ad8dc1784a331fabbd740ef6f71ce2198c7ed0890dab595adb9ea2d775a1/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8d1736cfb49381ba528cd5baa46f82fdc65c06e843dab24dd70b63d09121b3f", size = 514622, upload-time = "2025-11-30T20:22:25.16Z" },
+    { url = "https://files.pythonhosted.org/packages/63/8e/0cfa7ae158e15e143fe03993b5bcd743a59f541f5952e1546b1ac1b5fd45/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d948b135c4693daff7bc2dcfc4ec57237a29bd37e60c2fabf5aff2bbacf3e2f1", size = 414492, upload-time = "2025-11-30T20:22:26.505Z" },
+    { url = "https://files.pythonhosted.org/packages/60/1b/6f8f29f3f995c7ffdde46a626ddccd7c63aefc0efae881dc13b6e5d5bb16/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23", size = 394080, upload-time = "2025-11-30T20:22:27.934Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/d5/a266341051a7a3ca2f4b750a3aa4abc986378431fc2da508c5034d081b70/rpds_py-0.30.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:2e6ecb5a5bcacf59c3f912155044479af1d0b6681280048b338b28e364aca1f6", size = 408680, upload-time = "2025-11-30T20:22:29.341Z" },
+    { url = "https://files.pythonhosted.org/packages/10/3b/71b725851df9ab7a7a4e33cf36d241933da66040d195a84781f49c50490c/rpds_py-0.30.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a8fa71a2e078c527c3e9dc9fc5a98c9db40bcc8a92b4e8858e36d329f8684b51", size = 423589, upload-time = "2025-11-30T20:22:31.469Z" },
+    { url = "https://files.pythonhosted.org/packages/00/2b/e59e58c544dc9bd8bd8384ecdb8ea91f6727f0e37a7131baeff8d6f51661/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73c67f2db7bc334e518d097c6d1e6fed021bbc9b7d678d6cc433478365d1d5f5", size = 573289, upload-time = "2025-11-30T20:22:32.997Z" },
+    { url = "https://files.pythonhosted.org/packages/da/3e/a18e6f5b460893172a7d6a680e86d3b6bc87a54c1f0b03446a3c8c7b588f/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5ba103fb455be00f3b1c2076c9d4264bfcb037c976167a6047ed82f23153f02e", size = 599737, upload-time = "2025-11-30T20:22:34.419Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/e2/714694e4b87b85a18e2c243614974413c60aa107fd815b8cbc42b873d1d7/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7cee9c752c0364588353e627da8a7e808a66873672bcb5f52890c33fd965b394", size = 563120, upload-time = "2025-11-30T20:22:35.903Z" },
+]
+
+[[package]]
+name = "safetensors"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/29/9c/6e74567782559a63bd040a236edca26fd71bc7ba88de2ef35d75df3bca5e/safetensors-0.7.0.tar.gz", hash = "sha256:07663963b67e8bd9f0b8ad15bb9163606cd27cc5a1b96235a50d8369803b96b0", size = 200878, upload-time = "2025-11-19T15:18:43.199Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/06/578ffed52c2296f93d7fd2d844cabfa92be51a587c38c8afbb8ae449ca89/safetensors-0.7.0-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e07d91d0c92a31200f25351f4acb2bc6aff7f48094e13ebb1d0fb995b54b6542", size = 491748, upload-time = "2025-11-19T15:18:09.79Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/33/1debbbb70e4791dde185edb9413d1fe01619255abb64b300157d7f15dddd/safetensors-0.7.0-cp38-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8469155f4cb518bafb4acf4865e8bb9d6804110d2d9bdcaa78564b9fd841e104", size = 503881, upload-time = "2025-11-19T15:18:16.145Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/1c/40c2ca924d60792c3be509833df711b553c60effbd91da6f5284a83f7122/safetensors-0.7.0-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:54bef08bf00a2bff599982f6b08e8770e09cc012d7bba00783fc7ea38f1fb37d", size = 623463, upload-time = "2025-11-19T15:18:21.11Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/3a/13784a9364bd43b0d61eef4bea2845039bc2030458b16594a1bd787ae26e/safetensors-0.7.0-cp38-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:42cb091236206bb2016d245c377ed383aa7f78691748f3bb6ee1bfa51ae2ce6a", size = 532855, upload-time = "2025-11-19T15:18:25.719Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/60/429e9b1cb3fc651937727befe258ea24122d9663e4d5709a48c9cbfceecb/safetensors-0.7.0-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dac7252938f0696ddea46f5e855dd3138444e82236e3be475f54929f0c510d48", size = 507152, upload-time = "2025-11-19T15:18:33.023Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/a8/4b45e4e059270d17af60359713ffd83f97900d45a6afa73aaa0d737d48b6/safetensors-0.7.0-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1d060c70284127fa805085d8f10fbd0962792aed71879d00864acda69dbab981", size = 541856, upload-time = "2025-11-19T15:18:31.075Z" },
+    { url = "https://files.pythonhosted.org/packages/06/87/d26d8407c44175d8ae164a95b5a62707fcc445f3c0c56108e37d98070a3d/safetensors-0.7.0-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:cdab83a366799fa730f90a4ebb563e494f28e9e92c4819e556152ad55e43591b", size = 674060, upload-time = "2025-11-19T15:18:37.211Z" },
+    { url = "https://files.pythonhosted.org/packages/11/f5/57644a2ff08dc6325816ba7217e5095f17269dada2554b658442c66aed51/safetensors-0.7.0-cp38-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:672132907fcad9f2aedcb705b2d7b3b93354a2aec1b2f706c4db852abe338f85", size = 771715, upload-time = "2025-11-19T15:18:38.689Z" },
+    { url = "https://files.pythonhosted.org/packages/86/31/17883e13a814bd278ae6e266b13282a01049b0c81341da7fd0e3e71a80a3/safetensors-0.7.0-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:5d72abdb8a4d56d4020713724ba81dac065fedb7f3667151c4a637f1d3fb26c0", size = 714377, upload-time = "2025-11-19T15:18:40.162Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/d8/0c8a7dc9b41dcac53c4cbf9df2b9c83e0e0097203de8b37a712b345c0be5/safetensors-0.7.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b0f6d66c1c538d5a94a73aa9ddca8ccc4227e6c9ff555322ea40bdd142391dd4", size = 677368, upload-time = "2025-11-19T15:18:41.627Z" },
+]
+
+[[package]]
+name = "sentencepiece"
+version = "0.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/15/15/2e7a025fc62d764b151ae6d0f2a92f8081755ebe8d4a64099accc6f77ba6/sentencepiece-0.2.1.tar.gz", hash = "sha256:8138cec27c2f2282f4a34d9a016e3374cd40e5c6e9cb335063db66a0a3b71fad", size = 3228515, upload-time = "2025-08-12T07:00:51.718Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/89/fa/d3d5ebcba3cb9e6d3775a096251860c41a6bc53a1b9461151df83fe93255/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99f955df238021bf11f0fc37cdb54fd5e5b5f7fd30ecc3d93fb48b6815437167", size = 1316273, upload-time = "2025-08-12T06:59:44.476Z" },
+    { url = "https://files.pythonhosted.org/packages/04/88/14f2f4a2b922d8b39be45bf63d79e6cd3a9b2f248b2fcb98a69b12af12f5/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0cdfecef430d985f1c2bcbfff3defd1d95dae876fbd0173376012d2d7d24044b", size = 1387881, upload-time = "2025-08-12T06:59:46.09Z" },
+]
+
+[[package]]
+name = "sentry-sdk"
+version = "2.56.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi", marker = "sys_platform == 'linux'" },
+    { name = "urllib3", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/de/df/5008954f5466085966468612a7d1638487596ee6d2fd7fb51783a85351bf/sentry_sdk-2.56.0.tar.gz", hash = "sha256:fdab72030b69625665b2eeb9738bdde748ad254e8073085a0ce95382678e8168", size = 426820, upload-time = "2026-03-24T09:56:36.575Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cd/1a/b3a3e9f6520493fed7997af4d2de7965d71549c62f994a8fd15f2ecd519e/sentry_sdk-2.56.0-py2.py3-none-any.whl", hash = "sha256:5afafb744ceb91d22f4cc650c6bd048ac6af5f7412dcc6c59305a2e36f4dbc02", size = 451568, upload-time = "2026-03-24T09:56:34.807Z" },
+]
+
+[[package]]
+name = "setproctitle"
+version = "1.3.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8d/48/49393a96a2eef1ab418b17475fb92b8fcfad83d099e678751b05472e69de/setproctitle-1.3.7.tar.gz", hash = "sha256:bc2bc917691c1537d5b9bca1468437176809c7e11e5694ca79a9ca12345dcb9e", size = 27002, upload-time = "2025-09-05T12:51:25.278Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d0/99/71630546b9395b095f4082be41165d1078204d1696c2d9baade3de3202d0/setproctitle-1.3.7-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2906b6c7959cdb75f46159bf0acd8cc9906cf1361c9e1ded0d065fe8f9039629", size = 32932, upload-time = "2025-09-05T12:49:39.271Z" },
+    { url = "https://files.pythonhosted.org/packages/50/22/cee06af4ffcfb0e8aba047bd44f5262e644199ae7527ae2c1f672b86495c/setproctitle-1.3.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6915964a6dda07920a1159321dcd6d94fc7fc526f815ca08a8063aeca3c204f1", size = 33736, upload-time = "2025-09-05T12:49:40.565Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/00/a5949a8bb06ef5e7df214fc393bb2fb6aedf0479b17214e57750dfdd0f24/setproctitle-1.3.7-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cff72899861c765bd4021d1ff1c68d60edc129711a2fdba77f9cb69ef726a8b6", size = 35605, upload-time = "2025-09-05T12:49:42.362Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3a/50caca532a9343828e3bf5778c7a84d6c737a249b1796d50dd680290594d/setproctitle-1.3.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b7cb05bd446687ff816a3aaaf831047fc4c364feff7ada94a66024f1367b448c", size = 33143, upload-time = "2025-09-05T12:49:43.515Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/14/b843a251296ce55e2e17c017d6b9f11ce0d3d070e9265de4ecad948b913d/setproctitle-1.3.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:3a57b9a00de8cae7e2a1f7b9f0c2ac7b69372159e16a7708aa2f38f9e5cc987a", size = 34434, upload-time = "2025-09-05T12:49:45.31Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/b7/06145c238c0a6d2c4bc881f8be230bb9f36d2bf51aff7bddcb796d5eed67/setproctitle-1.3.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d8828b356114f6b308b04afe398ed93803d7fca4a955dd3abe84430e28d33739", size = 32795, upload-time = "2025-09-05T12:49:46.419Z" },
+]
+
+[[package]]
+name = "setuptools"
+version = "80.10.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/76/95/faf61eb8363f26aa7e1d762267a8d602a1b26d4f3a1e758e92cb3cb8b054/setuptools-80.10.2.tar.gz", hash = "sha256:8b0e9d10c784bf7d262c4e5ec5d4ec94127ce206e8738f29a437945fbc219b70", size = 1200343, upload-time = "2026-01-25T22:38:17.252Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/b8/f1f62a5e3c0ad2ff1d189590bfa4c46b4f3b6e49cef6f26c6ee4e575394d/setuptools-80.10.2-py3-none-any.whl", hash = "sha256:95b30ddfb717250edb492926c92b5221f7ef3fbcc2b07579bcd4a27da21d0173", size = 1064234, upload-time = "2026-01-25T22:38:15.216Z" },
+]
+
+[[package]]
+name = "shellingham"
+version = "1.5.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" },
+]
+
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
+]
+
+[[package]]
+name = "sniffio"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
+]
+
+[[package]]
+name = "sse-starlette"
+version = "3.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio", marker = "sys_platform == 'linux'" },
+    { name = "starlette", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/14/2f/9223c24f568bb7a0c03d751e609844dce0968f13b39a3f73fbb3a96cd27a/sse_starlette-3.3.3.tar.gz", hash = "sha256:72a95d7575fd5129bd0ae15275ac6432bb35ac542fdebb82889c24bb9f3f4049", size = 32420, upload-time = "2026-03-17T20:05:55.529Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/e2/b8cff57a67dddf9a464d7e943218e031617fb3ddc133aeeb0602ff5f6c85/sse_starlette-3.3.3-py3-none-any.whl", hash = "sha256:c5abb5082a1cc1c6294d89c5290c46b5f67808cfdb612b7ec27e8ba061c22e8d", size = 14329, upload-time = "2026-03-17T20:05:54.35Z" },
+]
+
+[[package]]
+name = "starlette"
+version = "0.52.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c4/68/79977123bb7be889ad680d79a40f339082c1978b5cfcf62c2d8d196873ac/starlette-0.52.1.tar.gz", hash = "sha256:834edd1b0a23167694292e94f597773bc3f89f362be6effee198165a35d62933", size = 2653702, upload-time = "2026-01-18T13:34:11.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/81/0d/13d1d239a25cbfb19e740db83143e95c772a1fe10202dda4b76792b114dd/starlette-0.52.1-py3-none-any.whl", hash = "sha256:0029d43eb3d273bc4f83a08720b4912ea4b071087a3b48db01b7c839f7954d74", size = 74272, upload-time = "2026-01-18T13:34:09.188Z" },
+]
+
+[[package]]
+name = "supervisor"
+version = "4.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/b5/37e7a3706de436a8a2d75334711dad1afb4ddffab09f25e31d89e467542f/supervisor-4.3.0.tar.gz", hash = "sha256:4a2bf149adf42997e1bb44b70c43b613275ec9852c3edacca86a9166b27e945e", size = 468912, upload-time = "2025-08-23T18:25:02.418Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/65/5e726c372da8a5e35022a94388b12252710aad0c2351699c3d76ae8dba78/supervisor-4.3.0-py2.py3-none-any.whl", hash = "sha256:0bcb763fddafba410f35cbde226aa7f8514b9fb82eb05a0c85f6588d1c13f8db", size = 320736, upload-time = "2025-08-23T18:25:00.767Z" },
+]
+
+[[package]]
+name = "sympy"
+version = "1.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mpmath", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" },
+]
+
+[[package]]
+name = "tabulate"
+version = "0.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/58/8c37dea7bbf769b20d58e7ace7e5edfe65b849442b00ffcdd56be88697c6/tabulate-0.10.0.tar.gz", hash = "sha256:e2cfde8f79420f6deeffdeda9aaec3b6bc5abce947655d17ac662b126e48a60d", size = 91754, upload-time = "2026-03-04T18:55:34.402Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/99/55/db07de81b5c630da5cbf5c7df646580ca26dfaefa593667fc6f2fe016d2e/tabulate-0.10.0-py3-none-any.whl", hash = "sha256:f0b0622e567335c8fabaaa659f1b33bcb6ddfe2e496071b743aa113f8774f2d3", size = 39814, upload-time = "2026-03-04T18:55:31.284Z" },
+]
+
+[[package]]
+name = "textual"
+version = "8.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py", extra = ["linkify"], marker = "sys_platform == 'linux'" },
+    { name = "mdit-py-plugins", marker = "sys_platform == 'linux'" },
+    { name = "platformdirs", marker = "sys_platform == 'linux'" },
+    { name = "pygments", marker = "sys_platform == 'linux'" },
+    { name = "rich", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/70/41/fd22435b96a50f24472af31f15e9874ce0ffef0edabb74fcf3d598ab8e53/textual-8.2.0.tar.gz", hash = "sha256:a06201a732b2d2683d2ea11c2538eeb7315c4c7138ed8c8bdb48150b805eaf1e", size = 1847670, upload-time = "2026-03-27T09:28:29.976Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/41/ed1f3e47b71b9e0bae23445189274048332a423798627d47e30314c739a0/textual-8.2.0-py3-none-any.whl", hash = "sha256:0478fed6e945bcadd6f3841e10d05213d318cdb5c4345c04ae78f7ec32e7b63d", size = 723752, upload-time = "2026-03-27T09:28:32.705Z" },
+]
+
+[[package]]
+name = "tiktoken"
+version = "0.12.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "regex", marker = "sys_platform == 'linux'" },
+    { name = "requests", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7d/ab/4d017d0f76ec3171d469d80fc03dfbb4e48a4bcaddaa831b31d526f05edc/tiktoken-0.12.0.tar.gz", hash = "sha256:b18ba7ee2b093863978fcb14f74b3707cdc8d4d4d3836853ce7ec60772139931", size = 37806, upload-time = "2025-10-06T20:22:45.419Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/66/c5/ed88504d2f4a5fd6856990b230b56d85a777feab84e6129af0822f5d0f70/tiktoken-0.12.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:65b26c7a780e2139e73acc193e5c63ac754021f160df919add909c1492c0fb37", size = 1129008, upload-time = "2025-10-06T20:21:54.832Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/90/3dae6cc5436137ebd38944d396b5849e167896fc2073da643a49f372dc4f/tiktoken-0.12.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:edde1ec917dfd21c1f2f8046b86348b0f54a2c0547f68149d8600859598769ad", size = 1152665, upload-time = "2025-10-06T20:21:56.129Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/fe/26df24ce53ffde419a42f5f53d755b995c9318908288c17ec3f3448313a3/tiktoken-0.12.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:35a2f8ddd3824608b3d650a000c1ef71f730d0c56486845705a8248da00f9fe5", size = 1194230, upload-time = "2025-10-06T20:21:57.546Z" },
+    { url = "https://files.pythonhosted.org/packages/20/cc/b064cae1a0e9fac84b0d2c46b89f4e57051a5f41324e385d10225a984c24/tiktoken-0.12.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:83d16643edb7fa2c99eff2ab7733508aae1eebb03d5dfc46f5565862810f24e3", size = 1254688, upload-time = "2025-10-06T20:21:58.619Z" },
+]
+
+[[package]]
+name = "tokenizers"
+version = "0.22.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "huggingface-hub", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/73/6f/f80cfef4a312e1fb34baf7d85c72d4411afde10978d4657f8cdd811d3ccc/tokenizers-0.22.2.tar.gz", hash = "sha256:473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917", size = 372115, upload-time = "2026-01-05T10:45:15.988Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d6/84/7990e799f1309a8b87af6b948f31edaa12a3ed22d11b352eaf4f4b2e5753/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2249487018adec45d6e3554c71d46eb39fa8ea67156c640f7513eb26f318cec7", size = 3290736, upload-time = "2026-01-05T10:40:32.165Z" },
+    { url = "https://files.pythonhosted.org/packages/78/59/09d0d9ba94dcd5f4f1368d4858d24546b4bdc0231c2354aa31d6199f0399/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:25b85325d0815e86e0bac263506dd114578953b7b53d7de09a6485e4a160a7dd", size = 3168835, upload-time = "2026-01-05T10:40:38.847Z" },
+    { url = "https://files.pythonhosted.org/packages/47/50/b3ebb4243e7160bda8d34b731e54dd8ab8b133e50775872e7a434e524c28/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bfb88f22a209ff7b40a576d5324bf8286b519d7358663db21d6246fb17eea2d5", size = 3521673, upload-time = "2026-01-05T10:40:56.614Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/fa/89f4cb9e08df770b57adb96f8cbb7e22695a4cb6c2bd5f0c4f0ebcf33b66/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1c774b1276f71e1ef716e5486f21e76333464f47bece56bbd554485982a9e03e", size = 3724818, upload-time = "2026-01-05T10:40:44.507Z" },
+    { url = "https://files.pythonhosted.org/packages/64/04/ca2363f0bfbe3b3d36e95bf67e56a4c88c8e3362b658e616d1ac185d47f2/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:df6c4265b289083bf710dff49bc51ef252f9d5be33a45ee2bed151114a56207b", size = 3379195, upload-time = "2026-01-05T10:40:51.139Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/76/932be4b50ef6ccedf9d3c6639b056a967a86258c6d9200643f01269211ca/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:369cc9fc8cc10cb24143873a0d95438bb8ee257bb80c71989e3ee290e8d72c67", size = 3274982, upload-time = "2026-01-05T10:40:58.331Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/28/5f9f5a4cc211b69e89420980e483831bcc29dade307955cc9dc858a40f01/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:29c30b83d8dcd061078b05ae0cb94d3c710555fbb44861139f9f83dcca3dc3e4", size = 9478245, upload-time = "2026-01-05T10:41:04.053Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/fb/66e2da4704d6aadebf8cb39f1d6d1957df667ab24cff2326b77cda0dcb85/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:37ae80a28c1d3265bb1f22464c856bd23c02a05bb211e56d0c5301a435be6c1a", size = 9560069, upload-time = "2026-01-05T10:45:10.673Z" },
+    { url = "https://files.pythonhosted.org/packages/16/04/fed398b05caa87ce9b1a1bb5166645e38196081b225059a6edaff6440fac/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:791135ee325f2336f498590eb2f11dc5c295232f288e75c99a36c5dbce63088a", size = 9899263, upload-time = "2026-01-05T10:45:12.559Z" },
+    { url = "https://files.pythonhosted.org/packages/05/a1/d62dfe7376beaaf1394917e0f8e93ee5f67fea8fcf4107501db35996586b/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:38337540fbbddff8e999d59970f3c6f35a82de10053206a7562f1ea02d046fa5", size = 10033429, upload-time = "2026-01-05T10:45:14.333Z" },
+]
+
+[[package]]
+name = "torch"
+version = "2.10.0+cu130"
+source = { registry = "https://download.pytorch.org/whl/cu130" }
+dependencies = [
+    { name = "cuda-bindings", marker = "sys_platform == 'linux'" },
+    { name = "filelock", marker = "sys_platform == 'linux'" },
+    { name = "fsspec", marker = "sys_platform == 'linux'" },
+    { name = "jinja2", marker = "sys_platform == 'linux'" },
+    { name = "networkx", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cublas", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cuda-cupti", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cuda-nvrtc", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cuda-runtime", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cudnn-cu13", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cufft", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cufile", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-curand", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cusolver", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cusparse", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cusparselt-cu13", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-nccl-cu13", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-nvjitlink", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-nvshmem-cu13", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-nvtx", marker = "sys_platform == 'linux'" },
+    { name = "setuptools", marker = "sys_platform == 'linux'" },
+    { name = "sympy", marker = "sys_platform == 'linux'" },
+    { name = "triton", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:4fc8f67637f4c92b989a07d80ffe755e79a3510ca02ebf23ce66396fb277c88d" },
+    { url = "https://download-r2.pytorch.org/whl/cu130/torch-2.10.0%2Bcu130-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:858f0cbcc78d726fea9499eb3464faa98392fa093845a3262209bd226b7844d6" },
+]
+
+[[package]]
+name = "torch-c-dlpack-ext"
+version = "0.1.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "torch", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/37/de/921b6491efce5c389a5ef9bbed3d2d6660005840dae488124173180859ab/torch_c_dlpack_ext-0.1.5.tar.gz", hash = "sha256:d06f0357d575d22a168cc77acb9020fc4bae30968ceb6718a055dcbe92bacabe", size = 12913, upload-time = "2026-01-12T11:25:08.484Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/87/06/8d760997307a5c3be4384424667bf31aae0a42060838c532c7d846516175/torch_c_dlpack_ext-0.1.5-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3562ee411258676f9c38b8ad39306d1c8d027b6a86f6a87c920d2d009a9d1510", size = 443069, upload-time = "2026-01-12T11:24:45.451Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/79/a914539b4785f3e44f891aa012a886edb8bc10fe081c440981c57543ce21/torch_c_dlpack_ext-0.1.5-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e6f9da4bb9af70e27facc777458be62e10dbbbddda7672d16138db0553c5a524", size = 897846, upload-time = "2026-01-12T11:24:48.168Z" },
+]
+
+[[package]]
+name = "torchaudio"
+version = "2.10.0+cu130"
+source = { registry = "https://download.pytorch.org/whl/cu130" }
+dependencies = [
+    { name = "torch", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://download-r2.pytorch.org/whl/cu130/torchaudio-2.10.0%2Bcu130-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:f04907b7a710cd612adb63db3a2dac6265e4679686fb2b1c9e1b70562b1bda29" },
+    { url = "https://download-r2.pytorch.org/whl/cu130/torchaudio-2.10.0%2Bcu130-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:ed573e7319ba9a6e137b4895eddf4c9fcd424bb4e10a629267d64b55acc57fbb" },
+]
+
+[[package]]
+name = "torchvision"
+version = "0.25.0+cu130"
+source = { registry = "https://download.pytorch.org/whl/cu130" }
+dependencies = [
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "pillow", marker = "sys_platform == 'linux'" },
+    { name = "torch", marker = "sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://download-r2.pytorch.org/whl/cu130/torchvision-0.25.0%2Bcu130-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:3646e6c8fa5066da392d0ff13002cc683301386fe1933f8f1432fc5292e5d288" },
+    { url = "https://download-r2.pytorch.org/whl/cu130/torchvision-0.25.0%2Bcu130-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:c2f5e38f0cd57a2796e4503c0f13365deba01dbc167ef820f0beec7ca96f5f2e" },
+]
+
+[[package]]
+name = "tqdm"
+version = "4.67.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", hash = "sha256:7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb", size = 169598, upload-time = "2026-02-03T17:35:53.048Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", hash = "sha256:ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf", size = 78374, upload-time = "2026-02-03T17:35:50.982Z" },
+]
+
+[[package]]
+name = "transformers"
+version = "5.5.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "huggingface-hub", marker = "sys_platform == 'linux'" },
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "packaging", marker = "sys_platform == 'linux'" },
+    { name = "pyyaml", marker = "sys_platform == 'linux'" },
+    { name = "regex", marker = "sys_platform == 'linux'" },
+    { name = "safetensors", marker = "sys_platform == 'linux'" },
+    { name = "tokenizers", marker = "sys_platform == 'linux'" },
+    { name = "tqdm", marker = "sys_platform == 'linux'" },
+    { name = "typer", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/af/35/cd5b0d1288e65d2c12db4ce84c1ec1074f7ee9bced040de6c9d69e70d620/transformers-5.5.3.tar.gz", hash = "sha256:3f60128e840b40d352655903552e1eed4f94ed49369a4d43e1bc067bd32d3f50", size = 8226047, upload-time = "2026-04-09T15:52:56.231Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a1/0b/f8524551ab2d896dfaca74ddb70a4453d515bbf4ab5451c100c7788ae155/transformers-5.5.3-py3-none-any.whl", hash = "sha256:e48f3ec31dd96505e96e66b63a1e43e1ad7a65749e108d9227caaf51051cdb02", size = 10236257, upload-time = "2026-04-09T15:52:52.866Z" },
+]
+
+[[package]]
+name = "triton"
+version = "3.6.0"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/17/5d/08201db32823bdf77a0e2b9039540080b2e5c23a20706ddba942924ebcd6/triton-3.6.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:374f52c11a711fd062b4bfbb201fd9ac0a5febd28a96fb41b4a0f51dde3157f4", size = 176128243, upload-time = "2026-01-20T16:16:07.857Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/a8/cdf8b3e4c98132f965f88c2313a4b493266832ad47fb52f23d14d4f86bb5/triton-3.6.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:74caf5e34b66d9f3a429af689c1c7128daba1d8208df60e81106b115c00d6fca", size = 188266850, upload-time = "2026-01-20T16:00:43.041Z" },
+]
+
+[[package]]
+name = "typer"
+version = "0.24.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc", marker = "sys_platform == 'linux'" },
+    { name = "click", marker = "sys_platform == 'linux'" },
+    { name = "rich", marker = "sys_platform == 'linux'" },
+    { name = "shellingham", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f5/24/cb09efec5cc954f7f9b930bf8279447d24618bb6758d4f6adf2574c41780/typer-0.24.1.tar.gz", hash = "sha256:e39b4732d65fbdcde189ae76cf7cd48aeae72919dea1fdfc16593be016256b45", size = 118613, upload-time = "2026-02-21T16:54:40.609Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4a/91/48db081e7a63bb37284f9fbcefda7c44c277b18b0e13fbc36ea2335b71e6/typer-0.24.1-py3-none-any.whl", hash = "sha256:112c1f0ce578bfb4cab9ffdabc68f031416ebcc216536611ba21f04e9aa84c9e", size = 56085, upload-time = "2026-02-21T16:54:41.616Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "uc-micro-py"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/78/67/9a363818028526e2d4579334460df777115bdec1bb77c08f9db88f6389f2/uc_micro_py-2.0.0.tar.gz", hash = "sha256:c53691e495c8db60e16ffc4861a35469b0ba0821fe409a8a7a0a71864d33a811", size = 6611, upload-time = "2026-03-01T06:31:27.526Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/61/73/d21edf5b204d1467e06500080a50f79d49ef2b997c79123a536d4a17d97c/uc_micro_py-2.0.0-py3-none-any.whl", hash = "sha256:3603a3859af53e5a39bc7677713c78ea6589ff188d70f4fee165db88e22b242c", size = 6383, upload-time = "2026-03-01T06:31:26.257Z" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.6.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
+]
+
+[[package]]
+name = "uvicorn"
+version = "0.42.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click", marker = "sys_platform == 'linux'" },
+    { name = "h11", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e3/ad/4a96c425be6fb67e0621e62d86c402b4a17ab2be7f7c055d9bd2f638b9e2/uvicorn-0.42.0.tar.gz", hash = "sha256:9b1f190ce15a2dd22e7758651d9b6d12df09a13d51ba5bf4fc33c383a48e1775", size = 85393, upload-time = "2026-03-16T06:19:50.077Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0a/89/f8827ccff89c1586027a105e5630ff6139a64da2515e24dafe860bd9ae4d/uvicorn-0.42.0-py3-none-any.whl", hash = "sha256:96c30f5c7abe6f74ae8900a70e92b85ad6613b745d4879eb9b16ccad15645359", size = 68830, upload-time = "2026-03-16T06:19:48.325Z" },
+]
+
+[package.optional-dependencies]
+standard = [
+    { name = "httptools", marker = "sys_platform == 'linux'" },
+    { name = "python-dotenv", marker = "sys_platform == 'linux'" },
+    { name = "pyyaml", marker = "sys_platform == 'linux'" },
+    { name = "uvloop", marker = "platform_python_implementation != 'PyPy' and sys_platform == 'linux'" },
+    { name = "watchfiles", marker = "sys_platform == 'linux'" },
+    { name = "websockets", marker = "sys_platform == 'linux'" },
+]
+
+[[package]]
+name = "uvloop"
+version = "0.22.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250, upload-time = "2025-10-16T22:17:19.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413, upload-time = "2025-10-16T22:16:31.644Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4", size = 4426307, upload-time = "2025-10-16T22:16:32.917Z" },
+    { url = "https://files.pythonhosted.org/packages/90/60/97362554ac21e20e81bcef1150cb2a7e4ffdaf8ea1e5b2e8bf7a053caa18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e047cc068570bac9866237739607d1313b9253c3051ad84738cbb095be0537b2", size = 4131970, upload-time = "2025-10-16T22:16:34.015Z" },
+    { url = "https://files.pythonhosted.org/packages/99/39/6b3f7d234ba3964c428a6e40006340f53ba37993f46ed6e111c6e9141d18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:512fec6815e2dd45161054592441ef76c830eddaad55c8aa30952e6fe1ed07c0", size = 4296343, upload-time = "2025-10-16T22:16:35.149Z" },
+]
+
+[[package]]
+name = "vllm"
+version = "0.19.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohttp", marker = "sys_platform == 'linux'" },
+    { name = "anthropic", marker = "sys_platform == 'linux'" },
+    { name = "blake3", marker = "sys_platform == 'linux'" },
+    { name = "cachetools", marker = "sys_platform == 'linux'" },
+    { name = "cbor2", marker = "sys_platform == 'linux'" },
+    { name = "cloudpickle", marker = "sys_platform == 'linux'" },
+    { name = "compressed-tensors", marker = "sys_platform == 'linux'" },
+    { name = "depyf", marker = "sys_platform == 'linux'" },
+    { name = "diskcache", marker = "sys_platform == 'linux'" },
+    { name = "einops", marker = "sys_platform == 'linux'" },
+    { name = "fastapi", extra = ["standard"], marker = "sys_platform == 'linux'" },
+    { name = "filelock", marker = "sys_platform == 'linux'" },
+    { name = "flashinfer-cubin", marker = "sys_platform == 'linux'" },
+    { name = "flashinfer-python", marker = "sys_platform == 'linux'" },
+    { name = "gguf", marker = "sys_platform == 'linux'" },
+    { name = "ijson", marker = "sys_platform == 'linux'" },
+    { name = "lark", marker = "sys_platform == 'linux'" },
+    { name = "llguidance", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'arm64' and sys_platform == 'linux') or (platform_machine == 'ppc64le' and sys_platform == 'linux') or (platform_machine == 's390x' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+    { name = "lm-format-enforcer", marker = "sys_platform == 'linux'" },
+    { name = "mcp", marker = "sys_platform == 'linux'" },
+    { name = "mistral-common", extra = ["image"], marker = "sys_platform == 'linux'" },
+    { name = "model-hosting-container-standards", marker = "sys_platform == 'linux'" },
+    { name = "msgspec", marker = "sys_platform == 'linux'" },
+    { name = "ninja", marker = "sys_platform == 'linux'" },
+    { name = "numba", marker = "sys_platform == 'linux'" },
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cudnn-frontend", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cutlass-dsl", marker = "sys_platform == 'linux'" },
+    { name = "openai", marker = "sys_platform == 'linux'" },
+    { name = "openai-harmony", marker = "sys_platform == 'linux'" },
+    { name = "opencv-python-headless", marker = "sys_platform == 'linux'" },
+    { name = "opentelemetry-api", marker = "sys_platform == 'linux'" },
+    { name = "opentelemetry-exporter-otlp", marker = "sys_platform == 'linux'" },
+    { name = "opentelemetry-sdk", marker = "sys_platform == 'linux'" },
+    { name = "opentelemetry-semantic-conventions-ai", marker = "sys_platform == 'linux'" },
+    { name = "outlines-core", marker = "sys_platform == 'linux'" },
+    { name = "partial-json-parser", marker = "sys_platform == 'linux'" },
+    { name = "pillow", marker = "sys_platform == 'linux'" },
+    { name = "prometheus-client", marker = "sys_platform == 'linux'" },
+    { name = "prometheus-fastapi-instrumentator", marker = "sys_platform == 'linux'" },
+    { name = "protobuf", marker = "sys_platform == 'linux'" },
+    { name = "psutil", marker = "sys_platform == 'linux'" },
+    { name = "py-cpuinfo", marker = "sys_platform == 'linux'" },
+    { name = "pybase64", marker = "sys_platform == 'linux'" },
+    { name = "pydantic", marker = "sys_platform == 'linux'" },
+    { name = "python-json-logger", marker = "sys_platform == 'linux'" },
+    { name = "pyyaml", marker = "sys_platform == 'linux'" },
+    { name = "pyzmq", marker = "sys_platform == 'linux'" },
+    { name = "quack-kernels", marker = "sys_platform == 'linux'" },
+    { name = "regex", marker = "sys_platform == 'linux'" },
+    { name = "requests", marker = "sys_platform == 'linux'" },
+    { name = "sentencepiece", marker = "sys_platform == 'linux'" },
+    { name = "setproctitle", marker = "sys_platform == 'linux'" },
+    { name = "setuptools", marker = "sys_platform == 'linux'" },
+    { name = "six", marker = "sys_platform == 'linux'" },
+    { name = "tiktoken", marker = "sys_platform == 'linux'" },
+    { name = "tokenizers", marker = "sys_platform == 'linux'" },
+    { name = "torch", marker = "sys_platform == 'linux'" },
+    { name = "torchaudio", marker = "sys_platform == 'linux'" },
+    { name = "torchvision", marker = "sys_platform == 'linux'" },
+    { name = "tqdm", marker = "sys_platform == 'linux'" },
+    { name = "transformers", marker = "sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+    { name = "watchfiles", marker = "sys_platform == 'linux'" },
+    { name = "xgrammar", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'arm64' and sys_platform == 'linux') or (platform_machine == 'ppc64le' and sys_platform == 'linux') or (platform_machine == 's390x' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/03/14/c330a72309051f762b357a2e41d5015bedbb106ad1e16a231bdfda2e2163/vllm-0.19.0.tar.gz", hash = "sha256:81e59cf87175e7a62eb8d9acf5989484bbd17089d5eface353f89067bda282d9", size = 31071745, upload-time = "2026-04-03T04:04:52.833Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c8/51/467e7a8cb4838022daa731b7f8b34c228691e36f938e1803c3a702c7bd69/vllm-0.19.0-cp38-abi3-manylinux_2_31_aarch64.whl", hash = "sha256:6ab90ccca5d7ca3bd2c8f90133f0fac85e8f4af582a1c67c6cc3f63c615521e3", size = 384650557, upload-time = "2026-04-03T04:05:52.513Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/08/6a431731e4c163bc1fab85b63e269d84104aad0fba98dac1af34fdc5077f/vllm-0.19.0-cp38-abi3-manylinux_2_31_x86_64.whl", hash = "sha256:2d0e5fae45367bdbf111fcad68f4c0f8fdddd2f2fb643e52f0f2daebef7b41cf", size = 432281473, upload-time = "2026-04-03T04:05:22.07Z" },
+]
+
+[[package]]
+name = "watchfiles"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", hash = "sha256:a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2", size = 94440, upload-time = "2025-10-14T15:06:21.08Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4b/5b/d3b460364aeb8da471c1989238ea0e56bec24b6042a68046adf3d9ddb01c/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8526e8f916bb5b9a0a777c8317c23ce65de259422bba5b31325a6fa6029d33af", size = 449374, upload-time = "2025-10-14T15:04:49.179Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/44/5769cb62d4ed055cb17417c0a109a92f007114a4e07f30812a73a4efdb11/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2edc3553362b1c38d9f06242416a5d8e9fe235c204a4072e988ce2e5bb1f69f6", size = 459485, upload-time = "2025-10-14T15:04:50.155Z" },
+    { url = "https://files.pythonhosted.org/packages/19/0c/286b6301ded2eccd4ffd0041a1b726afda999926cf720aab63adb68a1e36/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30f7da3fb3f2844259cba4720c3fc7138eb0f7b659c38f3bfa65084c7fc7abce", size = 488813, upload-time = "2025-10-14T15:04:51.059Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/2b/8530ed41112dd4a22f4dcfdb5ccf6a1baad1ff6eed8dc5a5f09e7e8c41c7/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8979280bdafff686ba5e4d8f97840f929a87ed9cdf133cbbd42f7766774d2aa", size = 594816, upload-time = "2025-10-14T15:04:52.031Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/d2/f5f9fb49489f184f18470d4f99f4e862a4b3e9ac2865688eb2099e3d837a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dcc5c24523771db3a294c77d94771abcfcb82a0e0ee8efd910c37c59ec1b31bb", size = 475186, upload-time = "2025-10-14T15:04:53.064Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/68/5707da262a119fb06fbe214d82dd1fe4a6f4af32d2d14de368d0349eb52a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db5d7ae38ff20153d542460752ff397fcf5c96090c1230803713cf3147a6803", size = 456812, upload-time = "2025-10-14T15:04:55.174Z" },
+    { url = "https://files.pythonhosted.org/packages/66/ab/3cbb8756323e8f9b6f9acb9ef4ec26d42b2109bce830cc1f3468df20511d/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:28475ddbde92df1874b6c5c8aaeb24ad5be47a11f87cde5a28ef3835932e3e94", size = 630196, upload-time = "2025-10-14T15:04:56.22Z" },
+    { url = "https://files.pythonhosted.org/packages/78/46/7152ec29b8335f80167928944a94955015a345440f524d2dfe63fc2f437b/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:36193ed342f5b9842edd3532729a2ad55c4160ffcfa3700e0d54be496b70dd43", size = 622657, upload-time = "2025-10-14T15:04:57.521Z" },
+]
+
+[[package]]
+name = "websockets"
+version = "16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/24/4b2031d72e840ce4c1ccb255f693b15c334757fc50023e4db9537080b8c4/websockets-16.0.tar.gz", hash = "sha256:5f6261a5e56e8d5c42a4497b364ea24d94d9563e8fbd44e78ac40879c60179b5", size = 179346, upload-time = "2026-01-10T09:23:47.181Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/29/71729b4671f21e1eaa5d6573031ab810ad2936c8175f03f97f3ff164c802/websockets-16.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9b5aca38b67492ef518a8ab76851862488a478602229112c4b0d58d63a7a4d5c", size = 184915, upload-time = "2026-01-10T09:22:51.071Z" },
+    { url = "https://files.pythonhosted.org/packages/97/bb/21c36b7dbbafc85d2d480cd65df02a1dc93bf76d97147605a8e27ff9409d/websockets-16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e0334872c0a37b606418ac52f6ab9cfd17317ac26365f7f65e203e2d0d0d359f", size = 186152, upload-time = "2026-01-10T09:22:52.224Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/34/9bf8df0c0cf88fa7bfe36678dc7b02970c9a7d5e065a3099292db87b1be2/websockets-16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a0b31e0b424cc6b5a04b8838bbaec1688834b2383256688cf47eb97412531da1", size = 185583, upload-time = "2026-01-10T09:22:53.443Z" },
+    { url = "https://files.pythonhosted.org/packages/47/88/4dd516068e1a3d6ab3c7c183288404cd424a9a02d585efbac226cb61ff2d/websockets-16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:485c49116d0af10ac698623c513c1cc01c9446c058a4e61e3bf6c19dff7335a2", size = 184880, upload-time = "2026-01-10T09:22:55.033Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/28/258ebab549c2bf3e64d2b0217b973467394a9cea8c42f70418ca2c5d0d2e/websockets-16.0-py3-none-any.whl", hash = "sha256:1637db62fad1dc833276dded54215f2c7fa46912301a24bd94d45d46a011ceec", size = 171598, upload-time = "2026-01-10T09:23:45.395Z" },
+]
+
+[[package]]
+name = "xgrammar"
+version = "0.1.33"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy", marker = "sys_platform == 'linux'" },
+    { name = "pydantic", marker = "sys_platform == 'linux'" },
+    { name = "torch", marker = "sys_platform == 'linux'" },
+    { name = "transformers", marker = "sys_platform == 'linux'" },
+    { name = "triton", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/db/43/e5dfddb1d2a4fccf3e3a88f103e88698cdefc3182f4e169a359ffe1c1794/xgrammar-0.1.33.tar.gz", hash = "sha256:8dbe5fc3d76651ab1fac7a68fc2a118b885fa0ec7189927fb6e0dce0081aea99", size = 2398956, upload-time = "2026-03-27T10:16:36.582Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4e/04/43d4baca876f5ae1b45897ec30a59801a2da37f16da1fcd85f9555e4c125/xgrammar-0.1.33-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c803e60d791854c5d1f271ece7e1f34d73c82dd4a8b2a06b7af5331482a78ac", size = 42133168, upload-time = "2026-03-27T10:15:16.994Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/a8/672833a3cff027253793aa999401d8364896ebf396967e475c7a878b895f/xgrammar-0.1.33-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:52b8eaa533282a0efb0835db6998ae72e7b3c7875d7a52e360ffebff9b78c30a", size = 42205803, upload-time = "2026-03-27T10:15:21.599Z" },
+]
+
+[[package]]
+name = "yarl"
+version = "1.23.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna", marker = "sys_platform == 'linux'" },
+    { name = "multidict", marker = "sys_platform == 'linux'" },
+    { name = "propcache", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/23/6e/beb1beec874a72f23815c1434518bfc4ed2175065173fb138c3705f658d4/yarl-1.23.0.tar.gz", hash = "sha256:53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5", size = 194676, upload-time = "2026-03-01T22:07:53.373Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/99/30/58260ed98e6ff7f90ba84442c1ddd758c9170d70327394a6227b310cd60f/yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8", size = 97587, upload-time = "2026-03-01T22:05:17.384Z" },
+    { url = "https://files.pythonhosted.org/packages/76/0a/8b08aac08b50682e65759f7f8dde98ae8168f72487e7357a5d684c581ef9/yarl-1.23.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53ad387048f6f09a8969631e4de3f1bf70c50e93545d64af4f751b2498755072", size = 92528, upload-time = "2026-03-01T22:05:18.804Z" },
+    { url = "https://files.pythonhosted.org/packages/52/07/0b7179101fe5f8385ec6c6bb5d0cb9f76bd9fb4a769591ab6fb5cdbfc69a/yarl-1.23.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a59ba56f340334766f3a4442e0efd0af895fae9e2b204741ef885c446b3a1a8", size = 105339, upload-time = "2026-03-01T22:05:20.235Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/8a/36d82869ab5ec829ca8574dfcb92b51286fcfb1e9c7a73659616362dc880/yarl-1.23.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:803a3c3ce4acc62eaf01eaca1208dcf0783025ef27572c3336502b9c232005e7", size = 105061, upload-time = "2026-03-01T22:05:22.268Z" },
+    { url = "https://files.pythonhosted.org/packages/66/3e/868e5c3364b6cee19ff3e1a122194fa4ce51def02c61023970442162859e/yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51", size = 100132, upload-time = "2026-03-01T22:05:23.638Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/26/9c89acf82f08a52cb52d6d39454f8d18af15f9d386a23795389d1d423823/yarl-1.23.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c75eb09e8d55bceb4367e83496ff8ef2bc7ea6960efb38e978e8073ea59ecb67", size = 99289, upload-time = "2026-03-01T22:05:25.749Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/54/5b0db00d2cb056922356104468019c0a132e89c8d3ab67d8ede9f4483d2a/yarl-1.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877b0738624280e34c55680d6054a307aa94f7d52fa0e3034a9cc6e790871da7", size = 96950, upload-time = "2026-03-01T22:05:27.318Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/40/10fa93811fd439341fad7e0718a86aca0de9548023bbb403668d6555acab/yarl-1.23.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b5405bb8f0e783a988172993cfc627e4d9d00432d6bbac65a923041edacf997d", size = 93960, upload-time = "2026-03-01T22:05:28.738Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/d2/8ae2e6cd77d0805f4526e30ec43b6f9a3dfc542d401ac4990d178e4bf0cf/yarl-1.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c3a3598a832590c5a3ce56ab5576361b5688c12cb1d39429cf5dba30b510760", size = 104703, upload-time = "2026-03-01T22:05:30.438Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/0c/b3ceacf82c3fe21183ce35fa2acf5320af003d52bc1fcf5915077681142e/yarl-1.23.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8419ebd326430d1cbb7efb5292330a2cf39114e82df5cc3d83c9a0d5ebeaf2f2", size = 98325, upload-time = "2026-03-01T22:05:31.835Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/e0/12900edd28bdab91a69bd2554b85ad7b151f64e8b521fe16f9ad2f56477a/yarl-1.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:be61f6fff406ca40e3b1d84716fde398fc08bc63dd96d15f3a14230a0973ed86", size = 105067, upload-time = "2026-03-01T22:05:33.358Z" },
+    { url = "https://files.pythonhosted.org/packages/15/61/74bb1182cf79c9bbe4eb6b1f14a57a22d7a0be5e9cedf8e2d5c2086474c3/yarl-1.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ceb13c5c858d01321b5d9bb65e4cf37a92169ea470b70fec6f236b2c9dd7e34", size = 100285, upload-time = "2026-03-01T22:05:35.4Z" },
+    { url = "https://files.pythonhosted.org/packages/69/68/c8739671f5699c7dc470580a4f821ef37c32c4cb0b047ce223a7f115757f/yarl-1.23.0-py3-none-any.whl", hash = "sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f", size = 48288, upload-time = "2026-03-01T22:07:51.388Z" },
+]
+
+[[package]]
+name = "zipp"
+version = "3.23.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" },
+]
diff --git a/vllm-down b/vllm-down
new file mode 100755
index 0000000..5683f74
--- /dev/null
+++ b/vllm-down
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec "$ROOT/scripts/backend_ctl.py" "vllm-down" "$@"
diff --git a/vllm-up b/vllm-up
new file mode 100755
index 0000000..4031656
--- /dev/null
+++ b/vllm-up
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec "$ROOT/scripts/backend_ctl.py" "vllm-up" "$@"
diff --git a/vllm-up-bg b/vllm-up-bg
new file mode 100755
index 0000000..38309b1
--- /dev/null
+++ b/vllm-up-bg
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec "$ROOT/scripts/backend_ctl.py" "vllm-up-bg" "$@"