ltcai 8.9.0 → 9.1.0

package/latticeai/services/memory_service.py

@@ -22,11 +22,12 @@ underlying store, and missing stores surface as ``unavailable``.
 from __future__ import annotations
 
 import json
-from datetime import datetime
+import logging
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from latticeai.core.workspace_os_utils import _file_size
+from latticeai.core.timeutil import now_iso as _now
 
 # Personal workspace memory kinds (from WorkspaceOS.MEMORY_KINDS).
 WORKSPACE_KINDS = (
@@ -40,10 +41,11 @@ WORKSPACE_KINDS = (
 )
 
 TIERS = ("workspace", "project", "agent", "conversation", "graph", "vector")
+LOGGER = logging.getLogger(__name__)
 
 
-def _now() -> str:
-    return datetime.now().isoformat(timespec="seconds")
+class MemoryServiceError(RuntimeError):
+    """Raised when a configured memory backend cannot be read reliably."""
 
 
 class MemoryService:
@@ -70,20 +72,23 @@ class MemoryService:
     def _workspace_memories(self, *, user_email: Optional[str], workspace_id: Optional[str]) -> List[Dict[str, Any]]:
         try:
             return list(self._store.list_memories(user_email=user_email, workspace_id=workspace_id).get("memories", []))
-        except Exception:
-            return []
+        except Exception as exc:
+            LOGGER.exception("workspace memory read failed")
+            raise MemoryServiceError("workspace memory backend unavailable") from exc
 
     def _all_memories(self) -> List[Dict[str, Any]]:
         try:
             return list(self._store.list_memories().get("memories", []))
-        except Exception:
-            return []
+        except Exception as exc:
+            LOGGER.exception("global memory read failed")
+            raise MemoryServiceError("memory backend unavailable") from exc
 
     def _snapshots(self, *, workspace_id: Optional[str]) -> List[Dict[str, Any]]:
         try:
             return list(self._store.list_memory_snapshots(workspace_id=workspace_id, limit=200).get("snapshots", []))
-        except Exception:
-            return []
+        except Exception as exc:
+            LOGGER.exception("memory snapshot read failed")
+            raise MemoryServiceError("memory snapshot backend unavailable") from exc
 
     def _conversations(self) -> List[Dict[str, Any]]:
         if self._conversation_store is not None:
@@ -92,15 +97,17 @@ class MemoryService:
                 for item in self._conversation_store.history():
                     grouped.setdefault(item.get("conversation_id") or "legacy-previous-history", []).append(item)
                 return [{"id": conv_id, "messages": msgs} for conv_id, msgs in grouped.items()]
-            except Exception:
-                return []
+            except Exception as exc:
+                LOGGER.exception("conversation store read failed")
+                raise MemoryServiceError("conversation backend unavailable") from exc
         if not self._history_file.exists():
             return []
         try:
             with open(self._history_file, "r", encoding="utf-8") as fh:
                 data = json.load(fh)
-        except Exception:
-            return []
+        except (OSError, json.JSONDecodeError, TypeError, ValueError) as exc:
+            LOGGER.exception("legacy conversation history read failed")
+            raise MemoryServiceError("conversation history is unreadable") from exc
         if isinstance(data, dict):
             convs = data.get("conversations")
             if isinstance(convs, list):
@@ -136,6 +143,7 @@ class MemoryService:
         try:
             return self._kg.stats()
         except Exception:
+            LOGGER.exception("knowledge graph stats read failed")
             return None
 
     def _kg_index(self) -> Optional[Dict[str, Any]]:
@@ -144,6 +152,7 @@ class MemoryService:
         try:
             return self._kg.index_status()
         except Exception:
+            LOGGER.exception("knowledge graph index status read failed")
             return None
 
     # ── Memory Manager: sources / usage / health ──────────────────────────
@@ -271,6 +280,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 +294,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 +365,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 +388,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 +546,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,
         *,
@@ -634,9 +856,12 @@ class MemoryService:
 
         results: List[Dict[str, Any]] = []
 
+        errors: List[Dict[str, str]] = []
         try:
             mem = self._store.search_memories(q, user_email=user_email, limit=limit, workspace_id=workspace_id).get("memories", [])
-        except Exception:
+        except Exception as exc:
+            LOGGER.exception("workspace memory search failed")
+            errors.append({"source": "workspace", "detail": str(exc)})
             mem = []
         for m in mem:
             matched = _matched_terms(m.get("content"), " ".join(m.get("tags") or []), m.get("kind"))
@@ -654,8 +879,15 @@ class MemoryService:
         if self._enable_graph and q:
             try:
                 # KnowledgeGraph.search returns {"query": ..., "matches": [...]}.
-                hits = self._kg.search(q, limit).get("matches", [])
-            except Exception:
+                search_kwargs = (
+                    {"allowed_workspaces": {workspace_id}}
+                    if workspace_id is not None
+                    else {}
+                )
+                hits = self._kg.search(q, limit, **search_kwargs).get("matches", [])
+            except Exception as exc:
+                LOGGER.exception("knowledge graph memory search failed")
+                errors.append({"source": "graph", "detail": str(exc)})
                 hits = []
             for hit in hits[:limit]:
                 matched = _matched_terms(hit.get("title"), hit.get("name"), hit.get("summary"), hit.get("content"))
@@ -685,6 +917,8 @@ class MemoryService:
             "results": results[: max(1, min(limit, 100))],
             "count": len(results),
             "source": "live",
+            "status": "degraded" if errors else "ok",
+            "errors": errors,
             "quality_gate": {
                 "candidates": candidates,
                 "passed": len(results),
@@ -736,6 +970,7 @@ class MemoryService:
             if m.get("id")
         }
         removed: List[str] = []
+        failed: List[Dict[str, str]] = []
         skipped: List[str] = []
         target_ids: List[str] = []
         seen: set = set()
@@ -756,11 +991,15 @@ class MemoryService:
             try:
                 self._store.delete_memory(mid)
                 removed.append(mid)
-            except Exception:
-                continue
+            except Exception as exc:
+                LOGGER.exception("memory deletion failed for %s", mid)
+                failed.append({"id": mid, "detail": str(exc)})
         result: Dict[str, Any] = {"removed": removed, "count": len(removed)}
         if skipped:
             result["skipped"] = skipped
+        if failed:
+            result["failed"] = failed
+            result["status"] = "partial" if removed else "error"
         return result
 
     def compact(
@@ -772,6 +1011,7 @@ class MemoryService:
         """Dedupe workspace memories with identical (kind, content)."""
         seen: set = set()
         removed: List[str] = []
+        failed: List[Dict[str, str]] = []
         # Oldest first so the first occurrence (oldest) is kept.
         memories = list(reversed(self._workspace_memories(user_email=user_email, workspace_id=workspace_id)))
         for m in memories:
@@ -781,11 +1021,18 @@ class MemoryService:
                     try:
                         self._store.delete_memory(m["id"])
                         removed.append(m["id"])
-                    except Exception:
-                        continue
+                    except Exception as exc:
+                        LOGGER.exception("memory compaction deletion failed for %s", m["id"])
+                        failed.append({"id": m["id"], "detail": str(exc)})
             else:
                 seen.add(key)
-        return {"compacted": len(removed), "removed": removed, "remaining": len(seen)}
+        return {
+            "compacted": len(removed),
+            "removed": removed,
+            "remaining": len(seen),
+            "failed": failed,
+            "status": "partial" if failed and removed else "error" if failed else "ok",
+        }
 
     def rebuild(self, target: str = "vector") -> Dict[str, Any]:
         if target in {"vector", "index", "vector_index"}: