ltcai 8.6.0 → 8.8.0

package/latticeai/app_factory.py

@@ -94,7 +94,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     from pydantic import BaseModel
 
     from latticeai.models.router import LLMRouter, normalize_branding
-    from lattice_brain._kg_common import set_llm_router
+    from lattice_brain.graph._kg_common import set_llm_router
     from lattice_brain.graph.schema import set_embed_dim
     from latticeai.core.security import (
         hash_password,
@@ -107,7 +107,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         enforce_rate_limit as _enforce_rate_limit,
     )
     from latticeai.core.audit import (
-        get_audit_log as _get_audit_log,
+        get_audit_log as _get_audit_log,  # noqa: F401 - legacy server_app attr exported via locals()
         classify_sensitive_message as _classify_sensitive_message,
         build_sensitivity_report as _build_sensitivity_report,
         build_admin_audit_report as _build_admin_audit_report,
@@ -992,7 +992,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         create_admin_router=create_admin_router,
         require_admin=require_admin,
         get_history=get_history,
-        get_audit_log=_get_audit_log,
+        get_audit_log=get_audit_log,
         audit_file=AUDIT_FILE,
         public_user=public_user,
         load_vpc_config=load_vpc_config,

package/latticeai/core/config.py

@@ -43,7 +43,12 @@ def _bool(env: Mapping[str, str], key: str, default: bool = False) -> bool:
     raw = env.get(key)
     if raw is None:
         return default
-    return raw.strip().lower() in {"1", "true", "yes", "on"}
+    normalized = raw.strip().lower()
+    if normalized in {"1", "true", "yes", "on"}:
+        return True
+    if normalized in {"0", "false", "no", "off"}:
+        return False
+    return default
 
 
 def _int(env: Mapping[str, str], key: str, default: int) -> int:
@@ -56,6 +61,13 @@ def _int(env: Mapping[str, str], key: str, default: int) -> int:
         return default
 
 
+def _port(env: Mapping[str, str], key: str, default: int) -> int:
+    port = _int(env, key, default)
+    if 1 <= port <= 65535:
+        return port
+    return default
+
+
 @dataclass(frozen=True)
 class Config:
     """Everything a caller must know about app-level settings.
@@ -146,7 +158,7 @@ class Config:
         is_public = app_mode == "public"
 
         host = _value(env, "LATTICEAI_HOST", "127.0.0.1")
-        port = _int(env, "LATTICEAI_PORT", 4825)
+        port = _port(env, "LATTICEAI_PORT", 4825)
         network_exposed = not host_is_loopback(host)
 
         cors_extra = [item.strip() for item in _value(env, "LATTICEAI_CORS_ALLOWED_ORIGINS", "").split(",") if item.strip()]

package/latticeai/core/legacy_compatibility.py

@@ -14,7 +14,7 @@ from pathlib import Path
 from typing import Any, Dict, List
 
 
-LEGACY_COMPATIBILITY_VERSION = "8.5.0"
+LEGACY_COMPATIBILITY_VERSION = "8.8.0"
 
 
 @dataclass(frozen=True)
@@ -43,7 +43,7 @@ LEGACY_SHIMS: List[LegacyShim] = [
     LegacyShim(
         path="knowledge_graph.py",
         owner="lattice_brain.graph",
-        replacement="from lattice_brain.store import KnowledgeGraphStore",
+        replacement="from lattice_brain.graph.store import KnowledgeGraphStore",
         reason="Historical scripts imported the graph store from the repo root.",
         removal_phase="major-release-after-8.x",
     ),
@@ -57,7 +57,7 @@ LEGACY_SHIMS: List[LegacyShim] = [
     LegacyShim(
         path="kg_schema.py",
         owner="lattice_brain.graph.schema",
-        replacement="from lattice_brain.schema import ...",
+        replacement="from lattice_brain.graph.schema import ...",
         reason="Historical graph schema tests and tools referenced root schema symbols.",
         removal_phase="major-release-after-8.x",
     ),
@@ -96,53 +96,59 @@ LEGACY_SHIMS: List[LegacyShim] = [
         reason="Local folder ingestion integrations used the root local knowledge API.",
         removal_phase="requires-api-route-migration",
     ),
+]
+
+# Shim layers that have completed their compatibility window and were
+# physically deleted. Kept in the report so consumers (docs, tests, release
+# notes) can tell "removed on purpose" apart from "missing by accident".
+# Removing the internal-only layers is the first step of extracting
+# ``lattice_brain`` as a standalone Brain Core package: the package now has
+# exactly one import surface (``lattice_brain.*`` physical paths).
+REMOVED_SHIMS: List[LegacyShim] = [
     LegacyShim(
         path="lattice_brain/store.py",
         owner="lattice_brain.graph.store",
         replacement="from lattice_brain.graph.store import KnowledgeGraphStore",
-        reason="Pre-graph-package imports used the flat Brain store module.",
-        removal_phase="major-release-after-8.x",
+        reason="Pre-graph-package flat modules were internal-only; removed in 8.8.0.",
+        removal_phase="removed-8.8.0",
         layer="brain-flat",
+        status="removed",
     ),
     LegacyShim(
         path="lattice_brain/ingest.py",
         owner="lattice_brain.graph.ingest",
         replacement="from lattice_brain.graph.ingest import KnowledgeGraphIngestMixin",
-        reason="Pre-graph-package imports used the flat Brain ingest module.",
-        removal_phase="major-release-after-8.x",
+        reason="Pre-graph-package flat modules were internal-only; removed in 8.8.0.",
+        removal_phase="removed-8.8.0",
         layer="brain-flat",
+        status="removed",
     ),
     LegacyShim(
         path="lattice_brain/retrieval.py",
         owner="lattice_brain.graph.retrieval",
         replacement="from lattice_brain.graph.retrieval import KnowledgeGraphRetrievalMixin",
-        reason="Pre-graph-package imports used the flat Brain retrieval module.",
-        removal_phase="major-release-after-8.x",
+        reason="Pre-graph-package flat modules were internal-only; removed in 8.8.0.",
+        removal_phase="removed-8.8.0",
         layer="brain-flat",
+        status="removed",
     ),
     LegacyShim(
-        path="latticeai/brain/store.py",
-        owner="lattice_brain.graph.store",
-        replacement="from lattice_brain.graph.store import KnowledgeGraphStore",
-        reason="The deprecated latticeai.brain namespace remains for package users.",
-        removal_phase="major-release-after-8.x",
-        layer="deprecated-namespace",
-    ),
-    LegacyShim(
-        path="latticeai/brain/ingest.py",
-        owner="lattice_brain.graph.ingest",
-        replacement="from lattice_brain.graph.ingest import KnowledgeGraphIngestMixin",
-        reason="The deprecated latticeai.brain namespace remains for package users.",
-        removal_phase="major-release-after-8.x",
+        path="latticeai/brain/",
+        owner="lattice_brain",
+        replacement="import lattice_brain",
+        reason="The deprecated latticeai.brain namespace completed its window; removed in 8.8.0.",
+        removal_phase="removed-8.8.0",
         layer="deprecated-namespace",
+        status="removed",
     ),
     LegacyShim(
         path="latticeai/services/agent_runtime.py",
         owner="lattice_brain.runtime.agent_runtime",
         replacement="from lattice_brain.runtime.agent_runtime import AgentRuntime",
-        reason="Service-layer imports existed before AgentRuntime moved into Brain runtime.",
-        removal_phase="major-release-after-8.x",
+        reason="The service-layer alias completed its window; removed in 8.8.0.",
+        removal_phase="removed-8.8.0",
         layer="service-alias",
+        status="removed",
     ),
 ]
 
@@ -152,23 +158,28 @@ def legacy_shim_report(root: Path | None = None) -> Dict[str, Any]:
         root = Path(__file__).resolve().parents[2]
     entries = [shim.as_dict() for shim in LEGACY_SHIMS]
     missing = [shim.path for shim in LEGACY_SHIMS if not (root / shim.path).exists()]
+    lingering = [shim.path for shim in REMOVED_SHIMS if (root / shim.path).exists()]
     phases = sorted({shim.removal_phase for shim in LEGACY_SHIMS})
     layers = sorted({shim.layer for shim in LEGACY_SHIMS})
     return {
         "schema_version": "legacy-compatibility/v1",
         "version_target": LEGACY_COMPATIBILITY_VERSION,
-        "status": "managed" if not missing else "incomplete",
+        "status": "managed" if not missing and not lingering else "incomplete",
         "remaining_count": len(LEGACY_SHIMS),
+        "removed_count": len(REMOVED_SHIMS),
         "missing": missing,
+        "lingering": lingering,
         "removal_phases": phases,
         "layers": layers,
         "shims": entries,
+        "removed": [shim.as_dict() for shim in REMOVED_SHIMS],
     }
 
 
 __all__ = [
     "LEGACY_COMPATIBILITY_VERSION",
     "LEGACY_SHIMS",
+    "REMOVED_SHIMS",
     "LegacyShim",
     "legacy_shim_report",
 ]

package/latticeai/core/marketplace.py

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

package/latticeai/core/workspace_os.py

@@ -49,7 +49,7 @@ __all__ = [
     "remove_skill_directory",
 ]
 
-WORKSPACE_OS_VERSION = "8.6.0"
+WORKSPACE_OS_VERSION = "8.8.0"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type

package/latticeai/models/router.py

@@ -13,8 +13,9 @@ import time
 from dataclasses import dataclass
 from pathlib import Path
 
-# Set MLX_VLM_DRAFT_KIND to 'mtp' to enable the Gemma 4 assistant MTP drafter.
-os.environ["MLX_VLM_DRAFT_KIND"] = "mtp"
+# Default Gemma 4 assistant drafting to MTP without overriding an operator's
+# explicit MLX runtime choice.
+os.environ.setdefault("MLX_VLM_DRAFT_KIND", "mtp")
 
 from concurrent.futures import ThreadPoolExecutor
 from typing import AsyncIterator, Dict, Optional, Tuple, List

package/latticeai/runtime/persistence_runtime.py

@@ -27,7 +27,7 @@ def build_persistence_runtime(
     import os
     from pathlib import Path
 
-    from lattice_brain.identity import DeviceIdentity
+    from lattice_brain.graph.identity import DeviceIdentity
     from lattice_brain.ingestion import IngestionPipeline
     from lattice_brain.portability import KGPortabilityService
     from latticeai.core.agent_registry import AgentRegistry

package/latticeai/runtime/platform_services_runtime.py

@@ -30,7 +30,7 @@ def build_brain_network(
 ) -> Any:
     """Construct peer sync/network service for brain portability routes."""
 
-    from lattice_brain.network import BrainNetwork
+    from lattice_brain.graph.network import BrainNetwork
 
     return BrainNetwork(
         identity=identity,

package/latticeai/runtime/router_registration.py

@@ -162,16 +162,22 @@ def build_auth_admin_security_router_bundle(
         append_audit_event=append_audit_event,
     )
 
-    def security_audit_events_safe() -> list[dict[str, Any]]:
+    def audit_log_events_safe() -> list[dict[str, Any]]:
         try:
-            return get_audit_log(audit_file)
+            return get_audit_log()
+        except TypeError:
+            try:
+                return get_audit_log(audit_file)
+            except Exception as exc:  # pragma: no cover - defensive legacy behavior
+                logger.warning("security audit events load failed: %s", exc)
+                return []
         except Exception as exc:  # pragma: no cover - defensive legacy behavior
             logger.warning("security audit events load failed: %s", exc)
             return []
 
     def security_list_uploaded_files() -> list[dict[str, Any]]:
         files: list[dict[str, Any]] = []
-        for idx, event in enumerate(security_audit_events_safe()):
+        for idx, event in enumerate(audit_log_events_safe()):
             if event.get("event_type") != "document_upload":
                 continue
             files.append({
@@ -191,7 +197,7 @@ def build_auth_admin_security_router_bundle(
     security_router = create_security_router(
         require_admin=require_admin,
         get_history=get_history,
-        get_audit_events=security_audit_events_safe,
+        get_audit_events=audit_log_events_safe,
         classify_sensitive_message=classify_sensitive_message,
         build_sensitivity_report=build_sensitivity_report,
         list_uploaded_files=security_list_uploaded_files,
@@ -205,7 +211,7 @@ def build_auth_admin_security_router_bundle(
         "security_router": security_router,
         "_graph_stats_safe": graph_stats_safe,
         "_product_hardening_status": product_hardening_status,
-        "_security_audit_events_safe": security_audit_events_safe,
+        "_security_audit_events_safe": audit_log_events_safe,
         "_security_list_uploaded_files": security_list_uploaded_files,
     }
 

package/latticeai/services/architecture_readiness.py

@@ -1,6 +1,6 @@
 """Machine-checkable architecture readiness gates for release work.
 
-8.6.0 keeps the major architecture priorities under an explicit release
+8.8.0 keeps the major architecture priorities under an explicit release
 contract while product maturity work reduces visible beta seams. AgentRuntime, ToolRegistry,
 central Config, decomposed server runtime, and Knowledge Graph stabilization
 must remain discoverable, ordered, and backed by tests before the release can be
@@ -17,7 +17,7 @@ from typing import Any, Dict, List
 from latticeai.core.legacy_compatibility import legacy_shim_report
 
 
-ARCHITECTURE_VERSION_TARGET = "8.6.0"
+ARCHITECTURE_VERSION_TARGET = "8.8.0"
 
 PREFERRED_REFACTORING_ORDER = [
     "agent-runtime",

package/latticeai/services/memory_service.py

@@ -533,6 +533,10 @@ class MemoryService:
                 "title": item.get("title"),
                 "snippet": item.get("snippet"),
                 "score": item.get("score", 0),
+                # Evidence explainability: why this item was recalled, so the
+                # citation UI can show the matched terms instead of a bare score.
+                "matched_terms": item.get("matched_terms") or [],
+                "confidence": item.get("confidence") or "low",
             }
             for item in recall.get("results", [])[: max(1, min(limit, 8))]
         ]
