ltcai 11.1.0 → 11.4.0

package/latticeai/services/multimodal_ports.py

@@ -14,7 +14,7 @@ every capability is honestly ``None``.
 from __future__ import annotations
 
 import os
-from typing import Any, Callable, Dict, Optional
+from typing import Any, Callable, Dict, List, Optional
 
 from lattice_brain.ingestion import ALLOW_MULTIMODAL_ENV
 from lattice_brain.multimodal import MODALITY_IMAGE, MultimodalPorts
@@ -65,11 +65,35 @@ def build_multimodal_ports(
         captioner=vision_caption_port(captioner),
         vision_embedder=resolved.as_port(),
         transcriber=transcriber,
+        text_to_image_embedder=text_to_image_port(provider),
         vision_model_id=provider.model_id if provider is not None else "",
         vision_space=resolved.space,
     )
 
 
+def text_to_image_port(
+    provider: Any,
+) -> Optional[Callable[[str], List[float]]]:
+    """A *query-text* → image-space vector port, only from a shared-space model.
+
+    This is what lets a typed question reach a picture through the image index
+    instead of only through its OCR text. It exists as its own port precisely
+    because most vision models cannot do it: a CLIP image vector and a BGE text
+    vector are not comparable, and `VisionEmbeddingProvider.embed_batch` refuses
+    outright unless the model declares a shared space. An image-space model
+    therefore yields ``None`` here — the honest answer, and the one the search
+    surface reports rather than silently ranking on a meaningless number.
+    """
+    if provider is None or not getattr(provider, "shares_text_space", False):
+        return None
+
+    def _embed(query: str) -> List[float]:
+        vectors = provider.embed_batch([str(query or "")])
+        return [float(value) for value in (vectors[0] if vectors else [])]
+
+    return _embed
+
+
 def describe_multimodal(ports: MultimodalPorts) -> Dict[str, Any]:
     """Operator-facing status: enabled, plus what is actually wired."""
     return {"enabled": multimodal_enabled(), **ports.describe()}
@@ -84,4 +108,5 @@ __all__ = [
     "build_multimodal_ports",
     "describe_multimodal",
     "multimodal_enabled",
+    "text_to_image_port",
 ]

package/latticeai/services/obsidian_bridge.py

@@ -35,7 +35,6 @@ be a lie in the summary.
 
 from __future__ import annotations
 
-import json
 import os
 import re
 from dataclasses import dataclass, field
@@ -48,6 +47,7 @@ from urllib.parse import unquote
 # store-extracted topic the same node instead of two nodes with one label.
 from lattice_brain.graph.ingest import _scoped_slug_id
 from lattice_brain.ingestion import IngestionItem
+from latticeai.services.interop_bridges import edge_row, topic_row
 
 SOURCE_TYPE = "obsidian"
 NOTE_EXTENSIONS = frozenset({".md", ".markdown"})
@@ -567,15 +567,9 @@ class ObsidianVaultBridge:
             "index": outcome.get("index"),
         }
 
-    @staticmethod
-    def _edge_row(from_id: str, to_id: str, relation: str, metadata: Dict[str, Any]) -> Dict[str, Any]:
-        return {
-            "from_node": from_id,
-            "to_node": to_id,
-            "type": relation,
-            "weight": 1.0,
-            "metadata_json": json.dumps(metadata, ensure_ascii=False),
-        }
+    # Row shapes are shared with every other bridge (v11.2.0): two copies of
+    # "what an edge row looks like" is two places to forget an encoding.
+    _edge_row = staticmethod(edge_row)
 
     @staticmethod
     def _topic_row(
@@ -586,21 +580,18 @@ class ObsidianVaultBridge:
         owner: Optional[str],
         workspace_id: Optional[str],
     ) -> Dict[str, Any]:
