ltcai 8.1.0 → 8.2.0

package/docs/DEVELOPMENT.md

@@ -1,8 +1,11 @@
 # Lattice AI Development
 
+Current release: **8.2.0 - Brain Brief**.
+
 This document is for contributors working on the local-first Digital Brain
 codebase. Product positioning and quick start stay in `README.md`; release
-history stays in `docs/CHANGELOG.md` and `RELEASE.md`.
+history is intentionally limited to 7.0.0-8.2.0 in `docs/CHANGELOG.md` and
+`RELEASE.md`.
 
 ## Product Contract
 
@@ -77,9 +80,21 @@ Runtime assembly seams live under `latticeai.runtime`:
 - `config_runtime.py` derives app config values from `Config`;
 - `security_runtime.py` applies trusted proxy/security-derived settings;
 - `brain_runtime.py` constructs Brain Core and conversation primitives.
+- model/runtime, ToolRegistry/MCP, router, static asset, and lifespan seams
+  should continue moving out of monolithic app-factory helpers.
+
+Future extraction should continue with AgentRuntime, ToolRegistry, config,
+server decomposition, and Knowledge Graph stabilization in that order when
+architectural debt is present.
+
+## Runtime Hook Coverage
 
-Future extraction should continue with router assembly, model runtime assembly,
-platform/hooks assembly, static asset serving, and lifespan/startup/shutdown.
+Knowledge Graph ingestion paths must continue to pass through the shared
+pre-tool/post-tool lifecycle:
+
+- browser `read-url` ingestion dispatches `tool.kg_ingest.*` events;
+- browser `ingest-current-tab` ingestion dispatches the same lifecycle;
+- `IngestionPipeline` remains the common ingestion boundary behind those routes.
 
 ## Documentation Sync
 
@@ -96,3 +111,11 @@ For user-facing, API, runtime, release, or packaging changes, check:
 
 Release/publish examples must use exact target-version filenames. Do not
 document wildcard artifact upload commands.
+
+For 8.2.0 release work, exact artifacts are:
+
+- `dist/ltcai-8.2.0-py3-none-any.whl`
+- `dist/ltcai-8.2.0.tar.gz`
+- `ltcai-8.2.0.tgz`
+- `dist/ltcai-8.2.0.vsix`
+- `src-tauri/target/release/bundle/dmg/Lattice AI_8.2.0_aarch64.dmg`

package/docs/LEGACY_COMPATIBILITY.md

@@ -1,10 +1,12 @@
 # Legacy Compatibility Map
 
+Current release: **8.2.0 - Brain Brief**.
+
 Lattice AI is moving toward a smaller, modular architecture centered on
 `lattice_brain`, `latticeai.services`, `latticeai.api`, and `latticeai.runtime`.
 Some root-level modules remain packaged for compatibility with older imports,
 CLI entrypoints, or extension workflows. Their presence does not define the
-current architecture.
+current 8.2.0 architecture.
 
 ## Current Policy
 

package/docs/TRUST_MODEL.md

@@ -1,7 +1,9 @@
 # Lattice AI Trust Model
 
-Lattice AI's trust model is local-first, opt-in for external communication, and
-honest when something is unavailable.
+Current release: **8.2.0 - Brain Brief**.
+
+Lattice AI is local-first, explicit about external communication, and honest
+when a capability is unavailable.
 
 ## Local By Default
 
@@ -9,58 +11,56 @@ By default, Lattice AI binds the API to `127.0.0.1`, stores Brain data under the
 local data directory, and does not send prompts, documents, graph content, or
 archives to Lattice-owned servers.
 
-Local data includes:
+Local data can include:
 
-- local profile and sessions;
-- conversations and memory records;
-- Knowledge Graph nodes, edges, provenance, and search indexes;
-- uploaded document blobs;
+- profile and session metadata;
+- conversations, memories, decisions, and workflow history;
+- Knowledge Graph nodes, edges, provenance, and indexes;
+- uploaded document blobs and extracted text;
 - audit and admin operation logs;
 - backups and encrypted `.latticebrain` archives.
 
 ## Explicit External Paths
 
