ltcai 5.3.0 → 5.5.0

package/latticeai/services/brain_automation.py

@@ -0,0 +1,214 @@
+"""Consent-first Brain automation recipes.
+
+The recipes here are product-level starter workflows, not hidden background
+jobs. Installing one creates a disabled draft workflow so the user can inspect
+and enable it deliberately.
+"""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+
+@dataclass(frozen=True)
+class BrainAutomationRecipe:
+    id: str
+    name: str
+    summary: str
+    user_value: str
+    cadence: str
+    trigger: Dict[str, Any]
+    prompt: str
+    creates: List[str]
+
+    def as_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "summary": self.summary,
+            "user_value": self.user_value,
+            "cadence": self.cadence,
+            "trigger": deepcopy(self.trigger),
+            "creates": list(self.creates),
+            "consent": {
+                "default_state": "draft_disabled",
+                "local_only": True,
+                "external_actions": False,
+                "requires_user_enable": True,
+                "review_before_run": True,
+            },
+        }
+
+
+_RECIPES: List[BrainAutomationRecipe] = [
+    BrainAutomationRecipe(
+        id="daily-memory-digest",
+        name="Daily Memory Digest",
+        summary="Collects the day's new memories into a short review draft.",
+        user_value="Users see what the Brain kept today without searching through chats.",
+        cadence="daily",
+        trigger={"trigger": "interval", "interval_seconds": 86_400},
+        prompt=(
+            "Review today's new Brain memories and draft a concise digest with "
+            "important decisions, unresolved questions, and suggested next actions. "
+            "Do not contact external services."
+        ),
+        creates=["memory digest", "decision summary", "next-action suggestions"],
+    ),
+    BrainAutomationRecipe(
+        id="weekly-project-review",
+        name="Weekly Project Review",
+        summary="Turns project context into a weekly checkpoint draft.",
+        user_value="Users can restart a project without explaining the week again.",
+        cadence="weekly",
+        trigger={"trigger": "interval", "interval_seconds": 604_800},
+        prompt=(
+            "Review this workspace's recent memories, workflow runs, and decisions. "
+            "Draft a project checkpoint with progress, risks, blockers, and next steps. "
+            "Keep it local and ask before any external action."
+        ),
+        creates=["project checkpoint", "risk list", "next-week plan"],
+    ),
+    BrainAutomationRecipe(
+        id="follow-up-radar",
+        name="Follow-up Radar",
+        summary="Looks for follow-up candidates when new knowledge enters the Brain.",
+        user_value="Users get gentle reminders for loose ends without a noisy task system.",
+        cadence="when new memory is saved",
+        trigger={"trigger": "brain_event"},
+        prompt=(
+            "Inspect the new Brain memory for follow-up signals such as decisions, "
+            "promises, deadlines, unresolved questions, or 'later' language. "
+            "Return suggestions only; do not create tasks without approval."
+        ),
+        creates=["follow-up suggestions", "open-question list", "approval-ready task drafts"],
+    ),
+]
+
+_RECIPE_BY_ID = {recipe.id: recipe for recipe in _RECIPES}
+
+
+def list_brain_automation_recipes() -> Dict[str, Any]:
+    """Return user-facing, consent-first automation recipe metadata."""
+    return {
+        "recipes": [recipe.as_dict() for recipe in _RECIPES],
+        "principles": {
+            "local_first": True,
+            "drafts_before_automation": True,
+            "no_external_actions_without_consent": True,
+        },
+    }
+
+
+def find_installed_recipe_workflow(
+    workflows: Any, recipe_id: str
+) -> Dict[str, Any] | None:
+    """Return an existing draft installed from ``recipe_id``, if any.
+
+    Installing a recipe is idempotent: clicking "Create reviewable draft" twice
+    should surface the existing draft instead of accumulating duplicates. We
+    match on the ``brain_automation_recipe`` provenance metadata stamped by
+    :func:`build_brain_automation_workflow`.
+    """
+    for workflow in workflows or []:
+        metadata = (workflow or {}).get("metadata") or {}
+        if (
+            metadata.get("created_from") == "brain_automation_recipe"
+            and metadata.get("recipe_id") == recipe_id
+        ):
+            return workflow
+    return None
+
+
+def build_brain_automation_workflow(recipe_id: str, *, enabled: bool = False) -> Dict[str, Any]:
+    """Build a workflow definition for a recipe.
+
+    ``enabled`` defaults to ``False`` so installing a recipe creates an
+    inspectable draft. The trigger service treats explicit ``enabled: false`` as
+    disarmed, while legacy workflows without the field keep their behavior.
+    """
+    recipe = _RECIPE_BY_ID.get(recipe_id)
+    if recipe is None:
+        raise KeyError(recipe_id)
+
+    trigger_config = {
+        **deepcopy(recipe.trigger),
+        "enabled": bool(enabled),
+        "consent_required": True,
+        "local_only": True,
+        "external_actions": False,
+    }
+    return {
+        "name": recipe.name,
+        "nodes": [
+            {
+                "id": "trigger",
+                "type": "trigger",
+                "name": "User-enabled schedule" if recipe.trigger["trigger"] == "interval" else "New Brain memory",
+                "config": trigger_config,
+                "next": "draft",
+            },
+            {
+                "id": "draft",
+                "type": "agent",
+                "name": "Draft Brain review",
+                "config": {
+                    "agent": "agent:planner",
+                    "prompt": recipe.prompt,
+                    "mode": "draft",
+                    "local_only": True,
+                    "external_actions": False,
+                    "requires_review": True,
+                },
+                "next": "output",
+            },
+            {
+                "id": "output",
+                "type": "output",
+                "name": "Review before saving",
+                "config": {
+                    "value": "Draft ready for review. Save, edit, or discard it before it becomes durable memory.",
+                },
+                "next": None,
+            },
+        ],
+        "metadata": {
+            "created_from": "brain_automation_recipe",
+            "recipe_id": recipe.id,
+            "recipe_summary": recipe.summary,
+            "recipe_user_value": recipe.user_value,
+            "automation_state": "enabled" if enabled else "draft_disabled",
+            "local_only": True,
+            "external_actions": False,
+            "requires_user_enable": not enabled,
+            "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/triggers.py

@@ -20,11 +20,17 @@ from __future__ import annotations
 
 import json
 import logging
+import os
 import threading
 import time
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional
 
+try:
+    from zoneinfo import ZoneInfo
+except Exception:  # pragma: no cover
+    ZoneInfo = None  # type: ignore
+
 DEFAULT_TICK_SECONDS = 5.0
 MIN_INTERVAL_SECONDS = 60
 
@@ -51,6 +57,15 @@ class TriggerService:
         self._stop_event = threading.Event()
         self._thread: Optional[threading.Thread] = None
         self._lock = threading.Lock()
+        # LATTICE_TZ: wall-clock / display 용. interval 계산은 여전히 unix seconds (duration 기반, drift 방지).
+        # describe()와 이벤트에 tz 정보 노출. calendar "daily at HH:MM" semantics 는 추후 cron 확장 시 사용.
+        self._tz_name = os.environ.get("LATTICE_TZ") or "UTC"
+        self._tz = None
+        if ZoneInfo is not None:
+            try:
+                self._tz = ZoneInfo(self._tz_name)
+            except Exception:
+                self._tz = ZoneInfo("UTC") if ZoneInfo else None
 
     # ── durable state ──────────────────────────────────────────────────────
     def _load_state(self) -> Dict[str, Any]:
@@ -86,27 +101,37 @@ class TriggerService:
                     continue
                 cfg = node.get("config") or {}
                 kind = str(cfg.get("trigger") or "manual")
+                if cfg.get("enabled") is False:
+                    continue
                 if kind in ("interval", "brain_event"):
                     found.append({"workflow": wf, "node": node, "kind": kind, "config": cfg})
         return found
 
     def describe(self) -> Dict[str, Any]:
-        """Honest status surface: what is armed, when it last fired/skipped."""
+        """Honest status surface: what is armed, when it last fired/skipped.
+        Includes LATTICE_TZ, per-trigger status (armed|degraded), consecutive_failures.
+        """
         state = self._load_state()
         armed = []
         for item in self._triggered_workflows():
             wf_id = item["workflow"].get("id")
+            entry = state.get(wf_id) or {}
+            fails = int(entry.get("consecutive_failures", 0))
+            status = "degraded" if fails >= 3 else "armed"
             armed.append({
                 "workflow_id": wf_id,
                 "name": item["workflow"].get("name"),
                 "kind": item["kind"],
                 "config": {k: v for k, v in item["config"].items() if k != "trigger"},
-                "last_fired_at": (state.get(wf_id) or {}).get("last_fired_at"),
-                "recent_events": (state.get(wf_id) or {}).get("events", [])[-5:],
+                "last_fired_at": entry.get("last_fired_at"),
+                "status": status,
+                "consecutive_failures": fails,
+                "recent_events": entry.get("events", [])[-5:],
             })
         return {
             "running": bool(self._thread and self._thread.is_alive()),
             "tick_seconds": self._tick,
+            "tz": self._tz_name,
             "armed": armed,
         }
 
@@ -133,6 +158,7 @@ class TriggerService:
                     skipped += missed
                 # Reset the cadence from now — no catch-up storm.
                 entry["last_fired_at"] = now if last is not None else entry.get("last_fired_at")
+                entry["last_attempt_at"] = now
             self._save_state(state)
         return skipped
 
@@ -152,9 +178,16 @@ class TriggerService:
                 if last is None:
                     # First sighting arms the schedule; it fires one interval later.
                     entry["last_fired_at"] = now
+                    entry["last_attempt_at"] = now
                     continue
                 if now - float(last) < interval:
                     continue
+                # Dedup guard (edge case): short cooldown + last_attempt prevents rapid re-fire on
+                # clock skew, tick jitter, or restart races. Interval 자체 + 이 가드로 중복 실행 방지.
+                last_attempt = float(entry.get("last_attempt_at") or 0)
+                if now - last_attempt < 10:
+                    continue
+                entry["last_attempt_at"] = now
                 entry["last_fired_at"] = now
                 self._record_event(state, wf_id, {"type": "fired", "trigger": "interval"})
                 fired += 1
@@ -181,7 +214,14 @@ class TriggerService:
                 if wanted and wanted != source_type:
                     continue
                 wf_id = item["workflow"].get("id")
-                state.setdefault(wf_id, {})["last_fired_at"] = self._clock()
+                entry = state.setdefault(wf_id, {})
+                now = self._clock()
+                # Dedup guard for brain_event too (rapid ingest burst 등).
+                last_attempt = float(entry.get("last_attempt_at") or 0)
+                if now - last_attempt < 5:
+                    continue
+                entry["last_attempt_at"] = now
+                entry["last_fired_at"] = now
                 self._record_event(state, wf_id, {
                     "type": "fired", "trigger": "brain_event", "source_type": source_type,
                 })
@@ -211,11 +251,28 @@ class TriggerService:
         def _run():
             try:
                 self._run_workflow(workflow_id, {"__trigger__": trigger_info})
+                self._record_fire_outcome(workflow_id, ok=True)
             except Exception as exc:
                 logging.warning("trigger run failed for %s: %s", workflow_id, exc)
+                self._record_fire_outcome(workflow_id, ok=False, detail=str(exc))
 
         threading.Thread(target=_run, name=f"trigger-{workflow_id}", daemon=True).start()
 
+    def _record_fire_outcome(self, wf_id: str, *, ok: bool, detail: str = "") -> None:
+        """Track consecutive launch failures for degraded status in describe().
+        (Deep execution failures are visible via workflow run records; 여기서는 scheduler fire 자체 실패를 카운트.)
+        """
+        with self._lock:
+            state = self._load_state()
+            entry = state.setdefault(wf_id, {})
+            if ok:
+                entry["consecutive_failures"] = 0
+            else:
+                fails = int(entry.get("consecutive_failures", 0)) + 1
+                entry["consecutive_failures"] = fails
+                self._record_event(state, wf_id, {"type": "failed", "detail": detail[:200]})
+            self._save_state(state)
+
     def start(self) -> None:
         if self._thread and self._thread.is_alive():
             return

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "5.3.0",
+  "version": "5.5.0",
   "description": "Lattice AI — local-first Digital Brain that keeps your knowledge durable across any AI model.",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {

package/src-tauri/Cargo.lock

@@ -1654,7 +1654,7 @@ dependencies = [
 
 [[package]]
 name = "lattice-ai-desktop"
-version = "5.3.0"
+version = "5.5.0"
 dependencies = [
  "plist",
  "serde",

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lattice-ai-desktop"
-version = "5.3.0"
+version = "5.5.0"
 description = "Lattice AI Digital Brain desktop shell"
 authors = ["TaeSoo Park"]
 edition = "2021"

package/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Lattice AI",
-  "version": "5.3.0",
+  "version": "5.5.0",
   "identifier": "ai.lattice.desktop",
   "build": {
     "beforeDevCommand": "npm run frontend:dev",

package/static/app/asset-manifest.json

@@ -1,13 +1,13 @@
 {
-  "version": "5.3.0",
+  "version": "5.5.0",
   "generated_at": "vite",
   "entrypoints": {
     "app": "/static/app/index.html"
   },
   "assets": {
     "../node_modules/@tauri-apps/api/core.js": "/static/app/assets/core-CwxXejkd.js",
-    "index.html": "/static/app/assets/index-sOXTFUQc.js",
-    "assets/index-CQmHhk8Q.css": "/static/app/assets/index-CQmHhk8Q.css"
+    "index.html": "/static/app/assets/index-C7vzwUjU.js",
+    "assets/index-HN4f2wbe.css": "/static/app/assets/index-HN4f2wbe.css"
   },
   "vite": {
     "../node_modules/@tauri-apps/api/core.js": {
@@ -17,7 +17,7 @@
       "isDynamicEntry": true
     },
     "index.html": {
-      "file": "assets/index-sOXTFUQc.js",
+      "file": "assets/index-C7vzwUjU.js",
       "name": "index",
       "src": "index.html",
       "isEntry": true,
@@ -25,7 +25,7 @@
         "../node_modules/@tauri-apps/api/core.js"
       ],
       "css": [
-        "assets/index-CQmHhk8Q.css"
+        "assets/index-HN4f2wbe.css"
       ]
     }
   }