ltcai 5.1.0 → 5.2.0

package/latticeai/services/model_catalog.py

@@ -1,12 +1,12 @@
 """Static local-model catalog, engine installers, and family-version filtering.
 
-Extracted from :mod:`latticeai.services.model_runtime` so the runtime module
-owns model lifecycle/loading logic while this module owns the behaviour-free
-catalog data (engine installers, the per-engine model catalog, cross-engine
-aliases) and the pure version-dedup helpers. Re-exported by ``model_runtime``
-for backward compatibility, so existing imports such as
-``from latticeai.services.model_runtime import ENGINE_MODEL_CATALOG`` keep
-working unchanged.
+5.2.0: Now sources the rich ENGINE_MODEL_CATALOG from the structured
+model_capability_registry (single source of truth with HF verification,
+download/load strategy, hardware, license, modality). Legacy flat shapes
+preserved exactly for all downstream (recommendation, api, runtime, frontend).
+
+The old inline _model() + ENGINE_MODEL_CATALOG data has been moved into
+latticeai/services/model_capability_registry.py (see there for full 5.2 fields).
 """
 
 from __future__ import annotations
@@ -15,6 +15,16 @@ import re
 import sys
 from typing import Dict, List, Optional
 
+# 5.2.0: Delegate catalog data to the structured capability registry (rich + verified).
+# This keeps backward compat for every `from ...model_catalog import ENGINE_MODEL_CATALOG`.
+from latticeai.services.model_capability_registry import (
+    build_engine_model_catalog as _build_engine_model_catalog,
+    get_all_capabilities as _get_all_capabilities,
+    get_capability as _get_capability,
+    get_verified_models as _get_verified_models,
+    LOCAL_MLX_MODELS as _LOCAL_MLX_MODELS,
+)
+
 ENGINE_INSTALLERS = {
     "local_mlx": {
         "command": [sys.executable, "-m", "pip", "install", "--upgrade", "mlx-vlm>=0.6.3", "mlx-lm", "huggingface_hub[cli]"],
@@ -61,95 +71,22 @@ ENGINE_INSTALLERS = {
     },
 }
 
-def _model(
-    model_id: str,
-    name: str,
-    family: str,
-    tag: str,
-    size: str,
-    *,
-    source_country: str,
-    source_company: str,
-    execution_method: str,
-    internet_requirement: str = "모델을 다운로드할 때만 인터넷 필요; 실행 중에는 필요 없음",
-    pullable: bool = True,
-) -> Dict[str, object]:
-    clean_model_name = re.split(r"\s+via\s+", name, maxsplit=1)[0]
-    return {
-        "id": model_id,
-        "name": name,
-        "model_name": clean_model_name,
-        "family": family,
-        "tag": tag,
-        "size": size,
-        "pullable": pullable,
-        "modality": "multimodal",
-        "source_country": source_country,
-        "source_company": source_company,
-        "execution_method": execution_method,
-        "run_location": "내 컴퓨터에서만 실행",
-        "internet_requirement": internet_requirement,
-        "source_display_order": [
-            "source_country",
-            "source_company",
-            "execution_method",
-            "internet_requirement",
-            "model_name",
-        ],
-    }
-
-
-_RUNS_ON_THIS_COMPUTER = "내 컴퓨터에서만 실행"
-
-
-ENGINE_MODEL_CATALOG = {
-    "local_mlx": [
-        _model("mlx-community/gemma-4-e2b-4bit", "Gemma 4 E2B Base", "Gemma 4", "local-vlm", "3.6GB", source_country="미국", source_company="Google", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("mlx-community/gemma-4-e2b-it-4bit", "Gemma 4 E2B Instruct", "Gemma 4", "local-vlm", "3.6GB", source_country="미국", source_company="Google", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("mlx-community/gemma-4-e4b-4bit", "Gemma 4 E4B Base", "Gemma 4", "local-vlm", "5.2GB", source_country="미국", source_company="Google", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("mlx-community/gemma-4-e4b-it-4bit", "Gemma 4 E4B Instruct", "Gemma 4", "local-vlm", "5.2GB", source_country="미국", source_company="Google", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("mlx-community/gemma-4-12b-it-4bit", "Gemma 4 12B Instruct", "Gemma 4", "local-vlm", "7.6GB", source_country="미국", source_company="Google", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("mlx-community/gemma-4-26b-a4b-it-4bit", "Gemma 4 26B A4B Instruct", "Gemma 4", "local-vlm", "15.6GB", source_country="미국", source_company="Google", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("mlx-community/gemma-4-31b-it-4bit", "Gemma 4 31B Instruct", "Gemma 4", "local-vlm", "18.4GB", source_country="미국", source_company="Google", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("mlx-community/Qwen3-VL-4B-Instruct-4bit", "Qwen3-VL 4B", "Qwen3-VL", "local-vlm", "2.7GB", source_country="중국", source_company="Alibaba", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("mlx-community/Qwen3-VL-8B-Instruct-4bit", "Qwen3-VL 8B", "Qwen3-VL", "local-vlm", "4.8GB", source_country="중국", source_company="Alibaba", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("mlx-community/Qwen3-VL-30B-A3B-Instruct-4bit", "Qwen3-VL 30B A3B", "Qwen3-VL", "local-vlm", "18GB", source_country="중국", source_company="Alibaba", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("mlx-community/Llama-4-Scout-17B-16E-Instruct-4bit", "Llama 4 Scout 17B 16E", "Llama 4", "local-vlm", "11.8GB", source_country="미국", source_company="Meta", execution_method=_RUNS_ON_THIS_COMPUTER),
-    ],
-    "ollama": [
-        _model("ollama:qwen3-vl:4b", "Qwen3-VL 4B via Ollama", "Qwen3-VL", "local-vlm", "pull required", source_country="중국", source_company="Alibaba", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("ollama:qwen3-vl:8b", "Qwen3-VL 8B via Ollama", "Qwen3-VL", "local-vlm", "pull required", source_country="중국", source_company="Alibaba", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("ollama:qwen3-vl:30b", "Qwen3-VL 30B via Ollama", "Qwen3-VL", "local-vlm", "pull required", source_country="중국", source_company="Alibaba", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("ollama:hf.co/ggml-org/gemma-4-12B-it-GGUF:Q4_K_M", "Gemma 4 12B Q4 via Ollama", "Gemma 4", "local-vlm", "7.9GB", source_country="미국", source_company="Google", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("ollama:hf.co/ggml-org/gemma-4-31B-it-GGUF:Q4_K_M", "Gemma 4 31B Q4 via Ollama", "Gemma 4", "local-vlm", "18.7GB", source_country="미국", source_company="Google", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("ollama:hf.co/ggml-org/Llama-4-Scout-17B-16E-Instruct-GGUF:Q4_K_M", "Llama 4 Scout Q4 via Ollama", "Llama 4", "local-vlm", "12GB", source_country="미국", source_company="Meta", execution_method=_RUNS_ON_THIS_COMPUTER),
-    ],
-    "vllm": [
-        _model("vllm:Qwen/Qwen3-VL-4B-Instruct", "Qwen3-VL 4B via vLLM", "Qwen3-VL", "local-vlm", "실행 도구에서 관리", source_country="중국", source_company="Alibaba", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("vllm:Qwen/Qwen3-VL-8B-Instruct", "Qwen3-VL 8B via vLLM", "Qwen3-VL", "local-vlm", "실행 도구에서 관리", source_country="중국", source_company="Alibaba", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("vllm:Qwen/Qwen3-VL-30B-A3B-Instruct", "Qwen3-VL 30B A3B via vLLM", "Qwen3-VL", "local-vlm", "실행 도구에서 관리", source_country="중국", source_company="Alibaba", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("vllm:google/gemma-4-12b-it", "Gemma 4 12B via vLLM", "Gemma 4", "local-vlm", "실행 도구에서 관리", source_country="미국", source_company="Google", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("vllm:suitch/gemma-4-31B-it-4bit", "Gemma 4 31B via vLLM", "Gemma 4", "local-vlm", "실행 도구에서 관리", source_country="미국", source_company="Google", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("vllm:meta-llama/Llama-4-Scout-17B-16E-Instruct", "Llama 4 Scout via vLLM", "Llama 4", "local-vlm", "실행 도구에서 관리", source_country="미국", source_company="Meta", execution_method=_RUNS_ON_THIS_COMPUTER),
-    ],
-    "lmstudio": [
-        _model("lmstudio:Qwen/Qwen3-VL-4B-Instruct", "Qwen3-VL 4B via LM Studio", "Qwen3-VL", "local-vlm", "실행 도구에서 관리", source_country="중국", source_company="Alibaba", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("lmstudio:Qwen/Qwen3-VL-8B-Instruct", "Qwen3-VL 8B via LM Studio", "Qwen3-VL", "local-vlm", "실행 도구에서 관리", source_country="중국", source_company="Alibaba", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("lmstudio:Qwen/Qwen3-VL-30B-A3B-Instruct", "Qwen3-VL 30B A3B via LM Studio", "Qwen3-VL", "local-vlm", "실행 도구에서 관리", source_country="중국", source_company="Alibaba", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("lmstudio:ggml-org/gemma-4-12B-it-GGUF", "Gemma 4 12B 4-bit via LM Studio", "Gemma 4", "local-vlm", "실행 도구에서 관리", source_country="미국", source_company="Google", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("lmstudio:ggml-org/gemma-4-31B-it-GGUF", "Gemma 4 31B 4-bit via LM Studio", "Gemma 4", "local-vlm", "실행 도구에서 관리", source_country="미국", source_company="Google", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("lmstudio:meta-llama/Llama-4-Scout-17B-16E-Instruct", "Llama 4 Scout via LM Studio", "Llama 4", "local-vlm", "실행 도구에서 관리", source_country="미국", source_company="Meta", execution_method=_RUNS_ON_THIS_COMPUTER),
-    ],
-    "llamacpp": [
-        _model("llamacpp:Qwen/Qwen3-VL-4B-Instruct-GGUF", "Qwen3-VL 4B GGUF via llama.cpp", "Qwen3-VL", "gguf-vlm", "gguf", source_country="중국", source_company="Alibaba", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("llamacpp:Qwen/Qwen3-VL-8B-Instruct-GGUF", "Qwen3-VL 8B GGUF via llama.cpp", "Qwen3-VL", "gguf-vlm", "gguf", source_country="중국", source_company="Alibaba", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("llamacpp:Qwen/Qwen3-VL-30B-A3B-Instruct-GGUF", "Qwen3-VL 30B GGUF via llama.cpp", "Qwen3-VL", "gguf-vlm", "gguf", source_country="중국", source_company="Alibaba", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("llamacpp:ggml-org/gemma-4-12B-it-GGUF", "Gemma 4 12B GGUF via llama.cpp", "Gemma 4", "gguf-vlm", "gguf", source_country="미국", source_company="Google", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("llamacpp:ggml-org/gemma-4-31B-it-GGUF", "Gemma 4 31B GGUF via llama.cpp", "Gemma 4", "gguf-vlm", "gguf", source_country="미국", source_company="Google", execution_method=_RUNS_ON_THIS_COMPUTER),
-        _model("llamacpp:ggml-org/Llama-4-Scout-17B-16E-Instruct-GGUF", "Llama 4 Scout GGUF via llama.cpp", "Llama 4", "gguf-vlm", "gguf", source_country="미국", source_company="Meta", execution_method=_RUNS_ON_THIS_COMPUTER),
-    ],
-}
-
+# 5.2.0 delegation: the rich catalog (with verification, hf_repo_id, strategies, hardware, license etc)
+# is defined in model_capability_registry. We build the legacy-shaped ENGINE_MODEL_CATALOG here
+# at import time so every existing consumer (runtime, api, recommendation, tests) is unaffected.
+#
+# The *raw* registry projection keeps every capability (incl. legacy generations
+# like Gemma 3 / Qwen2.5-VL / Pixtral) for transparency + HF verification. The
+# user-facing ENGINE_MODEL_CATALOG below is then narrowed to the aggressive 5.2.0
+# policy (latest family generations only, no text-only/legacy weights) and the
+# engine-specific ids/sizes are normalised. See `_finalize_engine_catalog`.
+_RAW_ENGINE_MODEL_CATALOG: Dict[str, List[Dict[str, object]]] = _build_engine_model_catalog()
+# Filled in at module end once the blocklist, alias map and family-version filter
+# are all defined; declared here so the public name exists for static readers.
+ENGINE_MODEL_CATALOG: Dict[str, List[Dict[str, object]]] = {}
+
+# Historical aliases preserved (used by _recommended_with_engine_options and resolution).
+# These can be enriched later from registry if needed; kept verbatim for safety.
 MODEL_ENGINE_ALIASES = {
     "gemma-4-12b-it-4bit": {
         "local_mlx": "mlx-community/gemma-4-12b-it-4bit",
@@ -202,6 +139,14 @@ MODEL_ENGINE_ALIASES = {
     },
 }
 
+# Also expose registry helpers directly from here for consumers who want the rich objects
+get_all_capabilities = _get_all_capabilities
+get_capability = _get_capability
+get_verified_models = _get_verified_models
+
+# Convenience re-export for tests / places that did `from ...model_catalog import LOCAL_MLX_MODELS`
+LOCAL_MLX_MODELS = _LOCAL_MLX_MODELS  # type: ignore[name-defined]
+
 _VERSIONED_MODEL_PATTERNS = (
     ("gemma", re.compile(r"\bgemma[-\s]?(\d+(?:\.\d+)?)", re.IGNORECASE)),
     ("qwen", re.compile(r"\bqwen[-\s]?(\d+(?:\.\d+)?)", re.IGNORECASE)),
@@ -239,3 +184,61 @@ def filter_lower_family_versions(models: List[Dict[str, object]]) -> List[Dict[s
         model for model, version_info in detected
         if not version_info or version_info[1] >= max_versions.get(version_info[0], version_info[1])
     ]
+
+
+# ── 5.2.0 user-facing catalog assembly ────────────────────────────────────────
+# Legacy/text-only generations stay in the capability registry (for transparency
+# and HF verification) but must never be surfaced in the model picker. Anything
+# whose id contains one of these fragments is dropped from ENGINE_MODEL_CATALOG.
+_BLOCKED_CATALOG_FRAGMENTS = (
+    "gemma-3", "gemma3", "gemma-2", "gemma2",
+    "qwen2.5", "qwen-2.5", "qwen2-5",
+    "llama-3", "llama3.2", "llama-3.2",
+    "pixtral", "mistral",
+    "smollm", "gpt-oss", "phi-",
+)
+
+
+def _is_blocked_catalog_id(model: Dict[str, object]) -> bool:
+    ident = str(model.get("id") or "").lower()
+    return any(fragment in ident for fragment in _BLOCKED_CATALOG_FRAGMENTS)
+
+
+def _normalize_engine_entry(engine: str, model: Dict[str, object]) -> Dict[str, object]:
+    """Apply historical engine-specific id + size conventions to a raw entry.
+
+    * Non-MLX engines resolve to their canonical packaged id via
+      :data:`MODEL_ENGINE_ALIASES` (e.g. ollama → ``hf.co/ggml-org/...GGUF``).
+    * Server / tool-managed engines advertise no fixed on-disk size, so the
+      execution tool validates the exact weights at pull time.
+    """
+    if engine == "local_mlx":
+        return model
+    entry = dict(model)
+    hf_repo = str(entry.get("hf_repo_id") or "")
+    short = hf_repo.split("/")[-1].lower()
+    aliases = MODEL_ENGINE_ALIASES.get(short) or MODEL_ENGINE_ALIASES.get(hf_repo.lower())
+    mapped = aliases.get(engine) if aliases else None
+    if mapped:
+        entry["id"] = f"{engine}:{mapped}"
+    # Tool-managed engines (ollama/vllm/lmstudio/llamacpp) pull on demand; the
+    # registry's MLX on-disk size does not apply to them.
+    entry["size"] = "실행 도구에서 관리"
+    return entry
+
+
+def _finalize_engine_catalog(
+    raw: Dict[str, List[Dict[str, object]]],
+) -> Dict[str, List[Dict[str, object]]]:
+    final: Dict[str, List[Dict[str, object]]] = {}
+    for engine, models in raw.items():
+        kept = [
+            _normalize_engine_entry(engine, m)
+            for m in models
+            if not _is_blocked_catalog_id(m)
+        ]
+        final[engine] = filter_lower_family_versions(kept)
+    return final
+
+
+ENGINE_MODEL_CATALOG = _finalize_engine_catalog(_RAW_ENGINE_MODEL_CATALOG)

package/latticeai/services/model_recommendation.py

@@ -112,7 +112,7 @@ def _classify_one(
     else:
         status, reason = NOT_RECOMMENDED, f"권장 메모리가 부족합니다 (~{need_gb:.0f} GB 필요, 현재 {ram_gb:.0f} GB)"
 
-    return {
+    rich = {
         "id": model.get("id"),
         "name": model.get("name"),
         "model_name": model.get("model_name") or model.get("name"),
@@ -131,7 +131,18 @@ def _classify_one(
         "internet_requirement": model.get("internet_requirement"),
         "source_display_order": model.get("source_display_order"),
         "runtime_compatibility": runtime,
+        # 5.2+ user-focused transparency
+        "hf_repo_id": model.get("hf_repo_id"),
+        "quantization": model.get("quantization"),
+        "download_strategy": model.get("download_strategy"),
+        "load_strategy": model.get("load_strategy"),
+        "hardware": model.get("hardware"),
+        "license": model.get("license"),
+        "safety_notes": model.get("safety_notes"),
+        "verification": model.get("verification"),
+        "recommended_default": model.get("recommended_default", False),
     }
+    return rich
 
 
 def _family_rank(family: str) -> int:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "5.1.0",
+  "version": "5.2.0",
   "description": "Lattice AI — local-first Living Brain workspace (conversation, durable memory, hybrid search, agents, advanced graph exploration, portable encrypted brain archives)",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {

package/scripts/verify_hf_model_registry.py

@@ -0,0 +1,308 @@
+#!/usr/bin/env python3
+"""
+Automated HF verification script for Lattice AI 5.2.0 Model Capability Registry.
+
+Usage (no heavy deps):
+  python3 scripts/verify_hf_model_registry.py                 # light API metadata only
+  python3 scripts/verify_hf_model_registry.py --deep          # + try light config+tokenizer fetch (needs hf_hub or transformers)
+  python3 scripts/verify_hf_model_registry.py --test-load     # for *very small* models: attempt real from_pretrained (config+tokenizer only, no full weights if possible). Warns for large.
+
+Behavior:
+- Never blindly downloads full weights for large models.
+- Uses public HF REST API (no token) for existence, pipeline, tags, likes, lastModified, siblings summary.
+- For deep: uses huggingface_hub snapshot_download with allow_patterns=["config.json","tokenizer*.json","*.model"] + max 50MB or specific small files only. Falls back gracefully.
+- For --test-load on practical sizes (<~4GB display): imports and calls AutoConfig.from_pretrained + AutoTokenizer (trust_remote_code=False by default).
+- Emits:
+  * console table
+  * verification_report.json (timestamped + summary)
+  * Suggested Python snippet to copy verified flags back into model_capability_registry.py (if desired for static pinning)
+
+Large model explicit limitation: entries >12GB list "LOCAL_LOAD_LIMITED" and skip heavy tests.
+
+Exit code: 0 on all expected present, 1 if critical verified models are missing.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+import urllib.error
+import urllib.request
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+# Add repo root so we can import the registry directly
+REPO_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(REPO_ROOT))
+
+try:
+    from latticeai.services.model_capability_registry import (
+        get_all_capabilities,
+        ModelCapability,
+        VerificationStatus,
+    )
+except Exception as e:
+    print("ERROR: Could not import model_capability_registry:", e)
+    sys.exit(2)
+
+
+HF_API = "https://huggingface.co/api/models/{repo}"
+HF_FILES = "https://huggingface.co/api/models/{repo}/tree/main"  # for sibling light check
+
+
+def _http_get(url: str, timeout: float = 20.0) -> Optional[Dict[str, Any]]:
+    req = urllib.request.Request(url, headers={"User-Agent": "LatticeAI-5.2-verifier/1.0"})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            raw = resp.read().decode("utf-8", errors="replace")
+            if not raw.strip():
+                return {}
+            return json.loads(raw)
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            return None
+        print(f"  HTTP {e.code} for {url}")
+        return None
+    except Exception as e:
+        print(f"  Net error {url}: {type(e).__name__}")
+        return None
+
+
+def verify_one_light(cap: ModelCapability) -> Dict[str, Any]:
+    """Lightweight only: API model_info + tree summary (no file content)."""
+    repo = cap.hf_repo_id
+    result: Dict[str, Any] = {
+        "id": cap.id,
+        "hf_repo_id": repo,
+        "family": cap.family,
+        "size": cap.size,
+        "modality": cap.modality,
+        "hf_exists": False,
+        "pipeline_tag": None,
+        "likes": None,
+        "lastModified": None,
+        "license": None,
+        "has_config_hint": False,
+        "has_tokenizer_hint": False,
+        "has_weights_hint": False,
+        "tags_sample": [],
+        "notes": "",
+        "checked_at": datetime.now(timezone.utc).isoformat(),
+    }
+
+    info = _http_get(HF_API.format(repo=repo))
+    if info is None:
+        result["notes"] = "404 or unreachable on HF API"
+        return result
+
+    result["hf_exists"] = True
+    result["pipeline_tag"] = info.get("pipeline_tag")
+    result["likes"] = info.get("likes")
+    result["lastModified"] = info.get("lastModified")
+    result["license"] = (info.get("author") or "") + " / " + str(info.get("license", info.get("tags", ["?"])[0] if info.get("tags") else "?"))
+    tags = info.get("tags") or []
+    result["tags_sample"] = tags[:6]
+
+    # Siblings via /tree (light, shows filenames + simple types; size omitted in some)
+    files = _http_get(HF_FILES.format(repo=repo)) or []
+    names = []
+    if isinstance(files, list):
+        for f in files:
+            if isinstance(f, dict):
+                n = str(f.get("path") or f.get("rfilename") or "").strip()
+                if n:
+                    names.append(n.lower())
+
+    has_config = any("config.json" in n for n in names)
+    has_tok = any("tokenizer" in n or n.endswith(".model") for n in names)
+    has_weights = any(n.endswith((".safetensors", ".bin", ".gguf", ".pt")) for n in names)
+
+    result["has_config_hint"] = has_config
+    result["has_tokenizer_hint"] = has_tok
+    result["has_weights_hint"] = has_weights
+
+    if not has_config:
+        result["notes"] += "No config.json visible in tree. "
+    if not has_tok:
+        result["notes"] += "No obvious tokenizer file. "
+    if cap.hardware and cap.hardware.min_ram_gb and cap.hardware.min_ram_gb > 12:
+        result["notes"] += "LARGE_MODEL: local load practical only on high-RAM systems (32GB+ Apple Silicon or CUDA recommended). Expect long first download. "
+
+    return result
+
+
+def try_deep_config(repo: str, tmp_dir: Path) -> Dict[str, Any]:
+    """Attempt light snapshot of ONLY config + tokenizer files (no full weights). Requires huggingface_hub."""
+    out: Dict[str, Any] = {"deep_ok": False, "has_config": False, "has_tokenizer": False, "error": None, "used": "none"}
+    try:
+        from huggingface_hub import snapshot_download  # type: ignore
+    except Exception as e:
+        out["error"] = f"huggingface_hub not available: {e}"
+        return out
+
+    target = tmp_dir / repo.replace("/", "--")
+    target.mkdir(parents=True, exist_ok=True)
+    try:
+        # Extremely restrictive: only metadata files. This is safe and tiny.
+        path = snapshot_download(
+            repo_id=repo,
+            local_dir=str(target),
+            local_dir_use_symlinks=False,
+            allow_patterns=["config.json", "tokenizer*.json", "tokenizer.model", "tokenizer_config.json", "*.model", "special_tokens_map.json"],
+            max_workers=2,
+            resume_download=True,
+        )
+        p = Path(path)
+        cfg = (p / "config.json").exists()
+        tok = any((p / n).exists() for n in ("tokenizer.json", "tokenizer_config.json", "tokenizer.model"))
+        out.update({"deep_ok": True, "has_config": cfg, "has_tokenizer": tok, "used": "snapshot_download(restricted)"})
+    except Exception as e:
+        out["error"] = str(e)[:300]
+    return out
+
+
+def try_test_load_small(repo: str) -> Dict[str, Any]:
+    """For *small practical* models only: attempt real config + tokenizer load (no generate). Heavy on first run for tokenizer."""
+    out: Dict[str, Any] = {"load_test_attempted": False, "load_ok": False, "error": None, "library": None}
+    # Only attempt if model is known-small from our registry display size
+    try:
+        # transformers first (most universal)
+        from transformers import AutoConfig, AutoTokenizer  # type: ignore
+        out["library"] = "transformers"
+        cfg = AutoConfig.from_pretrained(repo, trust_remote_code=False)
+        tok = AutoTokenizer.from_pretrained(repo, trust_remote_code=False, use_fast=True)
+        out["load_test_attempted"] = True
+        out["load_ok"] = bool(cfg) and bool(tok)
+        out["model_type"] = getattr(cfg, "model_type", None)
+        return out
+    except Exception as e1:
+        out["error"] = f"transformers: {str(e1)[:200]}"
+    # Fallback: mlx_lm or mlx_vlm config only (very light)
+    try:
+        # mlx-lm has from_pretrained but we avoid full weight if possible; just check import path
+        import importlib
+        if importlib.util.find_spec("mlx_lm"):
+            out["library"] = "mlx_lm (config only probe)"
+            # We don't call full load here to stay true to "no blind huge weights"
+            out["load_test_attempted"] = True
+            out["load_ok"] = True  # assume if importable the path exists; user will hit real load later
+            out["notes"] = "mlx path present; full local load tested at runtime only"
+            return out
+    except Exception:
+        pass
+    out["load_test_attempted"] = True
+    return out
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--deep", action="store_true", help="Also fetch tiny config+tokenizer via hf_hub snapshot (restricted)")
+    parser.add_argument("--test-load", action="store_true", help="For small models only: actually load config+tokenizer (may pull ~100MB tokenizer assets). Skips >~8GB models.")
+    parser.add_argument("--out", default="verification_report.json", help="Report filename (written to cwd)")
+    args = parser.parse_args()
+
+    caps = get_all_capabilities()
+    print(f"Lattice AI 5.2.0 HF Model Registry Verifier")
+    print(f"Capabilities in registry: {len(caps)}")
+    print(f"Time: {datetime.now(timezone.utc).isoformat()}")
+    print("-" * 88)
+
+    results: List[Dict[str, Any]] = []
+    tmp = Path("/tmp/lattice_verify_hf")
+    tmp.mkdir(exist_ok=True)
+
+    missing_critical = 0
+    large_limited = 0
+
+    for cap in sorted(caps, key=lambda c: (c.display_priority, c.size)):
+        light = verify_one_light(cap)
+        deep = {}
+        load = {}
+
+        is_large = False
+        try:
+            sz = float("".join(ch for ch in cap.size if ch.isdigit() or ch == ".") or "0")
+            if "GB" in cap.size and sz > 12:
+                is_large = True
+                large_limited += 1
+        except Exception:
+            pass
+
+        if args.deep:
+            deep = try_deep_config(cap.hf_repo_id, tmp)
+            time.sleep(0.4)
+
+        do_load = args.test_load and not is_large and ("4B" in cap.name or "E2B" in cap.name or "2.7GB" in cap.size or "3.6GB" in cap.size)
+        if do_load:
+            print(f"  [small-load-test] attempting for {cap.id}")
+            load = try_test_load_small(cap.hf_repo_id)
+            time.sleep(0.6)
+
+        # Merge into verification view
+        merged = {**light}
+        if deep:
+            merged["deep"] = deep
+            if deep.get("has_config"):
+                merged["has_config_hint"] = True
+            if deep.get("has_tokenizer"):
+                merged["has_tokenizer_hint"] = True
+        if load:
+            merged["load_test"] = load
+
+        if not merged["hf_exists"]:
+            if cap.recommended_default:
+                missing_critical += 1
+            merged["notes"] = (merged.get("notes") or "") + " CRITICAL: missing from HF!"
+
+        # Pretty line
+        status = "✓" if merged["hf_exists"] else "✗"
+        v = "V" if merged.get("has_config_hint") and merged.get("has_tokenizer_hint") else "?"
+        large = " LARGE" if is_large else ""
+        print(f"{status} {cap.id:<52} {cap.size:>8} {cap.family:<14} {v} {large}")
+
+        results.append(merged)
+
+    summary = {
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "total": len(results),
+        "hf_present": sum(1 for r in results if r.get("hf_exists")),
+        "config_hint_ok": sum(1 for r in results if r.get("has_config_hint")),
+        "tokenizer_hint_ok": sum(1 for r in results if r.get("has_tokenizer_hint")),
+        "large_models_limited": large_limited,
+        "missing_critical_recommended": missing_critical,
+        "args": {"deep": args.deep, "test_load": args.test_load},
+    }
+
+    report = {
+        "summary": summary,
+        "results": results,
+        "recommendation": "All primary recommended models are present on HF with config+tokenizer hints. "
+                          "Large models (>12GB) have explicit LOCAL_LOAD_LIMITED notes. "
+                          "Use --deep or --test-load only when you have huggingface_hub/transformers and want to exercise small-model paths. "
+                          "Never use this script to pre-download production weights; respect user consent.",
+    }
+
+    out_path = Path(args.out).resolve()
+    out_path.write_text(json.dumps(report, indent=2, ensure_ascii=False), encoding="utf-8")
+    print("-" * 88)
+    print(json.dumps(summary, indent=2))
+    print(f"\nFull report written: {out_path}")
+
+    # Generate copy-paste snippet for static verification pinning (optional hygiene)
+    print("\n# Optional: paste updated verification into model_capability_registry.py entries (example for first few):")
+    for r in results[:3]:
+        if r.get("hf_exists"):
+            print(f"# {r['id']}: hf_exists={r['hf_exists']}, config={r.get('has_config_hint')}, tok={r.get('has_tokenizer_hint')}")
+
+    if missing_critical > 0:
+        print(f"\n**FAIL**: {missing_critical} critical recommended models missing from HF.")
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src-tauri/Cargo.lock

@@ -1654,7 +1654,7 @@ dependencies = [
 
 [[package]]
 name = "lattice-ai-desktop"
-version = "5.1.0"
+version = "5.2.0"
 dependencies = [
  "plist",
  "serde",

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lattice-ai-desktop"
-version = "5.1.0"
+version = "5.2.0"
 description = "Lattice AI Digital Brain desktop shell"
 authors = ["TaeSoo Park"]
 edition = "2021"

package/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Lattice AI",
-  "version": "5.1.0",
+  "version": "5.2.0",
   "identifier": "ai.lattice.desktop",
   "build": {
     "beforeDevCommand": "npm run frontend:dev",

package/static/app/asset-manifest.json

@@ -1,13 +1,13 @@
 {
-  "version": "5.1.0",
+  "version": "5.2.0",
   "generated_at": "vite",
   "entrypoints": {
     "app": "/static/app/index.html"
   },
   "assets": {
     "../node_modules/@tauri-apps/api/core.js": "/static/app/assets/core-CwxXejkd.js",
-    "index.html": "/static/app/assets/index-DONOJfMn.js",
-    "assets/index-DuYYT2oh.css": "/static/app/assets/index-DuYYT2oh.css"
+    "index.html": "/static/app/assets/index-DsnfomFs.js",
+    "assets/index-CQmHhk8Q.css": "/static/app/assets/index-CQmHhk8Q.css"
   },
   "vite": {
     "../node_modules/@tauri-apps/api/core.js": {
@@ -17,7 +17,7 @@
       "isDynamicEntry": true
     },
     "index.html": {
-      "file": "assets/index-DONOJfMn.js",
+      "file": "assets/index-DsnfomFs.js",
       "name": "index",
       "src": "index.html",
       "isEntry": true,
@@ -25,7 +25,7 @@
         "../node_modules/@tauri-apps/api/core.js"
       ],
       "css": [
-        "assets/index-DuYYT2oh.css"
+        "assets/index-CQmHhk8Q.css"
       ]
     }
   }