@@ -616,15 +620,17 @@ class MemoryService:
         q = str(query or "").strip()
         query_tokens = [tok for tok in q.lower().split() if tok]
 
-        def _lexical_score(*texts: Any) -> float:
+        def _matched_terms(*texts: Any) -> List[str]:
+            haystack = " ".join(str(t or "") for t in texts).lower()
+            return [tok for tok in query_tokens if tok in haystack]
+
+        def _lexical_score(matched: List[str]) -> float:
             # Honest, comparable relevance: fraction of query tokens present.
             # Both tiers share this scorer so the cross-tier ranking is real,
             # not an artifact of per-tier constants.
             if not query_tokens:
                 return 0.0
-            haystack = " ".join(str(t or "") for t in texts).lower()
-            hits = sum(1 for tok in query_tokens if tok in haystack)
-            return round(hits / len(query_tokens), 4)
+            return round(len(matched) / len(query_tokens), 4)
 
         results: List[Dict[str, Any]] = []
 
@@ -633,13 +639,15 @@ class MemoryService:
         except Exception:
             mem = []
         for m in mem:
+            matched = _matched_terms(m.get("content"), " ".join(m.get("tags") or []), m.get("kind"))
             results.append({
                 "source": "workspace",
                 "id": m.get("id"),
                 "title": (m.get("kind") or "memory"),
                 "snippet": str(m.get("content") or "")[:240],
                 "kind": m.get("kind"),
-                "score": _lexical_score(m.get("content"), " ".join(m.get("tags") or []), m.get("kind")),
+                "score": _lexical_score(matched),
+                "matched_terms": matched,
                 "tags": m.get("tags") or [],
             })
 
