ltcai 0.3.1 → 0.3.2

package/README.md

@@ -21,6 +21,22 @@
 
 ---
 
+## What's new in 0.3.2
+
+- **Consistent "current model"** — model-card click → prepare/load → smoke test →
+  `current` update → chat-readiness flows through one path in the web UI, so the
+  model you see is always the model chat uses.
+- **3-way smoke status** — load-time chat probe now reports `ok` / `degraded` /
+  `failed` (special-token leakage, runaway repetition, over-long output), and the
+  UI shows a compatibility warning for `degraded` while still allowing chat.
+- **Timezone-correct security dashboard** — "events today" now uses the same
+  timezone as audit timestamps (configurable via `LATTICE_TZ`, e.g. `Asia/Seoul`),
+  fixing off-by-one day counts.
+- **Cleaner auto-graph** — Korean particle stripping, generic-word / file-extension
+  blacklists, and a single-source penalty so only concepts repeated across multiple
+  sources get promoted to nodes.
+- **Honest docs** — toned down unverifiable claims (telemetry, skill/plugin counts).
+
 ## What's new in 0.3.1
 
 - **Reliable model selection** — `ModelResolution` unifies recommended card ID,
@@ -49,11 +65,11 @@ See [docs/CHANGELOG.md](./docs/CHANGELOG.md) for the full list.
 
 Most AI tools forget everything after each conversation. Your files sit in folders, your chats vanish, and nothing connects.
 
-**Lattice AI remembers.** It reads your local files, indexes your conversations, and builds a knowledge graph that links people, projects, concepts, and documents — all on your machine, with zero data leaving your PC.
+**Lattice AI remembers.** It reads your local files, indexes your conversations, and builds a knowledge graph that links people, projects, concepts, and documents — all on your machine. With local models, nothing leaves your PC; cloud models are opt-in and clearly labeled.
 
 - **Your data stays local** — everything lives in `~/.ltcai/`, never sent to external servers
 - **Your AI gets smarter over time** — every chat and file builds your personal knowledge graph
-- **One install, works everywhere** — web UI, VS Code, Telegram, MCP clients, all connected to the same brain
+- **One local server, many surfaces** — a single local server powers the web UI, VS Code extension, and optional integrations (Telegram, MCP)
 
 ---
 
@@ -164,7 +180,7 @@ Based on public product behavior as of 2026-05.
 | Telegram bot | **Yes** | No | No | No |
 | MCP registry (one-click install) | **Yes** | Partial | Yes | No |
 | Admin + audit log | **Yes** | Yes | No | No |
-| Zero telemetry, self-hosted | **Yes** | Yes | Yes | No |
+| No built-in telemetry, self-hosted | **Yes** | Yes | Yes | No |
 | One-command public tunnel | **Yes** | No | No | No |
 | Free | **Yes** | Yes | Yes | No |
 
@@ -202,7 +218,7 @@ The setup wizard auto-detects your hardware and recommends the best model for yo
 | | |
 |---|---|
 | **Storage** | All data in `~/.ltcai/` on your machine |
-| **Telemetry** | None — no analytics, no tracking, no phoning home |
+| **Telemetry** | No built-in analytics or product telemetry by default |
 | **File access** | Approval-token gated — explicit consent per folder |
 | **Cloud models** | When using cloud APIs, prompts are sent to the provider. Local models keep everything offline. |
 | **Sensitive files** | `.env`, credentials, keys, certificates auto-excluded from indexing |
@@ -229,8 +245,8 @@ The setup wizard auto-detects your hardware and recommends the best model for yo
 | **Multi-LLM pipeline** | Plan → Execute → Review with different models |
 | **MCP server** | Use Lattice tools in Claude Desktop / Cursor |
 | **MCP registry** | One-click install from registry.modelcontextprotocol.io |
-| **Skills marketplace** | 77 official skills (Anthropic + verified third-party) |
-| **Plugin directory** | Browse 149 open-source plugins |
+| **Skills browser** | Optional browser for Anthropic + third-party skills |
+| **Plugin browser** | Browse open-source plugins from the registry |
 
 ### Access & Communication
 | Feature | Description |
