ltcai 4.3.0 → 4.3.1

package/latticeai/api/models.py

@@ -62,6 +62,7 @@ class LoadModelRequest(BaseModel):
     user_email: Optional[str] = None
     adapter_path: Optional[str] = None
     draft_model_id: Optional[str] = None
+    allow_download: bool = False
 
 
 class InstallEngineRequest(BaseModel):
@@ -82,6 +83,7 @@ class PrepareModelRequest(BaseModel):
     model: str
     engine: Optional[str] = None
     user_email: Optional[str] = None
+    allow_download: bool = False
 
 
 class VerifyCloudRequest(BaseModel):
@@ -127,9 +129,57 @@ def create_models_router(
     REQUIRE_AUTH = require_auth
     _list_compat_profiles = list_compat_profiles
 
-    def _recommended_with_engine_options(items: List[Dict[str, object]]) -> List[Dict[str, object]]:
+    def _recommended_with_engine_options(
+        items: List[Dict[str, object]],
+        engines: Optional[List[Dict[str, object]]] = None,
+        loaded_ids: Optional[List[str]] = None,
+        current_id: Optional[str] = None,
+    ) -> List[Dict[str, object]]:
+        engine_lookup = {str(engine.get("id") or ""): engine for engine in engines or []}
+        model_lookup: Dict[str, Dict[str, object]] = {}
+        for engine in engines or []:
+            engine_id = str(engine.get("id") or "")
+            for model in engine.get("models") or []:
+                if isinstance(model, dict):
+                    model_lookup[str(model.get("id") or "")] = {**model, "_engine": engine_id}
+        loaded = set(loaded_ids or [])
         out: List[Dict[str, object]] = []
         for item in items:
+            short_id = str(item["id"]).lower()
+            aliases = MODEL_ENGINE_ALIASES.get(short_id) or {}
+            options: List[Dict[str, str]] = []
+            for engine_name in ("local_mlx", "ollama", "lmstudio", "llamacpp", "vllm"):
+                real = aliases.get(engine_name)
+                if not real:
+                    continue
+                options.append({
+                    "engine": engine_name,
+                    "model_id": real,
+                    "load_id": real if engine_name == "local_mlx" else f"{engine_name}:{real}",
+                })
+            if not options:
+                options.append({"engine": "local_mlx", "model_id": item["id"], "load_id": item["id"]})
+            recommended_engine = options[0]["engine"]
+            load_id = options[0]["load_id"]
+            engine_info = engine_lookup.get(recommended_engine) or {}
+            model_info = model_lookup.get(load_id) or model_lookup.get(str(item["id"])) or {}
+            pulled = bool(model_info.get("pulled"))
+            is_loaded = load_id in loaded or str(item["id"]) in loaded or current_id in {load_id, str(item["id"])}
+            engine_installed = bool(engine_info.get("installed"))
+            pullable = bool(item.get("pullable", True))
+            download_required = bool(pullable and not pulled and not is_loaded)
+            if is_loaded:
+                load_status = "loaded"
+                unavailable_reason = None
+            elif not engine_installed:
+                load_status = "unavailable"
+                unavailable_reason = f"{engine_info.get('name') or recommended_engine} runtime is not installed."
+            elif download_required:
+                load_status = "download_required"
+                unavailable_reason = "Model files are not present locally. Downloads are opt-in and never start from token/model presence alone."
+            else:
+                load_status = "ready"
+                unavailable_reason = None
             base = {
                 "id": item["id"],
                 "name": item["name"],
@@ -144,23 +194,15 @@ def create_models_router(
                 "run_location": item.get("run_location"),
                 "internet_requirement": item.get("internet_requirement"),
                 "source_display_order": item.get("source_display_order"),
+                "pulled": pulled,
+                "download_required": download_required,
+                "load_available": is_loaded or (engine_installed and not download_required),
+                "load_status": load_status,
+                "unavailable_reason": unavailable_reason,
             }
-            short_id = str(item["id"]).lower()
-            aliases = MODEL_ENGINE_ALIASES.get(short_id) or {}
-            options: List[Dict[str, str]] = []
-            for engine_name in ("local_mlx", "ollama", "lmstudio", "llamacpp", "vllm"):
-                real = aliases.get(engine_name)
-                if not real:
-                    continue
-                options.append({
-                    "engine": engine_name,
-                    "model_id": real,
-                    "load_id": real if engine_name == "local_mlx" else f"{engine_name}:{real}",
-                })
-            if not options:
-                options.append({"engine": "local_mlx", "model_id": item["id"], "load_id": item["id"]})
             base["engine_options"] = options
-            base["recommended_engine"] = options[0]["engine"]
+            base["recommended_engine"] = recommended_engine
+            base["recommended_load_id"] = load_id
             out.append(base)
         return out
 
@@ -232,6 +274,7 @@ def create_models_router(
         require_user(request)
         return await prepare_and_load_model(
             req.model, request, engine=req.engine, user_email=req.user_email,
+            allow_download=req.allow_download,
         )
 
     @router.post("/engines/prepare-model/stream")
@@ -242,6 +285,7 @@ def create_models_router(
             try:
                 async for chunk in prepare_and_load_model_stream(
                     req.model, request, engine=req.engine, user_email=req.user_email,
+                    allow_download=req.allow_download,
                 ):
                     yield chunk
             except HTTPException as exc:
@@ -287,10 +331,13 @@ def create_models_router(
 
     @router.get("/models")
     async def list_models():
+        engines = await asyncio.to_thread(engine_status)
         recommended = _recommended_with_engine_options(
-            list(filter_lower_family_versions(ENGINE_MODEL_CATALOG.get("local_mlx", [])))
+            list(filter_lower_family_versions(ENGINE_MODEL_CATALOG.get("local_mlx", []))),
+            engines=engines,
+            loaded_ids=_router.loaded_model_ids,
+            current_id=_router.current_model_id,
         )
-        engines = await asyncio.to_thread(engine_status)
         return {
             "recommended": recommended,
             "cloud": _router.detected_cloud_models(),
@@ -319,6 +366,7 @@ def create_models_router(
             return await prepare_and_load_model(
                 model_id, request, engine=req.engine, user_email=req.user_email,
                 adapter_path=req.adapter_path, draft_model_id=req.draft_model_id,
+                allow_download=req.allow_download,
             )
         except HTTPException:
             raise

package/latticeai/brain/projection.py

@@ -94,17 +94,24 @@ class KnowledgeGraphProjectionMixin:
         """
         if KGStoreV2 is None or _exec_script is None:
             return
+        self._v2_projection_available = False
         try:
             self._backup_before_v2_flip()
             with self._connect() as conn:
                 conn.execute("BEGIN")
                 stale = self._projection_version(conn) != _PROJECTION_VERSION
+                # Reconstruction views are non-authoritative. Recreate them on
+                # every startup so older SQLite rename migrations cannot strand
+                # a view against a temporary table such as edges_v2_old.
+                for stmt in (
+                    "DROP VIEW IF EXISTS kgv2_edges",
+                    "DROP VIEW IF EXISTS kgv2_nodes",
+                ):
+                    conn.execute(stmt)
                 if stale:
                     # The projection is non-authoritative; drop it so init_schema
                     # recreates the tables with the current normalized columns.
                     for stmt in (
-                        "DROP VIEW IF EXISTS kgv2_edges",
-                        "DROP VIEW IF EXISTS kgv2_nodes",
                         "DROP TABLE IF EXISTS edges_v2",
                         "DROP TABLE IF EXISTS nodes_v2",
                     ):
@@ -128,6 +135,9 @@ class KnowledgeGraphProjectionMixin:
                     (_V2_WRITE_MASTER_KEY, _V2_WRITE_MASTER_KEY, mastered_at),
                 )
                 conn.execute(f"PRAGMA user_version={_KG_DB_FORMAT_VERSION}")
+                conn.execute("SELECT 1 FROM kgv2_nodes LIMIT 1").fetchone()
+                conn.execute("SELECT 1 FROM kgv2_edges LIMIT 1").fetchone()
+            self._v2_projection_available = True
         except Exception as e:
             logging.warning("knowledge_graph: v2 schema init/backfill skipped: %s", e)
 

package/latticeai/brain/retrieval.py

@@ -879,6 +879,16 @@ class KnowledgeGraphRetrievalMixin:
                     if isinstance(storage_capabilities, dict)
                     else "bruteforce-cosine"
                 ),
+                "vector_search_mode": (
+                    (storage_capabilities.get("metadata") or {}).get("vector_mode")
+                    if isinstance(storage_capabilities, dict)
+                    else "fallback"
+                ),
+                "sqlite_vec_ann_available": (
+                    bool((storage_capabilities.get("metadata") or {}).get("sqlite_vec_ann_available"))
+                    if isinstance(storage_capabilities, dict)
+                    else False
+                ),
             },
             "source_items": len(source_items),
             "indexed_items": sum(vector_counts.values()),

package/latticeai/brain/store.py

@@ -53,10 +53,15 @@ class KnowledgeGraphStore(
         self._embedding_model = (
             embedder if embedder is not None else LocalEmbeddingModel()
         )
+        self._v2_projection_available = False
         self._init_db()
         # Read graph queries from the v2 projection (kgv2_* views) when available.
         # Toggle off (e.g. in tests) to compare against the legacy tables.
-        self._read_from_v2 = KGStoreV2 is not None and _READ_FROM_V2_DEFAULT
+        self._read_from_v2 = (
+            KGStoreV2 is not None
+            and _READ_FROM_V2_DEFAULT
+            and self._v2_projection_available
+        )
 
     def _read_tables(self) -> tuple:
         """Return (nodes_table, edges_table) for read queries.

package/latticeai/core/config.py

@@ -157,6 +157,8 @@ class Config:
             if packaged_static.exists():
                 static_dir = packaged_static
 
+        default_sso_redirect = f"http://localhost:{port}/auth/sso/callback"
+
         return cls(
             app_mode=app_mode,
             is_public=is_public,
@@ -196,7 +198,7 @@ class Config:
             sso_discovery_url=_value(env, "OIDC_DISCOVERY_URL", ""),
             sso_client_id=_value(env, "OIDC_CLIENT_ID", ""),
             sso_client_secret=_value(env, "OIDC_CLIENT_SECRET", ""),
-            sso_redirect_uri=_value(env, "OIDC_REDIRECT_URI", "http://localhost:4825/auth/sso/callback"),
+            sso_redirect_uri=_value(env, "OIDC_REDIRECT_URI", default_sso_redirect),
             sso_provider_name=_value(env, "OIDC_PROVIDER_NAME", "SSO"),
             discord_permission_webhook=_value(env, "LATTICEAI_DISCORD_PERMISSION_WEBHOOK", ""),
             discord_bot_token=_value(env, "LATTICEAI_DISCORD_BOT_TOKEN", ""),

package/latticeai/core/marketplace.py

@@ -11,7 +11,7 @@ from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
 
-MARKETPLACE_VERSION = "4.3.0"
+MARKETPLACE_VERSION = "4.3.1"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent")
 
 

package/latticeai/core/multi_agent.py

@@ -14,7 +14,7 @@ from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional
 
 
-MULTI_AGENT_VERSION = "4.3.0"
+MULTI_AGENT_VERSION = "4.3.1"
 
 AGENT_ROLES = ("researcher", "planner", "executor", "reviewer", "release")
 CORE_PIPELINE = ("planner", "executor", "reviewer")

package/latticeai/core/product_hardening.py

@@ -12,6 +12,7 @@ import shutil
 from pathlib import Path
 from typing import Any, Dict, Mapping, Optional
 
+from latticeai import __version__
 from latticeai.core.config import Config
 
 
@@ -160,7 +161,7 @@ def build_product_hardening_status(
         identity = device_identity.describe()
     data_dir = Path(config.data_dir)
     return {
-        "version": "4.3.0",
+        "version": __version__,
         "startup": {
             "local_only_default": default_startup_local_only(config, env=env),
             "host": config.host,

package/latticeai/core/workspace_os.py

@@ -19,7 +19,7 @@ from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional
 
 
-WORKSPACE_OS_VERSION = "4.3.0"
+WORKSPACE_OS_VERSION = "4.3.1"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type

package/latticeai/services/agent_runtime.py

@@ -50,6 +50,10 @@ def _now() -> str:
     return datetime.now().isoformat(timespec="seconds")
 
 
+class AgentRuntimeUnavailable(RuntimeError):
+    """Raised when a product run would otherwise persist simulation output."""
+
+
 class AgentRuntime:
     def __init__(
         self,
@@ -60,6 +64,7 @@ class AgentRuntime:
         append_audit_event: Callable[..., None],
         max_retries_cap: int = 5,
         hooks: Any = None,
+        allow_simulation_runs: bool = False,
     ):
         self._store = store
         self._orchestrator_factory = orchestrator_factory
@@ -69,6 +74,7 @@ class AgentRuntime:
         # Lifecycle hooks registry (optional). When present, ``start`` fires the
         # ``pre_run`` / ``post_run`` hooks; a blocking ``pre_run`` aborts the run.
         self._hooks = hooks
+        self._allow_simulation_runs = bool(allow_simulation_runs)
         self._run_executor: Any = None
 
     def attach_executor(self, executor: Any) -> None:
@@ -85,6 +91,7 @@ class AgentRuntime:
             "default_pipeline": list(CORE_PIPELINE),
             "max_retries_cap": self._max_retries_cap,
             "execution_mode": self._execution_mode(),
+            "simulation_runs_allowed": self._allow_simulation_runs,
             "cancellation": (
                 "cooperative; running synchronous model/tool calls finish their current step before a cancelled status is persisted"
                 if self._run_executor is not None else
@@ -107,6 +114,7 @@ class AgentRuntime:
     def health(self) -> Dict[str, Any]:
         checks: Dict[str, Any] = {}
         ok = True
+        ready = True
         try:
             self._store.list_agents(workspace_id=None)
             checks["run_store"] = {"status": "ok"}
@@ -114,12 +122,42 @@ class AgentRuntime:
             ok = False
             checks["run_store"] = {"status": "error", "detail": str(exc)}
         try:
-            self._orchestrator_factory(None, None)
-            checks["orchestrator"] = {"status": "ok"}
+            orchestrator = self._orchestrator_factory(None, None)
+            mode = getattr(orchestrator, "mode", "simulation")
+            if mode == "simulation":
+                if self._allow_simulation_runs:
+                    checks["orchestrator"] = {
+                        "status": "ok",
+                        "mode": mode,
+                        "detail": "Simulation runs are explicitly enabled for this non-product runtime.",
+                    }
+                else:
+                    ready = False
+                    checks["orchestrator"] = {
+                        "status": "unavailable",
+                        "mode": mode,
+                        "detail": "No LLM-backed model is loaded; product execution API refuses simulation runs.",
+                    }
+            else:
+                checks["orchestrator"] = {"status": "ok", "mode": mode}
         except Exception as exc:  # pragma: no cover - defensive
             ok = False
             checks["orchestrator"] = {"status": "error", "detail": str(exc)}
-        return {"status": "ok" if ok else "degraded", "checks": checks}
+        return {
+            "status": "ok" if ok and ready else "unavailable" if ok else "degraded",
+            "ready": bool(ok and ready),
+            "checks": checks,
+        }
+
+    def _live_orchestrator(self, user_email: Optional[str], scope: Optional[str]) -> Any:
+        orchestrator = self._orchestrator_factory(user_email or None, scope)
+        mode = getattr(orchestrator, "mode", "simulation")
+        if mode == "simulation" and not self._allow_simulation_runs:
+            raise AgentRuntimeUnavailable(
+                "Agent execution is unavailable because no LLM-backed model is loaded. "
+                "Simulation mode is disabled in the product execution API so it cannot be recorded as real success."
+            )
+        return orchestrator
 
     # ── roster + status ───────────────────────────────────────────────────
     def _roster(self, runs: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
@@ -163,16 +201,21 @@ class AgentRuntime:
             listing = {"agents": [], "runs": [], "error": str(exc)}
         runs = list(listing.get("runs") or [])
         active = sum(1 for r in runs if str(r.get("status")) in _ACTIVE_STATUSES)
+        health = self.health()
+        orchestrator_status = (health.get("checks") or {}).get("orchestrator") or {}
+        ready = bool(health.get("ready"))
         return {
             "runtime": {
-                "ready": True,
+                "ready": ready,
                 "version": MULTI_AGENT_VERSION,
                 "execution_mode": self._execution_mode(),
+                "mode": orchestrator_status.get("mode", "unknown"),
+                "unavailable_reason": None if ready else orchestrator_status.get("detail"),
                 "default_pipeline": list(CORE_PIPELINE),
                 "total_runs": len(runs),
                 "active_runs": active,
             },
-            "health": self.health(),
+            "health": health,
             "roles": self.roles(),
             "agents": self._roster(runs),
             "runs": runs[:25],
@@ -288,11 +331,8 @@ class AgentRuntime:
             user_email=user_email,
             scope=scope,
         )
-        try:
-            orchestrator = self._orchestrator_factory(user_email or None, scope)
-            mode = getattr(orchestrator, "mode", "simulation")
-        except Exception:
-            mode = "simulation"
+        orchestrator = self._live_orchestrator(user_email, scope)
+        mode = getattr(orchestrator, "mode", "llm")
         run = self._store.record_agent_run(
             agent_id=ROLE_AGENT_IDS.get("executor", "agent:executor"),
             status="queued",
@@ -349,7 +389,7 @@ class AgentRuntime:
             started_at=run.get("started_at") or _now(),
         )
         try:
-            orchestrator = self._orchestrator_factory(user_email or None, scope)
+            orchestrator = self._live_orchestrator(user_email, scope)
             result = orchestrator.run(
                 goal,
                 user_email=user_email or None,
@@ -452,7 +492,7 @@ class AgentRuntime:
                 )
                 raise PermissionError(pre_dispatch.get("block_reason") or "Agent run blocked by a pre_run hook.")
 
-        orchestrator = self._orchestrator_factory(user_email or None, scope)
+        orchestrator = self._live_orchestrator(user_email, scope)
         result = orchestrator.run(
             goal,
             user_email=user_email or None,

package/latticeai/services/model_runtime.py

@@ -66,6 +66,51 @@ IS_PUBLIC_MODE = False
 keyring = None
 
 
+def _env_bool(key: str, default: bool = False) -> bool:
+    raw = os.getenv(key)
+    if raw is None:
+        return default
+    return raw.strip().lower() in {"1", "true", "yes", "on"}
+
+
+def _download_allowed(allow_download: bool = False) -> bool:
+    return bool(allow_download) or _env_bool("LATTICEAI_ALLOW_MODEL_DOWNLOADS", default=False) or bool(AUTOLOAD_MODELS)
+
+
+def _download_block(provider: str, model_name: str) -> None:
+    raise HTTPException(
+        status_code=409,
+        detail={
+            "status": "unavailable",
+            "capability": "model_download",
+            "provider": provider,
+            "model": model_name,
+            "reason": (
+                "Model files are not present locally. Lattice AI does not start "
+                "outbound model downloads by default, and token/model presence "
+                "alone never authorizes network activity."
+            ),
+            "action": "Use the explicit pull/prepare flow with download consent, or set LATTICEAI_ALLOW_MODEL_DOWNLOADS=true.",
+        },
+    )
+
+
+def _engine_install_block(engine: str) -> None:
+    raise HTTPException(
+        status_code=409,
+        detail={
+            "status": "unavailable",
+            "capability": "engine_install",
+            "engine": engine,
+            "reason": (
+                "The requested local runtime is not installed. Lattice AI does not "
+                "run package-manager or installer commands from Model Load by default."
+            ),
+            "action": "Install the runtime explicitly from Library/System setup, or enable explicit download/install consent for this request.",
+        },
+    )
+
+
 def _missing_current_user(_request: Request) -> Optional[str]:
     return None
 
@@ -1307,6 +1352,7 @@ async def prepare_and_load_model(
     user_email: Optional[str] = None,
     adapter_path: Optional[str] = None,
     draft_model_id: Optional[str] = None,
+    allow_download: bool = False,
 ) -> Dict[str, object]:
     model_id = normalize_local_model_request(model_id, engine)
     if not model_id:
@@ -1329,11 +1375,15 @@ async def prepare_and_load_model(
     download_result: Optional[Dict[str, object]] = None
 
     if parsed_provider in local_engines:
+        if not engine_installed(parsed_provider) and not _download_allowed(allow_download):
+            _engine_install_block(parsed_provider)
         install_result = ensure_engine_ready(parsed_provider)
 
     if parsed_provider == "local_mlx":
         explicit_path = Path(parsed_model).expanduser()
         if not explicit_path.exists() and not hf_model_ready(parsed_model, "local_mlx"):
+            if not _download_allowed(allow_download):
+                _download_block(parsed_provider, parsed_model)
             download_result = download_hf_model(parsed_model, "local_mlx")
     elif parsed_provider == "ollama":
         ensure_ollama_server()
@@ -1341,6 +1391,8 @@ async def prepare_and_load_model(
         if not ollama:
             raise HTTPException(status_code=400, detail="Ollama가 설치되지 않았습니다.")
         if parsed_model not in get_ollama_pulled_models():
+            if not _download_allowed(allow_download):
+                _download_block(parsed_provider, parsed_model)
             completed = subprocess.run(
                 [ollama, "pull", parsed_model],
                 capture_output=True,
@@ -1352,12 +1404,23 @@ async def prepare_and_load_model(
                 raise HTTPException(status_code=500, detail=completed.stderr[-2000:] or "Ollama 모델 다운로드 실패")
             download_result = {"provider": "ollama", "model": parsed_model, "returncode": completed.returncode}
     elif parsed_provider == "vllm":
+        if not hf_model_ready(parsed_model, "vllm") and not _download_allowed(allow_download):
+            _download_block(parsed_provider, parsed_model)
         ensure_vllm_server(parsed_model)
         download_result = {"provider": "vllm", "model": parsed_model, "server_ready": True}
     elif parsed_provider == "llamacpp":
+        if not hf_model_ready(parsed_model, "llamacpp") and not _download_allowed(allow_download):
+            _download_block(parsed_provider, parsed_model)
         ensure_llamacpp_server(parsed_model)
         download_result = {"provider": "llamacpp", "model": parsed_model, "server_ready": True}
     elif parsed_provider == "lmstudio":
+        downloaded = {
+            str(item.get("key") or "").strip()
+            for item in get_lmstudio_models()
+            if isinstance(item, dict)
+        }
+        if parsed_model not in downloaded and not _download_allowed(allow_download):
+            _download_block(parsed_provider, parsed_model)
         ensured = ensure_lmstudio_model(parsed_model)
         resolved_model = str(
             ensured.get("instance_id")
@@ -1399,7 +1462,7 @@ async def prepare_and_load_model(
         "installed_now": bool(install_result.get("installed_now")),
         "download": download_result,
         "resolution": resolution.to_dict(),
-        "downloaded": True,
+        "downloaded": bool(download_result and not (isinstance(download_result, dict) and download_result.get("cached"))),
         "loaded": True,
         "ready_to_chat": ready_to_chat,
         "compatibility_status": compat_status,
@@ -1416,6 +1479,7 @@ async def prepare_and_load_model_stream(
     request: Request,
     engine: Optional[str] = None,
     user_email: Optional[str] = None,
+    allow_download: bool = False,
 ) -> AsyncIterator[str]:
     model_id = normalize_local_model_request(model_id, engine)
     if not model_id:
@@ -1446,6 +1510,8 @@ async def prepare_and_load_model_stream(
                     percent=2,
                     indeterminate=True,
                 ))
+                if not engine_installed(parsed_provider) and not _download_allowed(allow_download):
+                    _engine_install_block(parsed_provider)
                 install_result = ensure_engine_ready(parsed_provider)
                 emit_progress(model_download_progress_payload(
                     "engine",
@@ -1466,6 +1532,8 @@ async def prepare_and_load_model_stream(
                         eta_seconds=0,
                     ))
                 elif not hf_model_ready(parsed_model, "local_mlx"):
+                    if not _download_allowed(allow_download):
+                        _download_block(parsed_provider, parsed_model)
                     download_result = download_hf_model(parsed_model, "local_mlx", progress_emit=emit_progress)
                 else:
                     download_result = {"model": parsed_model, "path": str(hf_model_dir(parsed_model)), "cached": True}
@@ -1484,6 +1552,8 @@ async def prepare_and_load_model_stream(
                 ))
                 ensure_ollama_server()
                 if parsed_model not in get_ollama_pulled_models():
+                    if not _download_allowed(allow_download):
+                        _download_block(parsed_provider, parsed_model)
                     download_result = pull_ollama_model_with_progress(parsed_model, progress_emit=emit_progress)
                 else:
                     download_result = {"provider": "ollama", "model": parsed_model, "cached": True}
@@ -1496,6 +1566,8 @@ async def prepare_and_load_model_stream(
                     ))
             elif parsed_provider == "vllm":
                 if not hf_model_ready(parsed_model, "vllm"):
+                    if not _download_allowed(allow_download):
+                        _download_block(parsed_provider, parsed_model)
                     download_result = download_hf_model(parsed_model, "vllm", progress_emit=emit_progress)
                 else:
                     download_result = {"provider": "vllm", "model": parsed_model, "cached": True}
@@ -1516,6 +1588,8 @@ async def prepare_and_load_model_stream(
                 download_result = {**(download_result or {}), "provider": "vllm", "model": parsed_model, "server_ready": True}
             elif parsed_provider == "llamacpp":
                 if not hf_model_ready(parsed_model, "llamacpp"):
+                    if not _download_allowed(allow_download):
+                        _download_block(parsed_provider, parsed_model)
                     download_result = download_hf_model(parsed_model, "llamacpp", progress_emit=emit_progress)
                 else:
                     download_result = {"provider": "llamacpp", "model": parsed_model, "cached": True}
@@ -1535,6 +1609,13 @@ async def prepare_and_load_model_stream(
                 ensure_llamacpp_server(parsed_model)
                 download_result = {**(download_result or {}), "provider": "llamacpp", "model": parsed_model, "server_ready": True}
             elif parsed_provider == "lmstudio":
+                downloaded = {
+                    str(item.get("key") or "").strip()
+                    for item in get_lmstudio_models()
+                    if isinstance(item, dict)
+                }
+                if parsed_model not in downloaded and not _download_allowed(allow_download):
+                    _download_block(parsed_provider, parsed_model)
                 emit_progress(model_download_progress_payload(
                     "download",
                     "LM Studio 모델을 확인하는 중입니다.",
@@ -1643,7 +1724,7 @@ async def prepare_and_load_model_stream(
         "installed_now": bool(isinstance(install_result, dict) and install_result.get("installed_now")),
         "download": download_result,
         "resolution": resolution_stream.to_dict(),
-        "downloaded": True,
+        "downloaded": bool(download_result and not (isinstance(download_result, dict) and download_result.get("cached"))),
         "loaded": True,
         "ready_to_chat": ready_to_chat,
         "compatibility_status": compat_status,

package/ltcai_cli.py

@@ -246,9 +246,15 @@ def main() -> None:
 
     os.chdir(app_dir)
 
-    # LATTICEAI_TUNNEL=true in .env acts like --tunnel flag
-    if not args.tunnel and os.getenv("LATTICEAI_TUNNEL", "").lower() in ("1", "true", "yes"):
-        args.tunnel = True
+    if not args.tunnel and os.getenv("LATTICEAI_TUNNEL", "").lower() in (
+        "1",
+        "true",
+        "yes",
+    ):
+        print(
+            "  LATTICEAI_TUNNEL is ignored during default local startup; "
+            "restart with --tunnel to expose this server."
+        )
 
     # --tunnel forces 0.0.0.0 so cloudflared can reach the server
     if args.tunnel and args.host == "127.0.0.1":
@@ -257,6 +263,11 @@ def main() -> None:
         os.environ.setdefault("LATTICEAI_CORS_ALLOW_NETWORK", "true")
         os.environ.setdefault("LATTICEAI_REQUIRE_AUTH", "true")
 
+    # Keep the app config in sync with CLI flags. ``Config.from_env`` is the
+    # source of truth for /mode, /health.features, SSO defaults, and routers.
+    os.environ["LATTICEAI_HOST"] = str(args.host)
+    os.environ["LATTICEAI_PORT"] = str(args.port)
+
     tunnel_url: str | None = None
     if args.tunnel:
         print()