@@ -650,17 +658,40 @@ class MemoryService:
             except Exception:
                 hits = []
             for hit in hits[:limit]:
+                matched = _matched_terms(hit.get("title"), hit.get("name"), hit.get("summary"), hit.get("content"))
                 results.append({
                     "source": "graph",
                     "id": hit.get("id") or hit.get("node_id"),
                     "title": hit.get("title") or hit.get("name") or "node",
                     "snippet": str(hit.get("summary") or hit.get("content") or "")[:240],
                     "kind": hit.get("type") or "node",
-                    "score": _lexical_score(hit.get("title"), hit.get("name"), hit.get("summary"), hit.get("content")),
+                    "score": _lexical_score(matched),
+                    "matched_terms": matched,
                 })
 
+        # Quality gate: when at least one result carries real lexical evidence,
+        # zero-score rows are noise relative to it and are dropped. When nothing
+        # scores (e.g. tokenization mismatch), everything is kept so the tiers'
+        # own search filters still decide — the gate never empties a recall.
+        candidates = len(results)
+        if query_tokens and any(r.get("score", 0) > 0 for r in results):
+            results = [r for r in results if r.get("score", 0) > 0]
+        for r in results:
+            r["confidence"] = "high" if r.get("score", 0) >= 0.65 else "medium" if r.get("score", 0) >= 0.3 else "low"
+
         results.sort(key=lambda r: r.get("score", 0), reverse=True)