-Some features can contact third parties, but they require explicit user/admin
-action or configuration:
+External communication requires configuration plus a user/admin action:
 
-- model downloads from model registries;
-- cloud model API calls after keys are configured and a cloud model is chosen;
+- cloud model calls after keys are configured and a cloud model is selected;
+- model downloads from registries after install consent;
 - Telegram bridge after the integration is enabled;
-- Brain Network peer actions after pairing/initiating network flows;
+- Brain Network peer actions after pairing;
 - Docker/Postgres setup after opt-in scale configuration;
-- update checks only when update checking is enabled;
-- remote marketplace/registry refreshes only through explicit user actions.
+- update checks only when enabled;
+- marketplace or remote registry refreshes only when invoked.
 
 Token presence alone must not start external communication.
 
 ## Consent And Honesty Gates
 
-Lattice AI should fail closed or report unavailable state for:
+Lattice AI should fail closed or show an unavailable state for:
 
 - no model loaded;
-- local model not installed;
-- installed model not loaded;
+- local model not installed or not loaded;
 - missing cloud key;
 - deterministic/model-free preview;
 - dry-run versus real execution;
 - no graph/context evidence available;
 - unavailable external integration;
 - wrong archive passphrase;
-- archive path traversal or tampering.
+- archive tampering, unsupported archive versions, or path traversal.
 
-## Admin Boundary
+## Product Boundary
 
-The normal user product is Brain Chat, memory, topics, relationships, graph
-exploration, model state, and Brain ownership. Admin Console is for users,
+Normal Brain use is conversation, memory, topics, relationships, model state,
+source capture, and Knowledge Graph exploration. Admin Console is for users,
 roles, audit logs, security events, retention, and operations. Admin visibility
 does not mean secrets should appear in clear text.
 
-## Known Limitations
+## Known Limits
 
-- Local files are only as protected as the user's machine, account, backups, and
-  disk encryption.
-- Cloud model prompts follow the selected provider's policy.
+- Local files are only as protected as the user's machine, OS account, backups,
+  and disk encryption.
+- Cloud model prompts follow the selected provider's policy once the user
+  explicitly chooses that provider.
 - A local admin can inspect local files and process memory outside Lattice AI.
 - Marketplace and model registries are third-party services when explicitly
   contacted.
-

package/docs/WHY_LATTICE.md

@@ -1,51 +1,54 @@
 # Why Lattice AI Exists
 
-**Lattice AI is a local-first Digital Brain that keeps your knowledge durable across any AI model.**
+Current release: **8.2.0 - Brain Brief**.
+
+**Lattice AI is a local-first Digital Brain that keeps your knowledge durable
+across any AI model.**
 
 **모델은 바꿔도, 내 지식은 남는 로컬 AI 브레인.**
 
-AI models change quickly. A model you use today may be replaced next month, and
-the conversation history, project context, decisions, and sources you built
-around it can become scattered across tools. Lattice AI exists so the durable
-asset is not the model. The durable asset is your Brain.
+AI models change quickly. A model you use today may be replaced tomorrow, and a
+cloud chat history can become scattered across tools. Lattice AI exists so the
+durable asset is not the model. The durable asset is your Brain.
 
 ## The Problem
 
-Most AI products begin with a model and treat your context as temporary prompt
-material. That works for short questions, but it fails for long-running work:
+Most AI products start with a model and treat your context as temporary prompt
+material. That breaks down for real work:
 
 - project decisions disappear into old chats;
-- documents and notes are disconnected from conversations;
+- documents and notes stay disconnected from conversations;
 - switching models often means losing useful context;
-- graph or database tools expose implementation details before user value;
-- cloud-only products make it hard to inspect, back up, or move your knowledge.
+- graph tools expose implementation detail before user value;
+- cloud-only products make your knowledge hard to inspect, back up, or move.
 
 ## The Lattice Answer
 