-        metadata = {
-            "topic": tag,
-            "source": SOURCE_TYPE,
-            "vault": vault,
-            "owner": owner,
-            "workspace_id": workspace_id,
-        }
-        return {
-            "id": topic_id,
-            "type": TOPIC_NODE_TYPE,
-            "title": tag,
-            "summary": f"Obsidian tag #{tag}",
-            "metadata_json": json.dumps(metadata, ensure_ascii=False),
-            "raw_json": "{}",
-        }
+        return topic_row(
+            topic_id,
+            tag,
+            summary=f"Obsidian tag #{tag}",
+            metadata={
+                "topic": tag,
+                "source": SOURCE_TYPE,
+                "vault": vault,
+                "owner": owner,
+                "workspace_id": workspace_id,
+            },
+        )
 
 
 __all__ = [

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 = "11.1.0"
+PRODUCT_VERSION_TARGET = "11.4.0"
 
 
 @dataclass(frozen=True)
@@ -44,7 +44,10 @@ PRODUCT_GATES: List[ProductGate] = [
             "frontend/src/features/brain/BrainHome.tsx",
             "frontend/src/App.tsx::brain-mobile-nav",
             "latticeai/setup/auto_setup.py",
-            "latticeai/setup/wizard.py",
+            # v11.3.0: the wizard is a package (paths / detect / plans /
+            # catalog / recommend / install); the recommender is the piece
+            # first-run actually shows.
+            "latticeai/setup/wizard/recommend.py",
         ],
     ),
     ProductGate(
@@ -64,8 +67,11 @@ PRODUCT_GATES: List[ProductGate] = [
             "latticeai/api/chat_intents.py::direct_write_file",
             # v9.9.2 ArtifactWritePipeline: every write path shares the same
             # extract → validate → repair guarantee, proven by the FG harness.
-            "latticeai/core/file_generation.py::sanitize_write_content",
-            "latticeai/core/agent.py::content_sanitize",
+            # v11.3.0: both modules became packages — the write-side door is
+            # its own submodule, and the agent's use of it lives in the
+            # EXECUTE phase.
+            "latticeai/core/file_generation/sanitize.py::sanitize_write_content",
+            "latticeai/core/agent/execution.py::content_sanitize",
             "tests/unit/test_artifact_write_scenarios.py::test_fg06_agent_dispatch_strips_fences_from_write_file_content",
             "tests/unit/test_chat_telegram_decoupling.py::test_chat_file_creation_intent_writes_real_file",
         ],
@@ -110,12 +116,14 @@ PRODUCT_GATES: List[ProductGate] = [
             f"docs/CHANGELOG.md::## [{PRODUCT_VERSION_TARGET}]",
             "FEATURE_STATUS.md",
             f"RELEASE_NOTES_v{PRODUCT_VERSION_TARGET}.md",
-            "latticeai/core/agent.py::SingleAgentRuntime",
+            # v11.3.0: the single-agent loop is a package; the composed
+            # class and its boundary contract live in the runtime half.
+            "latticeai/core/agent/runtime.py::SingleAgentRuntime",
             "lattice_brain/runtime/agent_runtime.py::class AgentRuntime",
             "lattice_brain/runtime/contracts.py::runtime-boundary/v1",
             "lattice_brain/runtime/contracts.py::RuntimeBoundaryProtocol",
             "lattice_brain/runtime/agent_runtime.py::def boundary",
-            "latticeai/core/agent.py::def boundary",
+            "latticeai/core/agent/runtime.py::def boundary",
             "latticeai/services/architecture_readiness.py::lattice-architecture-contract/v1",
             "latticeai/services/tool_dispatch.py::rollback_file",
         ],
@@ -148,7 +156,7 @@ PRODUCT_GATES: List[ProductGate] = [
             "scripts/brain_quality_eval.py",
             "scripts/product_readiness.py",
             "tests/unit/test_product_readiness.py",
-            "tests/visual/v3.spec.js::Brain Chat Home",
+            "tests/visual/v3.surfaces.spec.js::Brain Chat Home",
             ".github/workflows/ci.yml::scripts/product_readiness.py",
             ".github/workflows/release.yml::npm run lint",
         ],

package/latticeai/services/search_service.py

@@ -8,9 +8,11 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Any, Dict, List, Mapping, Optional
+from typing import Any, Dict, List, Mapping, Optional, Tuple
 
+from lattice_brain.gates import FeatureGate
 from lattice_brain.graph._kg_fsutil import _parse_iso, _recency_score
+from lattice_brain.graph.image_vectors import DEFAULT_IMAGE_FUSION_WEIGHT
 from lattice_brain.graph.retrieval_policy import resolve_policy
 
 DEFAULT_HYBRID_WEIGHTS = {
@@ -19,6 +21,33 @@ DEFAULT_HYBRID_WEIGHTS = {
     "graph": 0.25,
 }
 
+# ── text query → image space (v11.2.0) ───────────────────────────────────────
+# 11.1.0 shipped image late fusion as API-only, because the two vector spaces
+# are not comparable and nothing produced a query vector for the image index.
+# A *shared-space* vision model can produce one, and this is the switch that
+# lets the search API do it automatically. Off by default and resolved when
+# asked, so a settings toggle can move it without a restart; with it off the
+# hybrid response is byte-identical to 11.1.0's.
+TEXT_IMAGE_FUSION_ENV = "LATTICEAI_TEXT_IMAGE_FUSION"
+IMAGE_QUERY_FUSION_GATE = FeatureGate(
+    TEXT_IMAGE_FUSION_ENV,
+    default=False,
+    name="text_image_fusion",
+    detail=(
+        "Typed questions can also be scored against the image index when a "
+        "shared-space vision model is configured."
+    ),
+)
+IMAGE_FUSION_UNAVAILABLE = (
+    "no shared-space vision model is configured, so a typed question cannot be "
+    "scored against image vectors; pictures are still found through their OCR "
+    "text and captions"
+)
+IMAGE_FUSION_DISABLED = (
+    "automatic image fusion is off for this install "
+    f"({TEXT_IMAGE_FUSION_ENV}); the caller may still supply an image vector"
+)
+
 
 def _clean(text: Any, limit: int = 1000) -> str:
     return " ".join(str(text or "").split())[:limit]
@@ -31,6 +60,115 @@ def _result_key(result: Mapping[str, Any]) -> str:
 @dataclass
 class SearchService:
     graph_store: Any
+    #: ``(query_text) -> image-space vector``. Defaults to the port the store
+    #: already carries (``multimodal_ports.text_to_image_embedder``), so no new
+    #: wiring is needed; the field exists so a test — or an install with its
+    #: own encoder — can supply one directly.
+    image_query_embedder: Any = None
+
+    # ── image-space query channel (v11.2.0) ──────────────────────────────
+    def image_query_status(self) -> Dict[str, Any]:
+        """Whether a typed question can reach the image index here, and why not."""
+        port, detail = self._image_query_port()
+        return {
+            "available": port is not None,
+            "gate": IMAGE_QUERY_FUSION_GATE.describe(),
+            "detail": detail,
+        }
+
+    def _image_query_port(self) -> Tuple[Any, Optional[str]]:
+        """The text→image port and, when there is none, the honest reason."""
+        if self.image_query_embedder is not None:
+            return self.image_query_embedder, None
+        ports = getattr(self.graph_store, "multimodal_ports", None)
+        port = getattr(ports, "text_to_image_embedder", None)
+        return (port, None) if port is not None else (None, IMAGE_FUSION_UNAVAILABLE)
+
+    def _image_query_vector(self, query: str) -> Tuple[Optional[List[float]], Optional[str]]:
+        port, detail = self._image_query_port()
+        if port is None:
+            return None, detail
+        try:
+            vector = [float(value) for value in (port(query) or [])]
+        except Exception as exc:  # noqa: BLE001 — a broken encoder never fails a search
+            return None, f"the vision model could not embed the query: {exc}"
+        if not vector:
+            return None, "the vision model returned an empty query vector"
+        return vector, None
+
+    def _image_channel(
+        self, query: str, matches: List[Dict[str, Any]], *, requested: bool, limit: int
+    ) -> Optional[Dict[str, Any]]:
+        """Late-fuse the image index into an already-ranked match list.
+
+        Returns ``None`` when the caller did not ask, which is what keeps the
+        response byte-identical for everyone who did not opt in. When it *was*
+        asked for and could not run, it returns the reason rather than silently
+        producing the same answer as before.
+        """
+        if not requested:
+            return None
+        report: Dict[str, Any] = {
+            "requested": True,
+            "applied": False,
+            "weight": DEFAULT_IMAGE_FUSION_WEIGHT,
+            "candidates": 0,
+            "fused": 0,
+            "detail": None,
+        }
+        if not IMAGE_QUERY_FUSION_GATE.enabled():
+            report["detail"] = IMAGE_FUSION_DISABLED
+            return {"image_fusion": report}
+        vector, detail = self._image_query_vector(query)
+        if vector is None:
+            report["detail"] = detail
+            return {"image_fusion": report}
+        from lattice_brain.graph.image_vectors import image_similarity_search
+
+        try:
+            found = image_similarity_search(
+                self.graph_store, vector, top_k=max(1, int(limit) * 2)
+            )
+        except Exception as exc:  # noqa: BLE001 — the text answer must survive
+            report["detail"] = f"image index unavailable: {exc}"
+            return {"image_fusion": report}
+        report["candidates"] = int(found.get("candidates") or 0)
+        scores = {
+            str(match["node_id"]): float(match["score"])
+            for match in found.get("matches") or []
+        }
+        report["fused"] = self._blend_image_scores(matches, scores)
+        report["applied"] = True
+        report["detail"] = found.get("detail")
+        return {"image_fusion": report}
+
+    @staticmethod
+    def _blend_image_scores(
+        matches: List[Dict[str, Any]],
+        scores: Dict[str, float],
+        *,
+        weight: float = DEFAULT_IMAGE_FUSION_WEIGHT,
+    ) -> int:
+        """The graph layer's blend, over this layer's ``source_scores`` shape.
+
+        Late fusion by construction: the two rankings were produced
+        independently and only the final numbers meet, so neither space is ever
+        asked to interpret the other's.
+        """
+        touched = 0
+        for match in matches:
+            raw = scores.get(_result_key(match))
+            if raw is None:
+                continue
+            touched += 1
+            match.setdefault("source_scores", {})["image"] = round(raw, 6)
+            blended = (1.0 - weight) * float(match.get("score") or 0.0) + weight * raw
+            match["score"] = round(blended, 6)
+        if touched:
+            matches.sort(key=lambda item: float(item.get("score") or 0.0), reverse=True)
+            for rank, match in enumerate(matches, start=1):
+                match["rank"] = rank
+        return touched
 
     def _require_graph(self) -> Any:
         if self.graph_store is None:
@@ -410,6 +548,7 @@ class SearchService:
         weights: Optional[Mapping[str, float]] = None,
         allowed_workspaces=None,
         include_legacy_global: bool = False,
+        image_fusion: bool = False,
     ) -> Dict[str, Any]:
         # Single retrieval policy (review Wave 0.2): when the caller does not
         # pin explicit weights, resolve the query class + per-class channel
@@ -513,7 +652,10 @@ class SearchService:
             }
             if query_class is not None:
                 match["fusion"]["query_class"] = query_class
