ltcai 3.2.0 → 3.4.0

package/README.md

@@ -16,14 +16,14 @@
 [![npm version](https://img.shields.io/npm/v/ltcai?label=npm)](https://www.npmjs.com/package/ltcai)
 [![VS Code Marketplace](https://vsmarketplacebadges.dev/version-short/parktaesoo.ltcai.svg)](https://marketplace.visualstudio.com/items?itemName=parktaesoo.ltcai)
 [![Open VSX](https://img.shields.io/open-vsx/v/parktaesoo/ltcai?label=Open%20VSX)](https://open-vsx.org/extension/parktaesoo/ltcai)
-[![GitHub release](https://img.shields.io/github/v/release/TaeSooPark-PTS/LatticeAI?label=GitHub%20release)](https://github.com/TaeSooPark-PTS/LatticeAI/releases/tag/v3.2.0)
+[![GitHub release](https://img.shields.io/github/v/release/TaeSooPark-PTS/LatticeAI?label=GitHub%20release)](https://github.com/TaeSooPark-PTS/LatticeAI/releases)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 [![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue)](https://www.python.org/)
 [![VS Code extension](https://img.shields.io/badge/VS%20Code-extension-blue?logo=visualstudiocode)](https://marketplace.visualstudio.com/items?itemName=parktaesoo.ltcai)
 
 </div>
 
-![Lattice AI demo](docs/images/lattice-ai-demo.gif)
+![Lattice AI — local-first AI workspace](docs/assets/v3.4.0/home.png)
 
 ## Install
 
@@ -49,7 +49,7 @@ Install the coding extension:
 
 - [VS Code Marketplace: parktaesoo.ltcai](https://marketplace.visualstudio.com/items?itemName=parktaesoo.ltcai)
 - [Open VSX: parktaesoo.ltcai](https://open-vsx.org/extension/parktaesoo/ltcai)
-- [GitHub Release v3.2.0](https://github.com/TaeSooPark-PTS/LatticeAI/releases/tag/v3.2.0)
+- [GitHub Releases](https://github.com/TaeSooPark-PTS/LatticeAI/releases)
 
 ## Quick Start
 
@@ -86,9 +86,9 @@ Lattice AI v3 is a local-first AI workspace platform for people and teams who
 want their files, models, graph context, retrieval, and agent workflows in one
 place.
 
-- **Primary app shell**: `/app` is the default product experience with Native
-  Chat, Knowledge Graph, Hybrid Search, Files, Pipeline, Agents, Models, My
-  Computer, Settings, and Admin areas. Classic pages remain compatibility
+- **Primary app shell**: `/app` is the default product experience with Chat,
+  Files, Hybrid Search, Knowledge Graph, Memory, Models, Settings, Advanced
+  agent/workflow tooling, and Admin areas. Classic pages remain compatibility
   routes only; normal workflows stay in `/app`.
 - **Local-first AI Workspace**: work starts on your machine, with local data and
   workspace state by default.
@@ -122,79 +122,96 @@ and disconnected automations. Lattice AI keeps those parts together:
 - multi-agent workflows leave behind replayable plans, reviews, retries, and
   outcomes.
 
-## v3.2.0 Highlights
-
-Lattice AI v3.2.0 is the feature-complete release for all non-enterprise use
-cases. Every platform capability is operable from `/app` with no Classic
-dependency — built on real backends with honest live/unavailable states (never
-fabricated data).
-
-- **Multi-agent collaboration** — Planner → Researcher → Executor → Reviewer
-  with handoffs, shared context packets, and replayable timelines.
-- **Agent Registry** — every agent (built-in role + custom) carries registry
-  metadata: type, version, capabilities, and configuration. No hardcoded lists.
-- **Marketplace & Templates** — an offline catalog with five named agent
-  templates (Research Assistant, Coding Assistant, Knowledge Curator,
-  Documentation Writer, Workflow Builder) plus clone / export / import / install.
-- **Workflow Agents** — trigger → agent chain → tools → memory → result, with a
-  run ledger and replay.
-- **Autonomous Planning** — goal → plan → execute → review → replan, with
-  inspect/replay and bounded-retry safeguards.
-- **Long-Term Memory + Memory Manager** — workspace, project, agent,
-  conversation, graph, and vector tiers unified behind one service, with
-  recall, inspect, prune, compact, rebuild, and clear.
-- **Skills, Hooks, Tool Registry, and MCP Manager** — install/enable/disable
-  skills; lifecycle hooks across runs/tools/agents/pipelines/workflows; a
-  governed tool registry; and connected MCP servers, tools, and health.
-
-The earlier v3.1 work (Classic retired from normal workflows, retrieval wired
-through a shared service layer, hash-manifested assets) remains the foundation.
-
-Release audit: [docs/V3_2_AUDIT.md](docs/V3_2_AUDIT.md) records the v3.2.0
-claim audit, fixes, tests, real-app browser validation, and artifact checks.
-
-- Native v3 Chat lives inside `/app#/chat` and streams through the real
-  `POST /chat` backend while showing friendly setup guidance when no model is
-  loaded.
-- Knowledge Graph, Vector Index, and Hybrid Search are first-class retrieval
-  surfaces. Hybrid results show keyword, local vector, and graph scores.
-- Personal and Organization workspaces, plus Basic / Advanced / Admin modes,
-  are built into the shell.
-- Models can load/unload from the native Models view; Agents read the
-  AgentRuntime boundary with run health, history, events, replay, and stop
-  affordances.
-- Production embedding profiles cover local `bge-m3`, `nomic-embed-text`,
-  `e5-large`, `gte-large`, Ollama `nomic-embed-text`, `mxbai-embed-large`,
-  BGE-M3-compatible providers, MLX, and OpenAI-compatible
-  `text-embedding-3-small` / `text-embedding-3-large`. Hash embeddings remain
-  fallback only.
-- `/app` loads `static/v3/asset-manifest.json` and build-generated hashed
-  assets such as `app.<hash>.js` and `lattice.base.<hash>.css`; manual `?v=`
-  cache-busting is no longer used by runtime HTML.
+## v3.4.0 Highlights
+
+Lattice AI v3.4.0 is the **platform completion** release: it closes the remaining
+non-enterprise functionality gaps the v3.3.0 honesty audit flagged, so the
+local-first workspace is complete and demonstrable end-to-end. Each item below is
+runtime-verified on a live server, not only wired in source.
+
+- **Hooks now execute.** A real dispatch engine (`run_hook` / `run_hooks` /
+  `fire_hook` + `HookContext` / `HookResult`) runs hooks at genuine lifecycle
+  points — agents (pre/post-run), workflows (start/end), tools (pre/post-tool),
+  and the upload pipeline. `pre_*` hooks can gate (block) an action; every
+  dispatch is recorded to a persisted run log surfaced in the Hooks view.
+- **Uploads appear in Files.** Uploaded documents are listed with live ingest →
+  index state (`/knowledge-graph/documents`), completing upload → Files →
+  Knowledge Graph → Hybrid Search → Chat.
+- **Vision (VLM) image input.** The Chat composer accepts images by attach,
+  drag-and-drop, or paste, with a preview and a **Vision Enabled / Disabled**
+  badge driven by the active model's capability.
+- **Run agents from the Agents view.** A Run console (goal + roles → Run / Stop /
+  Status / Queue / Logs) executes the multi-agent pipeline locally; it runs
+  without a model and fires its pre/post-run hooks.
+- **On-device Local Agent + Connect Folder + Folder Watch.** My Computer reports
+  the real local-runtime agent status and handshake; folders can be connected and
+  watched (debounced reindex on change) through the existing on-device endpoints.
+- **Enterprise stays honestly disabled.** SSO, SCIM, DLP, Private VPC, SIEM, and
+  enterprise RBAC remain off with honest "not available in this build" states.
+
+See [RELEASE_NOTES_v3.4.0.md](RELEASE_NOTES_v3.4.0.md),
+[PLATFORM_COMPLETION_REPORT_v3.4.0.md](PLATFORM_COMPLETION_REPORT_v3.4.0.md), and
+the evidence-traced [FEATURE_STATUS.md](FEATURE_STATUS.md).
+
+## v3.3.1 Highlights
+
+Lattice AI v3.3.1 rebuilds the visible `/app` product experience while
+preserving the existing local-first runtime. The app now presents Chat, Files,
+Search, Knowledge, Memory, Models, Settings, Advanced tooling, and Admin
+workflows with clearer navigation and honest live/unavailable states.
+
+- **Visual product rebuild** — compact rail navigation, quieter topbar,
+  command-palette search, retrieval readiness footer, and denser controls.
+- **Truthful Home dashboard** — backend, model, retrieval, memory, source, and
+  trace readiness are derived from real endpoints instead of fabricated counts.
+- **Basic / Advanced / Admin navigation** — Basic focuses on core workspace
+  workflows; Advanced exposes agents, workflows, skills, hooks, and MCP; Admin
+  keeps organization controls separate.
+- **Files and Settings clarity** — manual upload is available immediately,
+  folder watching is explicitly tied to the desktop local agent, and Settings
+  shows backend, agent, model, telemetry, and embedding readiness.
+- **Design system refresh** — cooler neutral light/dark tokens, tighter 8px
+  radius discipline, compact cards/tables/stats/buttons, and regenerated
+  hashed v3 assets.
+
+The v3.2.0 platform remains the feature-complete foundation: multi-agent
+collaboration, Agent Registry, Marketplace templates, Workflow Agents,
+Autonomous Planning, Long-Term Memory, Skills, Hooks, Tool Registry, MCP
+Manager, production embedding profiles, and hash-manifested `/app` assets.
+Release audit: [docs/V3_2_AUDIT.md](docs/V3_2_AUDIT.md).
 
 ## Screenshots
 
-### Workspace
+All screenshots are the v3.4.0 `/app` shell. Live model output (VLM inference,
+agent-generated text) requires a loaded local model and is not depicted.
 
-![Workspace light theme](docs/images/workspace-light.png)
+### Home
 
-![Workspace dark theme](docs/images/workspace-dark.png)
+![Home — local-first workspace at a glance](docs/assets/v3.4.0/home.png)
 
-### Knowledge Graph
+### Chat with Vision (VLM) image input
+
+![Chat — image attach + Vision Enabled badge](docs/assets/v3.4.0/chat.png)
+
+### Files — uploaded documents + Connect Folder
 
-![Knowledge Graph](docs/images/knowledge-graph.png)
+![Files — uploaded documents with index state](docs/assets/v3.4.0/files.png)
 
-### AI Pipeline
+### Run agents from the Agents view
 
-![AI Pipeline designer](docs/images/pipeline.png)
+![Agent run — goal, roles, and live timeline logs](docs/assets/v3.4.0/agent-run.png)
 
-### Admin Dashboard
+### Hooks dispatch + run log
 
-![Admin dashboard](docs/images/admin-dashboard.png)
+![Hooks — per-hook Run and recent executions](docs/assets/v3.4.0/hooks-dispatch.png)
 
-### Mobile Responsive
+### Local Agent (on-device runtime)
+
+![My Computer — Local Agent status and handshake](docs/assets/v3.4.0/local-agent.png)
+
+### Knowledge Graph
 
-![Mobile responsive layout](docs/images/mobile-responsive.png)
+![Knowledge Graph](docs/assets/v3.4.0/knowledge-graph.png)
 
 ## Knowledge Graph Flow
 
@@ -290,7 +307,10 @@ Core areas:
 
 | Version | Theme |
 | --- | --- |
-| **3.2.0** | Feature-complete platform — multi-agent collaboration, agent registry, marketplace + templates, workflow agents, autonomous planning, long-term memory + manager, skills/hooks/tool registries, MCP manager, all operable from `/app` |
+| **3.4.0** | Platform completion — hooks execution engine, uploads visible in Files, VLM image input, agent run trigger, on-device Local Agent / Connect Folder / Folder Watch; Enterprise stays honestly disabled; refreshed v3.4.0 public assets |
+| 3.3.1 | Visual product rebuild — rebuilt `/app` shell, Basic/Advanced/Admin navigation, cooler token palette, compact component system, Home readiness dashboard, Files local-agent truthfulness, Settings runtime status, and v3.3.1 design notes |
+| **3.3.0** | Product quality & honesty release — evidence-based feature audit (`FEATURE_STATUS.md`), single-source version truth, working manual document upload in Files, fixed document-generation streaming, truthful Home retrieval status, documented design system (`STYLE_SYSTEM.md`) |
+| 3.2.0 | Feature-complete platform — multi-agent collaboration, agent registry, marketplace + templates, workflow agents, autonomous planning, long-term memory + manager, skills/hooks/tool registries, MCP manager, all operable from `/app` |
 | 3.1.0 | Mainline platform completion — native `/app` workflows, Classic retired from normal paths, production embedding profiles, AgentRuntime/registries, hashed v3 assets |
 | 3.0.1 | Release-blocker remediation — provider-backed embeddings (Hash/MLX/Ollama/OpenAI/Custom), unified AgentRuntime boundary, every v3 surface connected or clearly unavailable |
 | 3.0.0 | v3 local-first AI workspace platform — `/app`, Native Chat, Knowledge Graph, Vector Index, Hybrid Search, workspace modes |

package/docs/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## [3.3.1] - 2026-06-08
+
+> v3.3.1 — Visual Product Rebuild. The `/app` frontend keeps the same runtime
+> behavior but receives a new product shell, navigation hierarchy, visual token
+> system, and readiness-focused primary views.
+
+### Changed
+
+- Rebuilt the global `/app` shell with a denser command rail, grouped
+  Basic/Advanced/Admin navigation, local retrieval readiness footer, quiet
+  topbar, and mode-aware command palette.
+- Reorganized production navigation to Basic (Home, Chat, Files, Search,
+  Knowledge, Memory, Models, Settings), Advanced (Agents, Workflows, Skills,
+  Hooks, MCP), and Admin (Users, Permissions, Audit Logs, Security, Policies,
+  Private VPC). Compatibility-only views remain deep-linkable.
+- Replaced the v3.3.0 palette with cooler neutral light/dark tokens, tightened
+  cards/panels to an 8px radius system, and compacted buttons, inputs, stats,
+  tables, segmented controls, and empty states.
+- Rebuilt Home as a local readiness dashboard for backend, model, retrieval,
+  memory, connected sources, stats, and recent activity when available.
+- Clarified Files manual upload versus desktop local-agent folder connection.
+- Added Settings runtime readiness for backend, desktop local agent, model
+  runtime, host telemetry, and embedding provider configuration.
+- Fixed Chat send/stop button wiring so streaming uses a stable handler.
+
+### Added
+
+- `VISUAL_REBUILD_NOTES_v3.3.1.md` with implementation and QA notes.
+- `FIGMA_SPEC.md` as the in-repo Figma-equivalent design spec for v3.3.1.
+
+### Validation
+
+- `npm run build:assets` regenerated content-hashed v3 assets at `3.3.1`.
+- Package publication, deployment, tags, and GitHub Release creation were not
+  performed.
+
 ## [3.2.0] - 2026-06-08
 
 > v3.2 — Feature-Complete Platform. Multi-agent collaboration, an agent

package/docs/architecture.md

@@ -1,6 +1,7 @@
 # Lattice AI Architecture
 
-> v3.2.0 — feature-complete for non-enterprise use cases. The agent ecosystem
+> v3.3.1 — feature-complete for non-enterprise use cases with a rebuilt `/app`
+> visual shell. The agent ecosystem
 > (registry, marketplace + templates, workflow agents, autonomous planning),
 > the long-term memory platform + manager, and the skills/hooks/tool/MCP
 > registries are all operable from `/app`. Enterprise controls remain future

package/knowledge_graph.py

@@ -3046,6 +3046,51 @@ class KnowledgeGraphStore:
         "Decision",   # 결정 사항
     )
 
+    def list_documents(self, limit: int = 200) -> Dict[str, Any]:
+        """List ingested ``Document`` nodes with their ingest + index state.
+
+        Powers the Files view: every accepted upload and every indexed local
+        document becomes a ``Document`` node. A document is reported ``indexed``
+        once its retrieval chunks exist (searchable in Chat / Hybrid Search).
+        """
+        limit = max(1, min(int(limit or 200), 1000))
+        nt, _ = self._read_tables()
+        documents: List[Dict[str, Any]] = []
+        with self._connect() as conn:
+            rows = conn.execute(
+                f"SELECT id, title, summary, metadata_json, created_at, updated_at "
+                f"FROM {nt} WHERE type='Document' ORDER BY updated_at DESC, id ASC LIMIT ?",
+                (limit,),
+            ).fetchall()
+            for row in rows:
+                meta = _safe_loads(row["metadata_json"]) or {}
+                extracted = meta.get("extracted") or {}
+                node_id = row["id"]
+                chunk_count = conn.execute(
+                    f"SELECT COUNT(*) AS c FROM {nt} WHERE type='Chunk' AND metadata_json LIKE ?",
+                    (f"%{node_id}%",),
+                ).fetchone()["c"]
+                documents.append({
+                    "id": node_id,
+                    "filename": meta.get("filename") or row["title"],
+                    "ext": meta.get("ext"),
+                    "mime_type": meta.get("mime_type"),
+                    "bytes": meta.get("bytes"),
+                    "sha256": meta.get("sha256"),
+                    "uploader": meta.get("uploader"),
+                    "chars": extracted.get("chars"),
+                    "chunks": int(chunk_count or 0),
+                    "indexed": int(chunk_count or 0) > 0,
+                    "ingest_state": "indexed" if int(chunk_count or 0) > 0 else "ingested",
+                    "created_at": row["created_at"],
+                    "updated_at": row["updated_at"],
+                })
+        return {
+            "documents": documents,
+            "total": len(documents),
+            "generated_at": datetime.now().isoformat(timespec="seconds"),
+        }
+
     def graph(self, limit: int = 300) -> Dict[str, Any]:
         limit = max(1, min(int(limit or 300), 2000))
         visible = ",".join(f"'{t}'" for t in self._GRAPH_VISIBLE_TYPES)

package/knowledge_graph_api.py

@@ -75,6 +75,16 @@ def create_knowledge_graph_router(
         require_user(request)
         return graph().graph(limit)
 
+    @router.get("/knowledge-graph/documents")
+    async def knowledge_graph_documents(request: Request, limit: int = 200):
+        """Ingested documents (uploads + indexed local docs) with index state.
+
+        Backs the Files view so uploaded content is visible end-to-end:
+        upload → Files → Knowledge Graph → Hybrid Search → Chat.
+        """
+        require_user(request)
+        return graph().list_documents(limit)
+
     @router.get("/knowledge-graph/search")
     async def knowledge_graph_search(q: str, request: Request, limit: int = 30):
         require_user(request)

package/latticeai/__init__.py

@@ -1,3 +1,3 @@
 """Lattice AI - modular server package."""
 
-__version__ = "3.2.0"
+__version__ = "3.4.0"

package/latticeai/api/agents.py

@@ -173,5 +173,8 @@ def create_agents_router(
             )
         except ValueError as exc:
             raise HTTPException(status_code=400, detail=str(exc)) from exc
+        except PermissionError as exc:
+            # A pre_run hook gated this run (e.g. a policy/permission hook).
+            raise HTTPException(status_code=403, detail=str(exc)) from exc
 
     return router

package/latticeai/api/hooks.py

@@ -35,6 +35,13 @@ class HookRegisterRequest(BaseModel):
     enabled: bool = True
 
 
+class HookRunRequest(BaseModel):
+    kind: Optional[str] = None
+    hook_id: Optional[str] = None
+    event: str = ""
+    payload: dict = {}
+
+
 def create_hooks_router(
     *,
     registry: HooksRegistry,
@@ -48,6 +55,38 @@ def create_hooks_router(
         require_user(request)
         return registry.list(kind=kind)
 
+    # NOTE: declared before the ``/{hook_id:path}`` catch-all so "runs" is not
+    # captured as a hook id.
+    @router.get("/api/hooks/runs")
+    async def hook_runs(request: Request, limit: int = 50, kind: Optional[str] = None):
+        require_user(request)
+        return registry.recent_runs(limit=limit, kind=kind)
+
+    @router.post("/api/hooks/run")
+    async def run_hooks(req: HookRunRequest, request: Request):
+        """Execute hooks now — by ``kind`` (all enabled hooks of that kind) or a
+        single ``hook_id``. Returns the dispatch record so callers can see what
+        ran, in what order, and whether the action was blocked."""
+        user = require_user(request)
+        try:
+            if req.hook_id:
+                result = registry.run_hook(req.hook_id, event=req.event or None, payload=req.payload, user_email=user)
+            elif req.kind:
+                result = registry.run_hooks(req.kind, event=req.event or None, payload=req.payload, user_email=user)
+            else:
+                raise HTTPException(status_code=400, detail="Provide a 'kind' or a 'hook_id' to run.")
+        except KeyError as exc:
+            raise HTTPException(status_code=404, detail=f"Hook not found: {exc}") from exc
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        append_audit_event("hook_run", user_email=user, hook_id=req.hook_id, kind=req.kind, event=req.event)
+        return result
+
+    # Alias for the same dispatch action (fire == run).
+    @router.post("/api/hooks/fire")
+    async def fire_hooks(req: HookRunRequest, request: Request):
+        return await run_hooks(req, request)
+
     @router.get("/api/hooks/{hook_id:path}")
     async def inspect_hook(hook_id: str, request: Request):
         require_user(request)

package/latticeai/api/local_files.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import platform
 from pathlib import Path
 from typing import Optional
 
@@ -39,6 +40,46 @@ def create_local_files_router(
 ) -> APIRouter:
     router = APIRouter()
 
+    @router.get("/api/local-agent/status")
+    async def local_agent_status(request: Request):
+        """Real on-device runtime status — the 'Local Agent' is the Lattice
+        server running on this machine (filesystem access + folder watching +
+        local inference), not a separate desktop process. Everything reported
+        here is observed, never faked."""
+        require_user(request)
+        watch = local_kg_watcher.status() if local_kg_watcher else {"available": False, "active": {}}
+        sources = []
+        try:
+            if knowledge_graph is not None:
+                sources = (knowledge_graph.local_sources() or {}).get("sources", [])
+        except Exception:
+            sources = []
+        watched = len(watch.get("active", {}) or {})
+        return {
+            "agent": {
+                "id": "lattice-local-runtime",
+                "name": "Lattice Local Agent",
+                "kind": "on-device-runtime",
+                "online": True,
+                "platform": platform.platform(),
+                "machine": platform.machine(),
+                "python": platform.python_version(),
+            },
+            "handshake": {
+                "ok": True,
+                "transport": "in-process",
+                "detail": "The local Lattice runtime serves this workspace on-device; no external agent is required.",
+            },
+            "health": {
+                "status": "ok",
+                "filesystem_access": True,
+                "watcher_available": bool(watch.get("available")),
+            },
+            "folders": {"connected": len(sources), "watching": watched},
+            "watch": watch,
+            "sources": sources,
+        }
+
     @router.post("/local/list")
     async def local_list_endpoint(req: LocalAccessRequest, request: Request):
         current_user = permission_gateway.require_local_user(request)

package/latticeai/api/models.py

@@ -23,6 +23,39 @@ from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 
 
+def _vision_capability(current_model_id: Optional[str], engines: Any) -> Dict[str, Any]:
+    """Whether the active model can accept image input (VLM).
+
+    Honest, derived signal for the Chat 'Vision Enabled / Disabled' badge: a
+    model is vision-capable only when its compat profile reports
+    ``supports_vision``. The MLX-VLM engine availability is reported too so the
+    UI can explain a disabled badge ("load a vision model" vs "install MLX-VLM").
+    """
+    from latticeai.core.model_compat import get_model_profile
+
+    current_vision = False
+    if current_model_id:
+        try:
+            current_vision = bool(get_model_profile(current_model_id).get("supports_vision"))
+        except Exception:
+            current_vision = False
+    engine_available = False
+    try:
+        for eng in (engines or []):
+            if isinstance(eng, dict) and eng.get("id") in {"local_mlx", "mlx"} and eng.get("installed"):
+                engine_available = True
+                break
+    except Exception:
+        engine_available = False
+    return {
+        "current_model": current_model_id,
+        "current_supports_vision": current_vision,
+        "engine_available": engine_available,
+        # The badge is "enabled" only when a vision-capable model is active.
+        "enabled": bool(current_vision),
+    }
+
+
 class LoadModelRequest(BaseModel):
     model_id: str
     engine: Optional[str] = None
@@ -257,13 +290,15 @@ def create_models_router(
         recommended = _recommended_with_engine_options(
             list(filter_lower_family_versions(ENGINE_MODEL_CATALOG.get("local_mlx", [])))
         )
+        engines = await asyncio.to_thread(engine_status)
         return {
             "recommended": recommended,
             "cloud": _router.detected_cloud_models(),
-            "engines": await asyncio.to_thread(engine_status),
+            "engines": engines,
             "loaded": _router.loaded_model_ids,
             "current": _router.current_model_id,
             "compat_profiles": _list_compat_profiles(),
+            "vision": _vision_capability(_router.current_model_id, engines),
         }
 
     @router.get("/models/compat-profiles")

package/latticeai/api/tools.py

@@ -197,8 +197,10 @@ def create_tools_router(
     recommend_mcps,
     install_mcp,
     mcp_public_item,
+    hooks=None,
 ) -> APIRouter:
     api_router = APIRouter()
+    HOOKS = hooks
     CONFIG = config
     DATA_DIR = data_dir
     STATIC_DIR = static_dir
@@ -219,10 +221,22 @@ def create_tools_router(
     # ── Direct Tool API ───────────────────────────────────────────────────────────
     
     def _tool_response(fn, *args):
+        tool_name = getattr(fn, "__name__", "tool")
+        # ── pre_tool hooks ── a blocking pre_tool hook (e.g. a permission gate)
+        # stops the tool call before it runs.
+        if HOOKS is not None:
+            pre = HOOKS.fire_hook("pre_tool", f"tool.{tool_name}", payload={"tool": tool_name, "argc": len(args)})
+            if pre.get("blocked"):
+                raise HTTPException(status_code=403, detail=pre.get("block_reason") or f"Tool '{tool_name}' blocked by a pre_tool hook.")
         try:
-            return {"status": "ok", "workspace": str(AGENT_ROOT), "result": fn(*args)}
+            result = fn(*args)
         except ToolError as exc:
+            if HOOKS is not None:
+                HOOKS.fire_hook("post_tool", f"tool.{tool_name}", payload={"tool": tool_name, "status": "error", "detail": str(exc)})
             raise HTTPException(status_code=400, detail=str(exc))
+        if HOOKS is not None:
+            HOOKS.fire_hook("post_tool", f"tool.{tool_name}", payload={"tool": tool_name, "status": "ok"})
+        return {"status": "ok", "workspace": str(AGENT_ROOT), "result": result}
     
     
     @api_router.post("/tools/list_dir")
@@ -431,6 +445,7 @@ def create_tools_router(
             classify_sensitive_message=classify_sensitive_message,
             append_audit_event=append_audit_event,
             enforce_rate_limit=enforce_rate_limit,
+            hooks=HOOKS,
         )
     
     

package/latticeai/api/workflow_designer.py

@@ -57,6 +57,7 @@ def create_workflow_designer_router(
     append_audit_event: Callable[..., None],
     ui_file_response: Optional[Callable[[Path], Any]] = None,
     static_dir: Optional[Path] = None,
+    hooks: Any = None,
 ) -> APIRouter:
     from latticeai.core.workflow_engine import (
         WorkflowEngine,
@@ -147,7 +148,7 @@ def create_workflow_designer_router(
         except FileNotFoundError as exc:
             raise HTTPException(status_code=404, detail=f"Workflow not found: {exc}") from exc
         runners = build_runners(current_user or None, scope)
-        engine = WorkflowEngine(runners)
+        engine = WorkflowEngine(runners, hooks=hooks)
         result = engine.run(workflow, inputs=req.inputs)
         run = store.record_workflow_run(
             workflow_id=workflow_id,