-Lattice AI is a local-first private AI memory layer. It keeps conversations,
-documents, decisions, relationships, and project history in a Brain that belongs
-to the user. Models can be local, cloud, current, or future. The Brain remains.
+Lattice AI keeps conversations, documents, memories, decisions, relationships,
+and source provenance in a private local Brain. Models can be local, cloud,
+current, or future. The Brain remains.
+
+The graph matters, but it is not the product identity. The product identity is a
+local-first Digital Brain: a place where the user can talk, add sources, watch
+memory grow, and inspect the Knowledge Graph when they need proof.
 
-The graph is real, but it is not the product identity. Product category is
-local-first Digital Brain; core capability is a private AI memory layer; UX
-metaphor is the Living Brain. Users start with Brain
-Chat, memory, topics, relationships, ownership, backup, and graph exploration.
-Advanced admin logs, roles, hooks, workflows, Telegram, Brain Network, Docker,
-Postgres, and plugin details stay outside the normal user flow.
+In 8.2.0 the first screen is intentionally not a dashboard. The living Brain,
+conversation composer, and evidence-backed Brain Brief appear together so the
+user immediately knows what matters and what to do next.
 
 ## Practical Reasons To Use It
 
-- Ask what the team decided last week and see the source.
-- Drop in documents and build a searchable personal memory.
-- Prepare for a meeting from past notes, project decisions, and files.
-- Preserve context when moving from one model to another.
-- Export or back up the Brain as an encrypted `.latticebrain` archive.
+- Ask what the team decided and see the source.
+- Add documents and build a searchable private memory.
+- Prepare from old notes, project decisions, and files.
+- Preserve context when moving between models.
+- Export or restore the Brain as an encrypted `.latticebrain` archive.
 - Use Korean or English without changing the underlying Brain.
 - Avoid fake answers when no model or evidence is available.
 
 ## What Lattice AI Is Not
 
-- Not a hosted SaaS by default.
+- Not hosted SaaS by default.
 - Not just a model launcher.
 - Not just a graph viewer.
 - Not a generic dashboard.

package/docs/kg-schema.md

@@ -1,4 +1,6 @@
-# Knowledge Graph — v2 스키마
+# Knowledge Graph Schema
+
+Current release: **8.2.0 - Brain Brief**.
 
 명세 출처: `lattice_ai_full_spec.pptx` 슬라이드 20·21·22
 구현: `kg_schema.py`
