ltcai 5.5.0 → 6.0.0

package/latticeai/services/review_queue.py

@@ -0,0 +1,271 @@
+"""Brain review queue (5.6.0) — the suggestion inbox.
+
+Automation/trigger runs drop drafts here; the user approves, dismisses, snoozes,
+or unsnoozes them. This service owns the *policy* (legal status transitions,
+snooze expiry semantics, run_now back-linking); the store owns persistence.
+
+Design decisions (agreed in #develop-with-openclaw):
+
+* **run_now ≠ approve.** "Run now" is a preview/regenerate action: it executes
+  the underlying workflow but does **not** change ``status``. The fresh run id
+  is back-linked into ``payload.last_run_id`` / ``provenance.run_id`` and
+  ``updated_at`` is bumped. Accepting the result is a separate ``approve``.
+* **Snooze expiry is read-time only.** A snoozed item whose ``snoozed_until``
+  has passed is surfaced with ``effective_status == "pending"``; the stored
+  ``status`` is left untouched (no scheduler mutation in 5.6.0).
+* **Invalid transitions raise** :class:`InvalidReviewTransition` → HTTP 409.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Callable, Dict, Optional
+
+# status: terminal vs. open. Open items can still be acted on.
+OPEN_STATUSES = {"pending", "snoozed"}
+TERMINAL_STATUSES = {"approved", "dismissed"}
+ALL_STATUSES = OPEN_STATUSES | TERMINAL_STATUSES
+
+REVIEW_SOURCES = frozenset({"workflow_run", "trigger", "kg_change_digest"})
+
+# Which source statuses each action is allowed from.
+_ALLOWED_FROM: Dict[str, set] = {
+    "approve": {"pending", "snoozed"},
+    "dismiss": {"pending", "snoozed"},
+    "snooze": {"pending", "snoozed"},
+    # unsnooze only makes sense from a *stored* snoozed state (not pending).
+    "unsnooze": {"snoozed"},
+    # run_now is a preview, not a transition — only while still open.
+    "run_now": {"pending", "snoozed"},
+}
+
+
+def review_queue_opted_in(workflow: Dict[str, Any]) -> bool:
+    """True when the workflow's trigger node opts into the review inbox."""
+    for node in workflow.get("nodes") or []:
+        if node.get("type") != "trigger":
+            continue
+        if (node.get("config") or {}).get("review_queue") is True:
+            return True
+    return False
+
+
+class InvalidReviewTransition(Exception):
+    """Raised when an action is not legal from the item's current status."""
+
+    def __init__(self, action: str, status: str) -> None:
+        self.action = action
+        self.status = status
+        super().__init__(f"cannot {action!r} a review item in status {status!r}")
+
+
+def _parse_iso(value: Optional[str]) -> Optional[datetime]:
+    if not value:
+        return None
+    try:
+        return datetime.fromisoformat(str(value))
+    except (TypeError, ValueError):
+        return None
+
+
+class ReviewQueueService:
+    """Policy layer over the store's workspace-scoped ``review_items``."""
+
+    def __init__(self, *, store: Any, clock: Callable[[], datetime] = datetime.now) -> None:
+        self._store = store
+        self._clock = clock
+
+    # ── creation (also the review_sink entry point) ──────────────────────
+    def create(
+        self,
+        *,
+        title: str,
+        summary: str = "",
+        source: str = "workflow_run",
+        kind: str = "suggestion",
+        payload: Optional[Dict[str, Any]] = None,
+        provenance: Optional[Dict[str, Any]] = None,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        if source not in REVIEW_SOURCES:
+            raise ValueError(f"source must be one of {sorted(REVIEW_SOURCES)}")
+        item = self._store.create_review_item(
+            title=title,
+            summary=summary,
+            source=source,
+            kind=kind,
+            payload=payload,
+            provenance=provenance,
+            user_email=user_email,
+            workspace_id=workspace_id,
+        )
+        return self._view(item)
+
+    def list(
+        self, *, workspace_id: Optional[str] = None, user_email: Optional[str] = None,
+        status: Optional[str] = None, source: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        items = [
+            self._view(it)
+            for it in self._store.list_review_items(
+                workspace_id=workspace_id, user_email=user_email, source=source,
+            )
+        ]
+        if status:
+            # Filter on the *effective* status so an expired snooze reads as pending.
+            items = [it for it in items if it["effective_status"] == status]
+        return {"items": items}
+
+    def get(self, item_id: str, *, workspace_id: Optional[str] = None) -> Dict[str, Any]:
+        return self._view(self._store.get_review_item(item_id, workspace_id=workspace_id))
+
+    # ── transitions ──────────────────────────────────────────────────────
+    def approve(self, item_id: str, *, workspace_id: Optional[str] = None) -> Dict[str, Any]:
+        return self._transition(item_id, "approve", "approved", workspace_id=workspace_id)
+
+    def dismiss(self, item_id: str, *, workspace_id: Optional[str] = None) -> Dict[str, Any]:
+        return self._transition(item_id, "dismiss", "dismissed", workspace_id=workspace_id)
+
+    def snooze(
+        self, item_id: str, *, until: str, workspace_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        item = self._store.get_review_item(item_id, workspace_id=workspace_id)
+        self._guard("snooze", item)
+        updated = self._store.update_review_item(
+            item_id, workspace_id=workspace_id, status="snoozed", snoozed_until=until,
+        )
+        return self._view(updated)
+
+    def unsnooze(self, item_id: str, *, workspace_id: Optional[str] = None) -> Dict[str, Any]:
+        """Return a snoozed item to the pending queue.
+
+        Only legal from a *stored* ``status == "snoozed"`` (an expired snooze is
+        still stored as snoozed, so it remains unsnoozable). Clears the timer and
+        sets ``status = "pending"``; any other source status raises 409.
+        """
+        item = self._store.get_review_item(item_id, workspace_id=workspace_id)
+        self._guard("unsnooze", item)
+        updated = self._store.update_review_item(
+            item_id, workspace_id=workspace_id, status="pending", snoozed_until=None,
+        )
+        return self._view(updated)
+
+    # ── run_now: preview/regenerate, NOT a status change ─────────────────
+    def run_now(
+        self,
+        item_id: str,
+        *,
+        runner: Callable[[Dict[str, Any]], Any],
+        workspace_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Execute the item's underlying workflow and back-link the new run.
+
+        ``status`` is intentionally left untouched — only ``payload.last_run_id``,
+        ``provenance.run_id`` and ``updated_at`` move. ``runner`` receives the raw
+        stored item and must return a run id (str) or a dict carrying one.
+        """
+        item = self._store.get_review_item(item_id, workspace_id=workspace_id)
+        self._guard("run_now", item)
+        run_id = _extract_run_id(runner(item))
+        payload = dict(item.get("payload") or {})
+        provenance = dict(item.get("provenance") or {})
+        if run_id is not None:
+            payload["last_run_id"] = run_id
+            provenance["run_id"] = run_id
+        updated = self._store.update_review_item(
+            item_id, workspace_id=workspace_id, payload=payload, provenance=provenance,
+        )
+        return self._view(updated)
+
+    # ── internals ────────────────────────────────────────────────────────
+    def _transition(
+        self, item_id: str, action: str, new_status: str, *, workspace_id: Optional[str],
+    ) -> Dict[str, Any]:
+        item = self._store.get_review_item(item_id, workspace_id=workspace_id)
+        self._guard(action, item)
+        patch: Dict[str, Any] = {"status": new_status}
+        # Leaving the snooze state clears the timer so it can't resurface later.
+        if item.get("snoozed_until") is not None:
+            patch["snoozed_until"] = None
+        updated = self._store.update_review_item(item_id, workspace_id=workspace_id, **patch)
+        return self._view(updated)
+
+    def _guard(self, action: str, item: Dict[str, Any]) -> None:
+        status = str(item.get("status") or "pending")
+        if status not in _ALLOWED_FROM.get(action, set()):
+            raise InvalidReviewTransition(action, status)
+
+    def _effective_status(self, item: Dict[str, Any]) -> str:
+        """Read-time view: an expired snooze reads as pending (no mutation)."""
+        if str(item.get("status")) != "snoozed":
+            return str(item.get("status") or "pending")
+        until = _parse_iso(item.get("snoozed_until"))
+        if until is not None and until <= self._clock():
+            return "pending"
+        return "snoozed"
+
+    def _view(self, item: Dict[str, Any]) -> Dict[str, Any]:
+        view = dict(item)
+        view["effective_status"] = self._effective_status(item)
+        return view
+
+
+def enqueue_from_automation(
+    sink: "ReviewQueueService",
+    *,
+    workflow: Dict[str, Any],
+    source: str,
+    run_result: Any,
+    trigger_info: Optional[Dict[str, Any]] = None,
+    user_email: Optional[str] = None,
+    workspace_id: Optional[str] = None,
+) -> Optional[Dict[str, Any]]:
+    """Opt-in path: enqueue a review item when the workflow trigger requests it."""
+    if source not in REVIEW_SOURCES:
+        raise ValueError(f"source must be one of {sorted(REVIEW_SOURCES)}")
+    if not review_queue_opted_in(workflow):
+        return None
+    run_id = _extract_run_id(run_result)
+    wf_id = workflow.get("id")
+    provenance: Dict[str, Any] = {"workflow_id": wf_id}
+    if run_id is not None:
+        provenance["run_id"] = run_id
+    if trigger_info:
+        provenance["trigger_id"] = str(trigger_info.get("type") or "")
+        provenance["source_detail"] = str(trigger_info.get("type") or "")
+    return sink.create(
+        title=str(workflow.get("name") or "Automation suggestion"),
+        summary="",
+        source=source,
+        kind="suggestion",
+        payload={"workflow_id": wf_id},
+        provenance=provenance,
+        user_email=user_email,
+        workspace_id=workspace_id,
+    )
+
+
+def _extract_run_id(result: Any) -> Optional[str]:
+    if result is None:
+        return None
+    if isinstance(result, str):
+        return result
+    if isinstance(result, dict):
+        if result.get("run_id"):
+            return str(result["run_id"])
+        run = result.get("run")
+        if isinstance(run, dict) and run.get("id"):
+            return str(run["id"])
+        if result.get("id"):
+            return str(result["id"])
+    return None
+
+
+__all__ = [
+    "ReviewQueueService",
+    "InvalidReviewTransition",
+    "REVIEW_SOURCES",
+    "review_queue_opted_in",
+    "enqueue_from_automation",
+]

package/latticeai/services/run_executor.py

@@ -46,6 +46,7 @@ class RunExecutor:
         workspace_graph: Callable[[], Any],
         append_audit_event: Callable[..., None],
         hooks: Any = None,
+        review_sink: Any = None,
     ) -> None:
         self.store = store
         self.agent_runtime = agent_runtime
@@ -53,6 +54,8 @@ class RunExecutor:
         self.workspace_graph = workspace_graph
         self.append_audit_event = append_audit_event
         self.hooks = hooks
+        # Optional review-queue seam (5.6.0). Default None → no behavior change.
+        self.review_sink = review_sink
         self._handles: Dict[str, _RunHandle] = {}
         self._results: Dict[str, Dict[str, Any]] = {}
 
@@ -234,6 +237,12 @@ class RunExecutor:
                 workflow_id=workflow.get("id"),
                 status=result.status,
             )
+            self._maybe_enqueue_review(
+                workflow,
+                run_result={"run": updated, "result": result.as_dict()},
+                user_email=user_email,
+                workspace_id=handle.scope,
+            )
             self._results[run_id] = {"run": updated, "result": result.as_dict()}
         except Exception as exc:
             run = self.store.get_workflow_run(run_id, workspace_id=handle.scope)
@@ -252,6 +261,30 @@ class RunExecutor:
         finally:
             self._handles.pop(run_id, None)
 
+    def _maybe_enqueue_review(
+        self,
+        workflow: Dict[str, Any],
+        *,
+        run_result: Dict[str, Any],
+        user_email: Optional[str],
+        workspace_id: Optional[str],
+    ) -> None:
+        if self.review_sink is None:
+            return
+        try:
+            from latticeai.services.review_queue import enqueue_from_automation
+
+            enqueue_from_automation(
+                self.review_sink,
+                workflow=workflow,
+                source="workflow_run",
+                run_result=run_result,
+                user_email=user_email,
+                workspace_id=workspace_id,
+            )
+        except Exception:
+            pass
+
     def _execute_workflow_sync(
         self,
         workflow: Dict[str, Any],

package/latticeai/services/triggers.py

@@ -48,9 +48,13 @@ class TriggerService:
         data_dir: Path,
         clock: Callable[[], float] = time.time,
         tick_seconds: float = DEFAULT_TICK_SECONDS,
+        review_sink: Optional[Any] = None,
     ) -> None:
         self._store = store
         self._run_workflow = run_workflow
+        # Optional review-queue seam (5.6.0). When wired, fired runs can drop a
+        # reviewable suggestion into the queue. Default None keeps legacy behavior.
+        self._review_sink = review_sink
         self._state_file = Path(data_dir) / "triggers_state.json"
         self._clock = clock
         self._tick = float(tick_seconds)
@@ -250,14 +254,39 @@ class TriggerService:
     def _fire(self, workflow_id: str, trigger_info: Dict[str, Any]) -> None:
         def _run():
             try:
-                self._run_workflow(workflow_id, {"__trigger__": trigger_info})
+                result = self._run_workflow(workflow_id, {"__trigger__": trigger_info})
                 self._record_fire_outcome(workflow_id, ok=True)
+                self._maybe_enqueue_review(workflow_id, trigger_info, result)
             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 _maybe_enqueue_review(
+        self, workflow_id: str, trigger_info: Dict[str, Any], result: Dict[str, Any],
+    ) -> None:
+        if self._review_sink is None:
+            return
+        try:
+            from latticeai.services.review_queue import enqueue_from_automation
+
+            workflows = list(self._store.load_state().get("workflows") or [])
+            workflow = next((wf for wf in workflows if wf.get("id") == workflow_id), None)
+            if workflow is None:
+                return
+            trigger_type = str(trigger_info.get("type") or "")
+            source = "kg_change_digest" if trigger_type == "brain_event" else "trigger"
+            enqueue_from_automation(
+                self._review_sink,
+                workflow=workflow,
+                source=source,
+                run_result=result,
+                trigger_info=trigger_info,
+            )
+        except Exception as exc:
+            logging.warning("review_sink enqueue failed for %s: %s", workflow_id, exc)
+
     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 자체 실패를 카운트.)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "5.5.0",
+  "version": "6.0.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.5.0"
+version = "6.0.0"
 dependencies = [
  "plist",
  "serde",

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lattice-ai-desktop"
-version = "5.5.0"
+version = "6.0.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.5.0",
+  "version": "6.0.0",
   "identifier": "ai.lattice.desktop",
   "build": {
     "beforeDevCommand": "npm run frontend:dev",

package/static/app/asset-manifest.json

@@ -1,13 +1,13 @@
 {
-  "version": "5.5.0",
+  "version": "6.0.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-C7vzwUjU.js",
-    "assets/index-HN4f2wbe.css": "/static/app/assets/index-HN4f2wbe.css"
+    "index.html": "/static/app/assets/index-D2zafMYb.js",
+    "assets/index-xRn29gI8.css": "/static/app/assets/index-xRn29gI8.css"
   },
   "vite": {
     "../node_modules/@tauri-apps/api/core.js": {
@@ -17,7 +17,7 @@
       "isDynamicEntry": true
     },
     "index.html": {
-      "file": "assets/index-C7vzwUjU.js",
+      "file": "assets/index-D2zafMYb.js",
       "name": "index",
       "src": "index.html",
       "isEntry": true,
@@ -25,7 +25,7 @@
         "../node_modules/@tauri-apps/api/core.js"
       ],
       "css": [
-        "assets/index-HN4f2wbe.css"
+        "assets/index-xRn29gI8.css"
       ]
     }
   }