ltcai 11.5.2 → 11.7.0

package/latticeai/services/brain_automation.py

@@ -1,191 +0,0 @@
-"""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),
-        "review_queue": True,
-        "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",
-                    "goal": recipe.prompt,
-                    "prompt": recipe.prompt,
-                    "roles": ["researcher", "planner", "executor", "reviewer"],
-                    "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),
-        },
-    }

package/latticeai/services/brain_intelligence/__init__.py

@@ -1,58 +0,0 @@
-"""Proactive Brain Intelligence service (v9.3.0).
-
-The Brain graduates from a passive store to an active steward of its own
-knowledge. This service wires the previously dormant quality layer
-(:mod:`lattice_brain.quality` — dedupe, merge, conflict and temporal
-contradiction detection, retention) into router-facing capabilities:
-
-* **health_report** — scored diagnosis of the Brain across freshness,
-  connectivity, embedding coverage, and contradiction pressure, with
-  recommended next actions. Every number is read from the live stores;
-  a missing store degrades the dimension to ``unavailable``, never a guess.
-* **insights** — a proactive digest: recent knowledge growth, most active
-  types, stale knowledge, orphan (disconnected) nodes, and suggested
-  questions grounded in real node titles.
-* **contradictions** — surfaced conflicts across workspace memories
-  (negation/preference conflicts, temporal contradictions) plus explicit
-  CONTRADICTS edges already recorded in the graph.
-* **consolidate** — duplicate-memory and duplicate-edge detection. Dry-run
-  by default (consent-first, like every Brain automation); ``apply=True``
-  prunes only exact duplicate workspace memories through the audited
-  MemoryService path and never touches graph content.
-
-Pure service: no FastAPI, no globals. Collaborators are injected.
-
-Split into cohesive submodules in v11.3.0 (no behaviour change): ``constants``
-(windows + the two shared readings), ``proposals`` (the review-queue path and
-the proactive brief), ``sampling`` (the shared graph slice and memory read),
-``health`` (the scored diagnosis and vector freshness), ``digest`` (insights,
-garden, graph-layer quality reads), ``consistency`` (contradiction and
-consolidation scans), and ``service`` (the composed class). This module
-re-exports every name the single file exposed, so
-``latticeai.services.brain_intelligence.X`` keeps working.
-
-Stubbing note: rebinding one of these *here* changes only this module's name.
-The submodule that calls it holds its own reference, so a test standing in for
-``LOGGER`` or ``_parse_ts`` patches the submodule that uses it.
-"""
-
-from __future__ import annotations
-
-from lattice_brain.quality import GraphEdgeQualityManager as GraphEdgeQualityManager
-from lattice_brain.quality import MemoryQualityManager as MemoryQualityManager
-
-# noqa on the next line, not a redundant alias: the single file exposed this
-# name *renamed* (``brain_intelligence._now``), and reproducing that surface
-# exactly is the point — importing it as ``now_iso`` would add a name the
-# module never had.
-from latticeai.core.timeutil import now_iso as _now  # noqa: F401
-
-from .constants import _GRAPH_SAMPLE_LIMIT as _GRAPH_SAMPLE_LIMIT
-from .constants import _RECENT_DAYS as _RECENT_DAYS
-from .constants import _STALE_DAYS as _STALE_DAYS
-from .constants import LOGGER as LOGGER
-from .constants import _no_graph_reason as _no_graph_reason
-from .constants import _parse_ts as _parse_ts
-from .service import BrainIntelligenceService as BrainIntelligenceService
-
-__all__ = ["BrainIntelligenceService"]

package/latticeai/services/brain_intelligence/_contract.py

@@ -1,71 +0,0 @@
-"""The seam the Brain Intelligence mixins share.
-
-``BrainIntelligenceService`` is assembled from the proposal, sampling, health,
-digest and consistency mixins. Each reads constructor state it does not own,
-and several call methods another mixin implements — ``_graph_sample`` feeds
-almost everything, ``_proactive`` gates the graph-layer surfaces, and the
-garden view composes the contradiction scan. That contract existed as an
-unwritten convention inside one class; this module writes it down.
-
-Typing-only, exactly like :mod:`lattice_brain.portability._contract`: every
-body below is a bare ``raise NotImplementedError`` that the composed class
-always overrides, so the MRO and every method resolution stay what the
-single-file class had. Adding a cross-mixin call without declaring it here is a
-type error.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-
-class BrainIntelligenceCore:
-    """What any Brain Intelligence mixin may assume about ``self``.
-
-    Members are declared, not implemented: the implementation lives in
-    ``service.py`` (constructor state) or in whichever mixin owns the method.
-    """
-
-    # ── State owned by BrainIntelligenceService.__init__ ─────────────────────
-    _kg: Any
-    _memory: Any
-    _enable_graph: bool
-    _memory_quality: Any
-    _edge_quality: Any
-    _proactive_brain: Any
-    _review_queue_service: Any
-    _synthesizer: Any
-
-    # ── proposals.py: the review-queue seam every write door goes through ────
-    def _review_queue(self) -> Any:
-        raise NotImplementedError
-
-    def _synthesis(self) -> Any:
-        raise NotImplementedError
-
-    @staticmethod
-    def _no_queue(detail: str) -> Dict[str, Any]:
-        raise NotImplementedError
-
-    def importance_report(
-        self, *, user_email: Optional[str] = None, workspace_id: Optional[str] = None
-    ) -> Dict[str, Any]:
-        raise NotImplementedError
-
-    # ── sampling.py: the graph slice and the memory tier ─────────────────────
-    def _proactive(self) -> Any:
-        raise NotImplementedError
-
-    def _graph_sample(self, *, workspace_id: Optional[str]) -> Dict[str, Any]:
-        raise NotImplementedError
-
-    def _workspace_memories(
-        self, *, user_email: Optional[str], workspace_id: Optional[str]
-    ) -> List[Dict[str, Any]]:
-        raise NotImplementedError
-
-    # ── consistency.py: what the garden view composes ────────────────────────
-    def contradictions(
-        self, *, user_email: Optional[str] = None, workspace_id: Optional[str] = None
-    ) -> Dict[str, Any]:
-        raise NotImplementedError