-        return {"query": q, "results": results[: max(1, min(limit, 100))], "count": len(results), "source": "live"}
+        return {
+            "query": q,
+            "results": results[: max(1, min(limit, 100))],
+            "count": len(results),
+            "source": "live",
+            "quality_gate": {
+                "candidates": candidates,
+                "passed": len(results),
+                "filtered": candidates - len(results),
+                "gate": "lexical-evidence/v1",
+            },
+        }
 
     # ── inspect a single tier ─────────────────────────────────────────────
     def inspect(self, source: str, *, user_email: Optional[str] = None, workspace_id: Optional[str] = None, limit: int = 50) -> Dict[str, Any]:

package/latticeai/services/model_runtime.py

@@ -16,6 +16,7 @@ import shutil
 import time
 import urllib.error
 import urllib.request
+import warnings
 from pathlib import Path
 from typing import AsyncIterator, Dict, List, Optional
 
@@ -100,6 +101,21 @@ class ModelRuntimeState:
         self.get_user_api_key = _missing_user_api_key
 
     def sync_to_module_globals(self):
+        """Sync to bare module globals for legacy external importers.
+
+        This is a compatibility surface only. Internal code should use STATE.
+        Emits DeprecationWarning (future removal in major after 8.x).
+        """
+        warnings.warn(
+            "sync_to_module_globals is a legacy compatibility shim and will be removed "
+            "after 8.x. Use latticeai.services.model_runtime.STATE or injected context instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self._sync_globals()
+
+    def _sync_globals(self) -> None:
+        """Internal no-warning sync used at init."""
         global router, APP_MODE, DEFAULT_HOST, DEFAULT_PORT, DATA_DIR, BASE_DIR
         global ENABLE_TELEGRAM, ENABLE_GRAPH, AUTOLOAD_MODELS, MODEL_IDLE_UNLOAD_SECONDS
         global ALLOW_LOCAL_MODELS, REQUIRE_AUTH, INVITE_GATE_ENABLED, ALLOW_PLAINTEXT_API_KEYS
@@ -128,7 +144,7 @@ class ModelRuntimeState:
         get_user_api_key = self.get_user_api_key
 
 STATE = ModelRuntimeState()
-STATE.sync_to_module_globals()
+STATE._sync_globals()  # initial no-warning; public API warns on explicit legacy syncs
 
 # Configured by server_app.configure_model_runtime during app assembly.
 
@@ -141,7 +157,9 @@ def _env_bool(key: str, default: bool = False) -> bool:
 
 
 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)
