Update standalone Tater bundle to 0.1.12

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tater_reachy_standalone"
-version = "0.1.11"
+version = "0.1.12"
 description = "Full local Tater AI stack and voice satellite for Reachy Mini"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -61,6 +61,9 @@ dependencies = [
   "accelerate",
   "llama-cpp-python>=0.3.23",
   "mlx-lm; platform_system == 'Darwin' and platform_machine == 'arm64'",
+  "mlx-vlm; platform_system == 'Darwin' and platform_machine == 'arm64'",
+  "outlines; platform_system == 'Darwin' and platform_machine == 'arm64'",
+  "outlines-core==0.1.26; platform_system == 'Darwin' and platform_machine == 'arm64'",
   "faster-whisper",
   "vosk",
   "pykokoro",

tater_reachy_standalone/__init__.py

@@ -1,3 +1,3 @@
 """Standalone Tater app for Reachy Mini."""
 
-__version__ = "0.1.11"
+__version__ = "0.1.12"

tater_reachy_standalone/vendor/tater_app/README.md

@@ -320,22 +320,26 @@ After Tater is running, open TaterOS and finish the first-run setup:
    - enable `Beast Mode` and set per-head model settings for Chat/Astraeus/Thanatos/Minos/Hermes
 
 Hydra model settings are saved by TaterOS and used at runtime. Base, Spudex, Beast Mode routing, and Vision can each use the selected built-in local providers or OpenAI-compatible providers.
-Hugging Face Transformers model files are cached under `agent_lab/models/llm/huggingface` by default; override with `TATER_HF_TRANSFORMERS_MODEL_ROOT`.
-llama.cpp GGUF files are cached under `agent_lab/models/llm/llama-cpp` by default; override with `TATER_LLAMA_CPP_MODEL_ROOT`.
-MLX LM files are cached under `agent_lab/models/llm/mlx` by default; override with `TATER_MLX_LM_MODEL_ROOT`.
-For llama.cpp, the model value can be `owner/repo::filename.gguf`, `owner/repo/path/to/file.gguf`, a bare GGUF repo id such as `owner/repo` to auto-pick a preferred quant, or a local `.gguf` path.
-For MLX LM, the model value can be an MLX-compatible Hugging Face repo such as `mlx-community/Llama-3.2-3B-Instruct-4bit`, or a local MLX model folder.
-Download local Hugging Face Transformers, llama.cpp, or MLX LM models from the Hugging Face mini-tab first, then choose the downloaded model from the Settings mini-tab dropdown. The downloaded model registry is stored at `agent_lab/models/llm/downloaded_models.json` by default.
-The Hugging Face mini-tab can switch between text and vision model browsing. For llama.cpp vision GGUF repos, Tater detects `mmproj*.gguf` projector files and downloads the matching projector beside the selected GGUF when one is available.
-The Hugging Face browser and downloader use the token saved in Integration Manager -> Hugging Face for gated/private models and higher Hub rate limits; explicit env overrides like `TATER_HF_MODEL_BROWSER_TOKEN`, `TATER_HF_TRANSFORMERS_TOKEN`, or `TATER_MLX_LM_TOKEN` still take priority.
-llama.cpp tries GPU offload by default with `TATER_LLAMA_CPP_N_GPU_LAYERS=auto`; set it to `0` for CPU-only or to a specific layer count. GPU offload depends on installing llama-cpp-python with CUDA, Metal, or another supported acceleration build. On NVIDIA, rerun `sh setup_tater.sh nvidia` to replace a CPU-only llama.cpp install with the CUDA wheel/build path.
-MLX LM is intended for Apple Silicon Macs; use llama.cpp GGUF on Raspberry Pi, Linux, or non-Apple-Silicon devices.
-Thinking suppression is enabled by default for local providers where possible; set `TATER_HF_TRANSFORMERS_DISABLE_THINKING=false`, `TATER_LLAMA_CPP_DISABLE_THINKING=false`, or `TATER_MLX_LM_DISABLE_THINKING=false` if a model should keep its native reasoning tags.
-Local provider context length can be adjusted with a slider in Settings -> Models -> LLM / Vision. When Tater can read cached model metadata, the slider max follows the model's context limit. Transformers uses the value as the prompt truncation limit, llama.cpp uses it as `n_ctx`, and MLX LM uses it as `max_kv_size`.
-Vision can stay on an OpenAI-compatible API, automatically try the Base model first, use the Base model only, or load a dedicated local vision model. A loaded Base model is reused for local vision when its provider/model cache is already vision-capable; dedicated vision models are loaded and unloaded independently from Base.
-
-Access-log note:
-- `run_ui.sh` starts Uvicorn with `--no-access-log` to suppress per-request lines.
-
-
-https://github.com/user-attachments/assets/9138f485-ccd6-46e0-9295-f5617c079fea
+
+### Local Models
+
+- Download local Hugging Face Transformers, llama.cpp GGUF, or MLX models from the Hugging Face mini-tab first, then select them from Settings.
+- Model caches live under `agent_lab/models/llm/` by default:
+  - `huggingface` for Transformers
+  - `llama-cpp` for GGUF models and matching `mmproj*.gguf` vision projectors
+  - `mlx` for MLX text and vision models
+- The Hugging Face browser uses the token saved in **Integration Manager -> Hugging Face** for private/gated models and better Hub rate limits.
+- llama.cpp uses GPU offload by default when the installed build supports it. Set `TATER_LLAMA_CPP_N_GPU_LAYERS=0` for CPU-only.
+- MLX is intended for Apple Silicon Macs. Use llama.cpp GGUF on Linux, Raspberry Pi, NVIDIA, AMD/ROCm, Jetson, or other non-Apple-Silicon devices.
+
+### Vision
+
+- Vision can use an OpenAI-compatible API, the loaded Base model, or a dedicated local vision model.
+- If Base is already loaded and vision-capable, Tater reuses it instead of loading the same model twice.
+- Dedicated vision models are managed separately from Base.
+
+### Advanced Notes
+
+- Local context length is configured in **Settings -> Models -> LLM / Vision**.
+- Thinking suppression is enabled by default for local providers when supported.
+- `run_ui.sh` starts Uvicorn with `--no-access-log` to suppress per-request log spam.

tater_reachy_standalone/vendor/tater_app/requirements.txt

@@ -50,6 +50,9 @@ transformers
 accelerate
 llama-cpp-python>=0.3.23
 mlx-lm; platform_system == "Darwin" and platform_machine == "arm64"
+mlx-vlm; platform_system == "Darwin" and platform_machine == "arm64"
+outlines; platform_system == "Darwin" and platform_machine == "arm64"
+outlines-core==0.1.26; platform_system == "Darwin" and platform_machine == "arm64"
 faster-whisper
 vosk
 pykokoro

tater_reachy_standalone/vendor/tater_app/setup_tater.sh

@@ -272,6 +272,33 @@ install_llama_cpp_metal() {
   "${venv_python}" -m pip install --upgrade "${LLAMA_CPP_PYTHON_SPEC}" || warn "Default llama-cpp-python fallback failed."
 }
 
+install_mlx_engine_checkout() {
+  if [ "${TATER_SETUP_MLX_ENGINE:-1}" = "0" ]; then
+    warn "Skipping MLX engine checkout because TATER_SETUP_MLX_ENGINE=0."
+    return
+  fi
+  if ! command -v git >/dev/null 2>&1; then
+    warn "git was not found; skipping optional MLX engine checkout."
+    return
+  fi
+  mkdir -p "${RUNTIME_DIR}"
+  engine_dir="${RUNTIME_DIR}/mlx-engine"
+  if [ -d "${engine_dir}/mlx_engine" ]; then
+    ok "Using existing ${engine_dir}"
+    if [ -d "${engine_dir}/.git" ]; then
+      info "Updating optional MLX engine checkout"
+      git -C "${engine_dir}" pull --ff-only || warn "Could not update ${engine_dir}; using the existing checkout."
+    fi
+    return
+  fi
+  if [ -e "${engine_dir}" ]; then
+    warn "${engine_dir} exists but does not look like an mlx-engine checkout. Set TATER_MLX_ENGINE_PATH or remove it and rerun setup."
+    return
+  fi
+  info "Cloning optional MLX engine runtime"
+  git clone --depth 1 https://github.com/lmstudio-ai/mlx-engine.git "${engine_dir}" || warn "Could not clone mlx-engine; Tater will use mlx-lm/mlx-vlm directly."
+}
+
 install_macos() {
   venv_python="$1"
   tmp_req="$(mktemp "${TMPDIR:-/tmp}/tater-requirements-macos.XXXXXX")"
@@ -305,6 +332,9 @@ install_macos() {
   if ! "${venv_python}" -m pip install mlx-whisper kokoro; then
     warn "Apple-native speech extras failed to install. Tater will still run with Faster Whisper/Kokoro CPU fallbacks."
   fi
+  if [ "${is_apple_silicon}" = "1" ]; then
+    install_mlx_engine_checkout
+  fi
   rm -f "${tmp_req}"
   trap - EXIT
 }

tater_reachy_standalone/vendor/tater_app/tateros_app.py

@@ -6,6 +6,7 @@ import hmac
 import importlib
 import json
 import logging
+import mimetypes
 import os
 import queue
 import re
@@ -63,12 +64,28 @@ from hydra import (
 from emoji_responder import get_emoji_settings as get_core_emoji_settings, save_emoji_settings as save_core_emoji_settings
 from notify import notifier_destination_catalog
 from helpers import (
+    DEFAULT_HF_TRANSFORMERS_ATTN_IMPLEMENTATION,
     DEFAULT_HF_TRANSFORMERS_CONTEXT_TOKENS,
+    DEFAULT_HF_TRANSFORMERS_DEVICE,
+    DEFAULT_HF_TRANSFORMERS_DEVICE_MAP,
+    DEFAULT_HF_TRANSFORMERS_DTYPE,
+    DEFAULT_HF_TRANSFORMERS_TRUST_REMOTE_CODE,
+    DEFAULT_LLAMA_CPP_FLASH_ATTN,
     DEFAULT_LLAMA_CPP_CONTEXT_TOKENS,
     DEFAULT_LLAMA_CPP_MTP_DRAFT_TOKENS,
     DEFAULT_LLAMA_CPP_MTP_ENABLED,
+    DEFAULT_LLAMA_CPP_N_BATCH,
+    DEFAULT_LLAMA_CPP_N_UBATCH,
+    DEFAULT_LLAMA_CPP_OFFLOAD_KQV,
     DEFAULT_LLAMA_CPP_VISION_CONTEXT_TOKENS,
+    DEFAULT_MLX_LM_LAZY_LOAD,
+    DEFAULT_MLX_LM_TRUST_REMOTE_CODE,
+    HYDRA_HF_TRANSFORMERS_ATTN_IMPLEMENTATION_KEY,
     HYDRA_HF_TRANSFORMERS_CONTEXT_TOKENS_KEY,
+    HYDRA_HF_TRANSFORMERS_DEVICE_KEY,
+    HYDRA_HF_TRANSFORMERS_DEVICE_MAP_KEY,
+    HYDRA_HF_TRANSFORMERS_DTYPE_KEY,
+    HYDRA_HF_TRANSFORMERS_TRUST_REMOTE_CODE_KEY,
     HYDRA_LLM_BASE_SERVERS_KEY,
     HYDRA_LLM_PROVIDER_HF_TRANSFORMERS,
     HYDRA_LLM_PROVIDER_KEY,
@@ -76,10 +93,20 @@ from helpers import (
     HYDRA_LLM_PROVIDER_MLX_LM,
     HYDRA_LLM_PROVIDER_OPENAI_COMPATIBLE,
     HYDRA_LLAMA_CPP_CONTEXT_TOKENS_KEY,
+    HYDRA_LLAMA_CPP_FLASH_ATTN_KEY,
     HYDRA_LLAMA_CPP_MTP_DRAFT_TOKENS_KEY,
     HYDRA_LLAMA_CPP_MTP_ENABLED_KEY,
+    HYDRA_LLAMA_CPP_N_BATCH_KEY,
+    HYDRA_LLAMA_CPP_N_UBATCH_KEY,
+    HYDRA_LLAMA_CPP_OFFLOAD_KQV_KEY,
     HYDRA_LLAMA_CPP_VISION_CONTEXT_TOKENS_KEY,
+    HYDRA_MLX_ENGINE_KV_BITS_KEY,
+    HYDRA_MLX_ENGINE_KV_GROUP_SIZE_KEY,
+    HYDRA_MLX_ENGINE_PREFILL_STEP_SIZE_KEY,
+    HYDRA_MLX_ENGINE_QUANTIZED_KV_START_KEY,
     HYDRA_MLX_LM_CONTEXT_TOKENS_KEY,
+    HYDRA_MLX_LM_LAZY_LOAD_KEY,
+    HYDRA_MLX_LM_TRUST_REMOTE_CODE_KEY,
     HfLlmDownloadCancelled,
     decrypt_current_redis_snapshot,
     download_hf_transformers_llm_model,
@@ -88,11 +115,14 @@ from helpers import (
     encrypt_current_redis_snapshot,
     ensure_redis_encryption_key,
     get_llama_cpp_runtime_diagnostics,
+    get_llama_cpp_chat_template_info,
+    get_local_llm_chat_template_info,
     get_local_llm_loaded_models_snapshot,
     get_redis_connection_config,
     get_redis_encryption_status,
     get_redis_connection_status,
     get_llm_call_runtime_summary,
+    get_llm_debug_runtime_snapshot,
     get_vision_call_runtime_summary,
     get_llm_client_from_env,
     preload_hf_transformers_llm_model,
@@ -108,6 +138,10 @@ from helpers import (
     set_main_loop,
     shutdown_internal_redis,
     test_redis_connection_settings,
+    set_llama_cpp_chat_template_override,
+    clear_llama_cpp_chat_template_override,
+    set_local_llm_chat_template_override,
+    clear_local_llm_chat_template_override,
     unload_local_llm_models,
 )
 from runtime_executors import configure_runtime_executors, run_dashboard, run_wake, shutdown_runtime_executors
@@ -533,6 +567,63 @@ def _read_bool_setting(redis_key: str, env_keys: Tuple[str, ...], default: bool)
     return _as_bool_flag(raw, default=default)
 
 
+def _read_text_choice_setting(
+    redis_key: str,
+    env_keys: Tuple[str, ...],
+    default: str,
+    *,
+    allowed: Tuple[str, ...],
+) -> str:
+    raw = str(redis_client.get(redis_key) or "").strip()
+    if not raw:
+        for env_key in env_keys:
+            raw = str(os.getenv(env_key) or "").strip()
+            if raw:
+                break
+    token = str(raw or default or "").strip().lower()
+    aliases = {
+        "fp16": "float16",
+        "half": "float16",
+        "bf16": "bfloat16",
+        "fp32": "float32",
+        "none": "disabled",
+        "off": "disabled",
+        "false": "disabled",
+        "0": "disabled",
+        "default": "default",
+        "auto": "auto",
+    }
+    token = aliases.get(token, token)
+    allowed_set = {str(item).strip().lower() for item in allowed}
+    default_token = str(default or "").strip().lower()
+    return token if token in allowed_set else default_token
+
+
+def _read_optional_int_setting(
+    redis_key: str,
+    env_keys: Tuple[str, ...],
+    *,
+    minimum: int = 0,
+    maximum: int = 1_048_576,
+    allow_zero: bool = False,
+) -> str:
+    raw = str(redis_client.get(redis_key) or "").strip()
+    if not raw:
+        for env_key in env_keys:
+            raw = str(os.getenv(env_key) or "").strip()
+            if raw:
+                break
+    if not raw:
+        return ""
+    try:
+        value = int(float(raw))
+    except Exception:
+        return ""
+    if value < 0 or (value == 0 and not allow_zero):
+        return ""
+    return str(max(int(minimum), min(int(maximum), int(value))))
+
+
 def _read_bounded_int_setting(
     redis_key: str,
     env_keys: Tuple[str, ...],
@@ -1604,15 +1695,17 @@ def _hf_browser_models_api_url(
     task: str = "text-generation",
 ) -> str:
     library = _hf_browser_provider_library(provider)
-    app_filter = _hf_browser_provider_app_filter(provider)
+    app_filter = _hf_browser_provider_app_filter(provider, task)
+    pipeline_tag = _hf_browser_provider_pipeline_filter(provider, task)
     params: Dict[str, Any] = {
         "sort": sort,
         "direction": "-1",
         "limit": str(max(1, min(100, int(limit or 24)))),
         "full": "true",
         "cardData": "true",
-        "pipeline_tag": _normalize_hf_browser_task(task),
     }
+    if pipeline_tag:
+        params["pipeline_tag"] = pipeline_tag
     if library:
         params["library"] = library
     if app_filter:
@@ -1802,11 +1895,299 @@ def _hf_browser_provider_search(provider: str, query: str, task: str = "text-gen
     return q
 
 
-def _hf_browser_provider_app_filter(provider: str) -> str:
+HF_BROWSER_TATER_PICKS: Tuple[Dict[str, Any], ...] = (
+    {
+        "id": "TaterTotterson/gemma-4-26B-A4B-it-GGUF-Tater-NoThink",
+        "provider": HYDRA_LLM_PROVIDER_LLAMA_CPP,
+        "author": "TaterTotterson",
+        "model_size": "26B",
+        "library_name": "llama.cpp",
+        "pipeline_tag": "image-text-to-text",
+        "license": "apache-2.0",
+        "supports_vision": True,
+        "tasks": ("text-generation", "image-text-to-text"),
+        "tags": (
+            "tater",
+            "nothink",
+            "gguf",
+            "llama.cpp",
+            "gemma4",
+            "vision",
+            "UD-Q4_K_M",
+        ),
+        "tater_pick_label": "Tater Pick",
+        "tater_pick_note": "NoThink UD-Q4_K_M with matching mmproj-F16.",
+        "preferred_gguf": "gemma-4-26B-A4B-it-UD-Q4_K_M.gguf",
+        "preferred_mmproj": "mmproj-F16.gguf",
+    },
+)
+
+
+def _hf_browser_tater_pick_owner() -> str:
+    return str(os.getenv("TATER_HF_TATER_PICK_OWNER") or "TaterTotterson").strip()
+
+
+def _hf_browser_tater_pick_tag_tokens() -> Tuple[str, ...]:
+    raw = str(os.getenv("TATER_HF_TATER_PICK_TAGS") or "").strip()
+    if raw:
+        tags = [item.strip().lower() for item in re.split(r"[,;\s]+", raw) if item.strip()]
+    else:
+        tags = ["tater-pick", "tater-recommended", "tater-nothink"]
+    return tuple(dict.fromkeys(tags))
+
+
+def _hf_browser_card_tags(card_data: Any) -> List[str]:
+    if not card_data:
+        return []
+    if isinstance(card_data, dict):
+        raw = card_data.get("tags") or []
+    else:
+        raw = getattr(card_data, "tags", []) or []
+    if isinstance(raw, str):
+        return [raw]
+    if isinstance(raw, list):
+        return [str(item or "").strip() for item in raw if str(item or "").strip()]
+    return []
+
+
+def _hf_browser_paths_to_file_rows(paths: List[str]) -> List[Dict[str, Any]]:
+    rows: List[Dict[str, Any]] = []
+    seen: set[str] = set()
+    for raw_path in paths:
+        path = str(raw_path or "").strip()
+        if not path or path in seen:
+            continue
+        seen.add(path)
+        lower = path.lower()
+        rows.append(
+            {
+                "path": path,
+                "size": 0,
+                "is_gguf": lower.endswith(".gguf"),
+                "is_mmproj": lower.endswith(".gguf") and "mmproj" in lower,
+                "is_safetensors": lower.endswith(".safetensors"),
+                "is_config": os.path.basename(lower) in {"config.json", "tokenizer.json", "tokenizer.model"},
+                "quant": _hf_browser_file_quant(path),
+            }
+        )
+    return rows
+
+
+def _hf_browser_tater_pick_metadata(
+    model_id: Any,
+    *,
+    tags: Optional[List[str]] = None,
+    card_data: Any = None,
+    files: Optional[List[str]] = None,
+) -> Dict[str, Any]:
+    repo = str(model_id or "").strip()
+    if not repo:
+        return {}
+
+    static_row = _hf_browser_tater_pick_by_id(repo)
+    if static_row:
+        return static_row
+
+    owner = _hf_browser_tater_pick_owner().lower()
+    if not owner or "/" not in repo or repo.split("/", 1)[0].lower() != owner:
+        return {}
+
+    tag_set = {
+        str(item or "").strip().lower()
+        for item in [*(tags or []), *_hf_browser_card_tags(card_data)]
+        if str(item or "").strip()
+    }
+    pick_tags = set(_hf_browser_tater_pick_tag_tokens())
+    has_pick_tag = bool(tag_set.intersection(pick_tags))
+    has_nothink_marker = any(
+        token in tag_set
+        for token in (
+            "nothink",
+            "no-think",
+            "no_think",
+            "thinking-disabled",
+            "disable-thinking",
+            "non-thinking",
+        )
+    )
+    if not has_pick_tag:
+        return {}
+
+    file_rows = _hf_browser_paths_to_file_rows(files or [])
+    preferred_gguf = _hf_browser_preferred_gguf(file_rows) if file_rows else ""
+    preferred_mmproj = _hf_browser_preferred_mmproj(file_rows, preferred_gguf) if file_rows else ""
+    quant = _hf_browser_file_quant(preferred_gguf)
+    note_bits: List[str] = []
+    if has_nothink_marker:
+        note_bits.append("NoThink")
+    if quant:
+        note_bits.append(quant)
+    if preferred_mmproj:
+        note_bits.append("with matching projector")
+    note = " ".join(note_bits).strip()
+    return {
+        "id": repo,
+        "tater_pick_label": "Tater Pick",
+        "tater_pick_note": note or "Curated Tater model.",
+        "preferred_gguf": preferred_gguf,
+        "preferred_mmproj": preferred_mmproj,
+    }
+
+
+def _hf_browser_tater_pick_by_id(model_id: Any) -> Dict[str, Any]:
+    needle = str(model_id or "").strip().lower()
+    if not needle:
+        return {}
+    for row in HF_BROWSER_TATER_PICKS:
+        if str(row.get("id") or "").strip().lower() == needle:
+            return dict(row)
+    return {}
+
+
+def _hf_browser_tater_pick_matches_query(row: Dict[str, Any], query: str) -> bool:
+    q = str(query or "").strip().lower()
+    if not q:
+        return True
+    haystack = " ".join(
+        [
+            str(row.get("id") or ""),
+            str(row.get("provider") or ""),
+            str(row.get("library_name") or ""),
+            str(row.get("model_size") or ""),
+            str(row.get("tater_pick_note") or ""),
+            " ".join(str(item or "") for item in (row.get("tags") or [])),
+        ]
+    ).lower()
+    return all(token in haystack for token in q.split())
+
+
+def _hf_browser_tater_pick_summary(row: Dict[str, Any]) -> Dict[str, Any]:
+    provider_token = _normalize_hydra_llm_provider(row.get("provider"))
+    tags = [str(item or "").strip() for item in (row.get("tags") or []) if str(item or "").strip()]
+    return {
+        "id": str(row.get("id") or "").strip(),
+        "author": str(row.get("author") or "").strip(),
+        "model_size": str(row.get("model_size") or "").strip(),
+        "downloads": 0,
+        "likes": 0,
+        "last_modified": "",
+        "pipeline_tag": str(row.get("pipeline_tag") or "").strip(),
+        "library_name": str(row.get("library_name") or "").strip(),
+        "tags": tags[:30],
+        "license": str(row.get("license") or "").strip(),
+        "private": False,
+        "gated": "",
+        "compatible": True,
+        "supports_vision": bool(row.get("supports_vision")),
+        "provider": provider_token,
+        "provider_label": _hydra_llm_provider_label(provider_token),
+        "tater_pick": True,
+        "tater_pick_label": str(row.get("tater_pick_label") or "Tater Pick").strip(),
+        "tater_pick_note": str(row.get("tater_pick_note") or "").strip(),
+        "preferred_gguf": str(row.get("preferred_gguf") or "").strip(),
+        "preferred_mmproj": str(row.get("preferred_mmproj") or "").strip(),
+    }
+
+
+def _hf_browser_provider_for_model(model: Any, fallback: str = HYDRA_LLM_PROVIDER_HF_TRANSFORMERS) -> str:
+    for provider_token in (HYDRA_LLM_PROVIDER_LLAMA_CPP, HYDRA_LLM_PROVIDER_MLX_LM, HYDRA_LLM_PROVIDER_HF_TRANSFORMERS):
+        try:
+            if _hf_browser_provider_matches(model, provider_token):
+                return provider_token
+        except Exception:
+            continue
+    return _normalize_hydra_llm_provider(fallback)
+
+
+def _hf_browser_tater_pick_models_from_hub(*, query: str, task: str, limit: int, provider: str) -> List[Dict[str, Any]]:
+    owner = _hf_browser_tater_pick_owner()
+    if not owner:
+        return []
+    try:
+        from huggingface_hub import HfApi  # type: ignore
+    except Exception:
+        return []
+
+    api = HfApi(token=_hf_browser_token())
+    try:
+        iterator = _hf_hub_call_compat(
+            api.list_models,
+            author=owner,
+            sort="lastModified",
+            direction=-1,
+            limit=max(50, min(200, int(limit or 24) * 4)),
+            full=True,
+            cardData=True,
+            fetch_config=True,
+        )
+        raw_models = list(iterator or [])
+    except Exception as exc:
+        logger.warning("[huggingface-browser] Tater Picks live lookup failed: %s", exc)
+        return []
+
+    task_token = _normalize_hf_browser_task(task)
+    provider_filter = _normalize_hydra_llm_provider(provider)
+    rows: List[Dict[str, Any]] = []
+    seen: set[str] = set()
+    for model in raw_models:
+        model_id = str(_hf_browser_object_value(model, "modelId") or _hf_browser_object_value(model, "id") or "").strip()
+        if not model_id or model_id.lower() in seen:
+            continue
+        seen.add(model_id.lower())
+        tags = [
+            str(item or "").strip()
+            for item in (_hf_browser_object_value(model, "tags", []) or [])
+            if str(item or "").strip()
+        ]
+        siblings = _hf_browser_object_value(model, "siblings", []) or []
+        files = [
+            str(_hf_browser_object_value(item, "rfilename") or _hf_browser_object_value(item, "path") or "").strip()
+            for item in siblings
+            if str(_hf_browser_object_value(item, "rfilename") or _hf_browser_object_value(item, "path") or "").strip()
+        ]
+        card_data = _hf_browser_object_value(model, "cardData", None) or _hf_browser_object_value(model, "card_data", None)
+        if not _hf_browser_tater_pick_metadata(model_id, tags=tags, card_data=card_data, files=files):
+            continue
+        provider_token = _hf_browser_provider_for_model(model, fallback=HYDRA_LLM_PROVIDER_LLAMA_CPP)
+        if provider_token != provider_filter:
+            continue
+        summary = _hf_browser_model_summary(model, provider=provider_token)
+        if task_token == "image-text-to-text" and not bool(summary.get("supports_vision")):
+            continue
+        if not _hf_browser_tater_pick_matches_query(summary, query):
+            continue
+        rows.append(summary)
+    return rows[: max(1, min(100, int(limit or 24)))]
+
+
+def _hf_browser_tater_pick_models(*, query: str, task: str, limit: int, provider: str) -> List[Dict[str, Any]]:
+    task_token = _normalize_hf_browser_task(task)
+    provider_filter = _normalize_hydra_llm_provider(provider)
+    live_rows = _hf_browser_tater_pick_models_from_hub(query=query, task=task_token, limit=limit, provider=provider_filter)
+    rows: List[Dict[str, Any]] = list(live_rows)
+    seen = {str(row.get("id") or "").strip().lower() for row in rows if str(row.get("id") or "").strip()}
+    for row in HF_BROWSER_TATER_PICKS:
+        if str(row.get("id") or "").strip().lower() in seen:
+            continue
+        if _normalize_hydra_llm_provider(row.get("provider")) != provider_filter:
+            continue
+        tasks = {str(item or "").strip() for item in (row.get("tasks") or []) if str(item or "").strip()}
+        if tasks and task_token not in tasks:
+            continue
+        if not _hf_browser_tater_pick_matches_query(row, query):
+            continue
+        rows.append(_hf_browser_tater_pick_summary(row))
+    return rows[: max(1, min(100, int(limit or 24)))]
+
+
+def _hf_browser_provider_app_filter(provider: str, task: str = "text-generation") -> str:
     provider_token = _normalize_hydra_llm_provider(provider)
+    task_token = _normalize_hf_browser_task(task)
     if provider_token == HYDRA_LLM_PROVIDER_LLAMA_CPP:
         return "llama.cpp"
     if provider_token == HYDRA_LLM_PROVIDER_MLX_LM:
+        if task_token == "image-text-to-text":
+            return ""
         return "mlx-lm"
     return ""
 
@@ -1818,8 +2199,16 @@ def _hf_browser_provider_library(provider: str) -> str:
     return "transformers"
 
 
+def _hf_browser_provider_pipeline_filter(provider: str, task: str = "text-generation") -> str:
+    provider_token = _normalize_hydra_llm_provider(provider)
+    task_token = _normalize_hf_browser_task(task)
+    if task_token == "text-generation" and provider_token in {HYDRA_LLM_PROVIDER_LLAMA_CPP, HYDRA_LLM_PROVIDER_MLX_LM}:
+        return ""
+    return task_token
+
+
 def _hf_browser_text_generation_tokens() -> Tuple[str, ...]:
-    return ("text-generation",)
+    return ("text-generation", "text2text-generation", "conversational", "image-text-to-text")
 
 
 def _hf_browser_vision_tokens() -> Tuple[str, ...]:
@@ -1912,6 +2301,8 @@ def _hf_browser_provider_matches(model: Any, provider: str) -> bool:
         return (
             "mlx-lm" in provider_haystack
             or "mlx_lm" in provider_haystack
+            or "mlx-vlm" in provider_haystack
+            or "mlx_vlm" in provider_haystack
             or library == "mlx"
             or "mlx" in tags
             or "mlx" in files
@@ -1922,9 +2313,26 @@ def _hf_browser_provider_matches(model: Any, provider: str) -> bool:
 
 def _hf_browser_file_quant(path: str) -> str:
     name = os.path.basename(str(path or "")).upper()
-    for quant in ("Q2_K", "Q3_K_M", "Q4_K_M", "Q4_K_S", "Q5_K_M", "Q5_K_S", "Q6_K", "Q8_0", "F16", "BF16"):
+    for quant in (
+        "UD-Q4_K_M",
+        "UD_Q4_K_M",
+        "UD-Q4_K_S",
+        "UD_Q4_K_S",
+        "UD-Q5_K_M",
+        "UD_Q5_K_M",
+        "Q2_K",
+        "Q3_K_M",
+        "Q4_K_M",
+        "Q4_K_S",
+        "Q5_K_M",
+        "Q5_K_S",
+        "Q6_K",
+        "Q8_0",
+        "F16",
+        "BF16",
+    ):
         if quant in name:
-            return quant
+            return quant.replace("_Q", "-Q", 1) if quant.startswith("UD_") else quant
     return ""
 
 
@@ -1932,7 +2340,7 @@ def _hf_browser_preferred_gguf(files: List[Dict[str, Any]]) -> str:
     ggufs = [row for row in files if bool(row.get("is_gguf")) and "mmproj" not in str(row.get("path") or "").lower()]
     if not ggufs:
         return ""
-    preferred = ("Q4_K_M", "Q5_K_M", "Q4_K_S", "Q5_0", "Q4_0", "Q8_0")
+    preferred = ("UD-Q4_K_M", "Q4_K_M", "UD-Q5_K_M", "Q5_K_M", "UD-Q4_K_S", "Q4_K_S", "Q5_0", "Q4_0", "Q8_0")
 
     def _score(row: Dict[str, Any]) -> Tuple[int, int, str]:
         path = str(row.get("path") or "")
@@ -1985,6 +2393,8 @@ def _hf_browser_model_summary(model: Any, *, provider: str) -> Dict[str, Any]:
     lower_files = " ".join(files).lower()
     lower_library = str(_hf_browser_object_value(model, "library_name") or "").strip().lower()
     provider_haystack = f"{lower_id} {lower_library} {lower_tags} {lower_files}"
+    card_data = _hf_browser_object_value(model, "cardData", None) or _hf_browser_object_value(model, "card_data", None)
+    tater_pick = _hf_browser_tater_pick_metadata(model_id, tags=tags, card_data=card_data, files=files)
     supports_vision = _hf_browser_is_vision_model(model) or "mmproj" in lower_files
     if provider_token == HYDRA_LLM_PROVIDER_LLAMA_CPP:
         compatible = (
@@ -1996,12 +2406,17 @@ def _hf_browser_model_summary(model: Any, *, provider: str) -> Dict[str, Any]:
             or ".gguf" in lower_files
         )
     elif provider_token == HYDRA_LLM_PROVIDER_MLX_LM:
-        compatible = "mlx-lm" in provider_haystack or "mlx_lm" in provider_haystack or "mlx" in provider_haystack
+        compatible = (
+            "mlx-lm" in provider_haystack
+            or "mlx_lm" in provider_haystack
+            or "mlx-vlm" in provider_haystack
+            or "mlx_vlm" in provider_haystack
+            or "mlx" in provider_haystack
+        )
     else:
         compatible = ".gguf" not in lower_files
-    card_data = _hf_browser_object_value(model, "cardData", None) or _hf_browser_object_value(model, "card_data", None)
     model_size_label = _hf_browser_model_size_label(model_id, tags, files, model, card_data)
-    return {
+    summary = {
         "id": model_id,
         "author": str(_hf_browser_object_value(model, "author") or "").strip(),
         "model_size": model_size_label,
@@ -2022,6 +2437,17 @@ def _hf_browser_model_summary(model: Any, *, provider: str) -> Dict[str, Any]:
         "provider": provider_token,
         "provider_label": _hydra_llm_provider_label(provider_token),
     }
+    if tater_pick:
+        summary.update(
+            {
+                "tater_pick": True,
+                "tater_pick_label": str(tater_pick.get("tater_pick_label") or "Tater Pick").strip(),
+                "tater_pick_note": str(tater_pick.get("tater_pick_note") or "").strip(),
+                "preferred_gguf": str(tater_pick.get("preferred_gguf") or "").strip(),
+                "preferred_mmproj": str(tater_pick.get("preferred_mmproj") or "").strip(),
+            }
+        )
+    return summary
 
 
 def _hf_browser_file_rows(info: Any, fallback_files: List[str]) -> List[Dict[str, Any]]:
@@ -2393,7 +2819,10 @@ def _local_llm_provider_cache_rows(provider: str) -> List[Dict[str, Any]]:
                     "downloaded_ts": float(latest_snapshot.stat().st_mtime if latest_snapshot.exists() else time.time()),
                     "max_context_tokens": max_context,
                     "context_source": context_source,
-                    "supports_vision": bool(_local_llm_json_files_support_vision(latest_snapshot)),
+                    "supports_vision": bool(
+                        provider_token != HYDRA_LLM_PROVIDER_MLX_LM
+                        and _local_llm_json_files_support_vision(latest_snapshot)
+                    ),
                 }
             )
     return rows
@@ -2435,7 +2864,9 @@ def _normalize_local_llm_model_row(row: Dict[str, Any]) -> Dict[str, Any]:
     supports_vision = bool(row.get("supports_vision"))
     mmproj_filename = str(row.get("mmproj_filename") or "").strip()
     mmproj_path = str(row.get("mmproj_path") or "").strip()
-    if provider == HYDRA_LLM_PROVIDER_LLAMA_CPP:
+    if provider == HYDRA_LLM_PROVIDER_MLX_LM:
+        supports_vision = False
+    elif provider == HYDRA_LLM_PROVIDER_LLAMA_CPP:
         path_obj = Path(str(row.get("model_path") or "")).expanduser()
         if path_obj.exists():
             detected_mmproj = _local_llm_mmproj_for_gguf(path_obj)
@@ -2500,6 +2931,36 @@ def _local_llm_models_payload(provider: str = "") -> Dict[str, Any]:
     return {"models": models, "by_provider": by_provider, "updated_ts": time.time()}
 
 
+def _local_llm_chat_template_model_info(provider: str, model: str) -> Dict[str, Any]:
+    provider_token = _normalize_hydra_llm_provider(provider)
+    if not _is_local_hydra_llm_provider(provider_token):
+        raise HTTPException(status_code=400, detail="Local LLM provider is required.")
+    model_token = str(model or "").strip()
+    if not model_token:
+        raise HTTPException(status_code=400, detail="Local model is required.")
+    payload = _local_llm_models_payload(provider=provider_token)
+    row = next(
+        (
+            dict(item)
+            for item in payload.get("models", [])
+            if _normalize_hydra_llm_provider(item.get("provider")) == provider_token
+            and str(item.get("model") or "").strip() == model_token
+        ),
+        {},
+    )
+    model_path = str(row.get("model_path") or "").strip()
+    info = get_local_llm_chat_template_info(provider_token, model_token, model_path=model_path)
+    info["installed"] = bool(row)
+    info["provider"] = provider_token
+    info["provider_label"] = _hydra_llm_provider_label(provider_token)
+    info["model_path"] = model_path or str(info.get("model_path") or "")
+    return info
+
+
+def _llama_cpp_chat_template_model_info(model: str) -> Dict[str, Any]:
+    return _local_llm_chat_template_model_info(HYDRA_LLM_PROVIDER_LLAMA_CPP, model)
+
+
 def _record_downloaded_local_llm_model(
     *,
     provider: str,
@@ -3455,16 +3916,52 @@ def _enforce_user_assistant_alternation(loop_messages: List[Dict[str, Any]]) ->
     return merged
 
 
+def _compact_chat_history_row(row: Dict[str, Any]) -> Tuple[Dict[str, Any], bool]:
+    if not isinstance(row, dict):
+        return row, False
+    content = row.get("content")
+    if not isinstance(content, dict):
+        return row, False
+    content_type = str(content.get("type") or "").strip().lower()
+    mimetype_value = str(content.get("mimetype") or content.get("mime_type") or "").strip().lower()
+    if content_type not in {"image", "audio", "video", "file"} and not mimetype_value.startswith(("image/", "audio/", "video/")):
+        return row, False
+    has_inline_payload = any(
+        isinstance(content.get(key), (bytes, bytearray)) or (isinstance(content.get(key), str) and content.get(key).strip())
+        for key in ("data", "bytes", "data_b64")
+    )
+    has_materializable_ref = any(str(content.get(key) or "").strip() for key in ("blob_key", "path", "file_path", "artifact_path"))
+    if not has_inline_payload and not has_materializable_ref:
+        return row, False
+    normalized = _normalize_plugin_response_item(content)
+    if not isinstance(normalized, dict) or normalized == content:
+        return row, False
+    compacted = dict(row)
+    compacted["content"] = normalized
+    return compacted, True
+
+
 def _load_chat_history_tail(count: int) -> List[Dict[str, Any]]:
     if count <= 0:
         return []
+    try:
+        list_len = int(redis_client.llen(CHAT_HISTORY_KEY) or 0)
+    except Exception:
+        list_len = 0
+    start_index = max(0, list_len - int(count))
     raw = redis_client.lrange(CHAT_HISTORY_KEY, -count, -1)
     out: List[Dict[str, Any]] = []
-    for line in raw:
+    for offset, line in enumerate(raw):
         try:
             parsed = json.loads(line)
             if isinstance(parsed, dict):
-                out.append(parsed)
+                compacted, changed = _compact_chat_history_row(parsed)
+                out.append(compacted)
+                if changed and list_len > 0:
+                    try:
+                        redis_client.lset(CHAT_HISTORY_KEY, start_index + offset, json.dumps(compacted))
+                    except Exception:
+                        pass
         except Exception:
             continue
     return out
@@ -3473,11 +3970,17 @@ def _load_chat_history_tail(count: int) -> List[Dict[str, Any]]:
 def _load_chat_history() -> List[Dict[str, Any]]:
     raw = redis_client.lrange(CHAT_HISTORY_KEY, 0, -1)
     out: List[Dict[str, Any]] = []
-    for line in raw:
+    for idx, line in enumerate(raw):
         try:
             parsed = json.loads(line)
             if isinstance(parsed, dict):
-                out.append(parsed)
+                compacted, changed = _compact_chat_history_row(parsed)
+                out.append(compacted)
+                if changed:
+                    try:
+                        redis_client.lset(CHAT_HISTORY_KEY, idx, json.dumps(compacted))
+                    except Exception:
+                        pass
         except Exception:
             continue
     return out
@@ -4287,8 +4790,20 @@ def _normalize_plugin_response_item(item: Any) -> Any:
     if not isinstance(item, dict):
         return item
 
-    media_type = str(item.get("type") or "").strip().lower()
-    if media_type not in {"image", "audio", "video", "file"}:
+    raw_type = str(item.get("type") or "").strip().lower()
+    name = str(item.get("name") or item.get("filename") or "attachment").strip() or "attachment"
+    mimetype_value = str(item.get("mimetype") or item.get("mime_type") or "").strip().lower()
+    if not mimetype_value:
+        mimetype_value = str(mimetypes.guess_type(name)[0] or "").strip().lower() or "application/octet-stream"
+
+    inferred_type = _media_type_from_mimetype(mimetype_value)
+    if raw_type in {"image", "audio", "video"}:
+        media_type = raw_type
+    elif raw_type == "file":
+        media_type = inferred_type if inferred_type != "file" else "file"
+    elif inferred_type in {"image", "audio", "video"}:
+        media_type = inferred_type
+    else:
         return item
 
     raw = None
@@ -4296,15 +4811,62 @@ def _normalize_plugin_response_item(item: Any) -> Any:
         raw = bytes(item.get("data"))
     elif isinstance(item.get("bytes"), (bytes, bytearray)):
         raw = bytes(item.get("bytes"))
+    elif isinstance(item.get("data_b64"), str):
+        try:
+            raw = _decode_attachment_data(item.get("data_b64"))
+        except Exception:
+            raw = None
+    elif isinstance(item.get("data"), str):
+        try:
+            raw = _decode_attachment_data(item.get("data"))
+        except Exception:
+            raw = None
 
     if raw is None:
-        return item
+        blob_key = str(item.get("blob_key") or "").strip()
+        if blob_key:
+            try:
+                blob = redis_blob_client.get(blob_key)
+                if isinstance(blob, (bytes, bytearray)):
+                    raw = bytes(blob)
+            except Exception:
+                raw = None
+
+    if raw is None:
+        path_value = str(item.get("path") or item.get("file_path") or item.get("artifact_path") or "").strip()
+        if path_value:
+            try:
+                path = Path(path_value).expanduser()
+                if path.is_file():
+                    raw = path.read_bytes()
+                    if name == "attachment":
+                        name = path.name or name
+                    if mimetype_value == "application/octet-stream":
+                        mimetype_value = str(mimetypes.guess_type(name)[0] or mimetype_value).strip().lower()
+                        inferred_type = _media_type_from_mimetype(mimetype_value)
+                        if raw_type in {"", "file"} and inferred_type != "file":
+                            media_type = inferred_type
+            except Exception:
+                raw = None
 
     safe = dict(item)
     safe.pop("data", None)
     safe.pop("bytes", None)
-    safe["data_b64"] = base64.b64encode(raw).decode("utf-8")
-    safe["size"] = len(raw)
+    safe.pop("data_b64", None)
+    safe["type"] = media_type
+    safe["name"] = name
+    safe["mimetype"] = mimetype_value
+    if raw is not None:
+        file_id = str(uuid.uuid4())
+        _store_file_blob_in_redis(file_id, raw)
+        safe["id"] = file_id
+        safe["size"] = len(raw)
+        safe.pop("blob_key", None)
+        safe.pop("path", None)
+        safe.pop("file_path", None)
+        safe.pop("artifact_path", None)
+    elif str(safe.get("file_id") or "").strip() and not str(safe.get("id") or "").strip():
+        safe["id"] = str(safe.get("file_id") or "").strip()
     return safe
 
 
@@ -5844,6 +6406,13 @@ class LocalLlmModelDeleteRequest(BaseModel):
     model: Optional[str] = None
 
 
+class LlamaCppChatTemplateRequest(BaseModel):
+    provider: Optional[str] = None
+    model: Optional[str] = None
+    template: Optional[str] = None
+    reset: Optional[bool] = None
+
+
 class HfLlmWarmupCancelRequest(BaseModel):
     key: Optional[str] = None
     provider: Optional[str] = None
@@ -5928,11 +6497,26 @@ class AppSettingsRequest(BaseModel):
     hydra_llm_api_key: Optional[str] = None
     hydra_llm_provider: Optional[str] = None
     hydra_hf_transformers_context_tokens: Optional[Any] = None
+    hydra_hf_transformers_device: Optional[str] = None
+    hydra_hf_transformers_dtype: Optional[str] = None
+    hydra_hf_transformers_device_map: Optional[str] = None
+    hydra_hf_transformers_attn_implementation: Optional[str] = None
+    hydra_hf_transformers_trust_remote_code: Optional[bool] = None
     hydra_llama_cpp_context_tokens: Optional[Any] = None
     hydra_llama_cpp_vision_context_tokens: Optional[Any] = None
     hydra_llama_cpp_mtp_enabled: Optional[bool] = None
     hydra_llama_cpp_mtp_draft_tokens: Optional[Any] = None
+    hydra_llama_cpp_n_batch: Optional[Any] = None
+    hydra_llama_cpp_n_ubatch: Optional[Any] = None
+    hydra_llama_cpp_flash_attn: Optional[bool] = None
+    hydra_llama_cpp_offload_kqv: Optional[bool] = None
     hydra_mlx_lm_context_tokens: Optional[Any] = None
+    hydra_mlx_lm_trust_remote_code: Optional[bool] = None
+    hydra_mlx_lm_lazy_load: Optional[bool] = None
+    hydra_mlx_engine_prefill_step_size: Optional[Any] = None
+    hydra_mlx_engine_kv_bits: Optional[Any] = None
+    hydra_mlx_engine_kv_group_size: Optional[Any] = None
+    hydra_mlx_engine_quantized_kv_start: Optional[Any] = None
     spudex_llm_provider: Optional[str] = None
     spudex_llm_host: Optional[str] = None
     spudex_llm_model: Optional[str] = None
@@ -9902,6 +10486,11 @@ def runtime_breakdown() -> Dict[str, Any]:
     return {"ok": True, **payload}
 
 
+@app.get("/api/runtime/llm/debug")
+def runtime_llm_debug(since_id: int = 0, limit: int = 200) -> Dict[str, Any]:
+    return get_llm_debug_runtime_snapshot(since_id=since_id, limit=limit)
+
+
 @app.post("/api/runtime/local-llm/unload")
 def unload_runtime_local_llm(payload: LocalLlmUnloadRequest) -> Dict[str, Any]:
     try:
@@ -11938,11 +12527,26 @@ def get_settings() -> Dict[str, Any]:
         "hydra_llm_model": "",
         "hydra_llm_api_key": "",
         "hydra_hf_transformers_context_tokens": str(DEFAULT_HF_TRANSFORMERS_CONTEXT_TOKENS),
+        "hydra_hf_transformers_device": DEFAULT_HF_TRANSFORMERS_DEVICE,
+        "hydra_hf_transformers_dtype": DEFAULT_HF_TRANSFORMERS_DTYPE,
+        "hydra_hf_transformers_device_map": DEFAULT_HF_TRANSFORMERS_DEVICE_MAP,
+        "hydra_hf_transformers_attn_implementation": DEFAULT_HF_TRANSFORMERS_ATTN_IMPLEMENTATION,
+        "hydra_hf_transformers_trust_remote_code": bool(DEFAULT_HF_TRANSFORMERS_TRUST_REMOTE_CODE),
         "hydra_llama_cpp_context_tokens": str(DEFAULT_LLAMA_CPP_CONTEXT_TOKENS),
         "hydra_llama_cpp_vision_context_tokens": str(DEFAULT_LLAMA_CPP_VISION_CONTEXT_TOKENS),
         "hydra_llama_cpp_mtp_enabled": bool(DEFAULT_LLAMA_CPP_MTP_ENABLED),
         "hydra_llama_cpp_mtp_draft_tokens": str(DEFAULT_LLAMA_CPP_MTP_DRAFT_TOKENS),
+        "hydra_llama_cpp_n_batch": str(DEFAULT_LLAMA_CPP_N_BATCH),
+        "hydra_llama_cpp_n_ubatch": "",
+        "hydra_llama_cpp_flash_attn": bool(DEFAULT_LLAMA_CPP_FLASH_ATTN),
+        "hydra_llama_cpp_offload_kqv": bool(DEFAULT_LLAMA_CPP_OFFLOAD_KQV),
         "hydra_mlx_lm_context_tokens": "",
+        "hydra_mlx_lm_trust_remote_code": bool(DEFAULT_MLX_LM_TRUST_REMOTE_CODE),
+        "hydra_mlx_lm_lazy_load": bool(DEFAULT_MLX_LM_LAZY_LOAD),
+        "hydra_mlx_engine_prefill_step_size": "",
+        "hydra_mlx_engine_kv_bits": "",
+        "hydra_mlx_engine_kv_group_size": "",
+        "hydra_mlx_engine_quantized_kv_start": "",
         "hydra_beast_mode_enabled": False,
         "hydra_max_ledger_items": int(DEFAULT_MAX_LEDGER_ITEMS),
         "hydra_astraeus_plan_review_enabled": bool(DEFAULT_ASTRAEUS_PLAN_REVIEW_ENABLED),
@@ -12049,6 +12653,35 @@ def get_settings() -> Dict[str, Any]:
             ("TATER_HF_TRANSFORMERS_MAX_INPUT_TOKENS",),
             DEFAULT_HF_TRANSFORMERS_CONTEXT_TOKENS,
         ),
+        "hydra_hf_transformers_device": _read_text_choice_setting(
+            HYDRA_HF_TRANSFORMERS_DEVICE_KEY,
+            ("TATER_HF_TRANSFORMERS_DEVICE",),
+            DEFAULT_HF_TRANSFORMERS_DEVICE,
+            allowed=("auto", "cuda", "mps", "cpu"),
+        ),
+        "hydra_hf_transformers_dtype": _read_text_choice_setting(
+            HYDRA_HF_TRANSFORMERS_DTYPE_KEY,
+            ("TATER_HF_TRANSFORMERS_DTYPE",),
+            DEFAULT_HF_TRANSFORMERS_DTYPE,
+            allowed=("auto", "float16", "bfloat16", "float32"),
+        ),
+        "hydra_hf_transformers_device_map": _read_text_choice_setting(
+            HYDRA_HF_TRANSFORMERS_DEVICE_MAP_KEY,
+            ("TATER_HF_TRANSFORMERS_DEVICE_MAP",),
+            DEFAULT_HF_TRANSFORMERS_DEVICE_MAP,
+            allowed=("default", "disabled", "auto", "balanced"),
+        ),
+        "hydra_hf_transformers_attn_implementation": _read_text_choice_setting(
+            HYDRA_HF_TRANSFORMERS_ATTN_IMPLEMENTATION_KEY,
+            ("TATER_HF_TRANSFORMERS_ATTN_IMPLEMENTATION",),
+            DEFAULT_HF_TRANSFORMERS_ATTN_IMPLEMENTATION,
+            allowed=("", "auto", "sdpa", "flash_attention_2", "eager"),
+        ),
+        "hydra_hf_transformers_trust_remote_code": _read_bool_setting(
+            HYDRA_HF_TRANSFORMERS_TRUST_REMOTE_CODE_KEY,
+            ("TATER_HF_TRANSFORMERS_TRUST_REMOTE_CODE",),
+            DEFAULT_HF_TRANSFORMERS_TRUST_REMOTE_CODE,
+        ),
         "hydra_llama_cpp_context_tokens": _read_local_llm_context_setting(
             HYDRA_LLAMA_CPP_CONTEXT_TOKENS_KEY,
             ("TATER_LLAMA_CPP_N_CTX", "LLM_CONTEXT_SIZE"),
@@ -12071,12 +12704,71 @@ def get_settings() -> Dict[str, Any]:
             minimum=1,
             maximum=16,
         ),
+        "hydra_llama_cpp_n_batch": _read_bounded_int_setting(
+            HYDRA_LLAMA_CPP_N_BATCH_KEY,
+            ("TATER_LLAMA_CPP_N_BATCH",),
+            DEFAULT_LLAMA_CPP_N_BATCH,
+            minimum=32,
+            maximum=8192,
+        ),
+        "hydra_llama_cpp_n_ubatch": _read_bounded_int_setting(
+            HYDRA_LLAMA_CPP_N_UBATCH_KEY,
+            ("TATER_LLAMA_CPP_N_UBATCH",),
+            DEFAULT_LLAMA_CPP_N_UBATCH,
+            minimum=0,
+            maximum=8192,
+        ),
+        "hydra_llama_cpp_flash_attn": _read_bool_setting(
+            HYDRA_LLAMA_CPP_FLASH_ATTN_KEY,
+            ("TATER_LLAMA_CPP_FLASH_ATTN",),
+            DEFAULT_LLAMA_CPP_FLASH_ATTN,
+        ),
+        "hydra_llama_cpp_offload_kqv": _read_bool_setting(
+            HYDRA_LLAMA_CPP_OFFLOAD_KQV_KEY,
+            ("TATER_LLAMA_CPP_OFFLOAD_KQV",),
+            DEFAULT_LLAMA_CPP_OFFLOAD_KQV,
+        ),
         "hydra_mlx_lm_context_tokens": _read_local_llm_context_setting(
             HYDRA_MLX_LM_CONTEXT_TOKENS_KEY,
             ("TATER_MLX_LM_MAX_KV_SIZE",),
             None,
             minimum=128,
         ),
+        "hydra_mlx_lm_trust_remote_code": _read_bool_setting(
+            HYDRA_MLX_LM_TRUST_REMOTE_CODE_KEY,
+            ("TATER_MLX_LM_TRUST_REMOTE_CODE",),
+            DEFAULT_MLX_LM_TRUST_REMOTE_CODE,
+        ),
+        "hydra_mlx_lm_lazy_load": _read_bool_setting(
+            HYDRA_MLX_LM_LAZY_LOAD_KEY,
+            ("TATER_MLX_LM_LAZY",),
+            DEFAULT_MLX_LM_LAZY_LOAD,
+        ),
+        "hydra_mlx_engine_prefill_step_size": _read_optional_int_setting(
+            HYDRA_MLX_ENGINE_PREFILL_STEP_SIZE_KEY,
+            ("TATER_MLX_ENGINE_PREFILL_STEP_SIZE",),
+            minimum=1,
+            maximum=32768,
+        ),
+        "hydra_mlx_engine_kv_bits": _read_text_choice_setting(
+            HYDRA_MLX_ENGINE_KV_BITS_KEY,
+            ("TATER_MLX_ENGINE_KV_BITS",),
+            "",
+            allowed=("", "2", "3", "4", "6", "8"),
+        ),
+        "hydra_mlx_engine_kv_group_size": _read_text_choice_setting(
+            HYDRA_MLX_ENGINE_KV_GROUP_SIZE_KEY,
+            ("TATER_MLX_ENGINE_KV_GROUP_SIZE",),
+            "",
+            allowed=("", "32", "64", "128"),
+        ),
+        "hydra_mlx_engine_quantized_kv_start": _read_optional_int_setting(
+            HYDRA_MLX_ENGINE_QUANTIZED_KV_START_KEY,
+            ("TATER_MLX_ENGINE_QUANTIZED_KV_START",),
+            minimum=0,
+            maximum=1_048_576,
+            allow_zero=True,
+        ),
         "spudex_llm_provider": _normalize_hydra_llm_provider(spudex_settings.get("llm_provider") or ""),
         "spudex_llm_host": str(spudex_settings.get("llm_host") or ""),
         "spudex_llm_model": str(spudex_settings.get("llm_model") or ""),
@@ -12924,6 +13616,57 @@ def get_llama_cpp_diagnostics() -> Dict[str, Any]:
     return get_llama_cpp_runtime_diagnostics()
 
 
+@app.get("/api/settings/llama-cpp/chat-template")
+def get_llama_cpp_chat_template(model: str) -> Dict[str, Any]:
+    return _llama_cpp_chat_template_model_info(model)
+
+
+@app.post("/api/settings/llama-cpp/chat-template")
+def save_llama_cpp_chat_template(request: LlamaCppChatTemplateRequest) -> Dict[str, Any]:
+    model = str(request.model or "").strip()
+    if not model:
+        raise HTTPException(status_code=400, detail="llama.cpp model is required.")
+    try:
+        if request.reset:
+            clear_llama_cpp_chat_template_override(model)
+        else:
+            set_llama_cpp_chat_template_override(model, request.template or "")
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    unload_result = unload_local_llm_models(provider=HYDRA_LLM_PROVIDER_LLAMA_CPP, model=model)
+    info = _llama_cpp_chat_template_model_info(model)
+    info["ok"] = True
+    info["unload"] = unload_result
+    return info
+
+
+@app.get("/api/settings/local-llm/chat-template")
+def get_local_llm_chat_template(provider: str = "", model: str = "") -> Dict[str, Any]:
+    return _local_llm_chat_template_model_info(provider, model)
+
+
+@app.post("/api/settings/local-llm/chat-template")
+def save_local_llm_chat_template(request: LlamaCppChatTemplateRequest) -> Dict[str, Any]:
+    provider = _normalize_hydra_llm_provider(request.provider)
+    if not _is_local_hydra_llm_provider(provider):
+        raise HTTPException(status_code=400, detail="Local LLM provider is required.")
+    model = str(request.model or "").strip()
+    if not model:
+        raise HTTPException(status_code=400, detail="Local model is required.")
+    try:
+        if request.reset:
+            clear_local_llm_chat_template_override(provider, model)
+        else:
+            set_local_llm_chat_template_override(provider, model, request.template or "")
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    unload_result = unload_local_llm_models(provider=provider, model=model)
+    info = _local_llm_chat_template_model_info(provider, model)
+    info["ok"] = True
+    info["unload"] = unload_result
+    return info
+
+
 @app.get("/api/settings/huggingface/models")
 def get_huggingface_models(
     provider: str = "hf_transformers",
@@ -12938,6 +13681,25 @@ def get_huggingface_models(
         provider_token = HYDRA_LLM_PROVIDER_HF_TRANSFORMERS
     view_token = str(view or "trending").strip().lower().replace("_", "-")
     task_token = _normalize_hf_browser_task(task)
+    clean_limit = max(4, min(48, int(limit or 24)))
+    search = _hf_browser_provider_search(provider_token, query, task_token)
+    integration_status = _hf_browser_integration_status()
+    if view_token in {"picks", "tater", "tater-picks", "recommended"}:
+        models = _hf_browser_tater_pick_models(query=search, task=task_token, limit=clean_limit, provider=provider_token)
+        return {
+            "provider": provider_token,
+            "provider_label": _hydra_llm_provider_label(provider_token),
+            "view": "picks",
+            "query": search,
+            "task": task_token,
+            "library": "",
+            "app_filter": "",
+            "integration": integration_status,
+            "limit": clean_limit,
+            "has_next": False,
+            "next_cursor": "",
+            "models": models,
+        }
     if view_token in {"new", "recent", "latest"}:
         sort = "lastModified"
         response_view = "new"
@@ -12947,9 +13709,6 @@ def get_huggingface_models(
     else:
         sort = "trendingScore"
         response_view = "trending"
-    clean_limit = max(4, min(48, int(limit or 24)))
-    search = _hf_browser_provider_search(provider_token, query, task_token)
-    integration_status = _hf_browser_integration_status()
     page_url = _hf_browser_cursor_decode(cursor) if str(cursor or "").strip() else _hf_browser_models_api_url(
         provider=provider_token,
         search=search,
@@ -12988,7 +13747,7 @@ def get_huggingface_models(
         "query": search,
         "task": task_token,
         "library": _hf_browser_provider_library(provider_token),
-        "app_filter": _hf_browser_provider_app_filter(provider_token),
+        "app_filter": _hf_browser_provider_app_filter(provider_token, task_token),
         "integration": integration_status,
         "limit": clean_limit,
         "has_next": bool(next_cursor),
@@ -13244,6 +14003,60 @@ def update_settings(payload: AppSettingsRequest, response: Response) -> Dict[str
             )
         redis_client.set(redis_key, str(int(parsed)))
 
+    def _save_text_choice_setting(
+        payload_key: str,
+        redis_key: str,
+        *,
+        allowed: Tuple[str, ...],
+        default: str = "",
+    ) -> None:
+        if payload_key not in updates:
+            return
+        token = str(updates.get(payload_key) or default or "").strip().lower()
+        aliases = {
+            "fp16": "float16",
+            "half": "float16",
+            "bf16": "bfloat16",
+            "fp32": "float32",
+            "none": "disabled",
+            "off": "disabled",
+            "false": "disabled",
+            "0": "disabled",
+            "default": "default",
+            "auto": "auto",
+        }
+        token = aliases.get(token, token)
+        allowed_set = {str(item).strip().lower() for item in allowed}
+        if token not in allowed_set:
+            raise HTTPException(status_code=400, detail=f"{payload_key} has an unsupported value.")
+        redis_client.set(redis_key, token)
+
+    def _save_optional_int_setting(
+        payload_key: str,
+        redis_key: str,
+        *,
+        min_value: int = 0,
+        max_value: int = 1_048_576,
+        allow_zero: bool = False,
+    ) -> None:
+        if payload_key not in updates:
+            return
+        raw = str(updates.get(payload_key) or "").strip()
+        if not raw:
+            redis_client.delete(redis_key)
+            return
+        try:
+            parsed = int(float(raw))
+        except Exception as exc:
+            raise HTTPException(status_code=400, detail=f"{payload_key} must be a whole number.") from exc
+        if parsed < min_value or parsed > max_value or (parsed == 0 and not allow_zero):
+            lower = min_value if allow_zero or min_value > 0 else 1
+            raise HTTPException(
+                status_code=400,
+                detail=f"{payload_key} must be between {lower} and {max_value}.",
+            )
+        redis_client.set(redis_key, str(int(parsed)))
+
     _save_tater_api_settings_from_updates(updates)
 
     local_model_keys_cache: Optional[set[Tuple[str, str]]] = None
@@ -13308,10 +14121,25 @@ def update_settings(payload: AppSettingsRequest, response: Response) -> Dict[str
         "hydra_llm_provider",
         "hydra_base_servers",
         "hydra_hf_transformers_context_tokens",
+        "hydra_hf_transformers_device",
+        "hydra_hf_transformers_dtype",
+        "hydra_hf_transformers_device_map",
+        "hydra_hf_transformers_attn_implementation",
+        "hydra_hf_transformers_trust_remote_code",
         "hydra_llama_cpp_context_tokens",
         "hydra_llama_cpp_mtp_enabled",
         "hydra_llama_cpp_mtp_draft_tokens",
+        "hydra_llama_cpp_n_batch",
+        "hydra_llama_cpp_n_ubatch",
+        "hydra_llama_cpp_flash_attn",
+        "hydra_llama_cpp_offload_kqv",
         "hydra_mlx_lm_context_tokens",
+        "hydra_mlx_lm_trust_remote_code",
+        "hydra_mlx_lm_lazy_load",
+        "hydra_mlx_engine_prefill_step_size",
+        "hydra_mlx_engine_kv_bits",
+        "hydra_mlx_engine_kv_group_size",
+        "hydra_mlx_engine_quantized_kv_start",
     }
     spudex_model_keys = {"spudex_llm_provider", "spudex_llm_host", "spudex_llm_model"}
     vision_model_keys = {
@@ -13402,6 +14230,35 @@ def update_settings(payload: AppSettingsRequest, response: Response) -> Dict[str
         "hydra_hf_transformers_context_tokens",
         HYDRA_HF_TRANSFORMERS_CONTEXT_TOKENS_KEY,
     )
+    _save_text_choice_setting(
+        "hydra_hf_transformers_device",
+        HYDRA_HF_TRANSFORMERS_DEVICE_KEY,
+        allowed=("auto", "cuda", "mps", "cpu"),
+        default=DEFAULT_HF_TRANSFORMERS_DEVICE,
+    )
+    _save_text_choice_setting(
+        "hydra_hf_transformers_dtype",
+        HYDRA_HF_TRANSFORMERS_DTYPE_KEY,
+        allowed=("auto", "float16", "bfloat16", "float32"),
+        default=DEFAULT_HF_TRANSFORMERS_DTYPE,
+    )
+    _save_text_choice_setting(
+        "hydra_hf_transformers_device_map",
+        HYDRA_HF_TRANSFORMERS_DEVICE_MAP_KEY,
+        allowed=("default", "disabled", "auto", "balanced"),
+        default=DEFAULT_HF_TRANSFORMERS_DEVICE_MAP,
+    )
+    _save_text_choice_setting(
+        "hydra_hf_transformers_attn_implementation",
+        HYDRA_HF_TRANSFORMERS_ATTN_IMPLEMENTATION_KEY,
+        allowed=("", "auto", "sdpa", "flash_attention_2", "eager"),
+        default=DEFAULT_HF_TRANSFORMERS_ATTN_IMPLEMENTATION,
+    )
+    _save_bool_setting(
+        "hydra_hf_transformers_trust_remote_code",
+        HYDRA_HF_TRANSFORMERS_TRUST_REMOTE_CODE_KEY,
+        default=DEFAULT_HF_TRANSFORMERS_TRUST_REMOTE_CODE,
+    )
     _save_local_llm_context_setting(
         "hydra_llama_cpp_context_tokens",
         HYDRA_LLAMA_CPP_CONTEXT_TOKENS_KEY,
@@ -13422,11 +14279,70 @@ def update_settings(payload: AppSettingsRequest, response: Response) -> Dict[str
         min_value=1,
         max_value=16,
     )
+    _save_bounded_int_setting(
+        "hydra_llama_cpp_n_batch",
+        HYDRA_LLAMA_CPP_N_BATCH_KEY,
+        default=DEFAULT_LLAMA_CPP_N_BATCH,
+        min_value=32,
+        max_value=8192,
+    )
+    _save_bounded_int_setting(
+        "hydra_llama_cpp_n_ubatch",
+        HYDRA_LLAMA_CPP_N_UBATCH_KEY,
+        default=DEFAULT_LLAMA_CPP_N_UBATCH,
+        min_value=0,
+        max_value=8192,
+    )
+    _save_bool_setting(
+        "hydra_llama_cpp_flash_attn",
+        HYDRA_LLAMA_CPP_FLASH_ATTN_KEY,
+        default=DEFAULT_LLAMA_CPP_FLASH_ATTN,
+    )
+    _save_bool_setting(
+        "hydra_llama_cpp_offload_kqv",
+        HYDRA_LLAMA_CPP_OFFLOAD_KQV_KEY,
+        default=DEFAULT_LLAMA_CPP_OFFLOAD_KQV,
+    )
     _save_local_llm_context_setting(
         "hydra_mlx_lm_context_tokens",
         HYDRA_MLX_LM_CONTEXT_TOKENS_KEY,
         min_value=128,
     )
+    _save_bool_setting(
+        "hydra_mlx_lm_trust_remote_code",
+        HYDRA_MLX_LM_TRUST_REMOTE_CODE_KEY,
+        default=DEFAULT_MLX_LM_TRUST_REMOTE_CODE,
+    )
+    _save_bool_setting(
+        "hydra_mlx_lm_lazy_load",
+        HYDRA_MLX_LM_LAZY_LOAD_KEY,
+        default=DEFAULT_MLX_LM_LAZY_LOAD,
+    )
+    _save_optional_int_setting(
+        "hydra_mlx_engine_prefill_step_size",
+        HYDRA_MLX_ENGINE_PREFILL_STEP_SIZE_KEY,
+        min_value=1,
+        max_value=32768,
+    )
+    _save_text_choice_setting(
+        "hydra_mlx_engine_kv_bits",
+        HYDRA_MLX_ENGINE_KV_BITS_KEY,
+        allowed=("", "2", "3", "4", "6", "8"),
+        default="",
+    )
+    _save_text_choice_setting(
+        "hydra_mlx_engine_kv_group_size",
+        HYDRA_MLX_ENGINE_KV_GROUP_SIZE_KEY,
+        allowed=("", "32", "64", "128"),
+        default="",
+    )
+    _save_optional_int_setting(
+        "hydra_mlx_engine_quantized_kv_start",
+        HYDRA_MLX_ENGINE_QUANTIZED_KV_START_KEY,
+        min_value=0,
+        max_value=1_048_576,
+        allow_zero=True,
+    )
 
     username = updates.get("username")
     if isinstance(username, str):
@@ -13590,8 +14506,6 @@ def update_settings(payload: AppSettingsRequest, response: Response) -> Dict[str
             updates.get("vision_provider", current_vision.get("provider") or HYDRA_LLM_PROVIDER_OPENAI_COMPATIBLE)
         )
         vision_model = str(updates.get("vision_model", current_vision.get("model") or "")).strip()
-        if vision_mode == "dedicated" and vision_provider == HYDRA_LLM_PROVIDER_MLX_LM:
-            raise HTTPException(status_code=400, detail="Dedicated local vision currently supports Transformers and llama.cpp GGUF models.")
         if vision_mode == "dedicated" and _is_local_hydra_llm_provider(vision_provider):
             _require_downloaded_local_model(vision_provider, vision_model, "Vision")
         save_shared_vision_settings(

tater_reachy_standalone/vendor/tater_app/tateros_static/app.js

@@ -127,6 +127,12 @@ const state = {
   dashboardRefreshStatus: "",
   hfLlmWarmupPollTimer: 0,
   hfLlmWarmupLastSnapshot: null,
+  llmDebugPollTimer: 0,
+  llmDebugInFlight: false,
+  llmDebugNextId: 0,
+  llmDebugEvents: [],
+  llmDebugLastSnapshot: null,
+  llmDebugAutoScroll: String(safeStorageGet("tater_llm_debug_auto_scroll", "true")).trim().toLowerCase() !== "false",
   runtimeSettingsSaveHandler: null,
   runtimeSettingsOpenHandler: null,
   runtimeSettingsCloseHandler: null,
@@ -178,6 +184,14 @@ const state = {
 
 safeStorageSet("tater_tateros_session_id", state.sessionId);
 
+function clearLlmDebugPollTimer() {
+  if (state.llmDebugPollTimer) {
+    window.clearTimeout(state.llmDebugPollTimer);
+    state.llmDebugPollTimer = 0;
+  }
+  state.llmDebugInFlight = false;
+}
+
 const APP_BASE_PATH = (() => {
   const rawPath = String(window.location.pathname || "/").trim();
   const normalized = rawPath.replace(/\/+$/, "");
@@ -1016,6 +1030,35 @@ function finishActionProgress(tone = "success", statusText = "Completed.") {
   setActionProgress(100, statusText, tone);
 }
 
+function normalizeLocalLlmProviderToken(value) {
+  const token = String(value || "").trim().toLowerCase().replace(/[\s.-]+/g, "_");
+  if (["llama", "llamacpp", "llama_cpp", "gguf", "llama_cpp_python"].includes(token)) {
+    return "llama_cpp";
+  }
+  if (["mlx", "mlx_lm", "apple_mlx", "apple_silicon", "mlxlm"].includes(token)) {
+    return "mlx_lm";
+  }
+  if (["hf", "huggingface", "hugging_face", "transformers", "hf_transformers", "local_transformers"].includes(token)) {
+    return "hf_transformers";
+  }
+  return token || "hf_transformers";
+}
+
+function isLocalLlmProviderToken(value) {
+  return ["hf_transformers", "llama_cpp", "mlx_lm"].includes(normalizeLocalLlmProviderToken(value));
+}
+
+function localLlmProviderLabel(value) {
+  const provider = normalizeLocalLlmProviderToken(value);
+  if (provider === "llama_cpp") {
+    return "llama.cpp";
+  }
+  if (provider === "mlx_lm") {
+    return "MLX";
+  }
+  return "Transformers";
+}
+
 function closeActionProgressModal() {
   const modal = document.getElementById("action-progress-modal");
   if (!modal) {
@@ -1058,6 +1101,220 @@ async function runActionWithProgress(meta, actionFn) {
   }
 }
 
+function localLlmChatTemplateCapabilityBadges(capabilities = {}) {
+  const items = [
+    ["enable_thinking", "enable_thinking"],
+    ["reasoning_budget", "reasoning budget"],
+    ["no_think_marker", "/no_think"],
+    ["think_tags", "think tags"],
+  ];
+  return items
+    .map(([key, label]) => {
+      const active = Boolean(capabilities?.[key]);
+      return `<span class="llama-template-badge${active ? " active" : ""}">${escapeHtml(label)} ${active ? "found" : "missing"}</span>`;
+    })
+    .join("");
+}
+
+function ensureLocalLlmChatTemplateModal() {
+  let modal = document.getElementById("llama-chat-template-modal");
+  if (modal) {
+    return modal;
+  }
+  document.body.insertAdjacentHTML(
+    "beforeend",
+    `
+      <div id="llama-chat-template-modal" class="cerb-modal" aria-hidden="true">
+        <div class="cerb-modal-dialog card llama-chat-template-dialog" role="dialog" aria-modal="true" aria-label="Local Model Chat Template">
+          <div class="card-head runtime-breakdown-modal-head">
+            <span class="runtime-breakdown-modal-badge" aria-hidden="true">CT</span>
+            <div>
+              <h3 id="llama-chat-template-title" class="card-title">Chat Template</h3>
+              <div id="llama-chat-template-model" class="small"></div>
+            </div>
+            <button type="button" class="inline-btn" id="llama-chat-template-close">Close</button>
+          </div>
+          <div class="cerb-modal-body llama-chat-template-body">
+            <div id="llama-chat-template-summary" class="llama-chat-template-summary"></div>
+            <textarea id="llama-chat-template-editor" class="llama-chat-template-editor" spellcheck="false"></textarea>
+            <div class="llama-chat-template-actions">
+              <button type="button" class="inline-btn" id="llama-chat-template-use-embedded">Use Embedded</button>
+              <button type="button" class="inline-btn" id="llama-chat-template-reload">Reload</button>
+              <button type="button" class="inline-btn" id="llama-chat-template-reset">Reset Override</button>
+              <button type="button" class="inline-btn primary" id="llama-chat-template-save">Save Override</button>
+            </div>
+            <div id="llama-chat-template-status" class="small llama-chat-template-status"></div>
+          </div>
+        </div>
+      </div>
+    `
+  );
+  modal = document.getElementById("llama-chat-template-modal");
+  const closeModal = () => closePopupModal(modal);
+  document.getElementById("llama-chat-template-close")?.addEventListener("click", closeModal);
+  modal?.addEventListener("click", (event) => {
+    if (event.target === modal) {
+      closeModal();
+    }
+  });
+  document.addEventListener("keydown", (event) => {
+    if (event.key === "Escape" && modal?.classList.contains("active")) {
+      closeModal();
+    }
+  });
+  return modal;
+}
+
+async function openLocalLlmChatTemplateModal(provider, model, options = {}) {
+  const providerToken = normalizeLocalLlmProviderToken(provider);
+  const modelId = String(model || "").trim();
+  if (!isLocalLlmProviderToken(providerToken) || !modelId) {
+    showToast("Select a local model first.", "error", 2600);
+    return null;
+  }
+  const providerLabel = localLlmProviderLabel(providerToken);
+  const modal = ensureLocalLlmChatTemplateModal();
+  const titleEl = document.getElementById("llama-chat-template-title");
+  const modelEl = document.getElementById("llama-chat-template-model");
+  const summaryEl = document.getElementById("llama-chat-template-summary");
+  const editorEl = document.getElementById("llama-chat-template-editor");
+  const statusEl = document.getElementById("llama-chat-template-status");
+  const saveBtn = document.getElementById("llama-chat-template-save");
+  const resetBtn = document.getElementById("llama-chat-template-reset");
+  const reloadBtn = document.getElementById("llama-chat-template-reload");
+  const embeddedBtn = document.getElementById("llama-chat-template-use-embedded");
+  let latestPayload = null;
+
+  const setStatus = (text, tone = "") => {
+    if (!statusEl) {
+      return;
+    }
+    statusEl.textContent = String(text || "").trim();
+    statusEl.classList.toggle("success", tone === "success");
+    statusEl.classList.toggle("error", tone === "error");
+  };
+  const setBusy = (busy) => {
+    [
+      document.getElementById("llama-chat-template-save"),
+      document.getElementById("llama-chat-template-reset"),
+      document.getElementById("llama-chat-template-reload"),
+      document.getElementById("llama-chat-template-use-embedded"),
+    ].forEach((button) => {
+      if (button) {
+        button.disabled = Boolean(busy);
+      }
+    });
+  };
+  const renderPayload = (payload) => {
+    latestPayload = payload && typeof payload === "object" ? payload : {};
+    const effective = String(latestPayload.effective_template || latestPayload.override_template || latestPayload.embedded_template || "");
+    if (titleEl) {
+      titleEl.textContent = latestPayload.override_active ? "Chat Template Override" : "Chat Template";
+    }
+    if (modelEl) {
+      modelEl.textContent = `${providerLabel} • ${modelId}`;
+    }
+    if (editorEl) {
+      editorEl.value = effective;
+    }
+    const templateNames = Array.isArray(latestPayload.template_names) ? latestPayload.template_names : [];
+    const source = String(latestPayload.source || "none").trim();
+    const sourceLabel = source === "override" ? "Override active" : source === "gguf" || source === "embedded" ? "Using embedded model template" : "No embedded template found";
+    const embeddedChars = Number(latestPayload.embedded_template_chars || 0);
+    const overrideChars = Number(latestPayload.override_template_chars || 0);
+    const maxChars = Number(latestPayload.max_chars || 0);
+    if (summaryEl) {
+      summaryEl.innerHTML = `
+        <div class="llama-chat-template-summary-row">
+          <strong>${escapeHtml(sourceLabel)}</strong>
+          <span>${escapeHtml(templateNames.length ? templateNames.join(", ") : "default template")}</span>
+        </div>
+        <div class="llama-chat-template-badges">
+          ${localLlmChatTemplateCapabilityBadges(latestPayload.capabilities || {})}
+        </div>
+        <div class="llama-chat-template-meta">
+          <span>Embedded ${embeddedChars.toLocaleString()} chars</span>
+          <span>Override ${overrideChars.toLocaleString()} chars</span>
+          ${maxChars > 0 ? `<span>Limit ${maxChars.toLocaleString()} chars</span>` : ""}
+        </div>
+      `;
+    }
+    const embeddedButton = document.getElementById("llama-chat-template-use-embedded");
+    if (embeddedButton) {
+      embeddedButton.disabled = embeddedChars <= 0;
+    }
+    setStatus(source === "none" || source === "fallback" ? "No embedded template was found for this model." : "Template loaded.");
+  };
+  const load = async () => {
+    setBusy(true);
+    setStatus("Loading chat template...");
+    try {
+      const payload = await api(`/api/settings/local-llm/chat-template?provider=${encodeURIComponent(providerToken)}&model=${encodeURIComponent(modelId)}`, {
+        _timeoutMs: HEALTH_REQUEST_TIMEOUT_MS,
+      });
+      renderPayload(payload);
+    } catch (error) {
+      setStatus(`Load failed: ${error.message}`, "error");
+      if (summaryEl) {
+        summaryEl.innerHTML = `<div class="hf-model-browser-empty">Template metadata could not be loaded.</div>`;
+      }
+    } finally {
+      setBusy(false);
+    }
+  };
+  const save = async ({ reset = false } = {}) => {
+    setBusy(true);
+    setStatus(reset ? "Resetting override..." : "Saving override...");
+    try {
+      const payload = await api("/api/settings/local-llm/chat-template", {
+        method: "POST",
+        body: JSON.stringify({
+          provider: providerToken,
+          model: modelId,
+          template: reset ? "" : String(editorEl?.value || ""),
+          reset,
+        }),
+        _timeoutMs: HEALTH_REQUEST_TIMEOUT_MS,
+      });
+      renderPayload(payload);
+      setStatus(reset ? "Override reset. The next model call will use the embedded template." : "Override saved. The matching loaded model was unloaded for a clean reload.", "success");
+      if (typeof options.onSaved === "function") {
+        options.onSaved(payload);
+      }
+    } catch (error) {
+      setStatus(`${reset ? "Reset" : "Save"} failed: ${error.message}`, "error");
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  saveBtn?.replaceWith(saveBtn.cloneNode(true));
+  resetBtn?.replaceWith(resetBtn.cloneNode(true));
+  reloadBtn?.replaceWith(reloadBtn.cloneNode(true));
+  embeddedBtn?.replaceWith(embeddedBtn.cloneNode(true));
+  document.getElementById("llama-chat-template-save")?.addEventListener("click", () => {
+    void save();
+  });
+  document.getElementById("llama-chat-template-reset")?.addEventListener("click", () => {
+    if (window.confirm(`Reset chat template override for ${modelId}?`)) {
+      void save({ reset: true });
+    }
+  });
+  document.getElementById("llama-chat-template-reload")?.addEventListener("click", () => {
+    void load();
+  });
+  document.getElementById("llama-chat-template-use-embedded")?.addEventListener("click", () => {
+    if (editorEl && latestPayload) {
+      editorEl.value = String(latestPayload.embedded_template || "");
+      setStatus("Embedded template copied into the editor.");
+    }
+  });
+
+  openPopupModal(modal);
+  await load();
+  return modal;
+}
+
 async function api(path, options = {}) {
   const requestOptions = options && typeof options === "object" ? options : {};
   const skipRedisRecovery = Boolean(requestOptions._skipRedisRecovery);
@@ -4248,6 +4505,14 @@ function _sanitizeMarkdownHref(rawHref) {
   return "";
 }
 
+function _chatDirectMediaUrl(rawUrl) {
+  const safeHref = _sanitizeMarkdownHref(rawUrl);
+  if (!safeHref) {
+    return "";
+  }
+  return safeHref.startsWith("/") ? withBasePath(safeHref) : safeHref;
+}
+
 function _renderMarkdownInline(rawText) {
   const source = String(rawText ?? "");
   if (!source) {
@@ -4447,17 +4712,19 @@ function renderChatMessage(message) {
       `;
     } else {
       const contentType = String(content.type || "").toLowerCase();
-      const fileId = String(content.id || "").trim();
+      const fileId = String(content.id || content.file_id || "").trim();
       const fileName = String(content.name || "attachment").trim() || "attachment";
       const mimetype = String(content.mimetype || "").trim() || "application/octet-stream";
       const fileUrl = _chatFileUrl(fileId, mimetype);
+      const directMediaUrl = _chatDirectMediaUrl(content.url || content.src || content.href);
+      const mediaUrl = directMediaUrl || fileUrl;
       const hasDataB64 = typeof content.data_b64 === "string" && content.data_b64.trim().length > 0;
-      const hasFileUrl = Boolean(fileUrl);
+      const hasMediaUrl = Boolean(mediaUrl);
       if (contentType === "image" && hasDataB64) {
         const imageUrl = `data:${escapeHtml(content.mimetype || "image/png")};base64,${content.data_b64}`;
         bodyHtml = `<img class="chat-media-image" src="${imageUrl}" alt="${escapeHtml(content.name || "image")}" />`;
-      } else if (contentType === "image" && hasFileUrl) {
-        bodyHtml = `<img class="chat-media-image" src="${fileUrl}" alt="${escapeHtml(fileName)}" />`;
+      } else if (contentType === "image" && hasMediaUrl) {
+        bodyHtml = `<img class="chat-media-image" src="${escapeHtml(mediaUrl)}" alt="${escapeHtml(fileName)}" />`;
       } else if (contentType === "audio" && hasDataB64) {
         const mimetype = String(content.mimetype || "audio/mpeg");
         const audioUrl = `data:${escapeHtml(mimetype)};base64,${content.data_b64}`;
@@ -4468,12 +4735,12 @@ function renderChatMessage(message) {
             <a class="inline-btn" href="${audioUrl}" download="${escapeHtml(fileName)}">Download Audio</a>
           </div>
         `;
-      } else if (contentType === "audio" && hasFileUrl) {
+      } else if (contentType === "audio" && hasMediaUrl) {
         bodyHtml = `
           <div class="chat-media-wrap">
-            <audio controls preload="metadata" src="${fileUrl}"></audio>
+            <audio controls preload="metadata" src="${escapeHtml(mediaUrl)}"></audio>
             <div class="chat-file-meta">${escapeHtml(fileName)}</div>
-            <a class="inline-btn" href="${fileUrl}" download="${escapeHtml(fileName)}">Download Audio</a>
+            <a class="inline-btn" href="${escapeHtml(mediaUrl)}" download="${escapeHtml(fileName)}">Download Audio</a>
           </div>
         `;
       } else if (contentType === "video" && hasDataB64) {
@@ -4486,12 +4753,12 @@ function renderChatMessage(message) {
             <a class="inline-btn" href="${videoUrl}" download="${escapeHtml(fileName)}">Download Video</a>
           </div>
         `;
-      } else if (contentType === "video" && hasFileUrl) {
+      } else if (contentType === "video" && hasMediaUrl) {
         bodyHtml = `
           <div class="chat-media-wrap">
-            <video controls preload="metadata" src="${fileUrl}" class="chat-media-video"></video>
+            <video controls preload="metadata" src="${escapeHtml(mediaUrl)}" class="chat-media-video"></video>
             <div class="chat-file-meta">${escapeHtml(fileName)}</div>
-            <a class="inline-btn" href="${fileUrl}" download="${escapeHtml(fileName)}">Download Video</a>
+            <a class="inline-btn" href="${escapeHtml(mediaUrl)}" download="${escapeHtml(fileName)}">Download Video</a>
           </div>
         `;
       } else if (contentType === "file" && hasDataB64) {
@@ -4504,12 +4771,12 @@ function renderChatMessage(message) {
             )}">Download File</a>
           </div>
         `;
-      } else if (contentType === "file" && hasFileUrl) {
+      } else if (contentType === "file" && hasMediaUrl) {
         const sizeLabel = _formatBytes(content.size);
         bodyHtml = `
           <div class="chat-file-card">
             <div class="chat-file-meta">${escapeHtml(fileName)}${sizeLabel ? ` (${escapeHtml(sizeLabel)})` : ""}</div>
-            <a class="inline-btn" href="${fileUrl}" download="${escapeHtml(fileName)}">Download File</a>
+            <a class="inline-btn" href="${escapeHtml(mediaUrl)}" download="${escapeHtml(fileName)}">Download File</a>
           </div>
         `;
       } else {
@@ -8193,6 +8460,9 @@ function bindModelSettingsTabs(root = document) {
     if (load && ["speakerid", "emotionid"].includes(normalized)) {
       void ensureEspHomeRuntimeLoaded({ force: true, panel: normalized });
     }
+    if (normalized !== "routing") {
+      clearLlmDebugPollTimer();
+    }
   };
   buttons.forEach((button) => {
     if (button.dataset.modelsTabBound === "1") {
@@ -15885,6 +16155,16 @@ async function loadSettingsView() {
       .map((option) => `<option value="${escapeHtml(option.value)}"${option.value === selected ? " selected" : ""}>${escapeHtml(option.label)}</option>`)
       .join("");
   };
+  const renderChoiceOptions = (options, currentValue) => {
+    const selected = String(currentValue ?? "").trim().toLowerCase();
+    return (Array.isArray(options) ? options : [])
+      .map((option) => {
+        const value = String(option?.value ?? "").trim();
+        const label = String(option?.label ?? value).trim();
+        return `<option value="${escapeHtml(value)}"${value.toLowerCase() === selected ? " selected" : ""}>${escapeHtml(label)}</option>`;
+      })
+      .join("");
+  };
   const renderHydraLocalProviderOptions = (currentValue) => {
     const selected = normalizeHydraBaseProvider(currentValue);
     return hydraProviderOptions
@@ -16537,6 +16817,7 @@ async function loadSettingsView() {
                 <button type="button" class="settings-subtab-btn active" data-llm-vision-tab="settings">Settings</button>
                 <button type="button" class="settings-subtab-btn" data-llm-vision-tab="huggingface">Hugging Face</button>
                 <button type="button" class="settings-subtab-btn" data-llm-vision-tab="manage">Manage</button>
+                <button type="button" class="settings-subtab-btn" data-llm-vision-tab="debug">Debug</button>
               </div>
               <div id="settings-hf-model-browser" class="hf-model-browser" hidden>
                 <div class="hf-model-browser-hero">
@@ -16560,7 +16841,8 @@ async function loadSettingsView() {
                       <option value="image-text-to-text">Vision</option>
                     </select>
                     <div class="hf-model-browser-view-switch" role="group" aria-label="Model list">
-                      <button type="button" class="active" data-hf-model-view="trending">Trending</button>
+                      <button type="button" class="active" data-hf-model-view="picks">Tater Picks</button>
+                      <button type="button" data-hf-model-view="trending">Trending</button>
                       <button type="button" data-hf-model-view="new">New</button>
                       <button type="button" data-hf-model-view="downloads">Most Downloaded</button>
                     </div>
@@ -16611,6 +16893,27 @@ async function loadSettingsView() {
                 <div id="local-model-manager-status" class="small hf-model-browser-status"></div>
                 <div id="local-model-manager-list" class="local-model-manager-list"></div>
               </div>
+              <div id="settings-llm-debug-console" class="hf-model-browser llm-debug-console-shell" hidden>
+                <div class="hf-model-browser-hero llm-debug-hero">
+                  <div class="hf-model-browser-spud" aria-hidden="true">
+                    <span class="hf-model-browser-spud-eye left"></span>
+                    <span class="hf-model-browser-spud-eye right"></span>
+                    <span class="hf-model-browser-spud-spark"></span>
+                  </div>
+                  <div class="hf-model-browser-title">
+                    <strong>Live LLM Console</strong>
+                    <span>Runtime events, active calls, prompt timing, output previews, and backend errors.</span>
+                  </div>
+                  <div class="llm-debug-actions">
+                    <button type="button" id="llm-debug-refresh" class="inline-btn">Refresh</button>
+                    <button type="button" id="llm-debug-autoscroll" class="inline-btn">Auto-scroll On</button>
+                    <button type="button" id="llm-debug-clear" class="inline-btn danger">Clear View</button>
+                  </div>
+                </div>
+                <div id="llm-debug-status" class="small hf-model-browser-status">Open Debug to start the live console.</div>
+                <div id="llm-debug-active" class="llm-debug-active"></div>
+                <div id="llm-debug-events" class="llm-debug-events" role="log" aria-live="polite"></div>
+              </div>
               <div id="settings-hydra-base-fields" class="hydra-model-panel is-active llm-vision-settings-block">
                 <div class="hydra-model-panel-title">Base Model</div>
                 <div class="small hydra-model-panel-note">Used for regular AI calls. Multiple base servers rotate in round-robin order.</div>
@@ -16636,6 +16939,10 @@ async function loadSettingsView() {
                   <select id="set_hydra_llm_model_select"></select>
                   <div id="hydra-local-model-status" class="small"></div>
                 </label>
+                <div id="settings-llama-chat-template-tools" class="hydra-chat-template-tools" data-hydra-provider-field="local">
+                  <button type="button" id="settings-llama-chat-template-edit" class="inline-btn">Edit Chat Template</button>
+                  <span id="settings-llama-chat-template-status" class="small">Per-model template override.</span>
+                </div>
                 <label class="hydra-context-field" data-hydra-provider-field="hf_transformers">Context Length
                   <div class="hydra-context-control" data-hydra-context-control="hf_transformers">
                     <input id="set_hydra_hf_transformers_context_tokens_range" type="range" min="256" max="262144" step="256" value="${escapeHtml(
@@ -16648,6 +16955,71 @@ async function loadSettingsView() {
                   <div id="hydra-hf-context-hint" class="small hydra-context-hint"></div>
                   <div id="hydra-hf-context-estimate" class="hydra-context-estimate" data-hydra-context-estimate="hf_transformers"></div>
                 </label>
+                <label class="hydra-context-field" data-hydra-provider-field="hf_transformers">Device
+                  <select id="set_hydra_hf_transformers_device">
+                    ${renderChoiceOptions(
+                      [
+                        { value: "auto", label: "Auto" },
+                        { value: "cuda", label: "CUDA" },
+                        { value: "mps", label: "Apple MPS" },
+                        { value: "cpu", label: "CPU" },
+                      ],
+                      settings.hydra_hf_transformers_device || "auto"
+                    )}
+                  </select>
+                  <div class="small hydra-context-hint">Auto chooses CUDA, then Apple MPS, then CPU.</div>
+                </label>
+                <label class="hydra-context-field" data-hydra-provider-field="hf_transformers">Precision
+                  <select id="set_hydra_hf_transformers_dtype">
+                    ${renderChoiceOptions(
+                      [
+                        { value: "auto", label: "Auto" },
+                        { value: "float16", label: "Float16" },
+                        { value: "bfloat16", label: "BFloat16" },
+                        { value: "float32", label: "Float32" },
+                      ],
+                      settings.hydra_hf_transformers_dtype || "auto"
+                    )}
+                  </select>
+                  <div class="small hydra-context-hint">Auto lets Transformers choose the model dtype.</div>
+                </label>
+                <label class="hydra-context-field" data-hydra-provider-field="hf_transformers">Device Map
+                  <select id="set_hydra_hf_transformers_device_map">
+                    ${renderChoiceOptions(
+                      [
+                        { value: "default", label: "Default" },
+                        { value: "disabled", label: "Disabled" },
+                        { value: "auto", label: "Auto" },
+                        { value: "balanced", label: "Balanced" },
+                      ],
+                      settings.hydra_hf_transformers_device_map || "default"
+                    )}
+                  </select>
+                  <div class="small hydra-context-hint">Default uses automatic mapping on CUDA and direct device load elsewhere.</div>
+                </label>
+                <label class="hydra-context-field" data-hydra-provider-field="hf_transformers">Attention
+                  <select id="set_hydra_hf_transformers_attn_implementation">
+                    ${renderChoiceOptions(
+                      [
+                        { value: "auto", label: "Auto" },
+                        { value: "sdpa", label: "SDPA" },
+                        { value: "flash_attention_2", label: "Flash Attention 2" },
+                        { value: "eager", label: "Eager" },
+                      ],
+                      settings.hydra_hf_transformers_attn_implementation || "auto"
+                    )}
+                  </select>
+                  <div class="small hydra-context-hint">Uses Transformers attention implementation support when available.</div>
+                </label>
+                <label class="hydra-context-field" data-hydra-provider-field="hf_transformers">Trust Remote Code
+                  ${renderToggleRow(
+                    `<input id="set_hydra_hf_transformers_trust_remote_code" class="toggle-input" type="checkbox" ${
+                      settings.hydra_hf_transformers_trust_remote_code ? "checked" : ""
+                    } />`,
+                    "Enable"
+                  )}
+                  <div class="small hydra-context-hint">Allows custom model code from the selected repository.</div>
+                </label>
                 <label class="hydra-context-field" data-hydra-provider-field="llama_cpp">Context Length
                   <div class="hydra-context-control" data-hydra-context-control="llama_cpp">
                     <input id="set_hydra_llama_cpp_context_tokens_range" type="range" min="256" max="262144" step="256" value="${escapeHtml(
@@ -16660,6 +17032,46 @@ async function loadSettingsView() {
                   <div id="hydra-llama-context-hint" class="small hydra-context-hint"></div>
                   <div id="hydra-llama-context-estimate" class="hydra-context-estimate" data-hydra-context-estimate="llama_cpp"></div>
                 </label>
+                <label class="hydra-context-field" data-hydra-provider-field="llama_cpp">Eval Batch Size
+                  <div class="hydra-context-control hydra-llama-perf-control">
+                    <input id="set_hydra_llama_cpp_n_batch_range" type="range" min="32" max="8192" step="32" value="${escapeHtml(
+                      settings.hydra_llama_cpp_n_batch || "512"
+                    )}" />
+                    <input id="set_hydra_llama_cpp_n_batch" type="number" min="32" max="8192" step="32" value="${escapeHtml(
+                      settings.hydra_llama_cpp_n_batch || "512"
+                    )}" />
+                  </div>
+                  <div class="small hydra-context-hint">Higher values can improve prompt processing when memory allows.</div>
+                </label>
+                <label class="hydra-context-field" data-hydra-provider-field="llama_cpp">Micro-Batch Size
+                  <div class="hydra-context-control hydra-llama-perf-control">
+                    <input id="set_hydra_llama_cpp_n_ubatch_range" type="range" min="0" max="8192" step="32" value="${escapeHtml(
+                      settings.hydra_llama_cpp_n_ubatch || "0"
+                    )}" />
+                    <input id="set_hydra_llama_cpp_n_ubatch" type="number" min="0" max="8192" step="32" value="${escapeHtml(
+                      settings.hydra_llama_cpp_n_ubatch || "0"
+                    )}" />
+                  </div>
+                  <div class="small hydra-context-hint">0 lets llama.cpp use its default, usually matching the eval batch size.</div>
+                </label>
+                <label class="hydra-context-field" data-hydra-provider-field="llama_cpp">Flash Attention
+                  ${renderToggleRow(
+                    `<input id="set_hydra_llama_cpp_flash_attn" class="toggle-input" type="checkbox" ${
+                      settings.hydra_llama_cpp_flash_attn ? "checked" : ""
+                    } />`,
+                    "Enable"
+                  )}
+                  <div class="small hydra-context-hint">Optimizes attention computation when supported by the backend and model.</div>
+                </label>
+                <label class="hydra-context-field" data-hydra-provider-field="llama_cpp">GPU KV Offload
+                  ${renderToggleRow(
+                    `<input id="set_hydra_llama_cpp_offload_kqv" class="toggle-input" type="checkbox" ${
+                      settings.hydra_llama_cpp_offload_kqv !== false ? "checked" : ""
+                    } />`,
+                    "Enable"
+                  )}
+                  <div class="small hydra-context-hint">Keeps attention/KV work on the GPU when llama.cpp supports it.</div>
+                </label>
                 <label class="hydra-context-field" data-hydra-provider-field="llama_cpp">Multi-Token Prediction
                   ${renderToggleRow(
                     `<input id="set_hydra_llama_cpp_mtp_enabled" class="toggle-input" type="checkbox" ${
@@ -16691,6 +17103,66 @@ async function loadSettingsView() {
                   <div id="hydra-mlx-context-hint" class="small hydra-context-hint"></div>
                   <div id="hydra-mlx-context-estimate" class="hydra-context-estimate" data-hydra-context-estimate="mlx_lm"></div>
                 </label>
+                <label class="hydra-context-field" data-hydra-provider-field="mlx_lm">Lazy Load
+                  ${renderToggleRow(
+                    `<input id="set_hydra_mlx_lm_lazy_load" class="toggle-input" type="checkbox" ${
+                      settings.hydra_mlx_lm_lazy_load ? "checked" : ""
+                    } />`,
+                    "Enable"
+                  )}
+                  <div class="small hydra-context-hint">Defers some MLX weight materialization during model load.</div>
+                </label>
+                <label class="hydra-context-field" data-hydra-provider-field="mlx_lm">Trust Remote Code
+                  ${renderToggleRow(
+                    `<input id="set_hydra_mlx_lm_trust_remote_code" class="toggle-input" type="checkbox" ${
+                      settings.hydra_mlx_lm_trust_remote_code ? "checked" : ""
+                    } />`,
+                    "Enable"
+                  )}
+                  <div class="small hydra-context-hint">Allows custom tokenizer/config code from the selected repository.</div>
+                </label>
+                <label class="hydra-context-field" data-hydra-provider-field="mlx_lm">Prefill Step Size
+                  <input id="set_hydra_mlx_engine_prefill_step_size" type="number" min="1" max="32768" step="1" placeholder="Auto" value="${escapeHtml(
+                    settings.hydra_mlx_engine_prefill_step_size || ""
+                  )}" />
+                  <div class="small hydra-context-hint">Blank lets the MLX runtime choose the prompt prefill chunk size.</div>
+                </label>
+                <label class="hydra-context-field" data-hydra-provider-field="mlx_lm">Quantized KV Bits
+                  <select id="set_hydra_mlx_engine_kv_bits">
+                    ${renderChoiceOptions(
+                      [
+                        { value: "", label: "Auto" },
+                        { value: "2", label: "2-bit" },
+                        { value: "3", label: "3-bit" },
+                        { value: "4", label: "4-bit" },
+                        { value: "6", label: "6-bit" },
+                        { value: "8", label: "8-bit" },
+                      ],
+                      settings.hydra_mlx_engine_kv_bits || ""
+                    )}
+                  </select>
+                  <div class="small hydra-context-hint">Optional KV cache quantization for lower memory use.</div>
+                </label>
+                <label class="hydra-context-field" data-hydra-provider-field="mlx_lm">KV Group Size
+                  <select id="set_hydra_mlx_engine_kv_group_size">
+                    ${renderChoiceOptions(
+                      [
+                        { value: "", label: "Auto" },
+                        { value: "32", label: "32" },
+                        { value: "64", label: "64" },
+                        { value: "128", label: "128" },
+                      ],
+                      settings.hydra_mlx_engine_kv_group_size || ""
+                    )}
+                  </select>
+                  <div class="small hydra-context-hint">Blank uses the MLX runtime default.</div>
+                </label>
+                <label class="hydra-context-field" data-hydra-provider-field="mlx_lm">Quantized KV Start
+                  <input id="set_hydra_mlx_engine_quantized_kv_start" type="number" min="0" max="1048576" step="1" placeholder="Auto" value="${escapeHtml(
+                    settings.hydra_mlx_engine_quantized_kv_start || ""
+                  )}" />
+                  <div class="small hydra-context-hint">Token index where quantized KV begins. Blank uses the runtime default.</div>
+                </label>
                 <label id="hydra-base-api-key-wrap" data-hydra-provider-field="openai_compatible" style="grid-column: 1 / -1;">API Key (optional)
                   <input id="set_hydra_llm_api_key" type="password" autocomplete="new-password" value="${escapeHtml(
                     hydraPrimaryBaseRow.api_key || ""
@@ -17661,6 +18133,8 @@ async function loadSettingsView() {
       if (["speakerid", "emotionid"].includes(activeModelsPanel)) {
         void ensureEspHomeRuntimeLoaded({ force: true, panel: activeModelsPanel });
       }
+    } else {
+      clearLlmDebugPollTimer();
     }
   };
 
@@ -17819,6 +18293,8 @@ async function loadSettingsView() {
   const hydraBaseModelSelectEl = document.getElementById("set_hydra_llm_model_select");
   const hydraBaseModelLabelEl = document.getElementById("hydra-base-model-label");
   const hydraLocalModelStatusEl = document.getElementById("hydra-local-model-status");
+  const llamaChatTemplateEditEl = document.getElementById("settings-llama-chat-template-edit");
+  const llamaChatTemplateStatusEl = document.getElementById("settings-llama-chat-template-status");
   const contextControlConfig = {
     hf_transformers: {
       min: 256,
@@ -18034,6 +18510,42 @@ async function loadSettingsView() {
   llamaCppMtpDraftNumberEl?.addEventListener("input", () => syncLlamaCppMtpDraftControl(llamaCppMtpDraftNumberEl));
   llamaCppMtpDraftNumberEl?.addEventListener("blur", () => syncLlamaCppMtpDraftControl(llamaCppMtpDraftNumberEl));
   syncLlamaCppMtpDraftControl();
+  const syncPairedIntegerControl = ({ rangeEl, numberEl, fallback = 0, min = 0, max = 8192, step = 1 }) => {
+    if (!rangeEl || !numberEl) {
+      return;
+    }
+    const applyValue = (sourceEl = null) => {
+      const raw = Number(sourceEl?.value || numberEl.value || rangeEl.value || fallback);
+      let value = Number.isFinite(raw) ? Math.round(raw) : fallback;
+      value = Math.max(min, Math.min(max, value));
+      if (step > 1 && value > min) {
+        value = Math.round(value / step) * step;
+        value = Math.max(min, Math.min(max, value));
+      }
+      rangeEl.value = String(value);
+      numberEl.value = String(value);
+    };
+    rangeEl.addEventListener("input", () => applyValue(rangeEl));
+    numberEl.addEventListener("input", () => applyValue(numberEl));
+    numberEl.addEventListener("blur", () => applyValue(numberEl));
+    applyValue();
+  };
+  syncPairedIntegerControl({
+    rangeEl: document.getElementById("set_hydra_llama_cpp_n_batch_range"),
+    numberEl: document.getElementById("set_hydra_llama_cpp_n_batch"),
+    fallback: 512,
+    min: 32,
+    max: 8192,
+    step: 32,
+  });
+  syncPairedIntegerControl({
+    rangeEl: document.getElementById("set_hydra_llama_cpp_n_ubatch_range"),
+    numberEl: document.getElementById("set_hydra_llama_cpp_n_ubatch"),
+    fallback: 0,
+    min: 0,
+    max: 8192,
+    step: 32,
+  });
   const normalizeHydraBaseRowInput = (row) => ({
     provider: normalizeHydraBaseProvider(row?.provider || ""),
     host: String(row?.host || "").trim(),
@@ -18133,6 +18645,22 @@ async function loadSettingsView() {
     }
     return String(hydraBaseModelEl?.value || "").trim();
   };
+  const syncLlamaChatTemplateTools = () => {
+    const provider = normalizeHydraBaseProvider(hydraBaseProviderEl?.value || "");
+    const local = isHydraLocalProvider(provider);
+    const model = local ? getHydraBaseModelValue() : "";
+    if (llamaChatTemplateEditEl) {
+      llamaChatTemplateEditEl.disabled = !model;
+    }
+    if (llamaChatTemplateStatusEl) {
+      const providerLabel = provider === "llama_cpp" ? "GGUF" : provider === "mlx_lm" ? "MLX" : "Transformers";
+      llamaChatTemplateStatusEl.textContent = !local
+        ? ""
+        : model
+          ? `Per-model ${providerLabel} template override.`
+          : `Select a downloaded ${providerLabel} model first.`;
+    }
+  };
   const refreshLocalLlmModels = async ({ selectModel = "", provider = "" } = {}) => {
     try {
       localLlmModelsPayload = await api("/api/settings/local-llm/models", { _timeoutMs: HEALTH_REQUEST_TIMEOUT_MS });
@@ -18195,6 +18723,7 @@ async function loadSettingsView() {
     syncHydraProviderScopedFields(hydraBaseFieldsEl, provider);
     syncHydraModelInputForProvider(hydraBaseModelEl, hydraBaseModelLabelEl, provider);
     syncHydraPrimaryModelControl(provider);
+    syncLlamaChatTemplateTools();
   };
   const hydraRouteControls = [];
   const syncHydraRouteControl = (control, preferredModel = "") => {
@@ -18492,6 +19021,17 @@ async function loadSettingsView() {
     syncActiveHydraContextControl();
     renderHydraContextEstimateCards();
     syncVisionLlamaContextControl();
+    syncLlamaChatTemplateTools();
+  });
+  llamaChatTemplateEditEl?.addEventListener("click", () => {
+    const provider = normalizeHydraBaseProvider(hydraBaseProviderEl?.value || "");
+    const model = getHydraBaseModelValue();
+    void openLocalLlmChatTemplateModal(provider, model, {
+      onSaved: () => {
+        void refreshLocalLlmModels({ provider, selectModel: model });
+        syncLlamaChatTemplateTools();
+      },
+    });
   });
   syncHydraPrimaryProviderFields();
   if (state.hydraContextEstimateRuntimeListener) {
@@ -18545,11 +19085,18 @@ async function loadSettingsView() {
   const localModelManagerStatusEl = document.getElementById("local-model-manager-status");
   const localModelManagerListEl = document.getElementById("local-model-manager-list");
   const localModelManagerRefreshEl = document.getElementById("local-model-manager-refresh");
+  const llmDebugConsoleEl = document.getElementById("settings-llm-debug-console");
+  const llmDebugStatusEl = document.getElementById("llm-debug-status");
+  const llmDebugActiveEl = document.getElementById("llm-debug-active");
+  const llmDebugEventsEl = document.getElementById("llm-debug-events");
+  const llmDebugRefreshEl = document.getElementById("llm-debug-refresh");
+  const llmDebugAutoscrollEl = document.getElementById("llm-debug-autoscroll");
+  const llmDebugClearEl = document.getElementById("llm-debug-clear");
   const hfModelBrowserViewButtons = Array.from(root.querySelectorAll("[data-hf-model-view]"));
   const hfModelBrowserState = {
     provider: isHydraLocalProvider(hydraPrimaryBaseRow.provider) ? hydraPrimaryBaseRow.provider : "hf_transformers",
     task: "text-generation",
-    view: "trending",
+    view: "picks",
     query: "",
     loaded: false,
     loadingSeq: 0,
@@ -18575,6 +19122,9 @@ async function loadSettingsView() {
   const hfModelTaskLabel = (task) => normalizeHfModelTask(task) === "image-text-to-text" ? "vision" : "text";
   const normalizeHfModelView = (value) => {
     const token = String(value || "trending").trim().toLowerCase().replace(/_/g, "-");
+    if (["picks", "tater", "tater-picks", "recommended"].includes(token)) {
+      return "picks";
+    }
     if (token === "new" || token === "recent" || token === "latest") {
       return "new";
     }
@@ -18585,6 +19135,9 @@ async function loadSettingsView() {
   };
   const hfModelViewLabel = (value) => {
     const view = normalizeHfModelView(value);
+    if (view === "picks") {
+      return "Tater Picks";
+    }
     if (view === "new") {
       return "new";
     }
@@ -18681,6 +19234,7 @@ async function loadSettingsView() {
             </div>
             ${pathLabel ? `<div class="local-model-path">${escapeHtml(pathLabel)}</div>` : ""}
             <div class="local-model-actions">
+              <button type="button" class="inline-btn" data-local-model-template data-provider="${escapeHtml(row.provider)}" data-model="${escapeHtml(row.model)}">Chat Template</button>
               <button type="button" class="inline-btn danger" data-local-model-delete data-provider="${escapeHtml(row.provider)}" data-model="${escapeHtml(row.model)}">Delete</button>
             </div>
           </article>
@@ -18801,20 +19355,24 @@ async function loadSettingsView() {
         const library = String(model?.library_name || model?.pipeline_tag || "").trim();
         const compatible = Boolean(model?.compatible);
         const supportsVision = Boolean(model?.supports_vision) || normalizeHfModelTask(model?.task) === "image-text-to-text" || normalizeHfModelTask(hfModelBrowserState.task) === "image-text-to-text";
+        const isTaterPick = Boolean(model?.tater_pick);
+        const taterPickLabel = String(model?.tater_pick_label || "Tater Pick").trim();
+        const taterPickNote = String(model?.tater_pick_note || "").trim();
         const isMlxProvider = provider === "mlx_lm";
         const downloadLabel = isMlxProvider ? "Download Repo" : "Download";
         return `
-          <article class="hf-model-card ${compatible ? "" : "is-uncertain"}" role="button" tabindex="0" aria-label="Show files for ${escapeHtml(id)}" data-hf-model-card data-provider="${escapeHtml(provider)}" data-repo-id="${escapeHtml(id)}">
+          <article class="hf-model-card ${compatible ? "" : "is-uncertain"} ${isTaterPick ? "is-tater-pick" : ""}" role="button" tabindex="0" aria-label="Show files for ${escapeHtml(id)}" data-hf-model-card data-provider="${escapeHtml(provider)}" data-repo-id="${escapeHtml(id)}">
             <div class="hf-model-card-head">
               <div>
                 <strong>${escapeHtml(id)}</strong>
                 <span>${escapeHtml(library || hfModelProviderLabel(provider))}</span>
               </div>
-              <span class="hf-model-provider-pill">${escapeHtml(hfModelProviderLabel(provider))}</span>
+              <span class="${isTaterPick ? "hf-model-tater-pill" : "hf-model-provider-pill"}">${escapeHtml(isTaterPick ? taterPickLabel : hfModelProviderLabel(provider))}</span>
             </div>
             <div class="hf-model-card-meta">
               ${modelSize ? `<span class="hf-model-size-pill">${escapeHtml(modelSize)}</span>` : ""}
               ${supportsVision ? `<span class="hf-model-vision-pill" title="Supports vision models">Vision</span>` : ""}
+              ${isTaterPick && taterPickNote ? `<span class="hf-model-pick-note">${escapeHtml(taterPickNote)}</span>` : ""}
               <span>${escapeHtml(downloads)} downloads</span>
               <span>${escapeHtml(likes)} likes</span>
               ${updated ? `<span>${escapeHtml(updated)}</span>` : ""}
@@ -18922,7 +19480,13 @@ async function loadSettingsView() {
     hfModelBrowserState.provider = provider;
     hfModelBrowserState.task = task;
     hfModelBrowserState.query = query;
-    setHfModelBrowserStatus(`Loading ${hfModelViewLabel(hfModelBrowserState.view)} ${hfModelProviderLabel(provider)} ${hfModelTaskLabel(task)} models page ${hfModelBrowserState.pageIndex + 1}...`);
+    const viewLabel = hfModelViewLabel(hfModelBrowserState.view);
+    const viewIsPicks = normalizeHfModelView(hfModelBrowserState.view) === "picks";
+    setHfModelBrowserStatus(
+      viewIsPicks
+        ? `Loading ${viewLabel} ${hfModelProviderLabel(provider)} ${hfModelTaskLabel(task)} models...`
+        : `Loading ${viewLabel} ${hfModelProviderLabel(provider)} ${hfModelTaskLabel(task)} models page ${hfModelBrowserState.pageIndex + 1}...`
+    );
     if (hfModelBrowserResultsEl) {
       hfModelBrowserResultsEl.innerHTML = `<div class="hf-model-browser-empty">Loading models...</div>`;
     }
@@ -18949,7 +19513,12 @@ async function loadSettingsView() {
       }
       renderHfModelCards(payload?.models || []);
       renderHfModelBrowserPagination();
-      setHfModelBrowserStatus(`Page ${hfModelBrowserState.pageIndex + 1}: ${(payload?.models || []).length} models loaded.`, "success");
+      setHfModelBrowserStatus(
+        viewIsPicks
+          ? `${(payload?.models || []).length} ${viewLabel} ${hfModelProviderLabel(provider)} model${(payload?.models || []).length === 1 ? "" : "s"} loaded.`
+          : `Page ${hfModelBrowserState.pageIndex + 1}: ${(payload?.models || []).length} models loaded.`,
+        "success"
+      );
     } catch (error) {
       if (seq !== hfModelBrowserState.loadingSeq) {
         return;
@@ -19096,15 +19665,210 @@ async function loadSettingsView() {
       showToast(`Model delete failed: ${error.message}`, "error", 3600);
     }
   };
+  const llmDebugTimeLabel = (value) => {
+    const seconds = Number(value || 0);
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+      return "--:--";
+    }
+    try {
+      return new Date(seconds * 1000).toLocaleTimeString([], { hour: "numeric", minute: "2-digit", second: "2-digit" });
+    } catch {
+      return "--:--";
+    }
+  };
+  const llmDebugDurationLabel = (value) => {
+    const ms = Number(value || 0);
+    if (!Number.isFinite(ms) || ms <= 0) {
+      return "";
+    }
+    if (ms >= 1000) {
+      return `${(ms / 1000).toFixed(ms >= 10000 ? 1 : 2)}s`;
+    }
+    return `${Math.round(ms)}ms`;
+  };
+  const llmDebugTokenLabel = (event) => {
+    const promptTokens = Math.max(0, Number(event?.prompt_tokens || 0));
+    const completionTokens = Math.max(0, Number(event?.completion_tokens || 0));
+    const totalTokens = Math.max(0, Number(event?.total_tokens || 0));
+    const parts = [];
+    if (promptTokens > 0) {
+      parts.push(`in ${Math.round(promptTokens).toLocaleString()}`);
+    }
+    if (completionTokens > 0) {
+      parts.push(`out ${Math.round(completionTokens).toLocaleString()}`);
+    }
+    if (!parts.length && totalTokens > 0) {
+      parts.push(`${Math.round(totalTokens).toLocaleString()} tok`);
+    }
+    return parts.join(" / ");
+  };
+  const normalizeLlmDebugEvent = (row) => ({
+    id: Math.max(0, Number(row?.id || 0)),
+    ts: Number(row?.ts || row?.timestamp || 0),
+    level: String(row?.level || "info").trim().toLowerCase() || "info",
+    phase: String(row?.phase || "event").trim().toLowerCase() || "event",
+    message: String(row?.message || "").trim(),
+    detail: String(row?.detail || "").trim(),
+    output: String(row?.output || "").trim(),
+    provider: String(row?.provider || "").trim(),
+    host: String(row?.host || "").trim(),
+    model: String(row?.model || "").trim(),
+    activity: String(row?.activity || "").trim(),
+    source_label: String(row?.source_label || "").trim(),
+    source: String(row?.source || "").trim(),
+    kind: String(row?.kind || "").trim(),
+    call_id: String(row?.call_id || "").trim(),
+    prompt_tokens: Math.max(0, Number(row?.prompt_tokens || 0)),
+    completion_tokens: Math.max(0, Number(row?.completion_tokens || 0)),
+    total_tokens: Math.max(0, Number(row?.total_tokens || 0)),
+    duration_ms: Math.max(0, Number(row?.duration_ms || 0)),
+  });
+  const renderLlmDebugActiveCalls = (rows = []) => {
+    if (!llmDebugActiveEl) {
+      return;
+    }
+    const calls = Array.isArray(rows) ? rows : [];
+    if (!calls.length) {
+      llmDebugActiveEl.innerHTML = `<div class="llm-debug-active-empty">No active LLM calls.</div>`;
+      return;
+    }
+    llmDebugActiveEl.innerHTML = calls
+      .map((call) => {
+        const model = String(call?.model || "model").trim();
+        const source = String(call?.source_label || call?.source || "unknown").trim();
+        const activity = String(call?.activity || "llm").trim();
+        const age = Math.max(0, Number(call?.age_seconds || 0));
+        const host = String(call?.host || "").trim();
+        const messages = Math.max(0, Number(call?.message_count || 0));
+        return `
+          <div class="llm-debug-active-call">
+            <strong>${escapeHtml(activity)}</strong>
+            <span>${escapeHtml(model)}</span>
+            <small>${escapeHtml(source)}${host ? ` · ${escapeHtml(host)}` : ""} · ${messages} messages · ${Math.round(age)}s</small>
+          </div>
+        `;
+      })
+      .join("");
+  };
+  const renderLlmDebugEvents = () => {
+    if (!llmDebugEventsEl) {
+      return;
+    }
+    const rows = Array.isArray(state.llmDebugEvents) ? state.llmDebugEvents.slice(-220) : [];
+    if (!rows.length) {
+      llmDebugEventsEl.innerHTML = `<div class="llm-debug-empty">No LLM debug events yet.</div>`;
+      return;
+    }
+    const shouldScroll =
+      state.llmDebugAutoScroll &&
+      Math.abs(llmDebugEventsEl.scrollHeight - llmDebugEventsEl.clientHeight - llmDebugEventsEl.scrollTop) < 72;
+    llmDebugEventsEl.innerHTML = rows
+      .map((event) => {
+        const phase = event.phase || event.level || "event";
+        const meta = [
+          event.provider,
+          event.source_label || event.source,
+          event.activity,
+          event.model,
+          llmDebugTokenLabel(event),
+          llmDebugDurationLabel(event.duration_ms),
+        ].filter(Boolean);
+        return `
+          <article class="llm-debug-line ${escapeHtml(event.level)} phase-${escapeHtml(phase)}">
+            <span class="llm-debug-time">${escapeHtml(llmDebugTimeLabel(event.ts))}</span>
+            <span class="llm-debug-phase">${escapeHtml(phase.replace(/_/g, " "))}</span>
+            <div class="llm-debug-body">
+              <strong>${escapeHtml(event.message || phase)}</strong>
+              ${meta.length ? `<small>${escapeHtml(meta.join(" · "))}</small>` : ""}
+              ${event.detail ? `<pre>${escapeHtml(event.detail)}</pre>` : ""}
+              ${event.output ? `<pre class="llm-debug-output">${escapeHtml(event.output)}</pre>` : ""}
+            </div>
+          </article>
+        `;
+      })
+      .join("");
+    if (shouldScroll) {
+      llmDebugEventsEl.scrollTop = llmDebugEventsEl.scrollHeight;
+    }
+  };
+  const setLlmDebugStatus = (message, tone = "") => {
+    if (!llmDebugStatusEl) {
+      return;
+    }
+    llmDebugStatusEl.textContent = String(message || "");
+    llmDebugStatusEl.classList.toggle("error", tone === "error");
+    llmDebugStatusEl.classList.toggle("success", tone === "success");
+  };
+  const renderLlmDebugSnapshot = (payload = {}, { reset = false } = {}) => {
+    state.llmDebugLastSnapshot = payload && typeof payload === "object" ? payload : {};
+    const events = Array.isArray(payload?.events) ? payload.events.map((row) => normalizeLlmDebugEvent(row)).filter((row) => row.id > 0) : [];
+    if (reset) {
+      state.llmDebugEvents = events;
+    } else if (events.length) {
+      const merged = new Map((Array.isArray(state.llmDebugEvents) ? state.llmDebugEvents : []).map((row) => [Number(row.id), row]));
+      events.forEach((event) => merged.set(Number(event.id), event));
+      state.llmDebugEvents = Array.from(merged.values()).sort((a, b) => Number(a.id) - Number(b.id)).slice(-260);
+    }
+    state.llmDebugNextId = Math.max(Number(state.llmDebugNextId || 0), Number(payload?.next_id || 0));
+    renderLlmDebugActiveCalls(Array.isArray(payload?.active_calls) ? payload.active_calls : []);
+    renderLlmDebugEvents();
+    const activeTotal = Number(payload?.summary?.active_total ?? (payload?.active_calls || []).length ?? 0);
+    const eventCount = Array.isArray(state.llmDebugEvents) ? state.llmDebugEvents.length : 0;
+    setLlmDebugStatus(`${Math.max(0, activeTotal)} active LLM call${activeTotal === 1 ? "" : "s"} · ${eventCount} visible event${eventCount === 1 ? "" : "s"}`, "success");
+  };
+  const updateLlmDebugAutoscrollButton = () => {
+    if (llmDebugAutoscrollEl) {
+      llmDebugAutoscrollEl.textContent = state.llmDebugAutoScroll ? "Auto-scroll On" : "Auto-scroll Off";
+      llmDebugAutoscrollEl.classList.toggle("active", Boolean(state.llmDebugAutoScroll));
+    }
+  };
+  const refreshLlmDebugConsole = async ({ reset = false } = {}) => {
+    if (
+      !llmDebugConsoleEl ||
+      !document.body.contains(llmDebugConsoleEl) ||
+      document.body.dataset.view !== "settings" ||
+      state.llmDebugInFlight
+    ) {
+      return;
+    }
+    state.llmDebugInFlight = true;
+    try {
+      const sinceId = reset ? 0 : Math.max(0, Number(state.llmDebugNextId || 0));
+      const params = new URLSearchParams({ since_id: String(sinceId), limit: "220" });
+      const payload = await api(`/api/runtime/llm/debug?${params.toString()}`, { _skipRedisRecovery: true, _timeoutMs: HEALTH_REQUEST_TIMEOUT_MS });
+      renderLlmDebugSnapshot(payload, { reset });
+    } catch (error) {
+      setLlmDebugStatus(`Debug refresh failed: ${error.message}`, "error");
+    } finally {
+      state.llmDebugInFlight = false;
+    }
+  };
+  const scheduleLlmDebugPoll = (delayMs = 1200) => {
+    clearLlmDebugPollTimer();
+    if (
+      !llmDebugConsoleEl ||
+      !document.body.contains(llmDebugConsoleEl) ||
+      document.body.dataset.view !== "settings" ||
+      llmDebugConsoleEl.hidden
+    ) {
+      return;
+    }
+    state.llmDebugPollTimer = window.setTimeout(async () => {
+      state.llmDebugPollTimer = 0;
+      await refreshLlmDebugConsole();
+      scheduleLlmDebugPoll(1200);
+    }, Math.max(250, Number(delayMs || 1200)));
+  };
   const activateLlmVisionTab = (tab) => {
     const normalized = String(tab || "settings").trim() || "settings";
     const browserActive = normalized === "huggingface";
     const manageActive = normalized === "manage";
+    const debugActive = normalized === "debug";
     llmVisionTabButtons.forEach((button) => {
       button.classList.toggle("active", String(button.dataset.llmVisionTab || "") === normalized);
     });
     root.querySelectorAll(".llm-vision-settings-block").forEach((block) => {
-      block.classList.toggle("llm-vision-hidden", browserActive || manageActive);
+      block.classList.toggle("llm-vision-hidden", browserActive || manageActive || debugActive);
     });
     if (hfModelBrowserEl) {
       hfModelBrowserEl.hidden = !browserActive;
@@ -19114,6 +19878,13 @@ async function loadSettingsView() {
       localModelManagerEl.hidden = !manageActive;
       localModelManagerEl.classList.toggle("active", manageActive);
     }
+    if (llmDebugConsoleEl) {
+      llmDebugConsoleEl.hidden = !debugActive;
+      llmDebugConsoleEl.classList.toggle("active", debugActive);
+    }
+    if (!debugActive) {
+      clearLlmDebugPollTimer();
+    }
     if (browserActive) {
       renderHfDownloadSummary(state.hfLlmWarmupLastSnapshot || {});
       scheduleHfLlmWarmupPoll(150);
@@ -19122,6 +19893,12 @@ async function loadSettingsView() {
       renderLocalModelManager();
       void refreshLocalLlmModels();
     }
+    if (debugActive) {
+      updateLlmDebugAutoscrollButton();
+      renderLlmDebugSnapshot(state.llmDebugLastSnapshot || {}, { reset: false });
+      void refreshLlmDebugConsole({ reset: state.llmDebugNextId <= 0 });
+      scheduleLlmDebugPoll(800);
+    }
     if (browserActive && !hfModelBrowserState.loaded) {
       if (hfModelBrowserProviderEl) {
         hfModelBrowserProviderEl.value = isHydraLocalProvider(hydraBaseProviderEl?.value || "")
@@ -19134,6 +19911,23 @@ async function loadSettingsView() {
   llmVisionTabButtons.forEach((button) => {
     button.addEventListener("click", () => activateLlmVisionTab(button.dataset.llmVisionTab || "settings"));
   });
+  llmDebugRefreshEl?.addEventListener("click", () => {
+    void refreshLlmDebugConsole({ reset: true });
+    scheduleLlmDebugPoll(1000);
+  });
+  llmDebugAutoscrollEl?.addEventListener("click", () => {
+    state.llmDebugAutoScroll = !state.llmDebugAutoScroll;
+    safeStorageSet("tater_llm_debug_auto_scroll", state.llmDebugAutoScroll ? "true" : "false");
+    updateLlmDebugAutoscrollButton();
+    if (state.llmDebugAutoScroll && llmDebugEventsEl) {
+      llmDebugEventsEl.scrollTop = llmDebugEventsEl.scrollHeight;
+    }
+  });
+  llmDebugClearEl?.addEventListener("click", () => {
+    state.llmDebugEvents = [];
+    renderLlmDebugEvents();
+    setLlmDebugStatus("Debug view cleared. New events will continue to appear.");
+  });
   hfModelBrowserViewButtons.forEach((button) => {
     button.addEventListener("click", () => {
       hfModelBrowserState.view = normalizeHfModelView(button.dataset.hfModelView || "trending");
@@ -19270,6 +20064,20 @@ async function loadSettingsView() {
     void refreshLocalLlmModels();
   });
   localModelManagerListEl?.addEventListener("click", (event) => {
+    const templateButton = event.target instanceof Element ? event.target.closest("[data-local-model-template]") : null;
+    if (templateButton) {
+      const provider = normalizeHydraBaseProvider(templateButton.getAttribute("data-provider") || "");
+      const model = templateButton.getAttribute("data-model") || "";
+      if (isHydraLocalProvider(provider)) {
+        void openLocalLlmChatTemplateModal(provider, model, {
+          onSaved: () => {
+            void refreshLocalLlmModels({ provider, selectModel: model });
+            syncLlamaChatTemplateTools();
+          },
+        });
+      }
+      return;
+    }
     const button = event.target instanceof Element ? event.target.closest("[data-local-model-delete]") : null;
     if (!button) {
       return;
@@ -20682,10 +21490,25 @@ async function loadSettingsView() {
     const baseModel = getHydraBaseModelValue();
     const baseApiKey = String(document.getElementById("set_hydra_llm_api_key")?.value || "").trim();
     const hfTransformersContextTokens = String(document.getElementById("set_hydra_hf_transformers_context_tokens")?.value || "").trim();
+    const hfTransformersDevice = String(document.getElementById("set_hydra_hf_transformers_device")?.value || "auto").trim();
+    const hfTransformersDtype = String(document.getElementById("set_hydra_hf_transformers_dtype")?.value || "auto").trim();
+    const hfTransformersDeviceMap = String(document.getElementById("set_hydra_hf_transformers_device_map")?.value || "default").trim();
+    const hfTransformersAttnImplementation = String(document.getElementById("set_hydra_hf_transformers_attn_implementation")?.value || "auto").trim();
+    const hfTransformersTrustRemoteCode = Boolean(document.getElementById("set_hydra_hf_transformers_trust_remote_code")?.checked);
     const llamaCppContextTokens = String(document.getElementById("set_hydra_llama_cpp_context_tokens")?.value || "").trim();
     const llamaCppMtpEnabled = Boolean(document.getElementById("set_hydra_llama_cpp_mtp_enabled")?.checked);
     const llamaCppMtpDraftTokens = String(document.getElementById("set_hydra_llama_cpp_mtp_draft_tokens")?.value || "3").trim();
+    const llamaCppNBatch = String(document.getElementById("set_hydra_llama_cpp_n_batch")?.value || "512").trim();
+    const llamaCppNUbatch = String(document.getElementById("set_hydra_llama_cpp_n_ubatch")?.value || "0").trim();
+    const llamaCppFlashAttn = Boolean(document.getElementById("set_hydra_llama_cpp_flash_attn")?.checked);
+    const llamaCppOffloadKqv = Boolean(document.getElementById("set_hydra_llama_cpp_offload_kqv")?.checked);
     const mlxLmContextTokens = String(document.getElementById("set_hydra_mlx_lm_context_tokens")?.value || "").trim();
+    const mlxLmTrustRemoteCode = Boolean(document.getElementById("set_hydra_mlx_lm_trust_remote_code")?.checked);
+    const mlxLmLazyLoad = Boolean(document.getElementById("set_hydra_mlx_lm_lazy_load")?.checked);
+    const mlxEnginePrefillStepSize = String(document.getElementById("set_hydra_mlx_engine_prefill_step_size")?.value || "").trim();
+    const mlxEngineKvBits = String(document.getElementById("set_hydra_mlx_engine_kv_bits")?.value || "").trim();
+    const mlxEngineKvGroupSize = String(document.getElementById("set_hydra_mlx_engine_kv_group_size")?.value || "").trim();
+    const mlxEngineQuantizedKvStart = String(document.getElementById("set_hydra_mlx_engine_quantized_kv_start")?.value || "").trim();
     const additionalBaseRows = readHydraAdditionalBaseRows();
     const hydraBaseServersPayload = [
       normalizeHydraBaseRowInput({ provider: baseProvider, host: baseHost, port: basePort, model: baseModel, api_key: baseApiKey }),
@@ -20703,10 +21526,25 @@ async function loadSettingsView() {
         hydra_llm_model: baseModel,
         hydra_llm_api_key: baseApiKey,
         hydra_hf_transformers_context_tokens: hfTransformersContextTokens,
+        hydra_hf_transformers_device: hfTransformersDevice,
+        hydra_hf_transformers_dtype: hfTransformersDtype,
+        hydra_hf_transformers_device_map: hfTransformersDeviceMap,
+        hydra_hf_transformers_attn_implementation: hfTransformersAttnImplementation,
+        hydra_hf_transformers_trust_remote_code: hfTransformersTrustRemoteCode,
         hydra_llama_cpp_context_tokens: llamaCppContextTokens,
         hydra_llama_cpp_mtp_enabled: llamaCppMtpEnabled,
         hydra_llama_cpp_mtp_draft_tokens: llamaCppMtpDraftTokens,
+        hydra_llama_cpp_n_batch: llamaCppNBatch,
+        hydra_llama_cpp_n_ubatch: llamaCppNUbatch,
+        hydra_llama_cpp_flash_attn: llamaCppFlashAttn,
+        hydra_llama_cpp_offload_kqv: llamaCppOffloadKqv,
         hydra_mlx_lm_context_tokens: mlxLmContextTokens,
+        hydra_mlx_lm_trust_remote_code: mlxLmTrustRemoteCode,
+        hydra_mlx_lm_lazy_load: mlxLmLazyLoad,
+        hydra_mlx_engine_prefill_step_size: mlxEnginePrefillStepSize,
+        hydra_mlx_engine_kv_bits: mlxEngineKvBits,
+        hydra_mlx_engine_kv_group_size: mlxEngineKvGroupSize,
+        hydra_mlx_engine_quantized_kv_start: mlxEngineQuantizedKvStart,
         hydra_base_servers: hydraBaseServersPayload,
       },
     };
@@ -23371,6 +24209,9 @@ async function loadView(viewName) {
   if (state.view !== "spudex") {
     clearSpudexPollTimer();
   }
+  if (state.view !== "settings") {
+    clearLlmDebugPollTimer();
+  }
   document.body.dataset.view = String(viewName || "").trim().toLowerCase();
   setActiveNav(viewName);
   updateHeader();
@@ -23459,6 +24300,7 @@ window.addEventListener("beforeunload", () => {
   }
   clearDashboardRefreshTimer();
   clearSpudexPollTimer();
+  clearLlmDebugPollTimer();
   closeChatEventSource();
   stopAllChatJobPolling();
   stopRuntimeBreakdownPolling();

tater_reachy_standalone/vendor/tater_app/tateros_static/styles.css

@@ -2291,6 +2291,154 @@ body[data-popup-effect="melt"] .app-shell.sidebar-expanding .sidebar::after {
   min-width: 0;
 }
 
+.llm-debug-console-shell {
+  min-width: 0;
+}
+
+.llm-debug-hero {
+  grid-template-columns: auto minmax(0, 1fr) auto;
+}
+
+.llm-debug-actions {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  gap: 8px;
+}
+
+.llm-debug-actions .inline-btn.active {
+  border-color: rgba(214, 90, 31, 0.52);
+  background: rgba(214, 90, 31, 0.16);
+  color: var(--accent-soft);
+}
+
+.llm-debug-active {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+  gap: 8px;
+}
+
+.llm-debug-active-empty,
+.llm-debug-empty {
+  padding: 12px;
+  border: 1px solid var(--line-soft);
+  border-radius: 8px;
+  background: rgba(255, 255, 255, 0.035);
+  color: var(--text-muted);
+  font-size: 0.82rem;
+}
+
+.llm-debug-active-call {
+  display: grid;
+  gap: 3px;
+  min-width: 0;
+  padding: 10px;
+  border: 1px solid rgba(255, 151, 83, 0.22);
+  border-radius: 8px;
+  background:
+    linear-gradient(180deg, rgba(31, 32, 34, 0.98), rgba(20, 21, 23, 0.97)),
+    linear-gradient(135deg, rgba(214, 90, 31, 0.1), rgba(92, 155, 220, 0.06));
+}
+
+.llm-debug-active-call strong {
+  color: #f9efe7;
+  font-size: 0.86rem;
+  line-height: 1.2;
+}
+
+.llm-debug-active-call span,
+.llm-debug-active-call small {
+  min-width: 0;
+  overflow-wrap: anywhere;
+  color: #b8afa5;
+  font-size: 0.76rem;
+  line-height: 1.35;
+}
+
+.llm-debug-events {
+  max-height: min(58vh, 620px);
+  min-height: 360px;
+  overflow: auto;
+  border: 1px solid rgba(240, 131, 69, 0.2);
+  border-radius: 10px;
+  background:
+    linear-gradient(180deg, rgba(10, 11, 13, 0.96), rgba(8, 9, 11, 0.98)),
+    repeating-linear-gradient(0deg, rgba(255, 255, 255, 0.018) 0, rgba(255, 255, 255, 0.018) 1px, transparent 1px, transparent 24px);
+  box-shadow: var(--shadow-soft);
+  padding: 10px;
+  color: #e5e9e4;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
+  font-size: 0.78rem;
+  line-height: 1.45;
+}
+
+.llm-debug-line {
+  display: grid;
+  grid-template-columns: 88px 92px minmax(0, 1fr);
+  gap: 10px;
+  align-items: start;
+  padding: 7px 0;
+  border-bottom: 1px solid rgba(255, 255, 255, 0.04);
+}
+
+.llm-debug-time {
+  color: #8f9aa5;
+  white-space: nowrap;
+}
+
+.llm-debug-phase {
+  color: #f0a678;
+  font-weight: 900;
+  text-transform: lowercase;
+}
+
+.llm-debug-line.success .llm-debug-phase,
+.llm-debug-line.phase-output .llm-debug-phase {
+  color: #8ddfb1;
+}
+
+.llm-debug-line.warning .llm-debug-phase {
+  color: #ffd08a;
+}
+
+.llm-debug-line.error .llm-debug-phase {
+  color: #ff9b8e;
+}
+
+.llm-debug-body {
+  display: grid;
+  gap: 3px;
+  min-width: 0;
+}
+
+.llm-debug-body strong {
+  color: #f5efe7;
+  font-size: 0.8rem;
+  line-height: 1.35;
+}
+
+.llm-debug-body small {
+  color: #aeb8c2;
+  font-size: 0.72rem;
+  overflow-wrap: anywhere;
+}
+
+.llm-debug-body pre {
+  margin: 3px 0 0;
+  white-space: pre-wrap;
+  word-break: break-word;
+  color: #ccd5dc;
+  font: inherit;
+}
+
+.llm-debug-body .llm-debug-output {
+  padding: 8px;
+  border-left: 2px solid rgba(141, 223, 177, 0.55);
+  border-radius: 6px;
+  background: rgba(141, 223, 177, 0.07);
+  color: #e7f4ec;
+}
+
 .hf-model-card,
 .local-model-card,
 .hf-model-browser-detail {
@@ -2310,19 +2458,52 @@ body[data-popup-effect="melt"] .app-shell.sidebar-expanding .sidebar::after {
 
 .hf-model-card {
   cursor: pointer;
-  transition: border-color 0.16s ease, transform 0.16s ease, background 0.16s ease;
+  position: relative;
+  transition: border-color 0.16s ease, transform 0.16s ease, background 0.16s ease, box-shadow 0.16s ease;
 }
 
 .hf-model-card.is-uncertain {
   border-color: rgba(255, 255, 255, 0.075);
 }
 
+.hf-model-card.is-tater-pick {
+  border-color: rgba(255, 151, 83, 0.74);
+  background:
+    radial-gradient(circle at 8% 0%, rgba(255, 151, 83, 0.18), transparent 34%),
+    linear-gradient(180deg, rgba(37, 33, 29, 0.99), rgba(24, 23, 23, 0.98));
+  box-shadow:
+    0 0 0 1px rgba(255, 151, 83, 0.28),
+    0 0 24px rgba(255, 129, 55, 0.24),
+    0 12px 32px rgba(0, 0, 0, 0.38);
+}
+
+.hf-model-card.is-tater-pick::before {
+  content: "";
+  position: absolute;
+  inset: -2px;
+  z-index: -1;
+  border-radius: 10px;
+  background: linear-gradient(135deg, rgba(255, 151, 83, 0.42), rgba(255, 194, 104, 0.08), rgba(255, 151, 83, 0.28));
+  filter: blur(8px);
+  opacity: 0.72;
+  pointer-events: none;
+}
+
 .hf-model-card:hover,
 .hf-model-card:focus-visible {
   border-color: rgba(255, 151, 83, 0.38);
   background: linear-gradient(180deg, rgba(35, 34, 34, 0.98), rgba(24, 24, 25, 0.97));
 }
 
+.hf-model-card.is-tater-pick:hover,
+.hf-model-card.is-tater-pick:focus-visible {
+  border-color: rgba(255, 176, 102, 0.9);
+  box-shadow:
+    0 0 0 1px rgba(255, 151, 83, 0.34),
+    0 0 32px rgba(255, 129, 55, 0.34),
+    0 16px 36px rgba(0, 0, 0, 0.42);
+}
+
 .hf-model-card:focus-visible {
   outline: 2px solid rgba(255, 151, 83, 0.42);
   outline-offset: 2px;
@@ -2369,6 +2550,7 @@ body[data-popup-effect="melt"] .app-shell.sidebar-expanding .sidebar::after {
 }
 
 .hf-model-provider-pill,
+.hf-model-tater-pill,
 .hf-model-tags span {
   flex: 0 0 auto;
   border: 1px solid rgba(255, 151, 83, 0.24);
@@ -2383,6 +2565,14 @@ body[data-popup-effect="melt"] .app-shell.sidebar-expanding .sidebar::after {
   padding: 5px 8px;
 }
 
+.hf-model-tater-pill {
+  padding: 5px 9px;
+  border-color: rgba(255, 176, 102, 0.58);
+  background: linear-gradient(180deg, rgba(255, 151, 83, 0.24), rgba(255, 129, 55, 0.14));
+  color: #ffd2a8;
+  box-shadow: 0 0 14px rgba(255, 129, 55, 0.2);
+}
+
 .hf-model-card-meta {
   flex-wrap: wrap;
   color: #aaa198;
@@ -2408,6 +2598,11 @@ body[data-popup-effect="melt"] .app-shell.sidebar-expanding .sidebar::after {
   font-weight: 850;
 }
 
+.hf-model-pick-note {
+  color: #ffc086;
+  font-weight: 800;
+}
+
 .hf-model-tags {
   display: flex;
   flex-wrap: wrap;
@@ -2439,6 +2634,19 @@ body[data-popup-effect="melt"] .app-shell.sidebar-expanding .sidebar::after {
   justify-content: flex-end;
 }
 
+.hydra-chat-template-tools {
+  display: flex;
+  grid-column: 1 / -1;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 8px;
+  min-width: 0;
+}
+
+.hydra-chat-template-tools .small {
+  color: #a99f95;
+}
+
 .local-model-path {
   overflow-wrap: anywhere;
   border: 1px solid rgba(255, 255, 255, 0.06);
@@ -2733,6 +2941,110 @@ body[data-popup-effect="melt"] .app-shell.sidebar-expanding .sidebar::after {
   font-size: 0.68rem;
 }
 
+.llama-chat-template-dialog {
+  width: min(980px, 96vw);
+  border-color: rgba(240, 131, 69, 0.18);
+  background:
+    linear-gradient(180deg, rgba(28, 29, 30, 0.98), rgba(18, 19, 20, 0.985)),
+    radial-gradient(circle at top left, rgba(240, 131, 69, 0.1), transparent 42%);
+}
+
+.llama-chat-template-body {
+  display: grid;
+  gap: 12px;
+}
+
+.llama-chat-template-summary {
+  display: grid;
+  gap: 8px;
+  padding: 10px;
+  border: 1px solid rgba(255, 151, 83, 0.14);
+  border-radius: 8px;
+  background: rgba(0, 0, 0, 0.18);
+}
+
+.llama-chat-template-summary-row {
+  display: grid;
+  gap: 3px;
+}
+
+.llama-chat-template-summary-row strong {
+  color: #f5e9dc;
+  font-size: 0.88rem;
+  line-height: 1.25;
+}
+
+.llama-chat-template-summary-row span {
+  overflow-wrap: anywhere;
+  color: #a99f95;
+  font-size: 0.74rem;
+}
+
+.llama-chat-template-badges,
+.llama-chat-template-meta,
+.llama-chat-template-actions {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 7px;
+}
+
+.llama-template-badge,
+.llama-chat-template-meta span {
+  border: 1px solid rgba(255, 255, 255, 0.07);
+  border-radius: 999px;
+  background: rgba(255, 255, 255, 0.035);
+  color: #a99f95;
+  font-size: 0.7rem;
+  font-weight: 750;
+  line-height: 1.2;
+  padding: 4px 8px;
+}
+
+.llama-template-badge.active {
+  border-color: rgba(103, 204, 138, 0.28);
+  background: rgba(78, 188, 132, 0.12);
+  color: #a9edc4;
+}
+
+.llama-chat-template-editor {
+  width: 100%;
+  min-height: 360px;
+  max-height: min(56vh, 640px);
+  resize: vertical;
+  border: 1px solid rgba(255, 255, 255, 0.08);
+  border-radius: 8px;
+  background: rgba(4, 5, 7, 0.5);
+  color: #efe6dc;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 0.78rem;
+  line-height: 1.45;
+  padding: 11px;
+}
+
+.llama-chat-template-editor:focus {
+  border-color: rgba(255, 151, 83, 0.42);
+  outline: none;
+  box-shadow: 0 0 0 2px rgba(255, 151, 83, 0.12);
+}
+
+.llama-chat-template-actions {
+  justify-content: flex-end;
+}
+
+.llama-chat-template-status {
+  min-height: 1.2em;
+  color: #a99f95;
+}
+
+.llama-chat-template-status.success {
+  color: #a9edc4;
+}
+
+.llama-chat-template-status.error {
+  color: #ffb2a8;
+}
+
 .hf-model-browser-empty {
   grid-column: 1 / -1;
   padding: 12px;
@@ -2770,6 +3082,18 @@ body[data-popup-effect="melt"] .app-shell.sidebar-expanding .sidebar::after {
     grid-template-columns: 1fr;
   }
 
+  .llm-debug-actions {
+    justify-content: flex-start;
+  }
+
+  .llm-debug-line {
+    grid-template-columns: 72px minmax(0, 1fr);
+  }
+
+  .llm-debug-body {
+    grid-column: 1 / -1;
+  }
+
   .hf-download-summary {
     grid-template-columns: auto minmax(0, 1fr);
   }

tater_voice_sat/__init__.py

@@ -1,4 +1,3 @@
 """Tater voice satellite for Reachy."""
 
-__version__ = "0.1.0"
-
+__version__ = "0.1.1"

tater_voice_sat/sdk_app.py

@@ -210,8 +210,8 @@ def _resolve_app_config_path(config_path: str) -> Path:
 
     runtime_dir = Path.home() / ".tater_voice_sat"
     runtime_config = runtime_dir / requested.name
-    if not runtime_config.exists():
-        _seed_runtime_assets(runtime_dir)
+    _seed_runtime_assets(runtime_dir)
+    _migrate_default_wake_word(runtime_config)
     return runtime_config.resolve()
 
 
@@ -253,5 +253,28 @@ def _merge_wake_word_entries(*entry_groups: Any) -> list[dict[str, str]]:
     return list(merged.values())
 
 
+def _migrate_default_wake_word(config_path: Path) -> None:
+    try:
+        text = config_path.read_text(encoding="utf-8")
+    except OSError:
+        return
+    old_markers = (
+        'wake_word = "hey tater"',
+        'model = "hey_tater"',
+        'model_config = "./wakewords/hey_tater.json"',
+    )
+    if not all(marker in text for marker in old_markers):
+        return
+    updated = text
+    updated = updated.replace('wake_word = "hey tater"', 'wake_word = "hey reachy"', 1)
+    updated = updated.replace('model = "hey_tater"', 'model = "hey_reachy"', 1)
+    updated = updated.replace('model_config = "./wakewords/hey_tater.json"', 'model_config = "./wakewords/hey_reachy.json"', 1)
+    updated = updated.replace("threshold = 0.70", "threshold = 0.81", 1)
+    if updated == text:
+        return
+    config_path.write_text(updated, encoding="utf-8")
+    logger.info("migrated default wake word to hey_reachy")
+
+
 if __name__ == "__main__":
     main()