ltcai 8.9.0 → 9.0.0

package/latticeai/services/memory_service.py

@@ -271,6 +271,7 @@ class MemoryService:
         memory_count = len(memory_ids) + len(snaps) + len(convs)
         return {
             "sources": sources,
+            "recent_memories": self._manager_recent_memories([*ws_mem, *project_mem], limit=8),
             "tiers": list(TIERS),
             "usage": {"total_items": total_items, "total_bytes": total_bytes, "sources": len(sources)},
             "brain_readiness": self._brain_readiness(
@@ -284,6 +285,23 @@ class MemoryService:
             "generated_at": _now(),
         }
 
+    @staticmethod
+    def _manager_recent_memories(memories: List[Dict[str, Any]], *, limit: int = 8) -> List[Dict[str, Any]]:
+        rows: List[Dict[str, Any]] = []
+        for item in memories[: max(1, limit)]:
+            metadata = item.get("metadata") if isinstance(item.get("metadata"), dict) else {}
+            rows.append({
+                "id": item.get("id") or "",
+                "kind": item.get("kind") or "memory",
+                "content": str(item.get("content") or "")[:320],
+                "tags": item.get("tags") if isinstance(item.get("tags"), list) else [],
+                "metadata": metadata,
+                "workspace_id": item.get("workspace_id") or "personal",
+                "created_at": item.get("created_at"),
+                "updated_at": item.get("updated_at"),
+            })
+        return rows
+
     def brain_quality_summary(self, *, user_email: Optional[str] = None, workspace_id: Optional[str] = None) -> Dict[str, Any]:
         """Return the backend-owned Brain readiness signal for API consumers."""
         return self.manager(user_email=user_email, workspace_id=workspace_id)["brain_readiness"]
@@ -338,6 +356,22 @@ class MemoryService:
             has_recall=bool(recall_items),
             graph_concepts=graph_concepts,
         )