+    # Prefer STATE (the source of truth) over bare module global for internal logic.
+    autoload = getattr(STATE, "AUTOLOAD_MODELS", AUTOLOAD_MODELS)
+    return bool(allow_download) or _env_bool("LATTICEAI_ALLOW_MODEL_DOWNLOADS", default=False) or bool(autoload)
 
 
 def _download_block(provider: str, model_name: str) -> None:
@@ -204,7 +222,7 @@ def configure_model_runtime(**deps) -> None:
         elif key == "get_user_api_key":
             STATE.get_user_api_key = value
 
-    STATE.sync_to_module_globals()
+    STATE._sync_globals()  # wiring path uses internal (no spurious deprecation in normal startup)
 
 
 # Catalog data + version-dedup helpers live in ``model_catalog``; re-exported
@@ -727,7 +745,8 @@ def engine_installed(engine: str) -> bool:
     return False
 
 def engine_status() -> List[Dict]:
-    cloud_models = router.detected_cloud_models()
+    r = getattr(STATE, "router", None) or router
+    cloud_models = r.detected_cloud_models() if r else []
     cloud_by_provider = {}
     for model in cloud_models:
         cloud_by_provider.setdefault(model["provider"], []).append(model)
@@ -887,37 +906,41 @@ def engine_status() -> List[Dict]:
     return engines
 
 def runtime_features() -> Dict:
+    # Read from STATE object (central) for implementation; bare globals kept only
+    # for external legacy consumers who import names directly from this module.
+    s = STATE
+    r = getattr(s, "router", None) or router
     return {
-        "mode": APP_MODE,
-        "public": IS_PUBLIC_MODE,
-        "host": DEFAULT_HOST,
-        "port": DEFAULT_PORT,
-        "data_dir": str(DATA_DIR),
-        "telegram_enabled": ENABLE_TELEGRAM,
-        "graph_enabled": ENABLE_GRAPH,
-        "autoload_models": AUTOLOAD_MODELS,
-        "model_idle_unload_seconds": MODEL_IDLE_UNLOAD_SECONDS,
-        "model_memory_policy": router.model_memory_policy(),
-        "allow_local_models": ALLOW_LOCAL_MODELS,
+        "mode": s.APP_MODE,
+        "public": s.IS_PUBLIC_MODE,
+        "host": s.DEFAULT_HOST,
+        "port": s.DEFAULT_PORT,
+        "data_dir": str(s.DATA_DIR),
+        "telegram_enabled": s.ENABLE_TELEGRAM,
+        "graph_enabled": s.ENABLE_GRAPH,
+        "autoload_models": s.AUTOLOAD_MODELS,
+        "model_idle_unload_seconds": s.MODEL_IDLE_UNLOAD_SECONDS,
+        "model_memory_policy": r.model_memory_policy() if r else None,
+        "allow_local_models": s.ALLOW_LOCAL_MODELS,
         "security": {
-            "host": DEFAULT_HOST,
-            "require_auth": REQUIRE_AUTH,
-            "invite_gate_enabled": INVITE_GATE_ENABLED,
-            "keyring_available": keyring is not None,
-            "plaintext_api_keys_allowed": ALLOW_PLAINTEXT_API_KEYS,
-            "cors_allow_network": CORS_ALLOW_NETWORK,
+            "host": s.DEFAULT_HOST,
+            "require_auth": s.REQUIRE_AUTH,
+            "invite_gate_enabled": s.INVITE_GATE_ENABLED,
+            "keyring_available": s.keyring is not None,
+            "plaintext_api_keys_allowed": s.ALLOW_PLAINTEXT_API_KEYS,
+            "cors_allow_network": s.CORS_ALLOW_NETWORK,
         },
-        "default_model": PUBLIC_MODEL if IS_PUBLIC_MODE else LOCAL_MODEL,
+        "default_model": s.PUBLIC_MODEL if s.IS_PUBLIC_MODE else s.LOCAL_MODEL,
         "local_only_features": {
-            "mlx": ALLOW_LOCAL_MODELS and not IS_PUBLIC_MODE,
-            "telegram_bridge": ENABLE_TELEGRAM,
-            "desktop_chrome_bridge": not IS_PUBLIC_MODE,
-            "computer_use_bridge": not IS_PUBLIC_MODE,
+            "mlx": s.ALLOW_LOCAL_MODELS and not s.IS_PUBLIC_MODE,
+            "telegram_bridge": s.ENABLE_TELEGRAM,
+            "desktop_chrome_bridge": not s.IS_PUBLIC_MODE,
+            "computer_use_bridge": not s.IS_PUBLIC_MODE,
         },
         "public_features": {
             "web_ui": True,
             "openai_compatible_models": True,
-            "persistent_data_dir": str(DATA_DIR),
+            "persistent_data_dir": str(s.DATA_DIR),
         },
     }
 
@@ -1099,7 +1122,8 @@ async def _probe_cloud_model(model_ref: str) -> Dict[str, object]:
 
 async def verify_cloud_models(force: bool = False, provider_filter: Optional[str] = None) -> Dict[str, Dict]:
     now = time.time()
-    cloud_items = [item for item in router.detected_cloud_models() if item.get("tag") == "cloud"]
+    r = getattr(STATE, "router", None) or router
+    cloud_items = [item for item in (r.detected_cloud_models() if r else []) if item.get("tag") == "cloud"]
     if provider_filter:
         cloud_items = [item for item in cloud_items if item.get("provider") == provider_filter]
 

package/latticeai/services/product_readiness.py

@@ -18,7 +18,7 @@ from typing import Any, Dict, List
 
 from latticeai.services.architecture_readiness import architecture_readiness
 
-PRODUCT_VERSION_TARGET = "8.6.0"
+PRODUCT_VERSION_TARGET = "8.8.0"
 
 
 @dataclass(frozen=True)
