ltcai 8.0.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.0.0"
+__version__ = "8.2.0"
 
 __all__ = [
     "AgentRuntime",

package/lattice_brain/embeddings.py

@@ -15,6 +15,10 @@ DEFAULT_EMBEDDING_DIM = int(os.getenv("LATTICEAI_VECTOR_DIM", "384"))
 EMBEDDING_MODEL_ID = f"lattice-local-hash-v1:{DEFAULT_EMBEDDING_DIM}"
 
 
+def embedding_model_id(dim: int) -> str:
+    return f"lattice-local-hash-v1:{int(dim)}"
+
+
 def _tokenize(text: str) -> List[str]:
     raw = str(text or "").lower()
     tokens = re.findall(r"[a-z0-9][a-z0-9_.:/+-]{1,}|[가-힣]{2,}", raw)
@@ -49,6 +53,10 @@ class LocalEmbeddingModel:
     dim: int = DEFAULT_EMBEDDING_DIM
     model_id: str = EMBEDDING_MODEL_ID
 
+    def __post_init__(self) -> None:
+        if self.model_id == EMBEDDING_MODEL_ID and self.dim != DEFAULT_EMBEDDING_DIM:
+            object.__setattr__(self, "model_id", embedding_model_id(self.dim))
+
     def embed(self, text: str) -> List[float]:
         vector = [0.0] * self.dim
         features = _tokenize(text)
@@ -79,4 +87,4 @@ class LocalEmbeddingModel:
         return list(struct.unpack(f"<{count}f", payload[: count * 4]))
 
 
-__all__ = ["DEFAULT_EMBEDDING_DIM", "EMBEDDING_MODEL_ID", "LocalEmbeddingModel"]
+__all__ = ["DEFAULT_EMBEDDING_DIM", "EMBEDDING_MODEL_ID", "LocalEmbeddingModel", "embedding_model_id"]

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.0.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.0.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,
@@ -77,8 +79,6 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     import re
     import secrets
     import threading
-    import subprocess
-    import sys
     import time
     from pathlib import Path
 
@@ -95,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,
@@ -107,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,
@@ -195,8 +195,10 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     )
     from latticeai.core.tool_registry import TOOL_CATALOG_BRIEF as _TOOL_CATALOG_BRIEF  # noqa: F401
     from latticeai.core.mcp_registry import (
-        _get_combined_registry,
-        _fetch_skills_marketplace, install_skill, SKILLS_DIR,
+        _fetch_skills_marketplace,
+        install_skill,
+        SKILLS_DIR,
+        create_mcp_install_state,
     )
     from latticeai.services.p_reinforce import PReinforceGardener
     from setup_wizard import get_recommendations, scan_environment
@@ -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)
@@ -322,6 +307,15 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     MCP_FILE = DATA_DIR / "mcp_installs.json"
     AUDIT_FILE = DATA_DIR / "audit_log.json"
     SSO_FILE = DATA_DIR / "sso_config.json"
+
+    # MCP state extracted to mcp_registry.create_mcp_install_state (server decomp)
+    _mcp_state = create_mcp_install_state(DATA_DIR)
+    load_mcp_installs = _mcp_state["load_mcp_installs"]
+    save_mcp_installs = _mcp_state["save_mcp_installs"]
+    mcp_public_item = _mcp_state["mcp_public_item"]
+    recommend_mcps = _mcp_state["recommend_mcps"]
+    install_mcp = _mcp_state["install_mcp"]
+
     # Resolve the configured embedding provider once at startup. Degrades to the
     # offline hash fallback when the requested provider is unavailable, while
     # recording the requested-vs-active provider for the Embeddings status surface.
