ltcai 2.2.7 → 3.0.1

package/latticeai/services/agent_runtime.py

@@ -0,0 +1,245 @@
+"""AgentRuntime — the single boundary for agent execution and observability.
+
+Before this module the agent concern was spread across three places: the
+:class:`~latticeai.core.multi_agent.MultiAgentOrchestrator` (role pipeline),
+the :class:`~latticeai.services.platform_runtime.PlatformRuntime` (cross-system
+wiring + an ad-hoc ``run_agent``), and ``api/agents.py`` (HTTP transport that
+also owned orchestration + persistence + audit). The frontend reached past all
+of them into the workspace store via ``/workspace/agents``.
+
+``AgentRuntime`` collapses that into one façade with a small, stable surface:
+
+* **configuration** — :meth:`config`, :meth:`roles`
+* **status / health** — :meth:`status`, :meth:`health`
+* **execution**       — :meth:`start`, :meth:`stop`
+* **events / state**  — :meth:`list_runs`, :meth:`get_run`, :meth:`events`, :meth:`replay`
+
+It *wraps* the existing orchestrator and run store rather than reimplementing
+them — execution semantics are unchanged, but every caller (HTTP router and, via
+it, the frontend) now depends on this boundary instead of internal paths.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, List, Optional
+
+from latticeai.core.multi_agent import (
+    AGENT_ROLES,
+    CORE_PIPELINE,
+    MULTI_AGENT_VERSION,
+    ROLE_AGENT_IDS,
+)
+
+ROLE_DESCRIPTIONS = {
+    "researcher": "Gathers workspace context and memory for the goal.",
+    "planner": "Decomposes the goal into an ordered, bounded plan.",
+    "executor": "Executes each planned step, invoking tools and workflows.",
+    "reviewer": "Reviews the executed work and approves, rejects, or retries.",
+    "release": "Finalizes and summarizes the approved outcome.",
+}
+
+# Run statuses the orchestrator can emit that mean "still working". The default
+# orchestrator runs synchronously, so persisted runs are always terminal; this
+# set lets the runtime report live work if a future async runner lands.
+_ACTIVE_STATUSES = {"running", "in_progress", "queued", "retrying"}
+_TERMINAL_STATUSES = {"ok", "retried_ok", "failed", "rejected", "cancelled"}
+
+
+class AgentRuntime:
+    def __init__(
+        self,
+        *,
+        store: Any,
+        orchestrator_factory: Callable[[Optional[str], Optional[str]], Any],
+        workspace_graph: Callable[[], Any],
+        append_audit_event: Callable[..., None],
+        max_retries_cap: int = 5,
+    ):
+        self._store = store
+        self._orchestrator_factory = orchestrator_factory
+        self._workspace_graph = workspace_graph
+        self._append_audit_event = append_audit_event
+        self._max_retries_cap = int(max_retries_cap)
+
+    # ── configuration ─────────────────────────────────────────────────────
+    def config(self) -> Dict[str, Any]:
+        return {
+            "version": MULTI_AGENT_VERSION,
+            "roles": list(AGENT_ROLES),
+            "default_pipeline": list(CORE_PIPELINE),
+            "max_retries_cap": self._max_retries_cap,
+            "execution_mode": "synchronous",
+        }
+
+    def roles(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                "role": role,
+                "agent_id": ROLE_AGENT_IDS.get(role, f"agent:{role}"),
+                "description": ROLE_DESCRIPTIONS.get(role, ""),
+                "terminal": role not in {"researcher", "planner", "executor", "reviewer"},
+            }
+            for role in AGENT_ROLES
+        ]
+
+    # ── health ────────────────────────────────────────────────────────────
+    def health(self) -> Dict[str, Any]:
+        checks: Dict[str, Any] = {}
+        ok = True
+        try:
+            self._store.list_agents(workspace_id=None)
+            checks["run_store"] = {"status": "ok"}
+        except Exception as exc:  # pragma: no cover - defensive
+            ok = False
+            checks["run_store"] = {"status": "error", "detail": str(exc)}
+        try:
+            self._orchestrator_factory(None, None)
+            checks["orchestrator"] = {"status": "ok"}
+        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}
+
+    # ── roster + status ───────────────────────────────────────────────────
+    def _roster(self, runs: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Canonical role roster enriched with real run statistics."""
+        by_agent: Dict[str, Dict[str, Any]] = {}
+        for run in runs:
+            aid = str(run.get("agent_id") or "")
+            entry = by_agent.setdefault(aid, {"runs": 0, "last_status": None, "last_at": None})
+            entry["runs"] += 1
+            if entry["last_at"] is None:  # runs are newest-first
+                entry["last_status"] = run.get("status")
+                entry["last_at"] = run.get("created_at") or run.get("completed_at")
+
+        roster: List[Dict[str, Any]] = []
+        order = list(CORE_PIPELINE)  # planner, executor, reviewer first
+        ordered_roles = order + [r for r in AGENT_ROLES if r not in order]
+        for role in ordered_roles:
+            agent_id = ROLE_AGENT_IDS.get(role, f"agent:{role}")
+            stats = by_agent.get(agent_id, {"runs": 0, "last_status": None, "last_at": None})
+            handoffs = []
+            if role == "planner":
+                handoffs = [ROLE_AGENT_IDS["executor"]]
+            elif role == "executor":
+                handoffs = [ROLE_AGENT_IDS["reviewer"]]
+            roster.append({
+                "id": agent_id,
+                "name": role.capitalize(),
+                "role": ROLE_DESCRIPTIONS.get(role, ""),
+                "state": "available" if role != "release" else "idle",
+                "runs": stats["runs"],
+                "last_status": stats["last_status"],
+                "last_at": stats["last_at"],
+                "handoffs": handoffs,
+            })
+        return roster
+
+    def status(self, *, scope: Optional[str] = None) -> Dict[str, Any]:
+        try:
+            listing = self._store.list_agents(workspace_id=scope)
+        except Exception as exc:  # pragma: no cover - defensive
+            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)
+        return {
+            "runtime": {
+                "ready": True,
+                "version": MULTI_AGENT_VERSION,
+                "execution_mode": "synchronous",
+                "default_pipeline": list(CORE_PIPELINE),
+                "total_runs": len(runs),
+                "active_runs": active,
+            },
+            "health": self.health(),
+            "roles": self.roles(),
+            "agents": self._roster(runs),
+            "runs": runs[:25],
+        }
+
+    # ── events / state ────────────────────────────────────────────────────
+    def list_runs(self, *, scope: Optional[str] = None) -> Dict[str, Any]:
+        return self._store.list_agents(workspace_id=scope)
+
+    def get_run(self, run_id: str, *, scope: Optional[str] = None) -> Dict[str, Any]:
+        return {"run": self._store.get_agent_run(run_id, workspace_id=scope)}
+
+    def replay(self, run_id: str, *, scope: Optional[str] = None) -> Dict[str, Any]:
+        return {"replay": self._store.replay_agent_run(run_id, workspace_id=scope)}
+
+    def events(self, run_id: str, *, scope: Optional[str] = None) -> Dict[str, Any]:
+        run = self._store.get_agent_run(run_id, workspace_id=scope)
+        status = str(run.get("status") or "")
+        return {
+            "run_id": run_id,
+            "status": status,
+            "is_final": status in _TERMINAL_STATUSES or status not in _ACTIVE_STATUSES,
+            "current_role": run.get("current_role"),
+            "timeline": run.get("timeline") or [],
+            "handoffs": run.get("handoffs") or [],
+        }
+
+    # ── execution ─────────────────────────────────────────────────────────
+    def start(
+        self,
+        goal: str,
+        *,
+        user_email: Optional[str],
+        scope: Optional[str],
+        roles: Optional[List[str]] = None,
+        inputs: Optional[Dict[str, Any]] = None,
+        max_retries: int = 2,
+    ) -> Dict[str, Any]:
+        if not str(goal or "").strip():
+            raise ValueError("goal is required")
+        orchestrator = self._orchestrator_factory(user_email or None, scope)
+        result = orchestrator.run(
+            goal,
+            user_email=user_email or None,
+            workspace_id=scope,
+            inputs=inputs or {},
+            roles=roles or None,
+            max_retries=max(0, min(int(max_retries or 0), self._max_retries_cap)),
+        )
+        run = self._store.record_agent_run(
+            agent_id=result.agent_id,
+            status=result.status,
+            input_text=goal,
+            output_text=result.output,
+            timeline=result.timeline,
+            relationships=[ROLE_AGENT_IDS.get(r, f"agent:{r}") for r in result.roles_run],
+            handoffs=result.handoffs,
+            context_packets=result.context_packets,
+            plan=result.plan,
+            plan_review=result.plan_review,
+            review_history=result.review_history,
+            retry_history=result.retry_history,
+            memory_snapshots=result.memory_snapshots,
+            user_email=user_email or None,
+            graph=self._workspace_graph(),
+            workspace_id=scope,
+        )
+        self._append_audit_event(
+            "multi_agent_run",
+            user_email=user_email,
+            agent_id=result.agent_id,
+            status=result.status,
+            retries=result.retries,
+        )
+        return {"run": run, "result": result.as_dict()}
+
+    def stop(self, run_id: str, *, scope: Optional[str] = None) -> Dict[str, Any]:
+        """Best-effort stop.
+
+        The default runtime executes synchronously, so by the time a run id
+        exists the run has already completed. Report that honestly rather than
+        pretending a cancellation occurred.
+        """
+        try:
+            run = self._store.get_agent_run(run_id, workspace_id=scope)
+        except FileNotFoundError:
+            return {"stopped": False, "reason": "run not found", "run_id": run_id}
+        status = str(run.get("status") or "")
+        if status in _ACTIVE_STATUSES:
+            return {"stopped": False, "reason": "asynchronous cancellation is not supported by the synchronous runtime", "run_id": run_id, "status": status}
+        return {"stopped": False, "reason": "run already finished", "run_id": run_id, "status": status}