@@ -76,10 +76,10 @@ PRODUCT_GATES: List[ProductGate] = [
         evidence=[
             "package.json::release:artifacts",
             "package.json::release:validate",
-            "README.md::dist/ltcai-8.6.0-py3-none-any.whl",
-            "README.md::dist/ltcai-8.6.0.tar.gz",
-            "README.md::dist/ltcai-8.6.0.vsix",
-            "README.md::ltcai-8.6.0.tgz",
+            "README.md::dist/ltcai-8.8.0-py3-none-any.whl",
+            "README.md::dist/ltcai-8.8.0.tar.gz",
+            "README.md::dist/ltcai-8.8.0.vsix",
+            "README.md::ltcai-8.8.0.tgz",
             "scripts/validate_release_artifacts.py",
             "scripts/release_smoke.py",
             "Dockerfile",
@@ -95,12 +95,12 @@ PRODUCT_GATES: List[ProductGate] = [
         title="Release story is documented and honest",
         evidence=[
             "README.md",
-            "README.md::The current release is **8.6.0",
-            "SECURITY.md::8.6.x (latest)",
-            "vscode-extension/README.md::**8.6.0",
-            "docs/CHANGELOG.md::## [8.6.0]",
+            "README.md::The current release is **8.8.0",
+            "SECURITY.md::8.8.x (latest)",
+            "vscode-extension/README.md::**8.8.0",
+            "docs/CHANGELOG.md::## [8.8.0]",
             "FEATURE_STATUS.md",
-            "RELEASE_NOTES_v8.6.0.md",
+            "RELEASE_NOTES_v8.8.0.md",
             "latticeai/core/agent.py::SingleAgentRuntime",
             "latticeai/core/agent.py::AgentRuntime = SingleAgentRuntime",
             "lattice_brain/runtime/contracts.py::runtime-boundary/v1",
@@ -115,7 +115,7 @@ PRODUCT_GATES: List[ProductGate] = [
         id="ecosystem-path",
         title="Community and plugin growth path is explicit",
         evidence=[
-            "docs/COMMUNITY_AND_PLUGINS.md::8.6.0",
+            "docs/COMMUNITY_AND_PLUGINS.md::8.8.0",
             "docs/PLUGIN_SDK.md",
             "plugins/README.md",
             "plugins/hello-world/plugin.json",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "8.6.0",
+  "version": "8.8.0",
   "description": "Lattice AI — local-first Digital Brain that keeps your knowledge durable across any AI model.",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {
@@ -23,7 +23,8 @@
     "build:assets": "vite build && node scripts/build_frontend_assets.mjs",
     "build:python": "node scripts/run_python.mjs -m build",
     "check:python": "node scripts/run_python.mjs scripts/check_python.py",
-    "lint": "node --check tests/visual/mock_server.cjs && node --check tests/visual/v3.spec.js && npm run lint:frontend && node scripts/check_i18n_literals.mjs",
+    "lint": "npm run lint:python && node --check tests/visual/mock_server.cjs && node --check tests/visual/v3.spec.js && npm run lint:frontend && node scripts/check_i18n_literals.mjs",
+    "lint:python": "node scripts/run_python.mjs -m ruff check .",
     "lint:frontend": "node scripts/lint_frontend.mjs",
     "docs:check-links": "node scripts/check_markdown_links.mjs",
     "typecheck": "npm run typecheck:frontend && cd vscode-extension && npm run build",

package/scripts/bump_version.py

@@ -27,6 +27,8 @@ TARGETS = [
     ("latticeai/core/workspace_os.py", "regex", r'(WORKSPACE_OS_VERSION = ")([^"]+)(")'),
     ("latticeai/core/marketplace.py", "regex", r'(MARKETPLACE_VERSION = ")([^"]+)(")'),
     ("lattice_brain/runtime/multi_agent.py", "regex", r'(MULTI_AGENT_VERSION = ")([^"]+)(")'),
+    ("latticeai/services/architecture_readiness.py", "regex", r'(ARCHITECTURE_VERSION_TARGET = ")([^"]+)(")'),
+    ("latticeai/services/product_readiness.py", "regex", r'(PRODUCT_VERSION_TARGET = ")([^"]+)(")'),
     ("pyproject.toml", "regex", r'(^version = ")([^"]+)(")'),
     ("package.json", "json", "version"),
     ("package-lock.json", "package-lock", None),