@@ -346,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
@@ -470,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 {
@@ -546,144 +552,10 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         with open(VPC_FILE, "w", encoding="utf-8") as f:
             json.dump(config, f, ensure_ascii=False, indent=2)
 
-    def load_mcp_installs() -> Dict:
-        if not os.path.exists(MCP_FILE):
-            return {"installed": {}, "updated_at": None}
-        try:
-            with open(MCP_FILE, "r", encoding="utf-8") as f:
-                data = json.load(f)
-            if "installed" not in data:
-                data["installed"] = {}
-            return data
-        except Exception as e:
-            logging.warning("load_mcp_installs failed: %s", e)
-            return {"installed": {}, "updated_at": None}
-
-    def save_mcp_installs(data: Dict):
-        data["updated_at"] = datetime.now().isoformat()
-        with open(MCP_FILE, "w", encoding="utf-8") as f:
-            json.dump(data, f, ensure_ascii=False, indent=2)
-
-    def mcp_public_item(item: Dict, installed_state: Dict) -> Dict:
-        state = installed_state.get(item["id"]) or {}
-        installed = item["install_mode"] in {"builtin", "bundled"} or bool(state.get("installed"))
-        connector_pending = item["install_mode"] == "connector" and not state.get("authenticated")
-        authenticated = item["install_mode"] != "connector" or bool(state.get("authenticated"))
-        return {
-            "id": item["id"],
-            "name": item["name"],
-            "category": item.get("category", ""),
-            "install_mode": item["install_mode"],
-            "description": item.get("description", ""),
-            "capabilities": item.get("capabilities", []),
-            "connector_url": item.get("connector_url"),
-            "external_url": item.get("external_url"),
-            "package": item.get("package"),
-            "homepage": item.get("homepage"),
-            "source": item.get("source", "local"),
-            "installed": installed,
-            "status": state.get("status") or ("active" if installed and not connector_pending else "needs_auth" if connector_pending else "available"),
-            "authenticated": authenticated,
-            "updated_at": state.get("updated_at"),
-        }
-
-    async def recommend_mcps(query: str, limit: int = 5) -> List[Dict]:
-        text = (query or "").lower()
-        installed = load_mcp_installs().get("installed", {})
-        registry = await _get_combined_registry()
-        scored = []
-        for item in registry:
-            score = 0
-            hits = []
-            for keyword in item.get("keywords", []):
-                if keyword.lower() in text:
-                    score += 3 if len(keyword) > 2 else 1
-                    hits.append(keyword)
-            # description 키워드 매칭 (remote 항목 보완)
-            if not hits and text:
-                desc_words = item.get("description", "").lower().split()
-                for word in text.split():
-                    if len(word) > 2 and word in desc_words:
-                        score += 1
-                        hits.append(word)
-            if item["id"] == "filesystem" and any(word in text for word in ["만들", "구현", "build", "deploy", "코드", "앱"]):
-                score += 2
-            if score:
-                public = mcp_public_item(item, installed)
-                public["score"] = score
-                public["matched_keywords"] = hits[:6]
-                scored.append(public)
-        if not scored:
-            fallback_ids = ["filesystem", "browser", "documents"]
-            scored = [
-                {**mcp_public_item(item, installed), "score": 1, "matched_keywords": []}
-                for item in registry
-                if item["id"] in fallback_ids
-            ]
-        return sorted(scored, key=lambda item: item["score"], reverse=True)[: max(1, min(limit, 24))]
-
-    async def install_mcp(mcp_id: str) -> Dict:
-        registry = await _get_combined_registry()
-        item = next((entry for entry in registry if entry["id"] == mcp_id), None)
-        if not item:
-            raise HTTPException(status_code=404, detail="MCP를 찾을 수 없습니다.")
-        data = load_mcp_installs()
-        state = data.setdefault("installed", {})
-        status = "active"
-        message = "MCP가 활성화되었습니다."
-        if item["install_mode"] == "connector":
-            status = "needs_auth"
-            message = "커넥터 인증이 필요합니다. Codex 앱의 connector 설정에서 계정을 연결하면 바로 사용할 수 있습니다."
-        elif item["install_mode"] == "pip":
-            packages = item.get("pip_packages") or []
-            for pkg in packages:
-                completed = subprocess.run(
-                    [sys.executable, "-m", "pip", "install", "--upgrade", pkg],
-                    capture_output=True, text=True, timeout=900, check=False,
-                )
-                if completed.returncode != 0:
-                    raise HTTPException(status_code=500, detail=completed.stderr[-2000:] or f"{pkg} 설치 실패")
-            message = f"필수 패키지 설치 완료: {', '.join(packages)}"
-        elif item["install_mode"] == "pypi":
-            pkg = item.get("package", "")
-            version = item.get("package_version")
-            pkg_str = f"{pkg}=={version}" if version else pkg
-            completed = subprocess.run(
-                [sys.executable, "-m", "pip", "install", pkg_str],
-                capture_output=True, text=True, timeout=300, check=False,
-            )
-            if completed.returncode != 0:
-                raise HTTPException(status_code=500, detail=completed.stderr[-2000:] or f"{pkg} 설치 실패")
-            message = f"pip 패키지 설치 완료: {pkg_str}"
-        elif item["install_mode"] == "npm":
-            pkg = item.get("package", "")
-            version = item.get("package_version")
-            pkg_str = f"{pkg}@{version}" if version else pkg
-            completed = subprocess.run(
-                ["npm", "install", "-g", pkg_str],
-                capture_output=True, text=True, timeout=300, check=False,
-            )
-            if completed.returncode != 0:
-                raise HTTPException(status_code=500, detail=completed.stderr[-2000:] or f"{pkg} 설치 실패")
-            message = f"npm 패키지 설치 완료: {pkg_str}"
-        state[mcp_id] = {
-            "installed": True,
-            "status": status,
-            "authenticated": item["install_mode"] != "connector",
-            "updated_at": datetime.now().isoformat(),
-        }
-        save_mcp_installs(data)
-        public = mcp_public_item(item, state)
-        public["message"] = message
-        return public
 
     _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,
@@ -755,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()