ltcai 8.9.0 → 9.1.0

package/latticeai/services/architecture_readiness.py

@@ -1,6 +1,6 @@
 """Machine-checkable architecture readiness gates for release work.
 
-8.9.0 keeps the major architecture priorities under an explicit release
+The current release keeps the major architecture priorities under an explicit release
 contract while product maturity work reduces visible beta seams. AgentRuntime, ToolRegistry,
 central Config, decomposed server runtime, and Knowledge Graph stabilization
 must remain discoverable, ordered, and backed by tests before the release can be
@@ -17,7 +17,7 @@ from typing import Any, Dict, List
 from latticeai.core.legacy_compatibility import legacy_shim_report
 
 
-ARCHITECTURE_VERSION_TARGET = "8.9.0"
+ARCHITECTURE_VERSION_TARGET = "9.1.0"
 
 PREFERRED_REFACTORING_ORDER = [
     "agent-runtime",
@@ -54,16 +54,64 @@ def _symbol_exists(dotted: str) -> bool:
         return False
 
 
+def _forbidden_patterns(root: Path, relative_path: str, patterns: List[str]) -> List[str]:
+    path = root / relative_path
+    try:
+        source = path.read_text(encoding="utf-8")
+    except OSError:
+        return [f"missing:{relative_path}"]
+    return [pattern for pattern in patterns if pattern in source]
+
+
 def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
     if root is None:
         root = Path(__file__).resolve().parents[2]
     shim_report = legacy_shim_report(root)
+    factory_forbidden = _forbidden_patterns(
+        root,
+        "latticeai/app_factory.py",
+        ["build_runtime_namespace(locals", "dict(locals())"],
+    )
+    model_runtime_forbidden = _forbidden_patterns(
+        root,
+        "latticeai/services/model_runtime.py",
+        [
+            "def _sync_globals",
+            "global router",
+            "STATE = ModelRuntimeState",
+            "_STATE_EXPORTS",
+            "def __getattr__(name:",
+            "from fastapi import HTTPException",
+        ],
+    )
+    model_runtime_forbidden.extend(
+        _forbidden_patterns(
+            root,
+            "latticeai/services/model_loading.py",
+            ["from .model_runtime import STATE", "from fastapi import HTTPException"],
+        )
+    )
+    model_runtime_forbidden.extend(
+        _forbidden_patterns(
+            root,
+            "latticeai/services/model_engines.py",
+            ["from fastapi import HTTPException", "raise HTTPException"],
+        )
+    )
+    agent_alias_forbidden = _forbidden_patterns(
+        root,
+        "latticeai/core/agent.py",
+        ["AgentRuntime = SingleAgentRuntime"],
+    )
 
     gates = [
         ArchitectureGate(
             id="agent-runtime",
             title="AgentRuntime boundary",
-            status="complete" if _symbol_exists("lattice_brain.runtime.agent_runtime.AgentRuntime") else "incomplete",
+            status="complete" if (
+                _symbol_exists("lattice_brain.runtime.agent_runtime.AgentRuntime")
+                and not agent_alias_forbidden
+            ) else "incomplete",
             evidence=[
                 "lattice_brain.runtime.agent_runtime.AgentRuntime",
                 "latticeai.api.agents.create_agents_router(agent_runtime=...)",
@@ -83,7 +131,11 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
         ArchitectureGate(
             id="config-centralization",
             title="Central app Config",
-            status="complete" if _symbol_exists("latticeai.core.config.Config") else "incomplete",
+            status="complete" if (
+                _symbol_exists("latticeai.core.config.Config")
+                and _symbol_exists("latticeai.runtime.config_runtime.ConfigRuntime")
+                and not model_runtime_forbidden
+            ) else "incomplete",
             evidence=[
                 "latticeai.core.config.Config.from_env",
                 "latticeai.runtime.config_runtime.ConfigRuntime",
@@ -93,7 +145,19 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
         ArchitectureGate(
             id="server-decomposition",
             title="Server decomposition",
-            status="complete",
+            status="complete" if (
+                all(
+                    _symbol_exists(symbol)
+                    for symbol in [
+                        "latticeai.runtime.config_runtime.ConfigRuntime",
+                        "latticeai.runtime.security_runtime.SecurityRuntime",
+                        "latticeai.runtime.brain_runtime.BrainRuntime",
+                        "latticeai.runtime.model_wiring.ModelRuntime",
+                        "latticeai.runtime.router_registration.RouterBundle",
+                    ]
+                )
+                and not factory_forbidden
+            ) else "incomplete",
             evidence=[
                 "latticeai.app_factory.create_app composition root",
                 "latticeai.api.* domain routers",
@@ -192,6 +256,11 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
             "runtime_modules": runtime_module_count,
             "architecture_gates": len(gates),
             "legacy_shims_remaining": shim_report["remaining_count"],
+            "forbidden_patterns": {
+                "app_factory": factory_forbidden,
+                "model_runtime": model_runtime_forbidden,
+                "agent_alias": agent_alias_forbidden,
+            },
         },
         "legacy_compatibility": shim_report,
     }

package/latticeai/services/brain_automation.py

@@ -136,6 +136,7 @@ def build_brain_automation_workflow(recipe_id: str, *, enabled: bool = False) ->
     trigger_config = {
         **deepcopy(recipe.trigger),
         "enabled": bool(enabled),
+        "review_queue": True,
         "consent_required": True,
         "local_only": True,
         "external_actions": False,
@@ -156,7 +157,9 @@ def build_brain_automation_workflow(recipe_id: str, *, enabled: bool = False) ->
                 "name": "Draft Brain review",
                 "config": {
                     "agent": "agent:planner",
+                    "goal": recipe.prompt,
                     "prompt": recipe.prompt,
+                    "roles": ["researcher", "planner", "executor", "reviewer"],
                     "mode": "draft",
                     "local_only": True,
                     "external_actions": False,
@@ -186,29 +189,3 @@ def build_brain_automation_workflow(recipe_id: str, *, enabled: bool = False) ->
             "creates": list(recipe.creates),
         },
     }
-
-
-# === A방향 (Act/automation + BrainAutomationPanel) E2E 시나리오 초안 ===
-# (backend 인터페이스 list_brain_automation_recipes / find_installed... / build_... 완료 후 즉시 작성)
-# 1. Recipe 목록 노출: frontend BrainAutomationPanel이 list_brain_automation_recipes() 호출 → recipes + consent metadata 표시.
-# 2. "Create reviewable draft" 클릭:
-#    - build_brain_automation_workflow(recipe_id, enabled=False) 로 draft 생성 (metadata.recipe_id + created_from=brain_automation_recipe)
-#    - find_installed_recipe_workflow 로 사전 dedup 체크 → 이미 있으면 기존 반환, UI disabled + "✓ Reviewable draft ready" 피드백.
-#    - 생성된 workflow는 automation_state="draft_disabled", trigger.enabled=False → TriggerService 무시.
-# 3. Dedup guard (UI + backend): metadata.recipe_id + created_from 기준. 중복 클릭 가드 (no-dup) 로 double submit 방지.
-# 4. User가 draft를 review/수정 후 enabled=True 로 전환 → TriggerService._triggered_workflows 에서 enabled True인 것만 arm.
-# 5. Interval trigger E2E:
-#    - reconcile_missed() : 다운타임 중 missed → "skipped" 이벤트 기록 (catch-up storm 없음).
-#    - tick_intervals() : last_fired_at + interval + last_attempt_at dedup 가드 (10s cooldown) 로 중복 실행 방지.
-#    - LATTICE_TZ 환경변수: describe()에 "tz" 노출, 이벤트 at 값은 epoch이지만 클라이언트가 LATTICE_TZ로 현지화.
-# 6. Brain event trigger E2E: kg_ingest.* post_tool hook → on_brain_event → matching source_type 필터 → _fire (dedup 5s).
-# 7. Failure degraded:
-#    - _fire 에서 run_workflow 예외 → _record_fire_outcome → consecutive_failures++ , describe() "status":"degraded" ( >=3 ).
-#    - 성공 시 reset. (실행 내부 실패는 workflow run record에 남음, scheduler는 launch health만).
-# 8. Run provenance: fired run의 inputs["__trigger__"] = {"type": "interval"|"brain_event", ...} 로 감사/디버그 가능.
-# 9. Consent-first: draft_disabled 기본, user enable 전까지 절대 실행 안 됨. "review_before_run": True.
-# 10. End-to-end Act: draft → enable → trigger fire → agent:planner "Draft Brain review" 노드 → output (requires_review) → user review → save or discard.
-#
-# 다음: 실제 API (e.g. POST /brain/automation/install-draft) 가 UI에서 호출되면 위 시나리오에 대한 통합 테스트 + RunExecutor 경로 검증 즉시 추가.
-# 현재 상태: backend recipe 인터페이스 + TriggerService edge 하드닝 + AgentRuntime wiring 완료. UI (App.tsx + styles) + test_brain_automation.py 는 별도 완료 보고됨.
-

package/latticeai/services/chat_service.py

@@ -1,37 +1,191 @@
-"""Chat / session service seam.
+"""Non-HTTP chat orchestration: history persistence and answer traces.
 
-The streaming chat path in ``server_app`` is intentionally left in place — its
-generator and SSE behaviour are sensitive. This service provides a stable seam
-for the *bookkeeping* around answers (conversation history access and
-Workspace-OS answer-trace recording) so those concerns are named and wrapped
-rather than reaching into the store directly from the streaming handler.
+The API layer owns FastAPI requests/responses and SSE framing.  This service
+owns the reusable bookkeeping that must be identical across normal answers,
+streamed answers, document generation, and fast-path intents:
 
-It is a behaviour-preserving façade: methods forward to the injected history
-accessor and :class:`WorkspaceOSStore`, so wiring the chat path through it
-cannot change streaming output.
+* workspace/user-scoped history reads;
+* asynchronous persistence of user/assistant exchanges;
+* Graph-RAG answer trace construction and recording;
+* history search/grouping independent of HTTP.
+
+``coerce`` preserves lightweight test/embedding contexts that provide the old
+``build_graph_trace``/``record_trace`` façade without requiring them to grow a
+full service implementation.
 """
 
 from __future__ import annotations
 
+import asyncio
 from typing import Any, Callable, Dict, List, Optional
 
 from latticeai.core.workspace_os import WorkspaceOSStore
 
 
 class ChatService:
-    def __init__(self, *, store: WorkspaceOSStore, get_history: Callable[[], List[Dict[str, Any]]]):
+    def __init__(
+        self,
+        *,
+        store: WorkspaceOSStore,
+        get_history: Callable[..., List[Dict[str, Any]]],
+        save_to_history: Optional[Callable[..., None]] = None,
+        get_history_user: Optional[Callable[..., Dict[str, Any]]] = None,
+        trace_delegate: Any = None,
+    ):
         self._store = store
         self._get_history = get_history
+        self._save_to_history = save_to_history
+        self._get_history_user = get_history_user
+        self._trace_delegate = trace_delegate
+
+    @classmethod
+    def coerce(
+        cls,
+        candidate: Any,
+        *,
+        store: Any,
+        get_history: Callable[..., List[Dict[str, Any]]],
+        save_to_history: Callable[..., None],
+        get_history_user: Callable[..., Dict[str, Any]],
+    ) -> "ChatService":
+        """Return a fully wired service while preserving legacy trace fakes."""
+
+        if isinstance(candidate, cls):
+            candidate._get_history = get_history
+            candidate._save_to_history = save_to_history
+            candidate._get_history_user = get_history_user
+            return candidate
+        return cls(
+            store=store,
+            get_history=get_history,
+            save_to_history=save_to_history,
+            get_history_user=get_history_user,
+            trace_delegate=candidate,
+        )
 
     # ── conversation history ─────────────────────────────────────────────
 
-    def history(self) -> List[Dict[str, Any]]:
-        return self._get_history()
+    def history(self, **scope: Any) -> List[Dict[str, Any]]:
+        return self._get_history(**scope)
+
+    def history_scope(
+        self,
+        user_email: Optional[str],
+        *,
+        require_auth: bool,
+        allowed_workspaces_for: Optional[Callable[[str], Any]] = None,
+    ) -> Dict[str, Any]:
+        scoped_user = user_email if require_auth else None
+        allowed = None
+        if require_auth and scoped_user and allowed_workspaces_for is not None:
+            allowed = allowed_workspaces_for(scoped_user)
+        return {
+            "user_email": scoped_user,
+            "allowed_workspaces": allowed,
+            "include_legacy_global": not require_auth,
+        }
+
+    def history_user(
+        self,
+        user_email: Optional[str],
+        user_nickname: Optional[str],
+    ) -> Dict[str, Any]:
+        if self._get_history_user is None:
+            return {}
+        return self._get_history_user(user_email, user_nickname)
+
+    async def persist_entry(
+        self,
+        role: str,
+        content: str,
+        *,
+        history_meta: Optional[Dict[str, Any]] = None,
+        history_user: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        if self._save_to_history is None:
+            raise RuntimeError("chat history writer is not configured")
+        await asyncio.to_thread(
+            self._save_to_history,
+            role,
+            content,
+            **(history_meta or {}),
+            **(history_user or {}),
+        )
+
+    async def persist_exchange(
+        self,
+        *,
+        request_message: str,
+        stored_user_message: str,
+        answer: str,
+        source: Optional[str],
+        history_meta: Dict[str, Any],
+        history_user: Dict[str, Any],
+        notify: Optional[Callable[[str, str, Optional[str]], None]] = None,
+    ) -> None:
+        await self.persist_entry(
+            "user",
+            stored_user_message,
+            history_meta=history_meta,
+            history_user=history_user,
+        )
+        await self.persist_entry(
+            "assistant",
+            answer,
+            history_meta=history_meta,
+            history_user=history_user,
+        )
+        if notify is not None:
+            notify("user", request_message, source)
+            notify("assistant", answer, source)
+
+    def search_history(
+        self,
+        query: str,
+        *,
+        scope: Dict[str, Any],
+        conversation_title: Callable[[Dict[str, Any]], str],
+        limit: int = 30,
+    ) -> List[Dict[str, Any]]:
+        q_lower = str(query or "").strip().lower()
+        if not q_lower:
+            return []
+        matches = [
+            item
+            for item in self.history(**scope)
+            if q_lower in str(item.get("content") or "").lower()
+        ]
+        grouped: Dict[str, Dict[str, Any]] = {}
+        for item in matches:
+            conversation_id = item.get("conversation_id") or "legacy"
+            if conversation_id not in grouped:
+                grouped[conversation_id] = {
+                    "conversation_id": conversation_id,
+                    "title": conversation_title(item),
+                    "messages": [],
+                }
+            grouped[conversation_id]["messages"].append(item)
+        return list(grouped.values())[-max(1, int(limit or 30)) :]
 
     # ── answer-trace recording (Graph RAG) ───────────────────────────────
 
-    def build_graph_trace(self, question: str, graph: Any, context: str = "", *, limit: int = 8) -> Dict[str, Any]:
-        return self._store.build_graph_trace(question, graph, context, limit=limit)
+    def build_graph_trace(
+        self,
+        question: str,
+        graph: Any,
+        context: str = "",
+        *,
+        limit: int = 8,
+        allowed_workspaces=None,
+    ) -> Dict[str, Any]:
+        target = self._trace_delegate or self._store
+        return target.build_graph_trace(
+            question,
+            graph,
+            context,
+            limit=limit,
+            allowed_workspaces=allowed_workspaces,
+        )
 
     def record_trace(
         self,
@@ -43,7 +197,37 @@ class ChatService:
         trace: Dict[str, Any],
         workspace_id: Optional[str] = None,
     ) -> Dict[str, Any]:
-        return self._store.record_trace(
+        target = self._trace_delegate or self._store
+        return target.record_trace(
+            question=question,
+            response=response,
+            conversation_id=conversation_id,
+            user_email=user_email,
+            trace=trace,
+            workspace_id=workspace_id,
+        )
+
+    async def persist_answer(
+        self,
+        *,
+        question: str,
+        response: str,
+        conversation_id: Optional[str],
+        user_email: Optional[str],
+        user_nickname: Optional[str],
+        source: Optional[str],
+        trace: Dict[str, Any],
+        workspace_id: Optional[str],
+        history_meta: Dict[str, Any],
+        notify: Optional[Callable[[str, str, Optional[str]], None]] = None,
+    ) -> Dict[str, Any]:
+        await self.persist_entry(
+            "assistant",
+            response,
+            history_meta=history_meta,
+            history_user=self.history_user(user_email, user_nickname),
+        )
+        trace_record = self.record_trace(
             question=question,
             response=response,
             conversation_id=conversation_id,
@@ -51,3 +235,9 @@ class ChatService:
             trace=trace,
             workspace_id=workspace_id,
         )
+        if notify is not None:
+            notify("assistant", response, source)
+        return trace_record
+
+
+__all__ = ["ChatService"]