@@ -80,15 +82,15 @@ Edge {
 
 **엔드포인트 룰은 권고 사항이다 (스키마 문서 기준).** 코드에는 엔드포인트 페어
 검증기가 존재하지 않는다 — `validate_endpoints` 는 구현된 적이 없으며, 쓰기
-경로는 타입 페어를 거부하지 않는다. v4 의 쓰기 정규화는 *타입 어휘* 를
+경로는 타입 페어를 거부하지 않는다. 현재 쓰기 정규화는 *타입 어휘* 를
 강제한다: `_upsert_edge` 가 모든 엣지 타입을 canonical `EdgeType` 값으로
 정규화하므로 자유 문자열 타입은 더 이상 생성되지 않는다.
 
 ---
 
-## v3.6.0 — Knowledge Graph First 엔티티/관계
+## Current Knowledge Graph First 엔티티/관계
 
-v3.6.0 은 "모든 데이터 소스가 Knowledge Graph 로 수렴한다"는 원칙을 1급 스키마로
+8.2.0 은 "모든 데이터 소스가 Knowledge Graph 로 수렴한다"는 원칙을 1급 스키마로
 승격한다. 아래 타입은 **추가형(additive)**이다 — 기존 enum/legacy 매핑을 깨지 않고
 `from_legacy` 가 무손실로 정규화하며, 알 수 없는 타입은 여전히 `CONCEPT`/`MENTIONS` 로
 폴백한다. 스키마는 **확장 가능**하게 유지한다: 새 도메인 엔티티는 enum 멤버 1개 +

package/lattice_brain/__init__.py

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

package/lattice_brain/graph/schema.py

@@ -56,6 +56,12 @@ KG_SCHEMA_V2_VERSION = 2
 EMBED_DIM = int(os.getenv("LATTICEAI_EMBED_DIM", "1024"))
 
 
+def set_embed_dim(dim: int) -> None:
+    """Optional way for upper layers to override without direct module import at top level in lattice_brain."""
+    global EMBED_DIM
+    EMBED_DIM = int(dim)  # lattice_brain isolation: no direct latticeai import; callers can pre-set env if using central Config
+
+
 # ── Node / Edge taxonomy (PPT 슬라이드 20·21) ──────────────────────────────
 class NodeType(str, Enum):
     """워크스페이스의 모든 ‘명사’.

package/lattice_brain/runtime/multi_agent.py

@@ -21,7 +21,7 @@ from typing import Any, Callable, Dict, List, Optional
 from .contracts import multi_agent_contract
 
 
-MULTI_AGENT_VERSION = "8.1.0"
+MULTI_AGENT_VERSION = "8.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__ = "8.1.0"
+__version__ = "8.2.0"

package/latticeai/api/computer_use.py

@@ -42,12 +42,14 @@ Available actions:
 - computer_scroll: {"action":"computer_scroll","args":{"x":500,"y":300,"direction":"down","clicks":3}}
 - computer_move: {"action":"computer_move","args":{"x":500,"y":300}}
 - computer_drag: {"action":"computer_drag","args":{"x1":100,"y1":100,"x2":500,"y2":500}}
+- vision_analyze: {"action":"vision_analyze","args":{"image_b64": "...", "prompt": "What do you see on screen?"}} — use after screenshot to let VLM describe/answer about the image (only when multimodal model loaded)
 - final: {"action":"final","message":"Korean summary of what was accomplished"}
 
 Rules:
 - Respond with exactly ONE JSON object. No markdown, no extra text.
 - Do not take screenshots for simple app launch, URL opening, keyboard shortcuts, or non-visual tasks.
 - Take a screenshot before coordinate-based clicks/drags or when the task explicitly asks you to inspect the screen.
+- After screenshot, prefer vision_analyze (with good prompt) over raw b64 in next step when you need to understand what is on screen (especially with multimodal/VLM loaded).
 - After coordinate-based clicking or typing into an unknown focused field, take a screenshot only if verification is necessary.
 - Use coordinates relative to the screen (0,0 is top-left).
 - If a UI element is not visible, scroll or search for it first.

package/latticeai/api/memory.py

@@ -58,6 +58,19 @@ def create_memory_router(
         scope = gate_read(request)
         return service.brain_quality_summary(user_email=user, workspace_id=scope)
 
+    @router.get("/api/memory/brain-brief")
+    async def brain_brief(request: Request, q: str = "", limit: int = 3):
+        user = require_user(request)
+        scope = gate_read(request)
+        active_model = active_model_getter() if active_model_getter else ""
+        return service.brain_brief(
+            user_email=user,
+            workspace_id=scope,
+            active_model=active_model,
+            recall_query=q,
+            limit=limit,
+        )
+
     @router.get("/api/memory/brain-proof")
     async def brain_proof(request: Request, q: str = "", limit: int = 3):
         user = require_user(request)

package/latticeai/app_factory.py

@@ -44,6 +44,8 @@ from latticeai.runtime.platform_services_runtime import (
 from latticeai.runtime.platform_runtime_wiring import build_platform_automation_runtime
 from latticeai.runtime.persistence_runtime import build_persistence_runtime
 from latticeai.runtime.review_wiring import build_review_run_now_runner
+from latticeai.runtime.sso_runtime import build_sso_runtime
+from latticeai.runtime.audit_runtime import build_audit_runtime
 from latticeai.runtime.router_registration import (
     build_auth_admin_security_router_bundle,
     build_static_routes_bundle,
@@ -93,6 +95,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
 
     from latticeai.models.router import LLMRouter, normalize_branding
     from lattice_brain._kg_common import set_llm_router
+    from lattice_brain.graph.schema import set_embed_dim
     from latticeai.core.security import (
         hash_password,
         verify_password,
@@ -105,7 +108,6 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     )
     from latticeai.core.audit import (
         get_audit_log as _get_audit_log,
-        append_audit_event as _append_audit_event,
         classify_sensitive_message as _classify_sensitive_message,
         build_sensitivity_report as _build_sensitivity_report,
         build_admin_audit_report as _build_admin_audit_report,
@@ -249,29 +251,12 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     SSO_CLIENT_SECRET = _security_runtime["SSO_CLIENT_SECRET"]
     SSO_REDIRECT_URI = _security_runtime["SSO_REDIRECT_URI"]
     SSO_PROVIDER_NAME = _security_runtime["SSO_PROVIDER_NAME"]
-    _sso_discovery_cache: Optional[Dict] = None
-    _sso_discovery_cache_url: str = ""
-    _sso_states: Dict[str, float] = {}  # state → timestamp (CSRF protection)
 
-    async def _get_sso_discovery() -> Optional[Dict]:
-        nonlocal _sso_discovery_cache, _sso_discovery_cache_url
-        settings = get_sso_settings()
-        discovery_url = settings.get("discovery_url", "")
-        if _sso_discovery_cache and _sso_discovery_cache_url == discovery_url:
-            return _sso_discovery_cache
-        if not discovery_url:
-            return None
-        try:
-            import httpx as _httpx
-            async with _httpx.AsyncClient() as c:
-                r = await c.get(discovery_url, timeout=10)
-                r.raise_for_status()
-                _sso_discovery_cache = r.json()
-                _sso_discovery_cache_url = discovery_url
-        except Exception as e:
-            logging.warning("SSO discovery failed: %s", e)
-            return None
-        return _sso_discovery_cache
+    # SSO cache + discovery built after get_sso_settings is defined (see below)
+    _sso_discovery_cache = None
+    _sso_discovery_cache_url = ""
+    _sso_states: Dict[str, float] = {}
+    _get_sso_discovery = None  # filled after def below
 
     # ── Password hashing — used directly from latticeai.core.security ──────────────
     # (hash_password / verify_password are imported above; no local wrapper needed)
@@ -355,6 +340,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         extra={"target": CONFIG.embedding_custom_target},
         probe=_embedding_provider not in {"", "hash", "local", "fallback"},
     )
+    set_embed_dim(int(getattr(EMBEDDER, "dim", None) or _embedding_dim or 384))
     if EMBEDDER.fell_back:
         logging.warning("Embedding provider %s unavailable: %s", EMBEDDER.requested, EMBEDDER.detail)
     STORAGE_ENGINE = storage_from_env(os.environ, data_dir=DATA_DIR) if ENABLE_GRAPH else None
@@ -479,6 +465,17 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     def get_sso_settings() -> Dict[str, object]:
         return load_sso_config()
 
+    # Build SSO runtime (cache + helper) now that get_sso_settings exists in scope.
+    if _get_sso_discovery is None:
+        _sso = build_sso_runtime(
+            get_sso_settings=get_sso_settings,
+            logging=logging,
+        )
+        _sso_discovery_cache = _sso["_sso_discovery_cache"]
+        _sso_discovery_cache_url = _sso["_sso_discovery_cache_url"]
+        _sso_states = _sso["_sso_states"]
+        _get_sso_discovery = _sso["_get_sso_discovery"]
+
     def public_sso_config(config: Optional[Dict[str, object]] = None) -> Dict[str, object]:
         cfg = config or get_sso_settings()
         return {
@@ -558,11 +555,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
 
     _history_lock = threading.Lock()
 
-    def get_audit_log() -> List[Dict]:
-        return _get_audit_log(AUDIT_FILE)
-
-    def append_audit_event(event_type: str, **payload) -> None:
-        _append_audit_event(AUDIT_FILE, event_type, **payload)
+    # audit build moved after redact_secret_text is defined (see below)
 
     def save_to_history(
         role: str,
@@ -634,6 +627,15 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     def redact_secret_text(text: str) -> str:
         return _redact_secret_text(text)
 
+    # Build audit now that redact is available
+    _audit_rt = build_audit_runtime(
+        audit_file=AUDIT_FILE,
+        logging=logging,
+        redact_fn=redact_secret_text,
+    )
+    get_audit_log = _audit_rt["get_audit_log"]
+    append_audit_event = _audit_rt["append_audit_event"]
+
     def get_history():
         try:
             return CONVERSATIONS.history()

package/latticeai/brain/__init__.py

@@ -22,7 +22,7 @@ warnings.warn(
     "latticeai.brain is deprecated; import lattice_brain instead",
     DeprecationWarning,
     stacklevel=2,
-)
+)  # one-time per import site in practice; shims remain for compat surface
 
 __all__ = [
     "AssembledContext",

package/latticeai/core/config.py

@@ -26,6 +26,8 @@ from typing import List, Mapping, Optional
 from latticeai.core.security import host_is_loopback
 
 
+__all__ = ["Config", "_value", "_str", "_bool", "_int"]
+
 def _value(env: Mapping[str, str], key: str, default: str = "") -> str:
     """Mirror the legacy ``env_value``: ``getenv(key) or default or ""`` (no strip)."""
     return env.get(key) or default or ""
@@ -68,6 +70,7 @@ class Config:
     host: str
     port: int
     network_exposed: bool
+    timezone: str
 
     # ── feature flags ───────────────────────────────────────────────
     enable_telegram: bool
@@ -93,6 +96,9 @@ class Config:
     local_model: str
     local_draft_model: str
     auto_read_chat_paths: bool
+    max_local_models: int
+    allow_model_downloads: bool
+    model_download_timeout: int
 
     # ── embeddings (retrieval vector signal) ────────────────────────
     embedding_provider: str
@@ -165,6 +171,7 @@ class Config:
             host=host,
             port=port,
             network_exposed=network_exposed,
+            timezone=_value(env, "LATTICE_TZ", "UTC") or "UTC",
             enable_telegram=_bool(env, "LATTICEAI_ENABLE_TELEGRAM", default=False),
             enable_graph=_bool(env, "LATTICEAI_ENABLE_GRAPH", default=True),
             autoload_models=_bool(env, "LATTICEAI_AUTOLOAD_MODELS", default=is_public),
@@ -184,6 +191,9 @@ class Config:
             local_model=local_model,
             local_draft_model=_value(env, "LATTICEAI_LOCAL_DRAFT_MODEL", ""),
             auto_read_chat_paths=_bool(env, "LATTICEAI_AUTO_READ_CHAT_PATHS", default=False),
+            max_local_models=_int(env, "LATTICEAI_MAX_LOCAL_MODELS", 1),
+            allow_model_downloads=_bool(env, "LATTICEAI_ALLOW_MODEL_DOWNLOADS", default=False),
+            model_download_timeout=_int(env, "LATTICEAI_MODEL_DOWNLOAD_TIMEOUT", 300),
             embedding_provider=_value(env, "LATTICEAI_EMBEDDING_PROVIDER", "hash").strip().lower(),
             embedding_profile=_value(env, "LATTICEAI_EMBEDDING_PROFILE", "").strip().lower(),
             embedding_model=_value(env, "LATTICEAI_EMBEDDING_MODEL", ""),

package/latticeai/core/marketplace.py

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

package/latticeai/core/tool_registry.py

@@ -9,6 +9,16 @@ effects at import time.
 
 from __future__ import annotations
 
+__all__ = [
+    "ToolPolicy",
+    "ToolPermission",
+    "TOOL_CATALOG_BRIEF",
+    "FILE_CREATE_ACTIONS",
+    "LOCAL_WRITE_BLOCKED_PREFIXES",
+    "RISK_LEVEL_MAP",
+    "ToolRegistry",
+]
+
 from dataclasses import dataclass, field
 from typing import Any, Callable, Dict, Mapping, Optional, TypedDict