+        suggested_questions = self._brain_brief_suggested_questions(
+            focus=focus,
+            has_durable_evidence=bool(proofs.get("has_durable_evidence")),
+            has_recall=bool(recall_items),
+            graph_concepts=graph_concepts,
+            conversations=conversations,
+        )
+        proactive_actions = self._brain_brief_proactive_actions(
+            focus=focus,
+            state=state,
+            has_durable_evidence=bool(proofs.get("has_durable_evidence")),
+            has_recall=bool(recall_items),
+            graph_concepts=graph_concepts,
+            vector_items=vector_items,
+            healthy_sources=healthy_sources,
+        )
         return {
             "status": state,
             "score": int(readiness.get("score") or 0),
@@ -345,6 +379,8 @@ class MemoryService:
             "body_key": f"brain.brief.body.{state if state in {'quiet', 'forming', 'alive'} else 'quiet'}",
             "focus": focus,
             "next_actions": actions,
+            "suggested_questions": suggested_questions,
+            "proactive_actions": proactive_actions,
             "evidence": [
                 {
                     "id": "durable",
@@ -501,6 +537,183 @@ class MemoryService:
             })
         return sorted(actions, key=lambda item: int(item.get("priority") or 0), reverse=True)[:4]
 
+    @staticmethod
+    def _brain_brief_proactive_actions(
+        *,
+        focus: Dict[str, Any],
+        state: str,
+        has_durable_evidence: bool,
+        has_recall: bool,
+        graph_concepts: int,
+        vector_items: int,
+        healthy_sources: int,
+    ) -> List[Dict[str, Any]]:
+        """Return concrete, one-click actions Brain can proactively suggest."""
+        focus_title = str(focus.get("title") or "").strip() or "Brain"
+        focus_detail = str(focus.get("detail") or "").strip()
+        actions: List[Dict[str, Any]] = []
+        if not has_durable_evidence:
+            actions.append({
+                "id": "proactive_add_source",
+                "intent": "route",
+                "label_key": "brain.proactive.addSource.label",
+                "detail_key": "brain.proactive.addSource.detail",
+                "route": "/capture",
+                "prompt": "Add a useful source to my Brain and explain what it learned.",
+                "priority": 100,
+            })
+            actions.append({
+                "id": "proactive_seed_memory",
+                "intent": "ask",
+                "label_key": "brain.proactive.seed.label",
+                "detail_key": "brain.proactive.seed.detail",
+                "prompt": "Help me seed my Brain with the most useful personal context to remember.",
+                "priority": 90,
+            })
+            return actions
+
+        if has_recall:
+            actions.append({
+                "id": "proactive_evidence_review",
+                "intent": "ask",
+                "label_key": "brain.proactive.evidence.label",
+                "detail_key": "brain.proactive.evidence.detail",
+                "prompt": (
+                    f"Review the evidence Brain has for {focus_title}. "
+                    "Separate confirmed facts, weak signals, contradictions, and next checks."
+                ),
+                "priority": 100,
+                "context": {"focus": focus_title, "detail": focus_detail},
+            })
+            actions.append({
+                "id": "proactive_delegate",
+                "intent": "delegate",
+                "label_key": "brain.proactive.delegate.label",
+                "detail_key": "brain.proactive.delegate.detail",
+                "prompt": (
+                    f"Turn {focus_title} into an execution plan, verify the known context, "
+                    "and return concrete next steps with risks."
+                ),
+                "priority": 95,
+                "context": {"focus": focus_title, "detail": focus_detail},
+            })
+            actions.append({
+                "id": "proactive_review_draft",
+                "intent": "review",
+                "label_key": "brain.proactive.review.label",
+                "detail_key": "brain.proactive.review.detail",
+                "prompt": (
+                    f"Create a reviewable task from Brain's current focus: {focus_title}. "
+                    f"{focus_detail[:240]}"
+                ).strip(),
+                "priority": 90,
+                "context": {"focus": focus_title, "detail": focus_detail},
+            })
+
+        if graph_concepts > 0:
+            actions.append({
+                "id": "proactive_map_connections",
+                "intent": "route",
+                "label_key": "brain.proactive.map.label",
+                "detail_key": "brain.proactive.map.detail",
+                "route": "/knowledge-graph",
+                "prompt": f"Map the strongest Knowledge Graph connections around {focus_title}.",
+                "priority": 82,
+                "context": {"focus": focus_title, "graph_concepts": graph_concepts},
+            })
+
+        if state == "alive" and vector_items > 0 and healthy_sources > 0:
+            actions.append({
+                "id": "proactive_weekly_brief",
+                "intent": "review",
+                "label_key": "brain.proactive.weekly.label",
+                "detail_key": "brain.proactive.weekly.detail",
+                "prompt": (
+                    "Prepare a weekly Brain review: what changed, what decisions are pending, "
+                    "what should be delegated, and what evidence is stale."
+                ),
+                "priority": 78,
+                "context": {"vector_items": vector_items, "healthy_sources": healthy_sources},
+            })
+
+        return sorted(actions, key=lambda item: int(item.get("priority") or 0), reverse=True)[:4]
+
+    @staticmethod
+    def _brain_brief_suggested_questions(
+        *,
+        focus: Dict[str, Any],
+        has_durable_evidence: bool,
+        has_recall: bool,
+        graph_concepts: int,
+        conversations: int,
+    ) -> List[Dict[str, Any]]:
+        """Return reusable, localized UI prompt descriptors for the Brain home."""
+        focus_title = str(focus.get("title") or "").strip()
+        focus_kind = str(focus.get("kind") or "empty")
+        questions: List[Dict[str, Any]] = []
+
+        if not has_durable_evidence or focus_kind == "empty":
+            questions.extend([
+                {
+                    "id": "start_brain",
+                    "label_key": "brain.suggestion.start.label",
+                    "detail_key": "brain.suggestion.start.detail",
+                    "prompt_key": "brain.suggestion.start.prompt",
+                    "params": {},
+                    "priority": 10,
+                },
+                {
+                    "id": "add_context",
+                    "label_key": "brain.suggestion.context.label",
+                    "detail_key": "brain.suggestion.context.detail",
+                    "prompt_key": "brain.suggestion.context.prompt",
+                    "params": {},
+                    "priority": 9,
+                },
+            ])
+            return questions
+
+        questions.append({
+            "id": "focus_next",
+            "label_key": "brain.suggestion.focus.label",
+            "detail_key": "brain.suggestion.focus.detail",
+            "prompt_key": "brain.suggestion.focus.prompt",
+            "params": {"focus": focus_title or "Brain"},
+            "priority": 10,
+        })
+
+        if has_recall:
+            questions.append({
+                "id": "evidence_check",
+                "label_key": "brain.suggestion.evidence.label",
+                "detail_key": "brain.suggestion.evidence.detail",
+                "prompt_key": "brain.suggestion.evidence.prompt",
+                "params": {"focus": focus_title or "this topic"},
+                "priority": 9,
+            })
+
+        if graph_concepts > 0:
+            questions.append({
+                "id": "graph_connections",
+                "label_key": "brain.suggestion.graph.label",
+                "detail_key": "brain.suggestion.graph.detail",
+                "prompt_key": "brain.suggestion.graph.prompt",
+                "params": {"focus": focus_title or "Knowledge Graph"},
+                "priority": 8,
+            })
+
+        if conversations > 0:
+            questions.append({
+                "id": "conversation_followup",
+                "label_key": "brain.suggestion.history.label",
+                "detail_key": "brain.suggestion.history.detail",
+                "prompt_key": "brain.suggestion.history.prompt",
+                "params": {"focus": focus_title or "recent conversations"},
+                "priority": 7,
+            })
+
+        return sorted(questions, key=lambda item: int(item.get("priority") or 0), reverse=True)[:4]
+
     def brain_proof(
         self,
         *,

package/latticeai/services/platform_runtime.py

@@ -144,7 +144,15 @@ class PlatformRuntime:
         def provider(goal: str):
             try:
                 mems = self.store.search_memories(goal, user_email=user, workspace_id=scope).get("memories", [])
-                return [str(m.get("content") or "")[:160] for m in mems[:5]]
+                ctx = [str(m.get("content") or "")[:180] for m in mems[:6]]
+                # Enrich with agent-synthesis memories preferentially for self-improving Brain feel
+                try:
+                    allm = self.store.list_memories(user_email=user, workspace_id=scope).get("memories", [])
+                    synth = [str(m.get("content") or "")[:160] for m in allm if "agent-synthesis" in (m.get("tags") or [])][:3]
+                    ctx = synth + ctx
+                except Exception:
+                    pass
+                return ctx[:8]
             except Exception:
                 return []
         return provider

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.9.0"
+PRODUCT_VERSION_TARGET = "9.0.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.9.0-py3-none-any.whl",
-            "README.md::dist/ltcai-8.9.0.tar.gz",
-            "README.md::dist/ltcai-8.9.0.vsix",
-            "README.md::ltcai-8.9.0.tgz",
+            "README.md::dist/ltcai-9.0.0-py3-none-any.whl",
+            "README.md::dist/ltcai-9.0.0.tar.gz",
+            "README.md::dist/ltcai-9.0.0.vsix",
+            "README.md::ltcai-9.0.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.9.0",
-            "SECURITY.md::8.9.x (latest)",
-            "vscode-extension/README.md::**8.9.0",
-            "docs/CHANGELOG.md::## [8.9.0]",
+            "README.md::The current release is **9.0.0",
+            "SECURITY.md::9.0.x (latest)",
+            "vscode-extension/README.md::**9.0.0",
+            "docs/CHANGELOG.md::## [9.0.0]",
             "FEATURE_STATUS.md",
-            "RELEASE_NOTES_v8.9.0.md",
+            "RELEASE_NOTES_v9.0.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.9.0",
+            "docs/COMMUNITY_AND_PLUGINS.md::9.0.0",
             "docs/PLUGIN_SDK.md",
             "plugins/README.md",
             "plugins/hello-world/plugin.json",

package/latticeai/services/review_queue.py

@@ -21,12 +21,14 @@ from __future__ import annotations
 from datetime import datetime
 from typing import Any, Callable, Dict, Optional
 
+from latticeai.core.io_utils import parse_iso as _parse_iso
+
 # status: terminal vs. open. Open items can still be acted on.
 OPEN_STATUSES = {"pending", "snoozed"}
 TERMINAL_STATUSES = {"approved", "dismissed"}
 ALL_STATUSES = OPEN_STATUSES | TERMINAL_STATUSES
 
-REVIEW_SOURCES = frozenset({"workflow_run", "trigger", "kg_change_digest"})
+REVIEW_SOURCES = frozenset({"workflow_run", "trigger", "kg_change_digest", "chat_followup", "agent_followup"})
 
 # Which source statuses each action is allowed from.
 _ALLOWED_FROM: Dict[str, set] = {
@@ -59,15 +61,6 @@ class InvalidReviewTransition(Exception):
         super().__init__(f"cannot {action!r} a review item in status {status!r}")
 
 
-def _parse_iso(value: Optional[str]) -> Optional[datetime]:
-    if not value:
-        return None
-    try:
-        return datetime.fromisoformat(str(value))
-    except (TypeError, ValueError):
-        return None
-
-
 class ReviewQueueService:
     """Policy layer over the store's workspace-scoped ``review_items``."""
 
@@ -122,7 +115,20 @@ class ReviewQueueService:
 
     # ── transitions ──────────────────────────────────────────────────────
     def approve(self, item_id: str, *, workspace_id: Optional[str] = None) -> Dict[str, Any]:
-        return self._transition(item_id, "approve", "approved", workspace_id=workspace_id)
+        item = self._store.get_review_item(item_id, workspace_id=workspace_id)
+        self._guard("approve", item)
+        payload = dict(item.get("payload") or {})
+        provenance = dict(item.get("provenance") or {})
+        promoted = self._promote_agent_followup(item, workspace_id=workspace_id)
+        if promoted:
+            payload["promoted_workflow_id"] = promoted.get("id")
+            provenance["workflow_id"] = promoted.get("id")
+            provenance["promotion"] = "workflow_draft"
+        patch: Dict[str, Any] = {"status": "approved", "payload": payload, "provenance": provenance}
+        if item.get("snoozed_until") is not None:
+            patch["snoozed_until"] = None
+        updated = self._store.update_review_item(item_id, workspace_id=workspace_id, **patch)
+        return self._view(updated)
 
     def dismiss(self, item_id: str, *, workspace_id: Optional[str] = None) -> Dict[str, Any]:
         return self._transition(item_id, "dismiss", "dismissed", workspace_id=workspace_id)
@@ -210,6 +216,53 @@ class ReviewQueueService:
         view["effective_status"] = self._effective_status(item)
         return view
 
+    def _promote_agent_followup(self, item: Dict[str, Any], *, workspace_id: Optional[str]) -> Optional[Dict[str, Any]]:
+        if item.get("source") != "agent_followup" or not hasattr(self._store, "create_workflow"):
+            return None
+        payload = dict(item.get("payload") or {})
+        followup = str(payload.get("followup") or item.get("title") or "").strip()
+        if not followup:
+            return None
+        goal = str(payload.get("goal") or item.get("summary") or followup).strip()
+        nodes = [
+            {
+                "id": "trigger",
+                "type": "trigger",
+                "config": {"trigger": "manual", "review_queue": False},
+                "next": "agent",
+            },
+            {
+                "id": "agent",
+                "type": "agent",
+                "config": {
+                    "goal": followup,
+                    "roles": ["planner", "executor", "reviewer"],
+                    "source": "agent_followup",
+                },
+                "next": "output",
+            },
+            {
+                "id": "output",
+                "type": "output",
+                "config": {"format": "review_followup"},
+                "next": None,
+            },
+        ]
+        return self._store.create_workflow(
+            name=f"Follow-up: {str(item.get('title') or followup)[:96]}",
+            steps=[{"action": "agent", "goal": followup}],
+            nodes=nodes,
+            metadata={
+                "source": "review_center",
+                "review_item_id": item.get("id"),
+                "agent_followup": followup,
+                "goal": goal,
+                "draft": True,
+            },
+            user_email=item.get("user_email"),
+            workspace_id=workspace_id or item.get("workspace_id"),
+        )
+
 
 def enqueue_from_automation(
     sink: "ReviewQueueService",

package/latticeai/services/run_executor.py

@@ -129,6 +129,27 @@ class RunExecutor:
                 self._cancel_agent_record(run_id, handle.scope, "cancelled after the final result was persisted")
             else:
                 self._results[run_id] = payload
+        except Exception as exc:
+            try:
+                run = self.store.get_agent_run(run_id, workspace_id=handle.scope)
+                timeline = list(run.get("timeline") or [])
+                timeline.append({"event": "execution_failed", "status": "failed", "detail": str(exc), "timestamp": _now()})
+                failed = self.store.update_agent_run(
+                    run_id,
+                    workspace_id=handle.scope,
+                    status="failed",
+                    current_role=None,
+                    output_text=str(exc),
+                    timeline=timeline,
+                    graph=self.workspace_graph(),
+                )
+                self._results[run_id] = {"run": failed, "result": {"status": "failed", "error": str(exc)}}
+            except Exception:
+                self._results[run_id] = {"run": {"id": run_id, "status": "failed"}, "result": {"status": "failed", "error": str(exc)}}
+            try:
+                self.append_audit_event("agent_run_failed", user_email=user_email, run_id=run_id, error=str(exc))
+            except Exception:
+                pass
         finally:
             self._handles.pop(run_id, None)
 

package/latticeai/services/setup_detection.py

@@ -0,0 +1,80 @@
+"""Shared setup/environment detection helpers."""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple
+
+
+WhichFn = Callable[[str], Optional[str]]
+RunFn = Callable[[List[str]], str]
+
+
+def parse_windows_video_controllers(raw: str) -> List[Dict[str, Any]]:
+    controllers: List[Dict[str, Any]] = []
+    if not raw:
+        return controllers
+    try:
+        data = json.loads(raw)
+        if isinstance(data, dict):
+            data = [data]
+        if isinstance(data, list):
+            for item in data:
+                name = str(item.get("Name") or "").strip()
+                if not name:
+                    continue
+                try:
+                    ram_mb = int(item.get("AdapterRAM") or 0) // (1024 * 1024)
+                except Exception:
+                    ram_mb = 0
+                controllers.append({"name": name, "vram_mb": ram_mb})
+        if controllers:
+            return controllers
+    except Exception:
+        pass
+    current: Dict[str, Any] = {}
+    for line in raw.splitlines():
+        if line.startswith("Name="):
+            if current:
+                controllers.append(current)
+            current = {"name": line.split("=", 1)[-1].strip(), "vram_mb": 0}
+        elif line.startswith("AdapterRAM=") and current:
+            try:
+                current["vram_mb"] = int(line.split("=", 1)[-1].strip()) // (1024 * 1024)
+            except ValueError:
+                current["vram_mb"] = 0
+    if current:
+        controllers.append(current)
+    return controllers
+
+
+def detect_cuda(which: WhichFn, run: RunFn) -> Tuple[bool, str, Optional[str], Optional[str]]:
+    nvidia_smi = which("nvidia-smi")
+    nvcc = which("nvcc")
+    version = ""
+    if nvidia_smi:
+        raw = run([nvidia_smi, "--query-gpu=driver_version", "--format=csv,noheader"])
+        version = raw.splitlines()[0].strip() if raw.splitlines() else ""
+    if nvcc:
+        raw = run([nvcc, "--version"])
+        match = re.search(r"release\s+([\d.]+)", raw)
+        if match:
+            version = match.group(1)
+    return bool(nvidia_smi or nvcc), version, nvidia_smi, nvcc
+
+
+def detect_wsl_from_text(prof_os: str, raw: str) -> Tuple[bool, str]:
+    if prof_os.lower() != "linux":
+        return False, ""
+    lowered = (raw or "").lower()
+    is_wsl = "microsoft" in lowered or "wsl" in lowered
+    version = "2" if "microsoft-standard" in lowered or "wsl2" in lowered else ("1" if is_wsl else "")
+    return is_wsl, version
+
+
+def detect_tools(which: WhichFn, binaries: Iterable[str]) -> Dict[str, Optional[str]]:
+    return {binary: which(binary) for binary in binaries}
+
+
+__all__ = ["detect_cuda", "detect_tools", "detect_wsl_from_text", "parse_windows_video_controllers"]

package/latticeai/services/tool_dispatch.py

@@ -149,7 +149,7 @@ class ToolDispatchService:
                 status_code=403,
                 detail=(
                     f"'{tool_name}' 툴은 명시 승인이 필요합니다. "
-                    "8.9.0에서는 승인 UI가 없는 직접 실행 경로에서 기본 차단됩니다."
+                    "9.0.0에서는 승인 UI가 없는 직접 실행 경로에서 기본 차단됩니다."
                 ),
             )
         return policy

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "8.9.0",
+  "version": "9.0.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": {

package/setup_wizard.py

@@ -28,6 +28,12 @@ from latticeai.services.process_audit import (
     command_plan_for_commands,
     require_command_confirmation,
 )
+from latticeai.services.setup_detection import (
+    detect_cuda,
+    detect_tools,
+    detect_wsl_from_text,
+    parse_windows_video_controllers as _parse_windows_video_controllers,
+)
 
 # ── Helpers ───────────────────────────────────────────────────────────────────
 
@@ -411,43 +417,6 @@ def _detect_disk_free_gb() -> float:
         return 0.0
 
 
-def _parse_windows_video_controllers(raw: str) -> List[Dict[str, Any]]:
-    controllers: List[Dict[str, Any]] = []
-    if not raw:
-        return controllers
-    try:
-        data = _json.loads(raw)
-        if isinstance(data, dict):
-            data = [data]
-        if isinstance(data, list):
-            for item in data:
-                name = str(item.get("Name") or "").strip()
-                try:
-                    ram_mb = int(item.get("AdapterRAM") or 0) // (1024 * 1024)
-                except Exception:
-                    ram_mb = 0
-                if name:
-                    controllers.append({"name": name, "vram_mb": ram_mb})
-        if controllers:
-            return controllers
-    except Exception:
-        pass
-    current: Dict[str, Any] = {}
-    for line in raw.splitlines():
-        if line.startswith("Name="):
-            if current:
-                controllers.append(current)
-            current = {"name": line.split("=", 1)[-1].strip(), "vram_mb": 0}
-        elif line.startswith("AdapterRAM=") and current:
-            try:
-                current["vram_mb"] = int(line.split("=", 1)[-1].strip()) // (1024 * 1024)
-            except ValueError:
-                current["vram_mb"] = 0
-    if current:
-        controllers.append(current)
-    return controllers
-
-
 def _detect_gpu() -> Dict[str, Any]:
     devices: List[Dict[str, Any]] = []
     nvidia_smi = _which_any("nvidia-smi")
@@ -514,37 +483,24 @@ def _detect_gpu() -> Dict[str, Any]:
 
 
 def _detect_cuda() -> Dict[str, Any]:
-    nvidia_smi = _which_any("nvidia-smi")
-    nvcc = _which_any("nvcc")
-    version = ""
-    if nvidia_smi:
-        raw = _cmd([nvidia_smi, "--query-gpu=driver_version", "--format=csv,noheader"], timeout=5)
-        version = raw.splitlines()[0].strip() if raw.splitlines() else ""
-    if nvcc:
-        raw = _cmd([nvcc, "--version"], timeout=5)
-        m = re.search(r"release\s+([\d.]+)", raw)
-        if m:
-            version = m.group(1)
-    return {"available": bool(nvidia_smi or nvcc), "nvidia_smi": nvidia_smi, "nvcc": nvcc, "version": version}
+    available, version, nvidia_smi, nvcc = detect_cuda(_which_any, lambda args: _cmd(args, timeout=5))
+    return {"available": available, "nvidia_smi": nvidia_smi, "nvcc": nvcc, "version": version}
 
 
 def _detect_wsl() -> Dict[str, Any]:
-    if platform.system() != "Linux":
-        return {"is_wsl": False, "version": ""}
     raw = ""
     try:
         raw = Path("/proc/version").read_text(encoding="utf-8", errors="replace")
     except Exception:
         pass
-    is_wsl = "microsoft" in raw.lower() or "wsl" in raw.lower()
-    version = "2" if "microsoft-standard" in raw.lower() or "wsl2" in raw.lower() else ("1" if is_wsl else "")
+    is_wsl, version = detect_wsl_from_text(platform.system().lower(), raw)
     return {"is_wsl": is_wsl, "version": version}
 
 
 def _detect_tools() -> Dict[str, bool]:
     repair_path_for()
-    return {t: _which_any(t) is not None
-            for t in ["brew", "ollama", "python3", "python", "node", "npm", "git", "tesseract", "lms", "nvidia-smi", "nvcc"]}
+    detected = detect_tools(_which_any, ["brew", "ollama", "python3", "python", "node", "npm", "git", "tesseract", "lms", "nvidia-smi", "nvcc"])
+    return {tool: path is not None for tool, path in detected.items()}
 
 def _detect_mlx() -> Dict[str, Any]:
     return {

package/src-tauri/Cargo.lock

@@ -1584,7 +1584,7 @@ dependencies = [
 
 [[package]]
 name = "lattice-ai-desktop"
-version = "8.9.0"
+version = "9.0.0"
 dependencies = [
  "plist",
  "serde",

package/src-tauri/Cargo.toml

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