package/latticeai/services/search_service.py

@@ -0,0 +1,346 @@
+"""Backend search orchestration for Lattice AI v3.
+
+The service composes the existing knowledge graph, the local vector index, and
+keyword search into UI-ready contracts without tying routers to store internals.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, Mapping, Optional
+
+
+DEFAULT_HYBRID_WEIGHTS = {
+    "keyword": 0.35,
+    "vector": 0.40,
+    "graph": 0.25,
+}
+
+
+def _clean(text: Any, limit: int = 1000) -> str:
+    return " ".join(str(text or "").split())[:limit]
+
+
+def _result_key(result: Mapping[str, Any]) -> str:
+    return str(result.get("id") or result.get("node_id") or "")
+
+
+@dataclass
+class SearchService:
+    graph_store: Any
+
+    def _require_graph(self) -> Any:
+        if self.graph_store is None:
+            raise ValueError("knowledge graph is disabled")
+        return self.graph_store
+
+    def keyword_search(self, query: str, *, limit: int = 30) -> Dict[str, Any]:
+        graph = self._require_graph()
+        payload = graph.search(query, limit)
+        matches = []
+        for rank, match in enumerate(payload.get("matches", []), start=1):
+            matches.append({
+                "id": match["id"],
+                "node_id": match["id"],
+                "item_type": "node",
+                "type": match.get("type"),
+                "title": match.get("title"),
+                "summary": _clean(match.get("summary")),
+                "score": round(1.0 / rank, 6),
+                "rank": rank,
+                "sources": ["keyword"],
+                "source_scores": {"keyword": round(1.0 / rank, 6)},
+                "metadata": match.get("metadata") or {},
+                "updated_at": match.get("updated_at"),
+            })
+        return {"query": query, "mode": "keyword", "matches": matches}
+
+    def vector_search(self, query: str, *, limit: int = 30, min_score: float = 0.0) -> Dict[str, Any]:
+        graph = self._require_graph()
+        payload = graph.vector_search(query, limit=limit, min_score=min_score)
+        matches = []
+        for rank, match in enumerate(payload.get("matches", []), start=1):
+            score = float(match.get("score") or 0.0)
+            matches.append({
+                "id": match.get("id"),
+                "node_id": match.get("node_id"),
+                "item_type": match.get("item_type"),
+                "type": match.get("type"),
+                "title": match.get("title"),
+                "summary": _clean(match.get("summary")),
+                "score": round(score, 6),
+                "rank": rank,
+                "sources": ["vector"],
+                "source_scores": {"vector": round(score, 6)},
+                "metadata": match.get("metadata") or {},
+                "updated_at": match.get("updated_at"),
+            })
+        return {
+            "query": query,
+            "mode": "vector",
+            "embedding_model": payload.get("embedding_model"),
+            "embedding_dim": payload.get("embedding_dim"),
+            "matches": matches,
+        }
+
+    def graph_search(self, query: str, *, limit: int = 30, expand_depth: int = 1) -> Dict[str, Any]:
+        graph = self._require_graph()
+        limit = max(1, min(int(limit or 30), 100))
+        expand_depth = max(0, min(int(expand_depth or 1), 3))
+        direct = graph.search(query, limit=max(limit, 10)).get("matches", [])
+        relationships = graph.relationship_search(query=query, limit=limit).get("relationships", [])
+        by_id: Dict[str, Dict[str, Any]] = {}
+
+        def add_node(node: Mapping[str, Any], score: float, reason: str, edge: Optional[Mapping[str, Any]] = None) -> None:
+            node_id = str(node.get("id") or "")
+            if not node_id:
+                return
+            current = by_id.get(node_id)
+            if not current:
+                current = {
+                    "id": node_id,
+                    "node_id": node_id,
+                    "item_type": "node",
+                    "type": node.get("type"),
+                    "title": node.get("title"),
+                    "summary": _clean(node.get("summary")),
+                    "score": 0.0,
+                    "sources": ["graph"],
+                    "source_scores": {"graph": 0.0},
+                    "metadata": node.get("metadata") or {},
+                    "updated_at": node.get("updated_at"),
+                    "graph_context": [],
+                }
+                by_id[node_id] = current
+            current["score"] = max(float(current["score"]), score)
+            current["source_scores"]["graph"] = max(float(current["source_scores"]["graph"]), score)
+            context = {"reason": reason}
+            if edge:
+                context["relationship"] = {
+                    "id": edge.get("id"),
+                    "type": edge.get("type"),
+                    "weight": edge.get("weight"),
+                    "from": edge.get("from") or (edge.get("source") or {}).get("id"),
+                    "to": edge.get("to") or (edge.get("target") or {}).get("id"),
+                }
+            current["graph_context"].append(context)
+
+        for rank, match in enumerate(direct, start=1):
+            add_node(match, 1.0 / rank, "direct_match")
+            if expand_depth <= 0:
+                continue
+            try:
+                neighborhood = graph.traverse(match["id"], depth=expand_depth, limit=limit * 3)
+            except Exception:
+                neighborhood = {"nodes": [], "edges": []}
+            edge_by_pair = {
+                (edge.get("from"), edge.get("to")): edge
+                for edge in neighborhood.get("edges", [])
+            }
+            for node in neighborhood.get("nodes", []):
+                if node.get("id") == match.get("id"):
+                    continue
+                related_edge = None
+                for pair, edge in edge_by_pair.items():
+                    if match.get("id") in pair and node.get("id") in pair:
+                        related_edge = edge
+                        break
+                add_node(node, 0.45 / rank, "neighbor_expansion", related_edge)
+
+        for rank, rel in enumerate(relationships, start=1):
+            rel_score = 0.75 / rank
+            add_node(rel.get("source") or {}, rel_score, "relationship_match", rel)
+            add_node(rel.get("target") or {}, rel_score, "relationship_match", rel)
+
+        matches = sorted(by_id.values(), key=lambda item: item["score"], reverse=True)[:limit]
+        for rank, match in enumerate(matches, start=1):
+            match["rank"] = rank
+            match["score"] = round(float(match["score"]), 6)
+            match["source_scores"]["graph"] = round(float(match["source_scores"]["graph"]), 6)
+        return {"query": query, "mode": "graph", "expand_depth": expand_depth, "matches": matches}
+
+    def hybrid_search(
+        self,
+        query: str,
+        *,
+        limit: int = 30,
+        keyword_limit: int = 30,
+        vector_limit: int = 30,
+        graph_limit: int = 30,
+        weights: Optional[Mapping[str, float]] = None,
+    ) -> Dict[str, Any]:
+        weights = {**DEFAULT_HYBRID_WEIGHTS, **dict(weights or {})}
+        channels = {
+            "keyword": self.keyword_search(query, limit=keyword_limit),
+            "vector": self.vector_search(query, limit=vector_limit),
+            "graph": self.graph_search(query, limit=graph_limit),
+        }
+        fused: Dict[str, Dict[str, Any]] = {}
+        for source, payload in channels.items():
+            source_weight = float(weights.get(source, 0.0))
+            for rank, result in enumerate(payload.get("matches", []), start=1):
+                key = _result_key(result)
+                if not key:
+                    continue
+                source_score = float((result.get("source_scores") or {}).get(source, result.get("score") or 0.0))
+                rank_score = 1.0 / rank
+                contribution = source_weight * max(source_score, rank_score)
+                current = fused.get(key)
+                if not current:
+                    current = {
+                        **result,
+                        "sources": [],
+                        "source_scores": {},
+                        "score": 0.0,
+                    }
+                    fused[key] = current
+                current["score"] = float(current["score"]) + contribution
+                if source not in current["sources"]:
+                    current["sources"].append(source)
+                current["source_scores"][source] = round(source_score, 6)
+                if result.get("graph_context"):
+                    current.setdefault("graph_context", [])
+                    current["graph_context"].extend(result.get("graph_context") or [])
+
+        matches = sorted(fused.values(), key=lambda item: item["score"], reverse=True)[: max(1, min(limit, 100))]
+        for rank, match in enumerate(matches, start=1):
+            match["rank"] = rank
+            match["score"] = round(float(match["score"]), 6)
+            match["fusion"] = {
+                "weights": weights,
+                "sources": match.get("sources", []),
+            }
+        return {
+            "query": query,
+            "mode": "hybrid",
+            "weights": weights,
+            "channels": {
+                name: {
+                    key: value
+                    for key, value in payload.items()
+                    if key not in {"matches"}
+                }
+                for name, payload in channels.items()
+            },
+            "matches": matches,
+        }
+
+    def graph(self, *, limit: int = 300) -> Dict[str, Any]:
+        return self._require_graph().graph(limit=limit)
+
+    def node(self, node_id: str, *, include_neighbors: bool = True, depth: int = 1, limit: int = 100) -> Dict[str, Any]:
+        graph = self._require_graph()
+        payload = {"node": graph.get_node(node_id)}
+        if include_neighbors:
+            payload["neighborhood"] = graph.traverse(node_id, depth=depth, limit=limit)
+        return payload
+
+    def relationships(
+        self,
+        *,
+        query: str = "",
+        node_id: str = "",
+        relationship_type: str = "",
+        limit: int = 30,
+    ) -> Dict[str, Any]:
+        return self._require_graph().relationship_search(
+            query=query,
+            node_id=node_id,
+            relationship_type=relationship_type,
+            limit=limit,
+        )
+
+    def index_status(self) -> Dict[str, Any]:
+        return self._require_graph().index_status()
+
+    def embeddings_status(
+        self,
+        *,
+        resolved: Optional[Mapping[str, Any]] = None,
+        refresh: bool = False,
+    ) -> Dict[str, Any]:
+        """Report the active embedding provider for the Models → Embeddings UI.
+
+        Combines the resolved-provider info (requested vs active, fallback,
+        health) with the vector index's identity and last build time. The
+        ``state`` is one of ``production`` | ``fallback`` | ``unavailable`` so
+        the UI never shows a down provider as live.
+        """
+        resolved = dict(resolved or {})
+        graph = self.graph_store
+        embedder = getattr(graph, "_embedding_model", None)
+
+        meta: Dict[str, Any] = {}
+        if embedder is not None and hasattr(embedder, "metadata"):
+            try:
+                meta = dict(embedder.metadata())
+            except Exception:
+                meta = {}
+        else:  # legacy LocalEmbeddingModel
+            meta = {
+                "provider": "hash",
+                "model": getattr(embedder, "model_id", "lattice-local-hash-v1"),
+                "model_id": getattr(embedder, "model_id", "lattice-local-hash-v1"),
+                "dim": getattr(embedder, "dim", 384),
+                "grade": "fallback",
+            }
+
+        health = resolved.get("health") or {"status": "unknown", "detail": ""}
+        if refresh and embedder is not None and hasattr(embedder, "health"):
+            try:
+                health = embedder.health()
+            except Exception as exc:  # pragma: no cover - defensive
+                health = {"status": "unavailable", "detail": str(exc)}
+
+        fell_back = bool(resolved.get("fell_back"))
+        grade = str(meta.get("grade") or ("fallback" if fell_back else "production"))
+        if fell_back or health.get("status") == "unavailable":
+            state = "unavailable" if fell_back else "fallback"
+        else:
+            state = "fallback" if grade == "fallback" else "production"
+
+        index: Dict[str, Any] = {}
+        last_indexed_at = None
+        if graph is not None:
+            try:
+                status = graph.index_status()
+                index = {
+                    "status": status.get("status"),
+                    "source_items": status.get("source_items"),
+                    "indexed_items": status.get("indexed_items"),
+                    "ready_items": status.get("ready_items"),
+                    "pending_items": status.get("pending_items"),
+                    "stale_items": status.get("stale_items"),
+                    "embedding_model": (status.get("storage") or {}).get("embedding_model"),
+                    "embedding_dim": (status.get("storage") or {}).get("embedding_dim"),
+                }
+                for op in status.get("operations", []):
+                    if op.get("status") == "completed" and op.get("completed_at"):
+                        last_indexed_at = op.get("completed_at")
+                        break
+            except Exception as exc:  # pragma: no cover - defensive
+                index = {"error": str(exc)}
+
+        return {
+            "provider": meta.get("provider"),
+            "requested_provider": resolved.get("requested_provider") or meta.get("provider"),
+            "active_provider": resolved.get("active_provider") or meta.get("provider"),
+            "model": meta.get("model"),
+            "model_id": meta.get("model_id"),
+            "dimensions": meta.get("dim"),
+            "grade": grade,
+            "state": state,
+            "fell_back": fell_back,
+            "health": health,
+            "detail": resolved.get("detail", ""),
+            "last_indexed_at": last_indexed_at,
+            "index": index,
+            "available_providers": list(resolved.get("available_providers") or []),
+        }
+
+    def rebuild_index(self, *, full: bool = False, include_nodes: bool = True, include_chunks: bool = True) -> Dict[str, Any]:
+        return self._require_graph().rebuild_vector_index(
+            full=full,
+            include_nodes=include_nodes,
+            include_chunks=include_chunks,
+        )

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ltcai",
-  "version": "2.2.7",
-  "description": "Local-first AI workspace for knowledge graphs, AI pipelines, and multi-agent coding workflows.",
+  "version": "3.0.1",
+  "description": "Lattice AI v3 local-first AI workspace platform with knowledge graph, vector index, hybrid search, agents, and workspace modes.",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {
     "type": "git",
@@ -19,8 +19,9 @@
     "dev": "python3 ltcai_cli.py --reload",
     "build": "npm run build:python",
     "build:python": "python3 -m build",
-    "check:python": "python3 -m py_compile ltcai_cli.py server.py latticeai/server_app.py latticeai/api/chat.py latticeai/api/computer_use.py latticeai/api/deps.py latticeai/api/garden.py latticeai/api/local_files.py latticeai/api/permissions.py latticeai/api/setup.py latticeai/api/static_routes.py latticeai/api/tools.py latticeai/api/plugins.py latticeai/api/workflow_designer.py latticeai/api/agents.py latticeai/api/realtime.py latticeai/api/marketplace.py latticeai/services/app_context.py latticeai/services/model_runtime.py latticeai/services/model_catalog.py latticeai/services/model_recommendation.py latticeai/services/tool_dispatch.py latticeai/services/upload_service.py latticeai/core/tool_registry.py latticeai/core/enterprise.py latticeai/core/enterprise_admin.py latticeai/core/agent_prompts.py latticeai/core/workspace_os.py latticeai/core/plugins.py latticeai/core/marketplace.py latticeai/core/workflow_engine.py latticeai/core/multi_agent.py latticeai/core/realtime.py knowledge_graph.py knowledge_graph_api.py local_knowledge_api.py llm_router.py p_reinforce.py telegram_bot.py tools.py codex_telegram_bot.py",
-    "lint": "node --check static/scripts/account.js && node --check static/scripts/admin.js && node --check static/scripts/chat.js && node --check static/scripts/graph.js && node --check static/scripts/platform.js && node --check static/scripts/ux.js && node --check static/scripts/workspace.js && node --check tests/visual/mock_server.cjs",
+    "check:python": "python3 -m py_compile ltcai_cli.py server.py latticeai/server_app.py latticeai/api/chat.py latticeai/api/computer_use.py latticeai/api/deps.py latticeai/api/garden.py latticeai/api/local_files.py latticeai/api/permissions.py latticeai/api/setup.py latticeai/api/static_routes.py latticeai/api/tools.py latticeai/api/plugins.py latticeai/api/workflow_designer.py latticeai/api/agents.py latticeai/api/realtime.py latticeai/api/marketplace.py latticeai/api/search.py latticeai/services/search_service.py latticeai/core/local_embeddings.py latticeai/core/embedding_providers.py latticeai/services/agent_runtime.py latticeai/core/config.py latticeai/api/admin.py latticeai/services/app_context.py latticeai/services/model_runtime.py latticeai/services/model_catalog.py latticeai/services/model_recommendation.py latticeai/services/tool_dispatch.py latticeai/services/upload_service.py latticeai/core/tool_registry.py latticeai/core/enterprise.py latticeai/core/enterprise_admin.py latticeai/core/agent_prompts.py latticeai/core/workspace_os.py latticeai/core/plugins.py latticeai/core/marketplace.py latticeai/core/workflow_engine.py latticeai/core/multi_agent.py latticeai/core/realtime.py knowledge_graph.py knowledge_graph_api.py local_knowledge_api.py llm_router.py p_reinforce.py telegram_bot.py tools.py codex_telegram_bot.py",
+    "lint": "node --check static/scripts/account.js && node --check static/scripts/admin.js && node --check static/scripts/chat.js && node --check static/scripts/graph.js && node --check static/scripts/platform.js && node --check static/scripts/ux.js && node --check static/scripts/workspace.js && node --check tests/visual/mock_server.cjs && node --check tests/visual/v3.spec.js && npm run lint:v3",
+    "lint:v3": "node scripts/lint_v3.mjs",
     "typecheck": "cd vscode-extension && npm run build",
     "test": "python3 -m pytest tests/ -v",
     "test:unit": "python3 -m pytest tests/unit/ -v",
@@ -89,6 +90,7 @@
     "static/platform.css",
     "static/scripts/",
     "static/css/",
+    "static/v3/",
     "static/icons/",
     "plugins/",
     "docs/",

package/static/account.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover, interactive-widget=resizes-content">
     <title>Lattice AI</title>
-    <script src="/static/scripts/ux.js?v=2.2.7"></script>
+    <script src="/static/scripts/ux.js?v=3.0.0"></script>
     <link rel="manifest" href="/manifest.json">
     <meta name="theme-color" content="#f3ecff">
     <meta name="apple-mobile-web-app-capable" content="yes">
@@ -14,13 +14,13 @@
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&display=swap">
     <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@tabler/icons-webfont@latest/tabler-icons.min.css">
-    <link rel="stylesheet" href="/static/css/tokens.css?v=2.2.7">
-    <link rel="stylesheet" href="/static/css/reference/base.css?v=2.2.7">
-    <link rel="stylesheet" href="/static/css/reference/account.css?v=2.2.7">
-    <link rel="stylesheet" href="/static/css/reference/admin.css?v=2.2.7">
-    <link rel="stylesheet" href="/static/css/reference/graph.css?v=2.2.7">
-    <link rel="stylesheet" href="/static/css/reference/chat.css?v=2.2.7">
-    <link rel="stylesheet" href="/static/css/responsive.css?v=2.2.7">
+    <link rel="stylesheet" href="/static/css/tokens.css?v=3.0.0">
+    <link rel="stylesheet" href="/static/css/reference/base.css?v=3.0.0">
+    <link rel="stylesheet" href="/static/css/reference/account.css?v=3.0.0">
+    <link rel="stylesheet" href="/static/css/reference/admin.css?v=3.0.0">
+    <link rel="stylesheet" href="/static/css/reference/graph.css?v=3.0.0">
+    <link rel="stylesheet" href="/static/css/reference/chat.css?v=3.0.0">
+    <link rel="stylesheet" href="/static/css/responsive.css?v=3.0.0">
 </head>
 <body class="lattice-ref-auth">
     <div class="orb orb-1"></div>
@@ -110,6 +110,6 @@
         <a href="#" onclick="return false;" id="privacy-link">개인정보 처리방침</a>
     </footer>
 
-    <script src="/static/scripts/account.js?v=2.2.7"></script>
+    <script src="/static/scripts/account.js?v=3.0.0"></script>
 </body>
 </html>