package/latticeai/services/brain_intelligence/consistency.py

@@ -1,193 +0,0 @@
-"""What the Brain disagrees with itself about, and what it says twice.
-
-Two scans that wire the previously dormant quality layer
-(:mod:`lattice_brain.quality`) to real stores:
-
-* :meth:`contradictions` — four independent signals in one list: negation and
-  preference conflicts between workspace memories, temporal contradictions,
-  explicit ``CONTRADICTS`` edges already recorded in the graph, and the graph
-  layer's own node-content detector. Each item carries the signal that found
-  it, so a reviewer can weigh them differently.
-* :meth:`consolidate` — duplicate memories and duplicate edges. Dry-run by
-  default, consent-first like every Brain automation. ``apply=True`` prunes
-  only exact duplicate *workspace memories*, through the audited MemoryService
-  path; graph content is never mutated here — the node merge plan is surfaced
-  for a governed apply path to adopt.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-from latticeai.core.timeutil import now_iso as _now
-
-from ._contract import BrainIntelligenceCore as _Core
-from .constants import LOGGER
-
-
-class BrainConsistencyMixin(_Core):
-    """Contradiction and consolidation scans. Mixed into the service."""
-
-    # ── contradictions ───────────────────────────────────────────────────
-
-    def contradictions(
-        self, *, user_email: Optional[str] = None, workspace_id: Optional[str] = None
-    ) -> Dict[str, Any]:
-        memories = self._workspace_memories(user_email=user_email, workspace_id=workspace_id)
-        memory_rows = [
-            {
-                "id": str(m.get("id") or f"mem-{i}"),
-                "content": str(m.get("content") or ""),
-                "score": 0.6,
-                "source": "workspace",
-                "timestamp": m.get("created_at") or m.get("timestamp") or 0,
-            }
-            for i, m in enumerate(memories)
-            if str(m.get("content") or "").strip()
-        ]
-
-        conflicts: List[Dict[str, Any]] = []
-        candidates = self._memory_quality.extract_candidates(memory_rows)
-        for candidate in self._memory_quality.detect_conflicts(candidates):
-            pair_conflicts = [c for c in candidate.conflicts if c.startswith("conflict:contradicts:")]
-            for marker in pair_conflicts:
-                other_id = marker.rsplit(":", 1)[-1]
-                if any(
-                    c["kind"] == "memory_pair"
-                    and {c["left_id"], c["right_id"]} == {candidate.id, other_id}
-                    for c in conflicts
-                ):
-                    continue
-                other: Dict[str, Any] | None = next(
-                    (r for r in memory_rows if r["id"] == other_id), None
-                )
-                conflicts.append({
-                    "kind": "memory_pair",
-                    "left_id": candidate.id,
-                    "left_content": candidate.content[:200],
-                    "right_id": other_id,
-                    "right_content": (other or {}).get("content", "")[:200],
-                    "signal": "preference_negation",
-                })
-
-        temporal = self._memory_quality.detect_temporal_contradictions(memory_rows)
-        temporal_items = [
-            {
-                "kind": "temporal",
-                "id": item.get("id"),
-                "content": str(item.get("content") or "")[:200],
-                "signal": item.get("proactive_flag"),
-            }
-            for item in temporal
-        ]
-
-        edge_items: List[Dict[str, Any]] = []
-        sample = self._graph_sample(workspace_id=workspace_id)
-        for edge in sample["edges"]:
-            if "CONTRADICT" in str(edge.get("type") or "").upper():
-                edge_items.append({
-                    "kind": "graph_edge",
-                    "id": edge.get("id"),
-                    "source": edge.get("source") or edge.get("from_node"),
-                    "target": edge.get("target") or edge.get("to_node"),
-                    "signal": "contradicts_edge",
-                })
-
-        # v9.6.x additive: graph-layer node-content contradictions (proactive
-        # detector over node title/summary), on top of the memory + edge scans.
-        graph_pair_items: List[Dict[str, Any]] = []
-        proactive = self._proactive()
-        if proactive is not None:
-            try:
-                graph_result = proactive.detect_contradictions(workspace_id=workspace_id)
-                graph_pair_items = [
-                    {"kind": "graph_node_pair", **pair}
-                    for pair in graph_result.get("node_pairs") or []
-                ]
-            except Exception:
-                LOGGER.exception("graph contradiction scan failed")
-
-        items = conflicts + temporal_items + edge_items + graph_pair_items
-        return {
-            "items": items,
-            "count": len(items),
-            "sources": {
-                "memory_pairs": len(conflicts),
-                "temporal": len(temporal_items),
-                "graph_edges": len(edge_items),
-                "graph_node_pairs": len(graph_pair_items),
-            },
-            "memories_scanned": len(memory_rows),
-            "generated_at": _now(),
-        }
-
-    # ── consolidation ────────────────────────────────────────────────────
-
-    def consolidate(
-        self,
-        *,
-        apply: bool = False,
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        memories = self._workspace_memories(user_email=user_email, workspace_id=workspace_id)
-        memory_rows = [
-            {
-                "id": str(m.get("id") or f"mem-{i}"),
-                "content": str(m.get("content") or ""),
-                "score": 0.6,
-                "source": "workspace",
-            }
-            for i, m in enumerate(memories)
-            if str(m.get("content") or "").strip()
-        ]
-        candidates = self._memory_quality.extract_candidates(memory_rows)
-        kept = self._memory_quality.dedupe(candidates)
-        kept_ids = {c.id for c in kept}
-        duplicate_memory_ids = [c.id for c in candidates if c.id not in kept_ids]
-
-        sample = self._graph_sample(workspace_id=workspace_id)
-        duplicate_edge_ids = [
-            edge_id
-            for edge_id in self._edge_quality.detect_duplicate_edges(sample["edges"])
-            if edge_id
-        ]
-
-        pruned = 0
-        if apply and duplicate_memory_ids and self._memory is not None:
-            try:
-                result = self._memory.prune(
-                    ids=duplicate_memory_ids,
-                    user_email=user_email,
-                    workspace_id=workspace_id,
-                )
-                pruned = int(result.get("count") or 0)
-            except Exception:
-                LOGGER.exception("consolidation prune failed")
-
-        # v9.6.x additive: graph-layer node merge plan. Always dry-run from
-        # this service — graph content changes stay proposal-first; the plan
-        # is surfaced so a governed apply path can adopt it later.
-        graph_consolidation: Optional[Dict[str, Any]] = None
-        proactive = self._proactive()
-        if proactive is not None:
-            try:
-                graph_consolidation = proactive.consolidate_duplicates(
-                    workspace_id=workspace_id, dry_run=True
-                )
-            except Exception:
-                LOGGER.exception("graph consolidation plan failed")
-
-        return {
-            "mode": "applied" if apply else "dry_run",
-            "memories_scanned": len(memory_rows),
-            "duplicate_memories": duplicate_memory_ids,
-            "duplicate_memory_count": len(duplicate_memory_ids),
-            "pruned": pruned,
-            # Graph edges are reported for review only; consolidation never
-            # mutates graph content directly.
-            "duplicate_edges": duplicate_edge_ids[:50],
-            "duplicate_edge_count": len(duplicate_edge_ids),
-            "graph_consolidation": graph_consolidation,
-            "generated_at": _now(),
-        }

package/latticeai/services/brain_intelligence/constants.py

@@ -1,47 +0,0 @@
-"""Windows, sample sizes, and the two readings every surface shares.
-
-Leaf module: literals and pure functions only, no service and no store. The
-health report, the insights digest, the garden and the contradiction scan all
-measure against the same windows, which is what makes their numbers
-comparable.
-"""
-
-from __future__ import annotations
-
-import logging
-from datetime import datetime, timezone
-from typing import Any, Optional
-
-LOGGER = logging.getLogger(__name__)
-
-_STALE_DAYS = 45
-_RECENT_DAYS = 7
-_GRAPH_SAMPLE_LIMIT = 800
-
-
-def _parse_ts(value: Any) -> Optional[datetime]:
-    text = str(value or "").strip()
-    if not text:
-        return None
-    try:
-        parsed = datetime.fromisoformat(text.replace("Z", "+00:00"))
-    except ValueError:
-        return None
-    if parsed.tzinfo is None:
-        parsed = parsed.replace(tzinfo=timezone.utc)
-    return parsed
-
-
-def _no_graph_reason(graph_available: bool) -> str:
-    """Why a graph-derived health dimension has nothing to say.
-
-    Two different situations that both end in ``status: "unavailable"``: the
-    graph could not be read at all, and the graph read fine but holds nothing
-    yet. Telling them apart is the difference between "something is broken"
-    and "you have not saved anything yet".
-    """
-    return (
-        "no knowledge saved yet"
-        if graph_available
-        else "the knowledge graph could not be read"
-    )