ltcai 8.8.0 → 9.0.0

package/latticeai/services/memory_service.py

@@ -271,6 +271,7 @@ class MemoryService:
         memory_count = len(memory_ids) + len(snaps) + len(convs)
         return {
             "sources": sources,
+            "recent_memories": self._manager_recent_memories([*ws_mem, *project_mem], limit=8),
             "tiers": list(TIERS),
             "usage": {"total_items": total_items, "total_bytes": total_bytes, "sources": len(sources)},
             "brain_readiness": self._brain_readiness(
@@ -284,6 +285,23 @@ class MemoryService:
             "generated_at": _now(),
         }
 
+    @staticmethod
+    def _manager_recent_memories(memories: List[Dict[str, Any]], *, limit: int = 8) -> List[Dict[str, Any]]:
+        rows: List[Dict[str, Any]] = []
+        for item in memories[: max(1, limit)]:
+            metadata = item.get("metadata") if isinstance(item.get("metadata"), dict) else {}
+            rows.append({
+                "id": item.get("id") or "",
+                "kind": item.get("kind") or "memory",
+                "content": str(item.get("content") or "")[:320],
+                "tags": item.get("tags") if isinstance(item.get("tags"), list) else [],
+                "metadata": metadata,
+                "workspace_id": item.get("workspace_id") or "personal",
+                "created_at": item.get("created_at"),
+                "updated_at": item.get("updated_at"),
+            })
+        return rows
+
     def brain_quality_summary(self, *, user_email: Optional[str] = None, workspace_id: Optional[str] = None) -> Dict[str, Any]:
         """Return the backend-owned Brain readiness signal for API consumers."""
         return self.manager(user_email=user_email, workspace_id=workspace_id)["brain_readiness"]
@@ -338,6 +356,22 @@ class MemoryService:
             has_recall=bool(recall_items),
             graph_concepts=graph_concepts,
         )