-        return {
+        multimodal = self._image_channel(
+            query, matches, requested=image_fusion, limit=limit,
+        )
+        report: Dict[str, Any] = {
             "query": query,
             "mode": "hybrid",
             "query_class": query_class,
@@ -529,6 +671,11 @@ class SearchService:
             },
             "matches": matches,
         }
+        # Additive key only when the caller asked, so an untouched response is
+        # the one 11.1.0 returned.
+        if multimodal is not None:
+            report["multimodal"] = multimodal
+        return report
 
     def graph(
         self,

package/latticeai/services/tool_dispatch.py

@@ -486,6 +486,7 @@ def build_agent_runtime(
     brain_memory: Any = None,
     dispatch_service: ToolDispatchService = DEFAULT_TOOL_DISPATCH_SERVICE,
     permission_mode: Any = None,
+    self_model_summary: Any = None,
 ) -> SingleAgentRuntime:
     ensure_agent_root()
     mode = permission_mode if permission_mode is not None else dispatch_service.permission_mode
@@ -513,6 +514,9 @@ def build_agent_runtime(
         hooks=hooks,
         brain_memory=brain_memory,
         permission_mode=mode,
+        # v11.2.0: what the Brain knows about its owner reaches the agent loop.
+        # ``None`` keeps the pre-11.2.0 prompt bytes exactly.
+        self_model_summary=self_model_summary,
     )
     return SingleAgentRuntime(deps)
 

package/latticeai/setup/auto_setup.py

@@ -399,36 +399,36 @@ class Recommendation:
         return asdict(self)
 
 
-# 모델 카탈로그. PPT 슬라이드 16 의 "추천 모델" 열과 동기화.
+# 모델 카탈로그 — RAM/VRAM 내림차순. 첫 번째로 조건을 만족하는 항목이 선택된다.
+# 모든 repo id 는 2026-08-10 Hugging Face API 로 확인했다(존재·비gated·정확한 대소문자).
+# OS 오버헤드(~4-6 GB) + KV 캐시 여유를 감안한 보수적 RAM 임계값.
 _MODEL_CATALOG: List[Dict[str, Any]] = [
-    # (min_ram_mb, min_vram_mb, model_id, quant, runtime_preference)
-    # OS 오버헤드(~4-6 GB) + KV 캐시 여유를 감안한 보수적 RAM 임계값
+    # 대형 (48GB+): 최상위 dense / Gemma 4 최대 모델
     {"ram": 64 * 1024, "vram": 32 * 1024,
      "id": "mlx-community/gemma-4-31b-it-4bit", "q": "4bit", "multimodal": True},
-    {"ram": 64 * 1024, "vram": 32 * 1024,
-     "id": "Qwen/Qwen3-VL-30B-A3B-Instruct", "q": "q4_K_M", "multimodal": True},
     {"ram": 48 * 1024, "vram": 24 * 1024,
-     "id": "mlx-community/gemma-4-31b-it-4bit", "q": "4bit", "multimodal": True},
+     "id": "mlx-community/Qwen3.6-27B-4bit", "q": "4bit", "multimodal": True},
+    # MoE (32GB+)
+    {"ram": 40 * 1024, "vram": 24 * 1024,
+     "id": "mlx-community/Qwen3.6-35B-A3B-4bit", "q": "4bit", "multimodal": True},
     {"ram": 32 * 1024, "vram": 16 * 1024,
      "id": "mlx-community/gemma-4-26b-a4b-it-4bit", "q": "4bit", "multimodal": True},
-    {"ram": 48 * 1024, "vram": 24 * 1024,
-     "id": "Qwen/Qwen3-VL-30B-A3B-Instruct", "q": "q4_K_M", "multimodal": True},
-    {"ram": 24 * 1024, "vram": 12 * 1024,
-     "id": "mlx-community/Llama-4-Scout-17B-16E-Instruct-4bit", "q": "4bit", "multimodal": True},
-    {"ram": 16 * 1024, "vram": 8 * 1024,
-     "id": "mlx-community/gemma-4-12b-it-4bit", "q": "4bit", "multimodal": True},
-    {"ram": 32 * 1024, "vram": 16 * 1024,
-     "id": "Qwen/Qwen3-VL-8B-Instruct", "q": "q5_K_M", "multimodal": True},
+    # 범용 (24GB)
     {"ram": 24 * 1024, "vram": 12 * 1024,
-     "id": "Qwen/Qwen3-VL-8B-Instruct", "q": "q4_K_M", "multimodal": True},
+     "id": "mlx-community/gpt-oss-20b-MXFP4-Q8", "q": "MXFP4-Q8", "multimodal": False},
+    # 중형 (16GB)
     {"ram": 16 * 1024, "vram": 8 * 1024,
-     "id": "Qwen/Qwen3-VL-8B-Instruct", "q": "q4_K_M", "multimodal": True},
+     "id": "mlx-community/gemma-4-12B-it-4bit", "q": "4bit", "multimodal": True},
     {"ram": 12 * 1024, "vram": 6 * 1024,
-     "id": "Qwen/Qwen3-VL-4B-Instruct", "q": "q4_K_M", "multimodal": True},
+     "id": "mlx-community/Qwen3.5-9B-MLX-4bit", "q": "4bit", "multimodal": True},
+    # 경량 (10GB) / 초경량 (8GB 이하)
+    {"ram": 10 * 1024, "vram": 6 * 1024,
+     "id": "mlx-community/gemma-4-e4b-it-4bit", "q": "4bit", "multimodal": True},
     {"ram":  8 * 1024, "vram": 4 * 1024,
-     "id": "Qwen/Qwen3-VL-4B-Instruct", "q": "q4_K_M", "multimodal": True},
+     "id": "mlx-community/gemma-4-e2b-it-4bit", "q": "4bit", "multimodal": True},
+    # 최소 사양: 사진은 못 읽지만 한국어로 대답은 한다.
     {"ram":  4 * 1024, "vram": 0,
-     "id": "Qwen/Qwen3-VL-4B-Instruct", "q": "q4_K_M", "multimodal": True},
+     "id": "mlx-community/LFM2.5-2.6B-4bit", "q": "4bit", "multimodal": False},
 ]
 
 