@@ -387,7 +403,7 @@ Full reference: [docs/mcp-tools.md](docs/mcp-tools.md)
 | VS Code Marketplace | [marketplace.visualstudio.com](https://marketplace.visualstudio.com/items?itemName=parktaesoo.ltcai) |
 | Open VSX | [open-vsx.org](https://open-vsx.org/extension/parktaesoo/ltcai) |
 
-Current version: **0.2.2** — [Changelog](docs/CHANGELOG.md)
+Current version: **0.3.2** — [Changelog](docs/CHANGELOG.md)
 
 ---
 

package/docs/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## [0.3.2] - 2026-05-29
+
+> 안정화 릴리스 — 모델 current 일관성, smoke test 3분류, 보안 대시보드 timezone
+> 버그 수정, 자동 그래프 한국어 노이즈 개선, README 과장 표현 정리.
+
+### Model loading & UI
+
+- 웹 UI 모델 선택을 단일 흐름으로 통일(`selectModelByCard` → `prepareAndLoadModel`
+  → smoke test → `current` 반영 → 채팅 가능 여부 표시). cloud(`loadSelectedModel`)
+  경로도 백엔드 `current`를 단일 진실원으로 사용. "보이는 모델 ≠ 채팅에 쓰이는
+  모델" 문제 제거.
+- Smoke test 결과를 **ok / degraded / failed** 3분류로 확장
+  (`model_compat.classify_smoke_response()`). 특수/role 토큰 누출, 폭주 반복,
+  과도한 길이를 감지. `degraded`는 채팅은 가능하되 UI에 호환성 경고 표시.
+  `/models/load`·`/engines/prepare-model/stream` 응답의 `compatibility_status`가
+  3분류 값을 그대로 노출.
+
+### Security dashboard
+
+- **Timezone 버그 수정** — audit timestamp는 로컬 시간으로 기록되는데
+  "events_today"는 UTC로 계산해 한국 사용자에게 날짜가 어긋나던 문제 수정.
+  새 모듈 `latticeai/core/timezones.py`로 기준 시간대를 통일(`LATTICE_TZ` /
+  `LTCAI_TZ` 환경변수, 기본 시스템 로컬). overview 응답에 `timezone` 필드 추가.
+
+### Auto graph curator
+
+- 한국어 노이즈 감소 — 조사 제거, 일반어/파일확장자 blacklist, 단일 출처
+  후보 score 감점(여러 출처에서 반복된 개념만 승격).
+
+### Docs & tests
+
+- README/확장 설명의 과장 표현 완화(telemetry, skills/plugins 수치 등).
+- 단위 테스트 추가: timezone, smoke 3분류, graph 노이즈, export secret redaction.
+  (tests/unit 149 passed)
+
 ## [0.3.1] - 2026-05-29
 
 > Model loading reliability + auto-graph curation + AI Security & Audit Command Center.

package/latticeai/api/security_dashboard.py

@@ -36,6 +36,8 @@ from fastapi import APIRouter, HTTPException, Query, Request
 from fastapi.responses import Response, StreamingResponse
 from pydantic import BaseModel
 
+from ..core import timezones
+
 logger = logging.getLogger(__name__)
 
 
@@ -304,11 +306,13 @@ def create_security_router(
         report = build_sensitivity_report(history) or {}
         summary = report.get("summary", {})
         sev = summary.get("severity_counts", {}) or {}
-        today = datetime.utcnow().date().isoformat()
+        # item 7: audit timestamp(로컬/설정 시간대)와 동일한 기준으로 "오늘"을 계산한다.
+        today = timezones.today_str()
         today_events = [e for e in events if str(e.get("timestamp", ""))[:10] == today]
 
         return {
-            "generated_at": datetime.utcnow().isoformat() + "Z",
+            "generated_at": timezones.now_iso(),
+            "timezone": timezones.tz_name(),
             "cards": {
                 "events_today": len(today_events),
                 "high_risk_events": int(sev.get("high", 0)),

package/latticeai/core/audit.py

@@ -9,6 +9,8 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional
 
+from . import timezones
+
 _history_lock = threading.Lock()
 
 SENSITIVE_PATTERNS = [
@@ -41,7 +43,8 @@ def append_audit_event(audit_file: Path, event_type: str, **payload) -> None:
     try:
         event = {
             "event_type": event_type,
-            "timestamp": datetime.now().isoformat(),
+            # item 7: 대시보드 "오늘" 계산과 동일한 시간대 기준으로 기록한다.
+            "timestamp": timezones.now_iso(),
             **payload,
         }
         with _history_lock:

package/latticeai/core/graph_curator.py

@@ -72,6 +72,54 @@ _STOPWORDS: Set[str] = {
     "i'll", "as", "be", "is", "it", "an", "or", "to", "of", "in", "on",
 }
 
+# item 5: 한국어 그래프 노이즈를 줄이기 위한 일반어 blacklist 강화.
+# 의미를 담지 않는 흔한 단어들. (코드/도메인 고유명사는 제외)
+_GENERIC_BLACKLIST: Set[str] = {
+    # 한국어 일반어
+    "내용", "관련", "사용", "경우", "부분", "정도", "생각", "방법", "진행",
+    "확인", "작업", "설정", "추가", "수정", "정보", "결과", "상태", "기준",
+    "그것", "그거", "여기", "거기", "이거", "저거", "무엇", "어떤", "관해",
+    "그냥", "정말", "조금", "많이", "다시", "먼저", "현재", "다음", "이전",
+    # 영어 일반어
+    "thing", "things", "stuff", "etc", "really", "just", "like", "make",
+    "made", "want", "need", "good", "work", "works", "very", "more", "most",
+    "some", "such", "then", "than", "also", "here", "there", "what", "which",
+    "when", "where", "will", "would", "should", "could", "does", "done",
+}
+
+# item 5: 파일 확장자 토큰. 파일명에서 떨어져 나온 노이즈라 노드 후보로 부적절.
+_FILE_EXT_TOKENS: Set[str] = {
+    "py", "js", "ts", "tsx", "jsx", "json", "md", "txt", "csv", "tsv",
+    "png", "jpg", "jpeg", "gif", "svg", "webp", "pdf", "html", "css",
+    "yml", "yaml", "toml", "sh", "bash", "zsh", "log", "ipynb", "xml",
+    "lock", "cfg", "ini", "env", "bin", "exe", "zip", "tar", "gz",
+}
+
+_FILTER_TOKENS: Set[str] = _STOPWORDS | _GENERIC_BLACKLIST | _FILE_EXT_TOKENS
+
+# item 5: 한국어 조사. 토큰 끝에서 제거해 "그래프를"/"그래프가"/"그래프" 를 하나로 모은다.
+_JOSA_SUFFIXES: List[str] = sorted(
+    [
+        "으로는", "에서는", "에서의", "에게서", "이라는", "이라고", "라는", "라고",
+        "으로", "에서", "에게", "한테", "까지", "부터", "보다", "처럼", "마다",
+        "조차", "밖에", "라도", "이나", "에는", "에도", "께서", "이란",
+        "은", "는", "이", "가", "을", "를", "와", "과", "에", "의", "도",
+        "만", "로", "나", "께", "란",
+    ],
+    key=len,
+    reverse=True,
+)
+
+
+def _strip_josa(token: str) -> str:
+    """한국어 토큰 끝의 조사를 제거한다. (영문/혼합 토큰은 그대로)"""
+    if not re.search(r"[가-힣]", token):
+        return token
+    for suf in _JOSA_SUFFIXES:
+        if token.endswith(suf) and len(token) - len(suf) >= 2:
+            return token[: -len(suf)]
+    return token
+
 
 def _tokenize(text: str) -> List[str]:
     if not text:
@@ -81,10 +129,10 @@ def _tokenize(text: str) -> List[str]:
     tokens = [t for t in cleaned.split() if t]
     out = []
     for t in tokens:
-        low = t.lower()
+        low = _strip_josa(t.lower())
         if len(low) < 2:
             continue
-        if low in _STOPWORDS:
+        if low in _FILTER_TOKENS:
             continue
         out.append(low)
     return out
@@ -158,12 +206,20 @@ def extract_topic_candidates(
     for term, score in counts.items():
         if score < min_score:
             continue
-        normalized = math.log(1.0 + score) * (1.0 + 0.05 * len(term.split()))
+        term_sources = sources.get(term, [])
+        # item 5: 같은 대화/폴더(단일 출처)에서만 반복된 단어는 감점한다.
+        # 여러 출처에서 반복된 개념일수록 가산해 "진짜 주제"만 위로 올린다.
+        distinct_sources = len({s for s in term_sources if s})
+        if distinct_sources <= 1:
+            diversity = 0.5  # 단일 출처 노이즈 감점
+        else:
+            diversity = 1.0 + 0.15 * math.log(distinct_sources)
+        normalized = math.log(1.0 + score) * (1.0 + 0.05 * len(term.split())) * diversity
         candidates.append(
             TopicCandidate(
                 label=term,
                 score=round(normalized, 4),
-                sources=sources.get(term, [])[:20],
+                sources=term_sources[:20],
             )
         )
 

package/latticeai/core/model_compat.py

@@ -241,38 +241,70 @@ def fast_postprocess(text: str, profile: Dict[str, Any]) -> str:
 SMOKE_PROMPT = "한국어로 한 문장만 답해. 2+2는?"
 
 
-def validate_smoke_response(text: str) -> Tuple[bool, str]:
-    """Smoke test 응답의 정상성을 판단한다.
+def classify_smoke_response(text: str) -> Tuple[str, str]:
+    """Smoke test 응답을 ok / degraded / failed 로 분류한다. (item 3-3)
+
+    - failed: 채팅에 쓸 수 없는 수준 (빈 응답, 특수/role 토큰 누출, 심한 반복,
+      과도하게 긴 출력).
+    - degraded: 로드/채팅은 되지만 품질이 일정하지 않음 (가벼운 반복, 기대한
+      정답 없음, 다소 긴 출력).
+    - ok: 형식·정답·길이 모두 정상.
 
-    반환: (정상 여부, reason)
+    반환: (status, reason)
     """
     if text is None:
-        return False, "empty response"
+        return "failed", "empty response"
     raw = str(text).strip()
     if not raw:
-        return False, "empty response"
-    # 특수 토큰 leakage
+        return "failed", "empty response"
+
+    # 1. role / 특수 토큰 누출 → 채팅 형식이 깨진 것이므로 failed.
     for marker in BAD_MARKERS:
         if marker in raw:
-            return False, f"role token leakage ({marker})"
-    # 같은 문장 5회 이상 반복
-    sentences = re.split(r"[.!?\n]+", raw)
+            return "failed", f"role token leakage ({marker})"
+    if re.search(r"<\|[^|]{0,40}\|>", raw):
+        return "failed", "special token leakage"
+    # role marker 줄 출력 (예: "assistant:" 로 시작)
+    if re.match(r"^\s*(?:assistant|system|user)\s*:", raw, flags=re.I):
+        return "failed", "role marker leakage"
+
+    # 2. 반복 감지.
+    sentences = [s.strip() for s in re.split(r"[.!?\n]+", raw) if len(s.strip()) >= 3]
     counts: Dict[str, int] = {}
-    for s in sentences:
-        key = s.strip()
-        if len(key) >= 3:
-            counts[key] = counts.get(key, 0) + 1
-    if counts and max(counts.values()) >= 5:
-        return False, "repetition detected"
-    # 4 라는 답이 포함되어 있는지(약한 정상성 휴리스틱)
-    if "4" not in raw and "네" not in raw and "사" not in raw:
-        # 정답이 아니더라도 채팅 형식이 깨지지 않았으면 degraded로 통과
-        if len(raw) < 200:
-            return True, "no exact answer but formed"
-        return False, "answer did not contain 4 and response too long"
+    for key in sentences:
+        counts[key] = counts.get(key, 0) + 1
+    max_rep = max(counts.values()) if counts else 0
+    if max_rep >= 5:
+        return "failed", "severe repetition"
+    # 문자열 단위 폭주 반복 (예: "안녕안녕안녕…", "AAAA…")
+    if re.search(r"(.{1,20}?)\1{6,}", raw):
+        return "failed", "runaway repetition"
+
+    # 3. 과도하게 긴 출력 → failed.
     if len(raw) > 4000:
-        return False, "response too long"
-    return True, "ok"
+        return "failed", "response too long"
+
+    # 4. 여기까지 왔으면 채팅은 가능. degraded 신호를 모은다.
+    degraded: List[str] = []
+    if max_rep >= 3:
+        degraded.append("mild repetition")
+    if len(raw) > 600:
+        degraded.append("response longer than expected")
+    has_answer = ("4" in raw) or ("네" in raw) or ("사" in raw)
+    if not has_answer:
+        degraded.append("answer did not contain expected result")
+    if degraded:
+        return "degraded", "; ".join(degraded)
+    return "ok", "ok"
+
+
+def validate_smoke_response(text: str) -> Tuple[bool, str]:
+    """하위호환 wrapper. (ok 또는 degraded면 채팅 가능 → True)
+
+    반환: (채팅 가능 여부, reason)
+    """
+    status, reason = classify_smoke_response(text)
+    return status != "failed", reason
 
 
 # ── Compat cache (Slow Path) ──────────────────────────────────────────────────
@@ -346,11 +378,21 @@ def record_smoke_result(
     engine: Optional[str],
     ok: bool,
     reason: str,
+    *,
+    status: Optional[str] = None,
 ) -> CompatProfile:
+    """Smoke 결과를 프로필 캐시에 기록한다.
+
+    status 가 주어지면 ok/degraded/failed 3분류를 그대로 저장한다.
+    (하위호환: status 없이 ok bool만 오면 ok→"ok", False→"degraded")
+    """
     profile = ensure_profile(model_id, engine)
     profile.loaded = True
     profile.chat_compatible = bool(ok)
-    profile.quality_status = "ok" if ok else "degraded"
+    if status in ("ok", "degraded", "failed"):
+        profile.quality_status = status
+    else:
+        profile.quality_status = "ok" if ok else "degraded"
     profile.last_test_error = None if ok else reason
     profile.validated_at = time.time()
     remember_profile(profile)
@@ -395,6 +437,7 @@ __all__ = [
     "get_model_profile",
     "fast_postprocess",
     "validate_smoke_response",
+    "classify_smoke_response",
     "ensure_profile",
     "lookup_profile",
     "remember_profile",

package/latticeai/core/timezones.py

@@ -0,0 +1,80 @@
+"""Shared timezone helper (피드백 #5 / item 7).
+
+문제: audit 로그 timestamp는 ``datetime.now()`` (시스템 로컬 시간)으로 기록되는데,
+security_dashboard는 "오늘 이벤트 수"를 ``datetime.utcnow().date()`` (UTC) 기준으로
+계산해서 한국 사용자에게 events_today가 어긋났다.
+
+해결: 모든 날짜/시간 기준을 하나의 timezone 헬퍼로 통일한다.
+
+- 환경변수 ``LATTICE_TZ`` (또는 호환용 ``LTCAI_TZ``)가 있으면 그 시간대를 쓴다.
+  예: ``LATTICE_TZ=Asia/Seoul``.
+- 없으면 시스템 로컬 시간대를 쓴다 (기존 audit timestamp와 동일한 기준).
+
+이렇게 하면 "타임스탬프를 쓸 때 쓰는 시간대" === "오늘을 계산할 때 쓰는 시간대" 가
+항상 일치한다.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from datetime import datetime, tzinfo
+from typing import Optional
+
+try:  # py3.9+
+    from zoneinfo import ZoneInfo
+except Exception:  # pragma: no cover - 매우 오래된 런타임
+    ZoneInfo = None  # type: ignore
+
+logger = logging.getLogger(__name__)
+
+_TZ_ENV_VARS = ("LATTICE_TZ", "LTCAI_TZ")
+
+
+def _system_local_tz() -> tzinfo:
+    # tz-aware 시스템 로컬 시간대.
+    return datetime.now().astimezone().tzinfo  # type: ignore[return-value]
+
+
+def get_timezone() -> tzinfo:
+    """설정된 시간대를 돌려준다. (환경변수 → 시스템 로컬 순)"""
+    for var in _TZ_ENV_VARS:
+        name = (os.environ.get(var) or "").strip()
+        if not name:
+            continue
+        if ZoneInfo is None:
+            logger.warning("zoneinfo 사용 불가, %s=%s 무시하고 시스템 로컬 사용", var, name)
+            break
+        try:
+            return ZoneInfo(name)
+        except Exception:
+            logger.warning("알 수 없는 시간대 %s=%s, 시스템 로컬로 대체", var, name)
+            break
+    return _system_local_tz()
+
+
+def now(tz: Optional[tzinfo] = None) -> datetime:
+    """설정된 시간대의 현재 시각 (tz-aware)."""
+    return datetime.now(tz or get_timezone())
+
+
+def now_iso(tz: Optional[tzinfo] = None) -> str:
+    """ISO8601 문자열. audit timestamp 기록용."""
+    return now(tz).isoformat()
+
+
+def today_str(tz: Optional[tzinfo] = None) -> str:
+    """오늘 날짜 ``YYYY-MM-DD``. events_today 계산용."""
+    return now(tz).date().isoformat()
+
+
+def tz_name() -> str:
+    """설정된 시간대 이름(있으면 환경변수 값, 없으면 'local')."""
+    for var in _TZ_ENV_VARS:
+        name = (os.environ.get(var) or "").strip()
+        if name:
+            return name
+    return "local"
+
+
+__all__ = ["get_timezone", "now", "now_iso", "today_str", "tz_name"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Lattice AI local MLX/cloud LLM workspace server",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {
@@ -23,7 +23,7 @@
     "test:unit": "python3 -m pytest tests/unit/ -v",
     "test:integration": "python3 -m pytest tests/integration/ -v",
     "publish:npm": "npm publish --access public",
-    "publish:pypi": "python3 -m twine upload dist/*"
+    "publish:pypi": "python3 -m twine upload --skip-existing dist/*.tar.gz dist/*.whl"
   },
   "keywords": [
     "ltcai",

package/server.py

@@ -78,6 +78,7 @@ from latticeai.core.model_compat import (
     record_smoke_result as _record_smoke_result,
     fast_postprocess as _compat_fast_postprocess,
     validate_smoke_response as _validate_smoke_response,
+    classify_smoke_response as _classify_smoke_response,
     list_cached_profiles as _list_compat_profiles,
     SMOKE_PROMPT as _SMOKE_PROMPT,
 )
@@ -1125,7 +1126,7 @@ async def lifespan(app: FastAPI):
             except Exception:
                 pass
 
-app = FastAPI(title=f"Lattice AI Server ({APP_MODE})", version="0.3.0", lifespan=lifespan)
+app = FastAPI(title=f"Lattice AI Server ({APP_MODE})", version="0.3.2", lifespan=lifespan)
 
 CORS_ALLOWED_ORIGINS = [
     f"http://localhost:{DEFAULT_PORT}",
@@ -3054,9 +3055,12 @@ async def _smoke_test_loaded_model(
         )
     except Exception as exc:  # pragma: no cover - generator may not exist on all engines
         reason = str(exc)[:200] or "generation_failed"
-        profile = _record_smoke_result(resolution.load_id, resolution.engine, False, reason)
+        profile = _record_smoke_result(
+            resolution.load_id, resolution.engine, False, reason, status="failed"
+        )
         return {
             "ok": False,
+            "status": "failed",
             "reason": reason,
             "answer": None,
             "profile": profile.to_dict(),
@@ -3064,10 +3068,15 @@ async def _smoke_test_loaded_model(
 
     profile = _ensure_compat_profile(resolution.load_id, resolution.engine)
     cleaned = _compat_fast_postprocess(str(text or ""), profile.to_dict())
-    ok, reason = _validate_smoke_response(cleaned)
-    profile = _record_smoke_result(resolution.load_id, resolution.engine, ok, reason)
+    # item 3-3: ok / degraded / failed 3분류. degraded는 채팅은 가능하다.
+    status, reason = _classify_smoke_response(cleaned)
+    ok = status != "failed"
+    profile = _record_smoke_result(
+        resolution.load_id, resolution.engine, ok, reason, status=status
+    )
     return {
         "ok": ok,
+        "status": status,
         "reason": reason,
         "answer": cleaned,
         "profile": profile.to_dict(),
@@ -3159,7 +3168,8 @@ async def prepare_and_load_model(
     try:
         smoke_result = await _smoke_test_loaded_model(resolution, api_key_override=user_api_key)
         ready_to_chat = bool(smoke_result.get("ok"))
-        compat_status = "ok" if ready_to_chat else "degraded"
+        # item 3-3: smoke 결과의 3분류(ok/degraded/failed)를 그대로 노출한다.
+        compat_status = str(smoke_result.get("status") or ("ok" if ready_to_chat else "degraded"))
     except Exception as exc:  # never break load on smoke test failures
         logging.warning("smoke test failed for %s: %s", resolution.load_id, exc)
         compat_status = "unknown"
@@ -3402,7 +3412,8 @@ async def prepare_and_load_model_stream(
     try:
         smoke_result = await _smoke_test_loaded_model(resolution_stream, api_key_override=user_api_key)
         ready_to_chat = bool(smoke_result.get("ok"))
-        compat_status = "ok" if ready_to_chat else "degraded"
+        # item 3-3: smoke 결과의 3분류(ok/degraded/failed)를 그대로 노출한다.
+        compat_status = str(smoke_result.get("status") or ("ok" if ready_to_chat else "degraded"))
     except Exception as exc:
         logging.warning("smoke test (stream) failed for %s: %s", resolution_stream.load_id, exc)
         compat_status = "unknown"
@@ -3491,7 +3502,7 @@ async def verify_cloud_models(force: bool = False, provider_filter: Optional[str
 
 @app.get("/health")
 async def health(request: Request):
-    base = {"status": "ok", "version": "0.3.0", "mode": APP_MODE}
+    base = {"status": "ok", "version": "0.3.2", "mode": APP_MODE}
     if not get_current_user(request) and REQUIRE_AUTH:
         return base
     engines = await asyncio.to_thread(engine_status)

package/static/scripts/chat.js

@@ -1469,7 +1469,7 @@ const chatViewport = document.getElementById('chat-viewport');
             const icon = isUnavailable ? 'ti-lock' : (engineMissing || needsPull) ? 'ti-cloud-download' : verifyUnknown ? 'ti-activity' : 'ti-switch-3';
             const cls = (engineMissing || needsPull) && isLocalEngine ? ' needs-pull' : '';
             const action = isLocalEngine
-                ? `prepareAndLoadModel('${encodeURIComponent(model.id)}', '${engine?.id || ''}')`
+                ? `selectModelByCard('${encodeURIComponent(model.id)}', '${engine?.id || ''}')`
                 : `loadSelectedModel('${encodeURIComponent(model.id)}', '${engine?.id || ''}')`;
             return `
                 <button class="model-option${cls}" ${isUnavailable ? 'disabled' : ''} onclick="${action}">
@@ -1669,7 +1669,17 @@ const chatViewport = document.getElementById('chat-viewport');
                 if (!res.ok) throw new Error(data.detail || '모델 로드에 실패했습니다.');
                 closeModelPanel();
                 await loadModelStatus();
-                addMessage('ai', `모델을 <b>${escapeHtml(compactModelName(data.current || modelId))}</b>로 전환했습니다.`);
+                // 피드백 #1/#2: 클라우드 경로도 백엔드 current를 단일 진실원으로 사용한다.
+                const actualCurrent = resolveActualCurrent(data, modelId);
+                setCurrentModel(actualCurrent);
+                updateCurrentModelUI(actualCurrent);
+                let statusLine = `모델을 <b>${escapeHtml(compactModelName(actualCurrent))}</b>로 전환했습니다.`;
+                const compat = describeCompatibility(data);
+                if (compat) {
+                    statusLine += `<br><span class="sensitivity-preview">${escapeHtml(compat.message)}</span>`;
+                    showModelCompatibilityWarning(data);
+                }
+                addMessage('ai', statusLine);
             } catch (e) {
                 document.getElementById('model-list').innerHTML = `
                     <div class="sensitivity-preview">${escapeHtml(e.message)}</div>
@@ -1829,6 +1839,66 @@ const chatViewport = document.getElementById('chat-viewport');
             if (buffer.trim()) dispatchBlock(buffer.trim());
         }
 
+        // 피드백 #1/#2: "사용자가 보는 현재 모델" === "실제로 채팅에 사용되는 모델".
+        // 백엔드가 돌려준 current/resolution을 단일 진실원으로 사용한다.
+        function resolveActualCurrent(finalData, fallbackId) {
+            if (!finalData) return fallbackId || '';
+            return (
+                finalData.current
+                || (finalData.resolution && (finalData.resolution.expected_current || finalData.resolution.resolved_model))
+                || fallbackId
+                || ''
+            );
+        }
+
+        function setCurrentModel(modelId) {
+            if (!modelId) return;
+            window.__latticeActiveModel = modelId;
+        }
+
+        function updateCurrentModelUI(modelId) {
+            if (!modelId) return;
+            const modelEl = document.getElementById('ops-model');
+            if (modelEl) {
+                modelEl.textContent = compactModelName(modelId);
+                modelEl.title = modelId;
+            }
+            const metaEl = document.getElementById('ops-model-meta');
+            if (metaEl && !metaEl.dataset.loaded) {
+                metaEl.dataset.loaded = 'true';
+            }
+        }
+
+        function describeCompatibility(finalData) {
+            if (!finalData) return null;
+            if (finalData.ready_to_chat === false) {
+                const reason = (finalData.smoke_test && finalData.smoke_test.reason) || '채팅 호환성 검사 실패';
+                return {
+                    severity: 'degraded',
+                    message: `⚠️ 채팅 호환성이 낮습니다 (${reason}). 다른 실행 엔진을 추천합니다.`,
+                };
+            }
+            if (finalData.compatibility_status === 'degraded') {
+                return {
+                    severity: 'degraded',
+                    message: '⚠️ 모델은 로드됐지만 호환성 테스트가 degraded로 나왔습니다. 답변 품질이 일정하지 않을 수 있어요.',
+                };
+            }
+            if (finalData.compatibility_status === 'unknown') {
+                return {
+                    severity: 'unknown',
+                    message: '호환성 테스트를 완료하지 못했습니다. 채팅이 가능하지만 답변 품질이 일정하지 않을 수 있어요.',
+                };
+            }
+            return null;
+        }
+
+        function showModelCompatibilityWarning(finalData) {
+            const info = describeCompatibility(finalData);
+            if (!info) return;
+            try { showToast(info.message); } catch (_) {}
+        }
+
         async function prepareAndLoadModel(encodedId, engine = '') {
             const modelId = decodeURIComponent(encodedId);
             const displayName = compactModelName(modelId);
@@ -1870,22 +1940,22 @@ const chatViewport = document.getElementById('chat-viewport');
                 if (!finalData) throw new Error('모델 준비 응답이 비어 있습니다.');
                 closeModelPanel();
                 await loadModelStatus();
-                // 피드백 #1/#2: 사용자가 클릭한 modelId가 아니라 백엔드가 돌려준 current를 신뢰한다.
-                const actualCurrent = finalData.current || (finalData.resolution && finalData.resolution.expected_current) || modelId;
-                window.__latticeActiveModel = actualCurrent;
+                const actualCurrent = resolveActualCurrent(finalData, modelId);
+                setCurrentModel(actualCurrent);
+                updateCurrentModelUI(actualCurrent);
                 let statusLine = `<b>${escapeHtml(compactModelName(actualCurrent))}</b> 로드 되었습니다.`;
-                if (finalData.ready_to_chat === false) {
-                    const reason = (finalData.smoke_test && finalData.smoke_test.reason) || '채팅 호환성 검사 실패';
-                    statusLine += `<br><span class="sensitivity-preview">⚠️ 현재 채팅 호환성이 낮습니다 (${escapeHtml(reason)}). 다른 실행 엔진을 추천합니다.</span>`;
-                } else if (finalData.compatibility_status === 'unknown') {
-                    statusLine += `<br><span class="sensitivity-preview">호환성 테스트를 완료하지 못했습니다. 채팅이 가능하지만 답변 품질이 일정하지 않을 수 있어요.</span>`;
+                const compat = describeCompatibility(finalData);
+                if (compat) {
+                    statusLine += `<br><span class="sensitivity-preview">${escapeHtml(compat.message)}</span>`;
                 }
                 addMessage('ai', statusLine);
+                return finalData;
             } catch (e) {
                 document.getElementById('model-list').innerHTML = `
                     <div class="sensitivity-preview">${escapeHtml(e.message)}</div>
                     <button class="admin-action" onclick="openModelPanel()" style="margin-top: 12px;">목록으로 돌아가기</button>
                 `;
+                throw e;
             }
         }
 
@@ -1893,17 +1963,36 @@ const chatViewport = document.getElementById('chat-viewport');
             return prepareAndLoadModel(encodedId, engine);
         }
 
-        // 피드백 #1/#2: 사용자가 직접 모델을 선택했을 때도 같은 표준 흐름을 타도록 노출.
-        async function selectModelByCard(card) {
-            if (!card || !card.id) {
+        // 피드백 #1/#2: 모델 카드 클릭 → prepare/load → smoke test → current 반영 → 채팅 가능 여부 표시
+        // 가 하나의 흐름으로 이어지도록 한다. encodedId/engine 또는 card 객체 양쪽 모두 받는다.
+        async function selectModelByCard(modelIdOrCard, engineArg) {
+            let encoded;
+            let engine = engineArg || '';
+            if (typeof modelIdOrCard === 'string') {
+                encoded = modelIdOrCard.includes('%') ? modelIdOrCard : encodeURIComponent(modelIdOrCard);
+            } else if (modelIdOrCard && modelIdOrCard.id) {
+                encoded = encodeURIComponent(modelIdOrCard.id);
+                if (!engine) {
+                    engine = modelIdOrCard.engine
+                        || (Array.isArray(modelIdOrCard.engine_options) && modelIdOrCard.engine_options[0]?.engine)
+                        || '';
+                }
+            } else {
                 throw new Error('모델 카드가 비어 있습니다.');
             }
-            const encoded = encodeURIComponent(card.id);
-            const engine = card.engine || (Array.isArray(card.engine_options) && card.engine_options[0]?.engine) || '';
-            return prepareAndLoadModel(encoded, engine);
+            const result = await prepareAndLoadModel(encoded, engine);
+            if (result && result.current) {
+                setCurrentModel(result.current);
+                updateCurrentModelUI(result.current);
+            }
+            if (result && (result.ready_to_chat === false || result.compatibility_status === 'degraded')) {
+                showModelCompatibilityWarning(result);
+            }
+            return result;
         }
         if (typeof window !== 'undefined') {
             window.selectModelByCard = selectModelByCard;
+            window.prepareAndLoadModel = prepareAndLoadModel;
         }
 
         function fillVpcForm(config) {