+        suggested_questions = self._brain_brief_suggested_questions(
+            focus=focus,
+            has_durable_evidence=bool(proofs.get("has_durable_evidence")),
+            has_recall=bool(recall_items),
+            graph_concepts=graph_concepts,
+            conversations=conversations,
+        )
+        proactive_actions = self._brain_brief_proactive_actions(
+            focus=focus,
+            state=state,
+            has_durable_evidence=bool(proofs.get("has_durable_evidence")),
+            has_recall=bool(recall_items),
+            graph_concepts=graph_concepts,
+            vector_items=vector_items,
+            healthy_sources=healthy_sources,
+        )
         return {
             "status": state,
             "score": int(readiness.get("score") or 0),
@@ -345,6 +379,8 @@ class MemoryService:
             "body_key": f"brain.brief.body.{state if state in {'quiet', 'forming', 'alive'} else 'quiet'}",
             "focus": focus,
             "next_actions": actions,
+            "suggested_questions": suggested_questions,
+            "proactive_actions": proactive_actions,
             "evidence": [
                 {
                     "id": "durable",
@@ -501,6 +537,183 @@ class MemoryService:
             })
         return sorted(actions, key=lambda item: int(item.get("priority") or 0), reverse=True)[:4]
 
+    @staticmethod
+    def _brain_brief_proactive_actions(
+        *,
+        focus: Dict[str, Any],
+        state: str,
+        has_durable_evidence: bool,
+        has_recall: bool,
+        graph_concepts: int,
+        vector_items: int,
+        healthy_sources: int,
+    ) -> List[Dict[str, Any]]:
+        """Return concrete, one-click actions Brain can proactively suggest."""
+        focus_title = str(focus.get("title") or "").strip() or "Brain"
+        focus_detail = str(focus.get("detail") or "").strip()
+        actions: List[Dict[str, Any]] = []
+        if not has_durable_evidence:
+            actions.append({
+                "id": "proactive_add_source",
+                "intent": "route",
+                "label_key": "brain.proactive.addSource.label",
+                "detail_key": "brain.proactive.addSource.detail",
+                "route": "/capture",
+                "prompt": "Add a useful source to my Brain and explain what it learned.",
+                "priority": 100,
+            })
+            actions.append({
+                "id": "proactive_seed_memory",
+                "intent": "ask",
+                "label_key": "brain.proactive.seed.label",
+                "detail_key": "brain.proactive.seed.detail",
+                "prompt": "Help me seed my Brain with the most useful personal context to remember.",
+                "priority": 90,
+            })
+            return actions
+
+        if has_recall:
+            actions.append({
+                "id": "proactive_evidence_review",
+                "intent": "ask",
+                "label_key": "brain.proactive.evidence.label",
+                "detail_key": "brain.proactive.evidence.detail",
+                "prompt": (
+                    f"Review the evidence Brain has for {focus_title}. "
+                    "Separate confirmed facts, weak signals, contradictions, and next checks."
+                ),
+                "priority": 100,
+                "context": {"focus": focus_title, "detail": focus_detail},
+            })
+            actions.append({
+                "id": "proactive_delegate",
+                "intent": "delegate",
+                "label_key": "brain.proactive.delegate.label",
+                "detail_key": "brain.proactive.delegate.detail",
+                "prompt": (
+                    f"Turn {focus_title} into an execution plan, verify the known context, "
+                    "and return concrete next steps with risks."
+                ),
+                "priority": 95,
+                "context": {"focus": focus_title, "detail": focus_detail},
+            })
+            actions.append({
+                "id": "proactive_review_draft",
+                "intent": "review",
+                "label_key": "brain.proactive.review.label",
+                "detail_key": "brain.proactive.review.detail",
+                "prompt": (
+                    f"Create a reviewable task from Brain's current focus: {focus_title}. "
+                    f"{focus_detail[:240]}"
+                ).strip(),
+                "priority": 90,
+                "context": {"focus": focus_title, "detail": focus_detail},
+            })
+
+        if graph_concepts > 0:
+            actions.append({
+                "id": "proactive_map_connections",
+                "intent": "route",
+                "label_key": "brain.proactive.map.label",
+                "detail_key": "brain.proactive.map.detail",
+                "route": "/knowledge-graph",
+                "prompt": f"Map the strongest Knowledge Graph connections around {focus_title}.",
+                "priority": 82,
+                "context": {"focus": focus_title, "graph_concepts": graph_concepts},
+            })
+
+        if state == "alive" and vector_items > 0 and healthy_sources > 0:
+            actions.append({
+                "id": "proactive_weekly_brief",
+                "intent": "review",
+                "label_key": "brain.proactive.weekly.label",
+                "detail_key": "brain.proactive.weekly.detail",
+                "prompt": (
+                    "Prepare a weekly Brain review: what changed, what decisions are pending, "
+                    "what should be delegated, and what evidence is stale."
+                ),
+                "priority": 78,
+                "context": {"vector_items": vector_items, "healthy_sources": healthy_sources},
+            })
+
+        return sorted(actions, key=lambda item: int(item.get("priority") or 0), reverse=True)[:4]
+
+    @staticmethod
+    def _brain_brief_suggested_questions(
+        *,
+        focus: Dict[str, Any],
+        has_durable_evidence: bool,
+        has_recall: bool,
+        graph_concepts: int,
+        conversations: int,
+    ) -> List[Dict[str, Any]]:
+        """Return reusable, localized UI prompt descriptors for the Brain home."""
+        focus_title = str(focus.get("title") or "").strip()
+        focus_kind = str(focus.get("kind") or "empty")
+        questions: List[Dict[str, Any]] = []
+
+        if not has_durable_evidence or focus_kind == "empty":
+            questions.extend([
+                {
+                    "id": "start_brain",
+                    "label_key": "brain.suggestion.start.label",
+                    "detail_key": "brain.suggestion.start.detail",
+                    "prompt_key": "brain.suggestion.start.prompt",
+                    "params": {},
+                    "priority": 10,
+                },
+                {
+                    "id": "add_context",
+                    "label_key": "brain.suggestion.context.label",
+                    "detail_key": "brain.suggestion.context.detail",
+                    "prompt_key": "brain.suggestion.context.prompt",
+                    "params": {},
+                    "priority": 9,
+                },
+            ])
+            return questions
+
+        questions.append({
+            "id": "focus_next",
+            "label_key": "brain.suggestion.focus.label",
+            "detail_key": "brain.suggestion.focus.detail",
+            "prompt_key": "brain.suggestion.focus.prompt",
+            "params": {"focus": focus_title or "Brain"},
+            "priority": 10,
+        })
+
+        if has_recall:
+            questions.append({
+                "id": "evidence_check",
+                "label_key": "brain.suggestion.evidence.label",
+                "detail_key": "brain.suggestion.evidence.detail",
+                "prompt_key": "brain.suggestion.evidence.prompt",
+                "params": {"focus": focus_title or "this topic"},
+                "priority": 9,
+            })
+
+        if graph_concepts > 0:
+            questions.append({
+                "id": "graph_connections",
+                "label_key": "brain.suggestion.graph.label",
+                "detail_key": "brain.suggestion.graph.detail",
+                "prompt_key": "brain.suggestion.graph.prompt",
+                "params": {"focus": focus_title or "Knowledge Graph"},
+                "priority": 8,
+            })
+
+        if conversations > 0:
+            questions.append({
+                "id": "conversation_followup",
+                "label_key": "brain.suggestion.history.label",
+                "detail_key": "brain.suggestion.history.detail",
+                "prompt_key": "brain.suggestion.history.prompt",
+                "params": {"focus": focus_title or "recent conversations"},
+                "priority": 7,
+            })
+
+        return sorted(questions, key=lambda item: int(item.get("priority") or 0), reverse=True)[:4]
+
     def brain_proof(
         self,
         *,

package/latticeai/services/model_engines.py

@@ -23,6 +23,13 @@ from typing import Any, Dict, List, Optional
 
 from fastapi import HTTPException
 
+from latticeai.services.process_audit import (
+    CommandConfirmationError,
+    append_process_audit_event,
+    command_plan,
+    require_command_confirmation,
+)
+
 
 def _progress_payload(*args, **kwargs) -> Dict[str, object]:
     try:
@@ -440,8 +447,8 @@ def engine_support_status(engine: str) -> Dict[str, object]:
     return {"supported": True, "reason": None}
 
 
-def install_engine(engine: str) -> Dict[str, Any]:
-    from latticeai.services.model_runtime import BASE_DIR, ENGINE_INSTALLERS, engine_installed
+def _engine_install_command(engine: str) -> tuple[list[str], str, bool]:
+    from latticeai.services.model_runtime import BASE_DIR, ENGINE_INSTALLERS
 
     if engine not in ENGINE_INSTALLERS:
         raise HTTPException(status_code=400, detail="지원하지 않는 엔진입니다.")
@@ -449,14 +456,7 @@ def install_engine(engine: str) -> Dict[str, Any]:
     required_binary = installer.get("requires_binary")
     if required_binary and shutil.which(required_binary) is None:
         raise HTTPException(status_code=400, detail=f"{required_binary}가 설치되어 있지 않아 자동 설치할 수 없습니다.")
-    command = installer["command"]
-    run_kwargs = {
-        "cwd": str(BASE_DIR),
-        "capture_output": True,
-        "text": True,
-        "timeout": 900,
-        "check": False,
-    }
+    command = list(installer["command"])
 
     if engine == "vllm" and sys.platform == "darwin" and platform.machine() == "arm64":
         command = [
@@ -468,13 +468,69 @@ def install_engine(engine: str) -> Dict[str, Any]:
             "~/.venv-vllm-metal/bin/pip install -U pip setuptools wheel; "
             "~/.venv-vllm-metal/bin/pip install vllm-metal",
         ]
+    requires_admin = bool(command and command[0] in {"apt", "apt-get", "dnf", "pacman"})
+    return command, str(BASE_DIR), requires_admin
+
+
+def engine_install_plan(engine: str) -> Dict[str, Any]:
+    command, cwd, requires_admin = _engine_install_command(engine)
+    return command_plan(
+        command,
+        name=f"engine:{engine}",
+        purpose="engine_install",
+        cwd=cwd,
+        requires_admin=requires_admin,
+        metadata={"engine": engine},
+    )
+
+
+def install_engine(engine: str, confirmation_token: Optional[str] = None) -> Dict[str, Any]:
+    from latticeai.services.model_runtime import engine_installed
+
+    command, cwd, _requires_admin = _engine_install_command(engine)
+    plan = engine_install_plan(engine)
+    try:
+        require_command_confirmation(command, confirmation_token, cwd=cwd, purpose="engine_install")
+    except CommandConfirmationError as exc:
+        append_process_audit_event("engine_install", plan=plan, status="denied", error=str(exc))
+        raise HTTPException(
+            status_code=403,
+            detail={
+                "status": "confirmation_required",
+                "reason": str(exc),
+                "install_plan": plan,
+            },
+        ) from exc
+
+    run_kwargs = {
+        "cwd": cwd,
+        "capture_output": True,
+        "text": True,
+        "timeout": 900,
+        "check": False,
+    }
     try:
+        append_process_audit_event("engine_install", plan=plan, status="started")
         completed = subprocess.run(command, **run_kwargs)
     except subprocess.TimeoutExpired:
+        append_process_audit_event("engine_install", plan=plan, status="timeout")
         raise HTTPException(status_code=408, detail="엔진 설치 시간이 초과되었습니다.")
+    except Exception as exc:
+        append_process_audit_event("engine_install", plan=plan, status="error", error=str(exc))
+        raise
+    append_process_audit_event(
+        "engine_install",
+        plan=plan,
+        status="finished",
+        returncode=completed.returncode,
+        stdout=completed.stdout,
+        stderr=completed.stderr,
+    )
     result = {
         "engine": engine,
-        "command": " ".join(command),
+        "command_hash": plan["command_hash"],
+        "command_preview": plan["command_preview"],
+        "install_plan": plan,
         "returncode": completed.returncode,
         "stdout": completed.stdout[-12000:],
         "stderr": completed.stderr[-12000:],
@@ -491,15 +547,25 @@ def install_engine(engine: str) -> Dict[str, Any]:
         if already_up:
             result["daemon_started"] = "already_running"
         else:
+            daemon_command = [ollama, "serve"]
+            daemon_plan = command_plan(
+                daemon_command,
+                name="engine:ollama:serve",
+                purpose="engine_daemon_start",
+                metadata={"engine": "ollama"},
+            )
             try:
+                append_process_audit_event("engine_daemon_start", plan=daemon_plan, status="started")
                 subprocess.Popen(
-                    [ollama, "serve"],
+                    daemon_command,
                     stdout=subprocess.DEVNULL,
                     stderr=subprocess.DEVNULL,
                     start_new_session=True,
                 )
+                append_process_audit_event("engine_daemon_start", plan=daemon_plan, status="spawned")
                 result["daemon_started"] = True
             except Exception as exc:
+                append_process_audit_event("engine_daemon_start", plan=daemon_plan, status="error", error=str(exc))
                 logging.warning("ollama serve spawn failed: %s", exc)
                 result["daemon_started"] = False
     return result
@@ -589,6 +655,7 @@ __all__ = [
     "pull_ollama_model_with_progress",
     "get_ollama_pulled_models",
     "engine_support_status",
+    "engine_install_plan",
     "install_engine",
     "_smoke_test_loaded_model",
 ]

package/latticeai/services/model_runtime.py

@@ -47,6 +47,7 @@ from .model_engines import (
     pull_ollama_model_with_progress as _pull_ollama_model_with_progress,
     get_ollama_pulled_models as _get_ollama_pulled_models,
     engine_support_status as _engine_support_status,
+    engine_install_plan as _engine_install_plan,
     install_engine as _install_engine,
     local_binary as _local_binary,
     vllm_executable as _vllm_executable,
@@ -88,6 +89,8 @@ class ModelRuntimeState:
         self.ENABLE_GRAPH = True
         self.AUTOLOAD_MODELS = False
         self.MODEL_IDLE_UNLOAD_SECONDS = 0
+        self.ALLOW_MODEL_DOWNLOADS = False
+        self.MODEL_DOWNLOAD_TIMEOUT = 300
         self.ALLOW_LOCAL_MODELS = True
         self.REQUIRE_AUTH = False
         self.INVITE_GATE_ENABLED = False
@@ -118,7 +121,8 @@ class ModelRuntimeState:
         """Internal no-warning sync used at init."""
         global router, APP_MODE, DEFAULT_HOST, DEFAULT_PORT, DATA_DIR, BASE_DIR
         global ENABLE_TELEGRAM, ENABLE_GRAPH, AUTOLOAD_MODELS, MODEL_IDLE_UNLOAD_SECONDS
-        global ALLOW_LOCAL_MODELS, REQUIRE_AUTH, INVITE_GATE_ENABLED, ALLOW_PLAINTEXT_API_KEYS
+        global ALLOW_MODEL_DOWNLOADS, MODEL_DOWNLOAD_TIMEOUT, ALLOW_LOCAL_MODELS, REQUIRE_AUTH
+        global INVITE_GATE_ENABLED, ALLOW_PLAINTEXT_API_KEYS
         global CORS_ALLOW_NETWORK, PUBLIC_MODEL, LOCAL_MODEL, IS_PUBLIC_MODE
         global keyring, get_current_user, get_user_api_key
         router = self.router
@@ -131,6 +135,8 @@ class ModelRuntimeState:
         ENABLE_GRAPH = self.ENABLE_GRAPH
         AUTOLOAD_MODELS = self.AUTOLOAD_MODELS
         MODEL_IDLE_UNLOAD_SECONDS = self.MODEL_IDLE_UNLOAD_SECONDS
+        ALLOW_MODEL_DOWNLOADS = self.ALLOW_MODEL_DOWNLOADS
+        MODEL_DOWNLOAD_TIMEOUT = self.MODEL_DOWNLOAD_TIMEOUT
         ALLOW_LOCAL_MODELS = self.ALLOW_LOCAL_MODELS
         REQUIRE_AUTH = self.REQUIRE_AUTH
         INVITE_GATE_ENABLED = self.INVITE_GATE_ENABLED
@@ -159,7 +165,8 @@ def _env_bool(key: str, default: bool = False) -> bool:
 def _download_allowed(allow_download: bool = False) -> bool:
     # Prefer STATE (the source of truth) over bare module global for internal logic.
     autoload = getattr(STATE, "AUTOLOAD_MODELS", AUTOLOAD_MODELS)
-    return bool(allow_download) or _env_bool("LATTICEAI_ALLOW_MODEL_DOWNLOADS", default=False) or bool(autoload)
+    configured = getattr(STATE, "ALLOW_MODEL_DOWNLOADS", ALLOW_MODEL_DOWNLOADS)
+    return bool(allow_download) or bool(configured) or bool(autoload)
 
 
 def _download_block(provider: str, model_name: str) -> None:
@@ -726,6 +733,13 @@ def ensure_llamacpp_server(model_name: str) -> None:
     return _ensure_llamacpp_server(model_name)
 
 
+def _safe_engine_install_plan(engine: str) -> Optional[Dict[str, object]]:
+    try:
+        return _engine_install_plan(engine)
+    except Exception:
+        return None
+
+
 def engine_installed(engine: str) -> bool:
     if engine == "local_mlx":
         return bool(
@@ -847,6 +861,7 @@ def engine_status() -> List[Dict]:
             "installed": engine_installed("local_mlx"),
             "installable": True,
             "install_label": ENGINE_INSTALLERS["local_mlx"]["label"],
+            "install_plan": _safe_engine_install_plan("local_mlx"),
             "models": mlx_models,
         },
         {
@@ -857,6 +872,7 @@ def engine_status() -> List[Dict]:
             "installed": ollama_installed,
             "installable": True,
             "install_label": ENGINE_INSTALLERS["ollama"]["label"],
+            "install_plan": _safe_engine_install_plan("ollama"),
             "models": ollama_models,
         },
     ]
@@ -872,6 +888,7 @@ def engine_status() -> List[Dict]:
             "support_reason": support["reason"],
             "installable": support["supported"] and spec["id"] in ENGINE_INSTALLERS,
             "install_label": ENGINE_INSTALLERS.get(spec["id"], {}).get("label"),
+            "install_plan": _safe_engine_install_plan(spec["id"]) if spec["id"] in ENGINE_INSTALLERS else None,
             "requires": spec["requires"],
             "models": (
                 vllm_models if spec["id"] == "vllm"
@@ -900,6 +917,7 @@ def engine_status() -> List[Dict]:
             "installed": engine_installed(provider),
             "installable": True,
             "install_label": ENGINE_INSTALLERS[provider]["label"],
+            "install_plan": _safe_engine_install_plan(provider),
             "requires": env_key,
             "models": provider_models,
         })
@@ -920,6 +938,8 @@ def runtime_features() -> Dict:
         "graph_enabled": s.ENABLE_GRAPH,
         "autoload_models": s.AUTOLOAD_MODELS,
         "model_idle_unload_seconds": s.MODEL_IDLE_UNLOAD_SECONDS,
+        "allow_model_downloads": s.ALLOW_MODEL_DOWNLOADS,
+        "model_download_timeout": s.MODEL_DOWNLOAD_TIMEOUT,
         "model_memory_policy": r.model_memory_policy() if r else None,
         "allow_local_models": s.ALLOW_LOCAL_MODELS,
         "security": {
@@ -944,8 +964,8 @@ def runtime_features() -> Dict:
         },
     }
 
-def install_engine(engine: str) -> Dict:
-    return _install_engine(engine)
+def install_engine(engine: str, confirmation_token: Optional[str] = None) -> Dict:
+    return _install_engine(engine, confirmation_token=confirmation_token)
 
 
 def _resolve_model_alias(model_id: str, engine: Optional[str] = None) -> str:

package/latticeai/services/platform_runtime.py

@@ -144,7 +144,15 @@ class PlatformRuntime:
         def provider(goal: str):
             try:
                 mems = self.store.search_memories(goal, user_email=user, workspace_id=scope).get("memories", [])
-                return [str(m.get("content") or "")[:160] for m in mems[:5]]
+                ctx = [str(m.get("content") or "")[:180] for m in mems[:6]]
+                # Enrich with agent-synthesis memories preferentially for self-improving Brain feel
+                try:
+                    allm = self.store.list_memories(user_email=user, workspace_id=scope).get("memories", [])
+                    synth = [str(m.get("content") or "")[:160] for m in allm if "agent-synthesis" in (m.get("tags") or [])][:3]
+                    ctx = synth + ctx
+                except Exception:
+                    pass
+                return ctx[:8]
             except Exception:
                 return []
         return provider