@@ -622,17 +622,14 @@ def plan(profile: SystemProfile, rec: Recommendation) -> InstallPlan:
     # 모델 가중치 풀
     model_command = ["huggingface-cli", "download", rec.model_id, "--quiet"]
     if rec.runtime == "ollama":
-        lower = rec.model_id.lower()
-        if "gemma-4-31b" in lower:
-            model_command = ["ollama", "pull", "hf.co/ggml-org/gemma-4-31B-it-GGUF:Q4_K_M"]
-        elif "gemma-4-12b" in lower:
-            model_command = ["ollama", "pull", "hf.co/ggml-org/gemma-4-12B-it-GGUF:Q4_K_M"]
-        elif "llama-4-scout" in lower:
-            model_command = ["ollama", "pull", "hf.co/ggml-org/Llama-4-Scout-17B-16E-Instruct-GGUF:Q4_K_M"]
-        elif "qwen3-vl-8b" in lower:
-            model_command = ["ollama", "pull", "qwen3-vl:8b"]
-        elif "qwen3-vl-4b" in lower:
-            model_command = ["ollama", "pull", "qwen3-vl:4b"]
+        # Local import: this module keeps a stdlib-only import graph so it can be
+        # run before the app is wired. The alias table is the single source of
+        # truth for per-engine repo ids — the old hardcoded if/elif chain here
+        # drifted from it and still named Llama 4 Scout and Qwen3-VL.
+        from latticeai.services.model_catalog import MODEL_ENGINE_ALIASES
+        ollama_target = (MODEL_ENGINE_ALIASES.get(rec.model_id.lower()) or {}).get("ollama")
+        if ollama_target:
+            model_command = ["ollama", "pull", ollama_target]
     elif rec.runtime == "lmstudio":
         model_command = ["lms", "get", rec.model_id]
     steps.append(InstallStep(

package/latticeai/setup/wizard/__init__.py

@@ -0,0 +1,126 @@
+"""
+Smart Setup Wizard — Environment Scanner, Recommender & Auto-Installer
+Detects hardware, tools, and API keys; returns tailored recommendations;
+streams SSE installation progress.
+
+Formerly the root ``setup.py``; renamed in v4 so it no longer collides with
+the setuptools build entrypoint and actually ships in the wheel
+(``pyproject.toml`` py-modules). Packaging is owned entirely by
+``pyproject.toml`` — there is deliberately no root ``setup.py``.
+
+Split into cohesive submodules in v11.3.0 (no behaviour change): ``paths``
+(PATH repair + binary lookup + the module-level ``COMMON_PATH_DIRS``),
+``detect`` (hardware/OS/tool probes and ``scan_environment``), ``plans``
+(SSE framing + confirmation-token command plans), ``catalog`` (model tables),
+``recommend`` (``get_recommendations``) and ``install`` (verify/repair and the
+SSE ``install_stream``). This module re-exports every name the single file
+exposed, so ``latticeai.setup.wizard.X`` keeps working.
+
+Stubbing note: rebinding one of these names *here* changes only this module's
+name. The submodule that calls it holds its own reference, so a test standing
+in for a helper patches the submodule that uses it.
+"""
+
+from __future__ import annotations
+
+# The single file had no ``__all__``, so its public surface was "every module
+# global" — including the names it imported for its own use. Every re-export
+# below therefore uses the redundant-alias form: it reproduces exactly that
+# surface, and it marks each name as deliberate rather than a leftover import.
+from latticeai.core.quiet import quiet as quiet
+from latticeai.services.process_audit import (
+    CommandConfirmationError as CommandConfirmationError,
+)
+from latticeai.services.process_audit import (
+    append_process_audit_event as append_process_audit_event,
+)
+from latticeai.services.process_audit import command_plan as command_plan
+from latticeai.services.process_audit import (
+    command_plan_for_commands as command_plan_for_commands,
+)
+from latticeai.services.process_audit import (
+    require_command_confirmation as require_command_confirmation,
+)
+from latticeai.services.setup_detection import detect_cuda as detect_cuda
+from latticeai.services.setup_detection import detect_tools as detect_tools
+from latticeai.services.setup_detection import (
+    detect_wsl_from_text as detect_wsl_from_text,
+)
+from latticeai.setup.wizard.catalog import (
+    _BEST_MODEL_TIERS as _BEST_MODEL_TIERS,
+)
+from latticeai.setup.wizard.catalog import (
+    _CROSS_PLATFORM_MODEL_CATALOG as _CROSS_PLATFORM_MODEL_CATALOG,
+)
+from latticeai.setup.wizard.catalog import (
+    _MODEL_CATALOG as _MODEL_CATALOG,
+)
+from latticeai.setup.wizard.catalog import (
+    _VERSIONED_MODEL_PATTERNS as _VERSIONED_MODEL_PATTERNS,
+)
+from latticeai.setup.wizard.catalog import (
+    _best_model_for_engine as _best_model_for_engine,
+)
+from latticeai.setup.wizard.catalog import (
+    _catalog_row_family_version as _catalog_row_family_version,
+)
+from latticeai.setup.wizard.catalog import (
+    _filter_lower_family_versions as _filter_lower_family_versions,
+)
+from latticeai.setup.wizard.catalog import (
+    _version_tuple as _version_tuple,
+)
+from latticeai.setup.wizard.detect import _cmd as _cmd
+from latticeai.setup.wizard.detect import _detect_api_keys as _detect_api_keys
+from latticeai.setup.wizard.detect import _detect_chip as _detect_chip
+from latticeai.setup.wizard.detect import _detect_cpu as _detect_cpu
+from latticeai.setup.wizard.detect import _detect_cuda as _detect_cuda
+from latticeai.setup.wizard.detect import (
+    _detect_disk_free_gb as _detect_disk_free_gb,
+)
+from latticeai.setup.wizard.detect import _detect_gpu as _detect_gpu
+from latticeai.setup.wizard.detect import _detect_mlx as _detect_mlx
+from latticeai.setup.wizard.detect import _detect_ram_gb as _detect_ram_gb
+from latticeai.setup.wizard.detect import _detect_tools as _detect_tools
+from latticeai.setup.wizard.detect import _detect_wsl as _detect_wsl
+from latticeai.setup.wizard.detect import (
+    _parse_windows_video_controllers as _parse_windows_video_controllers,
+)
+from latticeai.setup.wizard.detect import scan_environment as scan_environment
+from latticeai.setup.wizard.install import _brew_install as _brew_install
+from latticeai.setup.wizard.install import _pip_install as _pip_install
+from latticeai.setup.wizard.install import _repair_action as _repair_action
+from latticeai.setup.wizard.install import _verify_action as _verify_action
+from latticeai.setup.wizard.install import _verify_binary as _verify_binary
+from latticeai.setup.wizard.install import _wait_for_binary as _wait_for_binary
+from latticeai.setup.wizard.install import install_stream as install_stream
+from latticeai.setup.wizard.install import open_url as open_url
+from latticeai.setup.wizard.paths import COMMON_PATH_DIRS as COMMON_PATH_DIRS
+from latticeai.setup.wizard.paths import OFFICIAL_DOWNLOADS as OFFICIAL_DOWNLOADS
+from latticeai.setup.wizard.paths import PACKAGE_MODULES as PACKAGE_MODULES
+from latticeai.setup.wizard.paths import (
+    WINDOWS_BINARY_CANDIDATES as WINDOWS_BINARY_CANDIDATES,
+)
+from latticeai.setup.wizard.paths import _component_detail as _component_detail
+from latticeai.setup.wizard.paths import _merge_path_dirs as _merge_path_dirs
+from latticeai.setup.wizard.paths import _module_available as _module_available
+from latticeai.setup.wizard.paths import _package_module as _package_module
+from latticeai.setup.wizard.paths import _persist_extra_path as _persist_extra_path
+from latticeai.setup.wizard.paths import _project_env_file as _project_env_file
+from latticeai.setup.wizard.paths import _update_env_file as _update_env_file
+from latticeai.setup.wizard.paths import _which_any as _which_any
+from latticeai.setup.wizard.paths import _which_detail as _which_detail
+from latticeai.setup.wizard.paths import repair_path_for as repair_path_for
+from latticeai.setup.wizard.plans import _action_command_plan as _action_command_plan
+from latticeai.setup.wizard.plans import _action_commands as _action_commands
+from latticeai.setup.wizard.plans import _attach_action_plan as _attach_action_plan
+from latticeai.setup.wizard.plans import (
+    _hydrate_install_actions as _hydrate_install_actions,
+)
+from latticeai.setup.wizard.plans import _sse as _sse
+from latticeai.setup.wizard.plans import (
+    _verify_action_confirmation as _verify_action_confirmation,
+)
+from latticeai.setup.wizard.recommend import (
+    get_recommendations as get_recommendations,
+)