ltcai 7.0.0 → 7.2.0

package/lattice_brain/__init__.py

@@ -26,7 +26,7 @@ from .storage import (
     storage_from_env,
 )
 
-__version__ = "7.0.0"
+__version__ = "7.2.0"
 
 __all__ = [
     "AgentRuntime",

package/lattice_brain/runtime/agent_runtime.py

@@ -228,6 +228,57 @@ class AgentRuntime:
             "runs": runs[:25],
         }
 
+    def preview(
+        self,
+        goal: str,
+        *,
+        roles: Optional[List[str]] = None,
+        inputs: Optional[Dict[str, Any]] = None,
+        max_retries: int = 2,
+        scope: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Return the execution contract without reserving or starting a run.
+
+        The preview is the product-facing readiness gate for agent execution:
+        clients can show whether a real LLM-backed run can start, which roles
+        will execute, how retry limits are clamped, and why the run is blocked.
+        """
+
+        requested_roles = list(roles or CORE_PIPELINE)
+        unknown_roles = [role for role in requested_roles if role not in AGENT_ROLES]
+        health = self.health()
+        goal_ready = bool(str(goal or "").strip())
+        retry_budget = max(0, min(int(max_retries or 0), self._max_retries_cap))
+        blocking_reasons: List[str] = []
+        if not goal_ready:
+            blocking_reasons.append("goal is required")
+        if unknown_roles:
+            blocking_reasons.append(f"unknown roles: {', '.join(unknown_roles)}")
+        if not health.get("ready"):
+            orchestrator = (health.get("checks") or {}).get("orchestrator") or {}
+            blocking_reasons.append(str(orchestrator.get("detail") or "agent runtime is unavailable"))
+        can_start = not blocking_reasons
+        return {
+            "ready": can_start,
+            "can_start": can_start,
+            "blocking_reasons": blocking_reasons,
+            "goal": str(goal or "").strip(),
+            "roles": requested_roles,
+            "unknown_roles": unknown_roles,
+            "inputs_keys": sorted((inputs or {}).keys()),
+            "max_retries": retry_budget,
+            "max_retries_requested": max_retries,
+            "scope": scope,
+            "execution_mode": self._execution_mode(),
+            "runtime": {
+                "version": MULTI_AGENT_VERSION,
+                "default_pipeline": list(CORE_PIPELINE),
+                "max_retries_cap": self._max_retries_cap,
+                "simulation_runs_allowed": self._allow_simulation_runs,
+            },
+            "health": health,
+        }
+
     # ── events / state ────────────────────────────────────────────────────
     def list_runs(self, *, scope: Optional[str] = None) -> Dict[str, Any]:
         return self._store.list_agents(workspace_id=scope)

package/lattice_brain/runtime/multi_agent.py

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

package/latticeai/__init__.py

@@ -1,3 +1,3 @@
 """Lattice AI - modular server package."""
 
-__version__ = "7.0.0"
+__version__ = "7.2.0"

package/latticeai/api/agents.py

@@ -192,4 +192,16 @@ def create_agents_router(
             # A pre_run hook gated this run (e.g. a policy/permission hook).
             raise HTTPException(status_code=403, detail=str(exc)) from exc
 
+    @router.post("/agents/api/run/preview")
+    async def agent_run_preview(req: AgentRunRequest, request: Request):
+        require_user(request)
+        scope = gate_read(request)
+        return runtime.preview(
+            req.goal,
+            scope=scope,
+            roles=req.roles or None,
+            inputs=req.inputs,
+            max_retries=req.max_retries,
+        )
+
     return router

package/latticeai/api/tools.py

@@ -25,6 +25,8 @@ from latticeai.services.tool_dispatch import (
     check_tool_role as _check_tool_role,
     get_tool_permission,
     list_tool_permissions,
+    tool_registry_diagnostics,
+    tool_registry_manifest,
 )
 from latticeai.services.router_context import ToolRouterContext
 from latticeai.services.p_reinforce import BRAIN_DIR
@@ -602,6 +604,18 @@ def create_tools_router(
         """
         require_user(request)
         return {"status": "ok", "permissions": list_tool_permissions()}
+
+    @api_router.get("/tools/registry")
+    async def tools_registry(request: Request):
+        """Full ToolRegistry contract: handlers, governance, catalog, diagnostics."""
+        require_user(request)
+        return tool_registry_manifest()
+
+    @api_router.get("/tools/registry/diagnostics")
+    async def tools_registry_diagnostics(request: Request):
+        """Small drift check for CI/admin runtime readiness views."""
+        require_user(request)
+        return {"status": "ok", "diagnostics": tool_registry_diagnostics()}
     
     
     # ── MCP / skills / plugins router (latticeai.api.mcp, v1.3.0) ────────────────

package/latticeai/api/workspace.py

@@ -99,6 +99,25 @@ class WorkspaceVSCodeRequest(BaseModel):
     content: str = ""
     selection: str = ""
     prompt: str = ""
+    extension_version: str = ""
+    workspace_folder: str = ""
+
+
+class WorkspaceVSCodeStatusRequest(BaseModel):
+    status: str = "connected"
+    index_status: str = "unknown"
+    workspace_folder: str = ""
+    extension_version: str = ""
+    active_file: str = ""
+    detail: str = ""
+
+
+_VSCODE_STATUS: Dict[str, object] = {
+    "connected": False,
+    "status": "offline",
+    "index_status": "unknown",
+    "last_seen_ms": 0,
+}
 
 
 class WorkspaceCreateRequest(BaseModel):
@@ -630,9 +649,49 @@ def create_workspace_router(context: AppContext) -> APIRouter:
 
     # ── VS Code workflow bridge ───────────────────────────────────────────
 
+    @router.get("/workspace/vscode/status")
+    async def workspace_vscode_status(request: Request):
+        require_user(request)
+        last_seen = int(_VSCODE_STATUS.get("last_seen_ms") or 0)
+        now_ms = int(datetime.utcnow().timestamp() * 1000)
+        connected = last_seen > 0 and (now_ms - last_seen) < 60000
+        return {
+            **_VSCODE_STATUS,
+            "connected": connected,
+            "status": _VSCODE_STATUS.get("status") if connected else "offline",
+        }
+
+    @router.post("/workspace/vscode/status")
+    async def workspace_vscode_status_update(req: WorkspaceVSCodeStatusRequest, request: Request):
+        current_user = require_user(request)
+        now_ms = int(datetime.utcnow().timestamp() * 1000)
+        _VSCODE_STATUS.update({
+            "connected": True,
+            "status": req.status or "connected",
+            "index_status": req.index_status or "unknown",
+            "workspace_folder": req.workspace_folder,
+            "extension_version": req.extension_version,
+            "active_file": req.active_file,
+            "detail": req.detail,
+            "last_seen_ms": now_ms,
+            "user_email": current_user,
+        })
+        return {"status": "ok", **_VSCODE_STATUS}
+
     @router.post("/workspace/vscode/send")
     async def workspace_vscode_send(req: WorkspaceVSCodeRequest, request: Request):
         current_user = require_user(request)
+        now_ms = int(datetime.utcnow().timestamp() * 1000)
+        _VSCODE_STATUS.update({
+            "connected": True,
+            "status": "synced",
+            "index_status": "synced",
+            "workspace_folder": req.workspace_folder,
+            "extension_version": req.extension_version,
+            "active_file": req.file_path or "",
+            "last_seen_ms": now_ms,
+            "user_email": current_user,
+        })
         content = req.selection or req.content or req.prompt
         workflow = WORKSPACE_OS.create_workflow(
             name=f"VS Code: {req.action}",

package/latticeai/core/marketplace.py

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

package/latticeai/core/tool_registry.py

@@ -130,6 +130,7 @@ TOOL_GOVERNANCE: Dict[str, ToolPolicy] = {
     "todo_read": _r(),
     "local_list": _r(sandbox="home"),
     "local_read": _r(sandbox="home"),
+    "read_document": _r(sandbox="home"),
     "git_status": _rs(),
     "git_diff": _rs(),
     "git_log": _rs(),
@@ -189,6 +190,7 @@ MCP_TOOL_DESCRIPTIONS: Dict[str, str] = {
     "clear_history": "Clear chat history to reduce context and speed up responses.",
     "inspect_html": "Inspect local HTML structure and assets.",
     "preview_url": "Return a server URL for a workspace file.",
+    "create_web_project": "Create a web project scaffold inside the workspace.",
     "create_docx": "Create a Word DOCX document in the agent workspace.",
     "create_xlsx": "Create an XLSX spreadsheet in the agent workspace.",
     "create_pptx": "Create a PPTX presentation deck in the agent workspace.",
@@ -251,6 +253,51 @@ class ToolRegistry:
     def registered_tools(self) -> frozenset[str]:
         return frozenset(self.handlers)
 
+    def diagnostics(self) -> Dict[str, Any]:
+        """Return registry drift checks without executing any tool.
+
+        This is intentionally derived from the live registry instance, not from
+        duplicated constants, so admin/runtime surfaces can prove whether the
+        dispatch, governance, and catalog projections are still aligned.
+        """
+
+        registered = set(self.registered_tools())
+        governed = set(self.governance)
+        described = set(self.descriptions)
+        return {
+            "ready": not (governed - registered or registered - governed or registered - described),
+            "registered_tools": len(registered),
+            "governed_tools": len(governed),
+            "described_tools": len(described),
+            "governance_without_handler": sorted(governed - registered),
+            "handler_without_governance": sorted(registered - governed),
+            "handler_without_description": sorted(registered - described),
+            "description_without_handler": sorted(described - registered),
+        }
+
+    def manifest(self) -> Dict[str, Any]:
+        """Serializable tool registry contract for runtime/admin inspection."""
+
+        tools = []
+        for name in sorted(self.registered_tools() | set(self.governance) | set(self.descriptions)):
+            policy = self.policy_for(name, {})
+            tools.append({
+                "name": name,
+                "registered": name in self.handlers,
+                "governed": name in self.governance,
+                "described": name in self.descriptions,
+                "description": self.descriptions.get(name, ""),
+                "policy": dict(policy),
+                "permission": dict(self.permission(name, {})),
+            })
+        diagnostics = self.diagnostics()
+        return {
+            "status": "ok" if diagnostics["ready"] else "degraded",
+            "catalog_brief": self.catalog_brief.strip(),
+            "diagnostics": diagnostics,
+            "tools": tools,
+        }
+
     def execute(self, action: str, args: Dict[str, Any], *, error_cls: type[Exception]) -> Dict[str, Any]:
         handler = self.handlers.get(action)
         if handler is None:

package/latticeai/core/workspace_os.py

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

package/latticeai/services/tool_dispatch.py

@@ -90,6 +90,12 @@ class ToolDispatchService:
     def permissions(self) -> list[ToolPermission]:
         return self.registry.permissions()
 
+    def diagnostics(self) -> Dict[str, Any]:
+        return self.registry.diagnostics()
+
+    def manifest(self) -> Dict[str, Any]:
+        return self.registry.manifest()
+
     def check_role(self, tool_name: str, current_user: str) -> None:
         if tool_name not in self.registry.admin_only_tools:
             return
@@ -131,6 +137,14 @@ def list_tool_permissions() -> list:
     return DEFAULT_TOOL_DISPATCH_SERVICE.permissions()
 
 
+def tool_registry_diagnostics() -> Dict[str, Any]:
+    return DEFAULT_TOOL_DISPATCH_SERVICE.diagnostics()
+
+
+def tool_registry_manifest() -> Dict[str, Any]:
+    return DEFAULT_TOOL_DISPATCH_SERVICE.manifest()
+
+
 def check_tool_role(tool_name: str, current_user: str) -> None:
     DEFAULT_TOOL_DISPATCH_SERVICE.check_role(tool_name, current_user)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "7.0.0",
+  "version": "7.2.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/src-tauri/Cargo.lock

@@ -1654,7 +1654,7 @@ dependencies = [
 
 [[package]]
 name = "lattice-ai-desktop"
-version = "7.0.0"
+version = "7.2.0"
 dependencies = [
  "plist",
  "serde",

package/src-tauri/Cargo.toml

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

package/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Lattice AI",
-  "version": "7.0.0",
+  "version": "7.2.0",
   "identifier": "ai.lattice.desktop",
   "build": {
     "beforeDevCommand": "npm run frontend:dev",

package/static/app/asset-manifest.json

@@ -1,20 +1,20 @@
 {
-  "version": "7.0.0",
+  "version": "7.2.0",
   "generated_at": "vite",
   "entrypoints": {
     "app": "/static/app/index.html"
   },
   "assets": {
     "../node_modules/@tauri-apps/api/core.js": "/static/app/assets/core-CwxXejkd.js",
-    "_primitives-DcO2H3yh.js": "/static/app/assets/primitives-DcO2H3yh.js",
-    "_textarea-DR2Tyy_6.js": "/static/app/assets/textarea-DR2Tyy_6.js",
-    "index.html": "/static/app/assets/index-C-7aHabu.js",
-    "assets/index-DKFpn5Kn.css": "/static/app/assets/index-DKFpn5Kn.css",
-    "src/pages/Act.tsx": "/static/app/assets/Act-DhLaHnrT.js",
-    "src/pages/Brain.tsx": "/static/app/assets/Brain-DS7NULyY.js",
-    "src/pages/Capture.tsx": "/static/app/assets/Capture-CAKouj52.js",
-    "src/pages/Library.tsx": "/static/app/assets/Library-B_hW4AwR.js",
-    "src/pages/System.tsx": "/static/app/assets/System-9OAoXWPz.js"
+    "_primitives-CdwcE--L.js": "/static/app/assets/primitives-CdwcE--L.js",
+    "_textarea-CqOdBPL1.js": "/static/app/assets/textarea-CqOdBPL1.js",
+    "index.html": "/static/app/assets/index-COuGp7_5.js",
+    "assets/index-Bi_bpigM.css": "/static/app/assets/index-Bi_bpigM.css",
+    "src/pages/Act.tsx": "/static/app/assets/Act-Di4tRFWY.js",
+    "src/pages/Brain.tsx": "/static/app/assets/Brain-BZB3Gy9w.js",
+    "src/pages/Capture.tsx": "/static/app/assets/Capture-tNyYWxnh.js",
+    "src/pages/Library.tsx": "/static/app/assets/Library-DAtDDLdg.js",
+    "src/pages/System.tsx": "/static/app/assets/System-DEu0xNUc.js"
   },
   "vite": {
     "../node_modules/@tauri-apps/api/core.js": {
@@ -23,22 +23,22 @@
       "src": "../node_modules/@tauri-apps/api/core.js",
       "isDynamicEntry": true
     },
-    "_primitives-DcO2H3yh.js": {
-      "file": "assets/primitives-DcO2H3yh.js",
+    "_primitives-CdwcE--L.js": {
+      "file": "assets/primitives-CdwcE--L.js",
       "name": "primitives",
       "imports": [
         "index.html"
       ]
     },
-    "_textarea-DR2Tyy_6.js": {
-      "file": "assets/textarea-DR2Tyy_6.js",
+    "_textarea-CqOdBPL1.js": {
+      "file": "assets/textarea-CqOdBPL1.js",
       "name": "textarea",
       "imports": [
         "index.html"
       ]
     },
     "index.html": {
-      "file": "assets/index-C-7aHabu.js",
+      "file": "assets/index-COuGp7_5.js",
       "name": "index",
       "src": "index.html",
       "isEntry": true,
@@ -51,59 +51,59 @@
         "src/pages/System.tsx"
       ],
       "css": [
-        "assets/index-DKFpn5Kn.css"
+        "assets/index-Bi_bpigM.css"
       ]
     },
     "src/pages/Act.tsx": {
-      "file": "assets/Act-DhLaHnrT.js",
+      "file": "assets/Act-Di4tRFWY.js",
       "name": "Act",
       "src": "src/pages/Act.tsx",
       "isDynamicEntry": true,
       "imports": [
         "index.html",
-        "_primitives-DcO2H3yh.js",
-        "_textarea-DR2Tyy_6.js"
+        "_primitives-CdwcE--L.js",
+        "_textarea-CqOdBPL1.js"
       ]
     },
     "src/pages/Brain.tsx": {
-      "file": "assets/Brain-DS7NULyY.js",
+      "file": "assets/Brain-BZB3Gy9w.js",
       "name": "Brain",
       "src": "src/pages/Brain.tsx",
       "isDynamicEntry": true,
       "imports": [
         "index.html",
-        "_primitives-DcO2H3yh.js",
-        "_textarea-DR2Tyy_6.js"
+        "_primitives-CdwcE--L.js",
+        "_textarea-CqOdBPL1.js"
       ]
     },
     "src/pages/Capture.tsx": {
-      "file": "assets/Capture-CAKouj52.js",
+      "file": "assets/Capture-tNyYWxnh.js",
       "name": "Capture",
       "src": "src/pages/Capture.tsx",
       "isDynamicEntry": true,
       "imports": [
         "index.html",
-        "_primitives-DcO2H3yh.js"
+        "_primitives-CdwcE--L.js"
       ]
     },
     "src/pages/Library.tsx": {
-      "file": "assets/Library-B_hW4AwR.js",
+      "file": "assets/Library-DAtDDLdg.js",
       "name": "Library",
       "src": "src/pages/Library.tsx",
       "isDynamicEntry": true,
       "imports": [
         "index.html",
-        "_primitives-DcO2H3yh.js"
+        "_primitives-CdwcE--L.js"
       ]
     },
     "src/pages/System.tsx": {
-      "file": "assets/System-9OAoXWPz.js",
+      "file": "assets/System-DEu0xNUc.js",
       "name": "System",
       "src": "src/pages/System.tsx",
       "isDynamicEntry": true,
       "imports": [
         "index.html",
-        "_primitives-DcO2H3yh.js"
+        "_primitives-CdwcE--L.js"
       ]
     }
   }