ltcai 11.5.2 → 11.6.0

package/latticeai/services/memory_service/manager.py

@@ -1,186 +0,0 @@
-"""The Memory Manager: one cross-tier report over every backing store.
-
-:meth:`manager` is the service's centre of gravity — sources, counts, sizes,
-health and the Brain readiness signal in a single read that the brief, the
-proof and the API all build on. Nothing here is estimated: a tier with no
-backing reports ``unavailable`` and contributes ``None``, never a zero dressed
-up as a measurement.
-
-``_brain_readiness`` lives here rather than in the frontend so the growth score
-is auditable and the Memory Manager stays the single owner of cross-tier
-signals.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-from latticeai.core.timeutil import now_iso as _now
-from latticeai.core.workspace_os_utils import _file_size
-
-from ._contract import MemoryCore as _Core
-from .constants import TIERS
-
-
-class MemoryManagerMixin(_Core):
-    """Sources / usage / health. Mixed into ``MemoryService``."""
-
-    # ── Memory Manager: sources / usage / health ──────────────────────────
-    def _brain_readiness(
-        self,
-        *,
-        memory_count: int,
-        concept_count: Optional[int],
-        relationship_count: Optional[int],
-        healthy_sources: int,
-    ) -> Dict[str, Any]:
-        """Summarize how ready the user's Brain is for the product UI.
-
-        The frontend should render this signal instead of re-deriving it from
-        UI fragments. Keeping it here makes the score auditable and keeps the
-        Memory Manager as the single owner of cross-tier Brain growth signals.
-        """
-        concepts = max(0, int(concept_count or 0))
-        relationships = max(0, int(relationship_count or 0))
-        memories = max(0, int(memory_count or 0))
-        healthy = max(0, int(healthy_sources or 0))
-        score = min(100, round(memories * 12 + concepts * 8 + relationships * 4 + healthy * 3))
-
-        if memories < 1 and concepts < 1:
-            state = "quiet"
-            depth = 2
-            title_key = "brain.readiness.quiet"
-            action_key = "brain.readiness.start"
-            score = max(12, score)
-        elif concepts < 3 or relationships < 2:
-            state = "forming"
-            depth = 3 if concepts < 3 else 4
-            title_key = "brain.readiness.forming"
-            action_key = "brain.readiness.grow"
-            score = max(38, score)
-        else:
-            state = "alive"
-            depth = 5
-            title_key = "brain.readiness.alive"
-            action_key = "brain.readiness.map"
-            score = max(72, score)
-
-        return {
-            "score": score,
-            "state": state,
-            "depth": depth,
-            "title_key": title_key,
-            "action_key": action_key,
-            "signals": {
-                "memory_count": memories,
-                "concept_count": concepts,
-                "relationship_count": relationships,
-                "healthy_sources": healthy,
-            },
-            "source": "memory_service",
-        }
-
-    def manager(self, *, user_email: Optional[str] = None, workspace_id: Optional[str] = None) -> Dict[str, Any]:
-        ws_mem = self._workspace_memories(user_email=user_email, workspace_id=workspace_id or "personal")
-        if workspace_id is None:
-            project_mem = [m for m in self._all_memories() if (m.get("workspace_id") or "personal") != "personal"]
-        else:
-            project_mem = self._workspace_memories(user_email=user_email, workspace_id=workspace_id)
-        snaps = self._snapshots(workspace_id=workspace_id)
-        convs = self._scoped_conversations(user_email=user_email, workspace_id=workspace_id)
-        kg_stats = self._kg_stats()
-        kg_index = self._kg_index()
-
-        ws_bytes = _file_size(self._data_dir / "workspace_os.json")
-        kg_bytes = _file_size(self._data_dir / "knowledge_graph.sqlite")
-        if self._conversation_store is not None:
-            conv_bytes = int(getattr(self._conversation_store, "size_bytes", lambda: 0)())
-        else:
-            conv_bytes = _file_size(self._history_file)
-
-        node_total = sum((kg_stats or {}).get("nodes", {}).values()) if kg_stats else None
-        edge_total = sum((kg_stats or {}).get("edges", {}).values()) if kg_stats else None
-        vector_total = None
-        if kg_index and isinstance(kg_index.get("vector_counts"), dict):
-            vector_total = sum(kg_index["vector_counts"].values())
-        elif kg_index:
-            vector_total = kg_index.get("indexed") or kg_index.get("ready")
-
-        sources: List[Dict[str, Any]] = [
-            {
-                "id": "workspace", "type": "workspace", "label": "Workspace Memory",
-                "count": len(ws_mem), "size_bytes": ws_bytes if ws_mem else 0,
-                "health": "ok", "detail": "Personal workspace knowledge, by kind.",
-            },
-            {
-                "id": "project", "type": "project", "label": "Project Memory",
-                "count": len(project_mem), "size_bytes": 0,
-                "health": "ok", "detail": "Memory scoped to organization workspaces.",
-            },
-            {
-                "id": "agent", "type": "agent", "label": "Agent Memory",
-                "count": len(snaps), "size_bytes": 0,
-                "health": "ok", "detail": "Per-run agent memory snapshots.",
-            },
-            {
-                "id": "conversation", "type": "conversation", "label": "Conversation Memory",
-                "count": len(convs), "size_bytes": conv_bytes,
-                "health": "ok" if (self._conversation_store is not None or self._history_file.exists()) else "empty",
-                "detail": "Historical interaction memory from chat.",
-            },
-            {
-                "id": "graph", "type": "graph", "label": "Graph Memory",
-                "count": node_total, "size_bytes": kg_bytes,
-                "health": "ok" if kg_stats else "unavailable",
-                "detail": "Knowledge Graph entities and relations." if kg_stats else "Knowledge graph disabled or unavailable.",
-                "edges": edge_total,
-            },
-            {
-                "id": "vector", "type": "vector", "label": "Vector Memory",
-                "count": vector_total, "size_bytes": 0,
-                "health": "ok" if kg_index else "unavailable",
-                "detail": "Local embedding vector index." if kg_index else "Vector index unavailable.",
-            },
-        ]
-        total_items = sum(int(s["count"] or 0) for s in sources)
-        total_bytes = ws_bytes + kg_bytes + conv_bytes
-        healthy = sum(1 for s in sources if s["health"] == "ok")
-        overall = "ok" if healthy >= 4 else "degraded" if healthy >= 1 else "unavailable"
-        memory_ids = {m.get("id") for m in [*ws_mem, *project_mem] if m.get("id")}
-        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(
-                memory_count=memory_count,
-                concept_count=node_total,
-                relationship_count=edge_total,
-                healthy_sources=healthy,
-            ),
-            "health": overall,
-            "graph_enabled": self._enable_graph,
-            "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"]

package/latticeai/services/memory_service/proof.py

@@ -1,136 +0,0 @@
-"""Brain Proof: the durable evidence behind "your Brain outlives the model".
-
-Backend-owned on purpose. The first-run Brain screen must show the stores it
-can actually recall from, and the model-continuity claim has to be independent
-of whichever LLM happens to be loaded — a UI-derived version of this would be
-an assertion, not a proof.
-
-The two are deliberately separated: ``capability`` is always true (the design
-is model-independent), while ``proven`` stays false until there is durable
-evidence on disk to recall from.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Dict, Optional
-
-from latticeai.core.timeutil import now_iso as _now
-
-from ._contract import MemoryCore as _Core
-
-
-class MemoryProofMixin(_Core):
-    """The proof points and the query they are demonstrated with."""
-
-    def brain_proof(
-        self,
-        *,
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-        active_model: Optional[str] = None,
-        recall_query: str = "",
-        limit: int = 3,
-    ) -> Dict[str, Any]:
-        """Return the proof points that make Brain feel model-independent.
-
-        This is intentionally backend-owned instead of UI-derived: the first-run
-        Brain screen needs to show the durable stores it can actually recall
-        from, and the model continuity claim must be independent from whichever
-        LLM is currently loaded.
-        """
-        manager = self.manager(user_email=user_email, workspace_id=workspace_id)
-        sources = {str(source.get("id")): source for source in manager.get("sources", []) if isinstance(source, dict)}
-        readiness = manager.get("brain_readiness") or {}
-        conversation_count = int(sources.get("conversation", {}).get("count") or 0)
-        workspace_count = int(sources.get("workspace", {}).get("count") or 0)
-        graph_count = int(sources.get("graph", {}).get("count") or 0)
-        vector_count = int(sources.get("vector", {}).get("count") or 0)
-        query = recall_query.strip() or self._latest_recall_query(user_email=user_email, workspace_id=workspace_id)
-        recall: Dict[str, Any] = (
-            self.recall(query, user_email=user_email, workspace_id=workspace_id, limit=limit)
-            if query
-            else {"query": "", "results": [], "count": 0, "source": "live"}
-        )
-        recall_items = [
-            {
-                "id": item.get("id"),
-                "source": item.get("source"),
-                "title": item.get("title"),
-                "snippet": item.get("snippet"),
-                "score": item.get("score", 0),
-                # Evidence explainability: why this item was recalled, so the
-                # citation UI can show the matched terms instead of a bare score.
-                "matched_terms": item.get("matched_terms") or [],
-                "confidence": item.get("confidence") or "low",
-                # v11.1.0: what kind of memory this is, and — for a picture —
-                # the caption and inline thumbnail the Evidence panel renders.
-                "kind": item.get("kind") or "",
-                **({"caption": item["caption"]} if item.get("caption") else {}),
-                **({"thumbnail": item["thumbnail"]} if item.get("thumbnail") else {}),
-            }
-            for item in list(recall.get("results", []))[: max(1, min(limit, 8))]
-        ]
-        durable_items = workspace_count + conversation_count + graph_count
-        # Capability and proof are deliberately separated. The brain is
-        # architecturally model-independent, so the capability is always true.
-        # The proof stays false until there is durable evidence on disk.
-        has_durable_evidence = durable_items > 0
-        proven_continuity = has_durable_evidence
-        return {
-            "status": readiness.get("state") or "quiet",
-            "readiness": readiness,
-            "model_continuity": {
-                "active_model": active_model or "",
-                "brain_owner": "lattice_brain",
-                # Design capability: the brain is built to outlive any model.
-                "capability": True,
-                # Proof: only true when durable evidence exists to recall.
-                "survives_model_switch": proven_continuity,
-                "proven": proven_continuity,
-                "context_store": "workspace + conversation + graph + vector",
-            },
-            "proofs": {
-                "durable_items": durable_items,
-                "has_durable_evidence": has_durable_evidence,
-                "workspace_memories": workspace_count,
-                "conversations": conversation_count,
-                "graph_concepts": graph_count,
-                "vector_items": vector_count,
-                "healthy_sources": readiness.get("signals", {}).get("healthy_sources", 0),
-            },
-            "recall": {
-                "query": recall.get("query") or query,
-                "items": recall_items,
-                "count": recall.get("count", 0),
-            },
-            "claims": {
-                "can_recall_user_context": bool(recall_items or durable_items > 0),
-                # Proven, not asserted: no durable evidence means no continuity claim.
-                "keeps_context_across_models": proven_continuity,
-                "is_knowledge_store": bool(graph_count or vector_count or workspace_count or conversation_count),
-            },
-            "generated_at": _now(),
-        }
-
-    def _latest_recall_query(self, *, user_email: Optional[str], workspace_id: Optional[str]) -> str:
-        for memory in self._workspace_memories(user_email=user_email, workspace_id=workspace_id or "personal"):
-            content = str(memory.get("content") or "").strip()
-            if content:
-                return content[:96]
-        for conversation in self._conversations():
-            messages = conversation.get("messages") or []
-            if not isinstance(messages, list):
-                continue
-            for message in reversed(messages[-8:]):
-                if not isinstance(message, dict):
-                    continue
-                if user_email and message.get("user_email") != user_email:
-                    continue
-                message_workspace = message.get("workspace_id") or "personal"
-                target_workspace = workspace_id or "personal"
-                if message_workspace != target_workspace:
-                    continue
-                content = str(message.get("content") or "").strip()
-                if content:
-                    return content[:96]
-        return ""

package/latticeai/services/memory_service/recall.py

@@ -1,225 +0,0 @@
-"""Unified retrieval across the memory tiers, and single-tier inspection.
-
-:meth:`recall` blends three sources into one honestly comparable ranking:
-
-* **workspace** memories, scored lexically as the fraction of query tokens
-  present — the same scorer both text tiers use, so cross-tier ordering is real
-  rather than an artifact of per-tier constants;
-* **graph** nodes from the Knowledge Graph search;
-* **vector** neighbours (v9.3.0 hybrid recall), which is what lets recall find
-  knowledge phrased differently from the query. The vector tier is optional:
-  any failure degrades recall to pure lexical instead of breaking it.
-
-A quality gate then drops zero-score rows *only* when at least one row carries
-real evidence, so the gate can never empty a recall. Every row reports its
-confidence and which evidence kinds produced it.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-from ._contract import MemoryCore as _Core
-from .constants import LOGGER, TIERS, WORKSPACE_KINDS, _visual_fields
-
-
-class MemoryRecallMixin(_Core):
-    """Recall, tiers, and per-tier inspection. Mixed into ``MemoryService``."""
-
-    def tiers(self) -> Dict[str, Any]:
-        return {"tiers": list(TIERS), "workspace_kinds": list(WORKSPACE_KINDS)}
-
-    # ── recall (unified retrieval over the memory tiers) ───────────────────
-    def recall(
-        self,
-        query: str,
-        *,
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-        limit: int = 20,
-    ) -> Dict[str, Any]:
-        q = str(query or "").strip()
-        query_tokens = [tok for tok in q.lower().split() if tok]
-
-        def _matched_terms(*texts: Any) -> List[str]:
-            haystack = " ".join(str(t or "") for t in texts).lower()
-            return [tok for tok in query_tokens if tok in haystack]
-
-        def _lexical_score(matched: List[str]) -> float:
-            # Honest, comparable relevance: fraction of query tokens present.
-            # Both tiers share this scorer so the cross-tier ranking is real,
-            # not an artifact of per-tier constants.
-            if not query_tokens:
-                return 0.0
-            return round(len(matched) / len(query_tokens), 4)
-
-        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 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"))
-            results.append({
-                "source": "workspace",
-                "id": m.get("id"),
-                "title": (m.get("kind") or "memory"),
-                "snippet": str(m.get("content") or "")[:240],
-                "kind": m.get("kind"),
-                "score": _lexical_score(matched),
-                "matched_terms": matched,
-                "tags": m.get("tags") or [],
-            })
-
-        if self._enable_graph and q:
-            try:
-                # KnowledgeGraph.search returns {"query": ..., "matches": [...]}.
-                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"))
-                results.append({
-                    "source": "graph",
-                    "id": hit.get("id") or hit.get("node_id"),
-                    "title": hit.get("title") or hit.get("name") or "node",
-                    "snippet": str(hit.get("summary") or hit.get("content") or "")[:240],
-                    "kind": hit.get("type") or "node",
-                    "score": _lexical_score(matched),
-                    "matched_terms": matched,
-                    **_visual_fields(hit),
-                })
-
-        # v9.3.0 hybrid recall: blend semantic similarity from the vector
-        # index into the lexical ranking. Vector evidence lets recall find
-        # knowledge phrased differently from the query — the main lexical
-        # blind spot. The vector tier is optional: any failure degrades recall
-        # back to pure lexical instead of breaking it.
-        vector_used = False
-        if self._enable_graph and q and hasattr(self._kg, "vector_search"):
-            try:
-                vector_hits = list(
-                    self._kg.vector_search(q, limit=limit).get("matches", [])
-                )
-                # Workspace scoping is server-owned: the vector index is
-                # global, so scoped calls must filter matches to visible
-                # nodes before they can influence results.
-                if workspace_id is not None and vector_hits and hasattr(self._kg, "filter_scoped_nodes"):
-                    vector_hits = self._kg.filter_scoped_nodes(
-                        vector_hits, {workspace_id}, id_key="node_id"
-                    )
-                vector_used = True
-            except Exception as exc:
-                LOGGER.exception("vector recall failed; falling back to lexical")
-                errors.append({"source": "vector", "detail": str(exc)})
-                vector_hits = []
-            by_node_id = {str(r.get("id")): r for r in results if r.get("source") == "graph"}
-            for hit in vector_hits:
-                node_id = str(hit.get("node_id") or hit.get("id") or "")
-                similarity = round(float(hit.get("score") or 0.0), 4)
-                if similarity <= 0:
-                    continue
-                # Citation precision (v9.9.6): a chunk hit knows where in the
-                # document it came from (section heading / page). Carry that
-                # locator onto the recall row so the citation can say it.
-                hit_metadata = hit.get("metadata")
-                locator = (
-                    str(hit_metadata.get("locator") or "")
-                    if isinstance(hit_metadata, dict)
-                    else ""
-                )
-                existing = by_node_id.get(node_id)
-                if existing is not None:
-                    existing["vector_score"] = max(existing.get("vector_score", 0.0), similarity)
-                    existing["score"] = round(
-                        max(existing.get("score", 0.0), 0.4 * existing.get("score", 0.0) + 0.6 * similarity),
-                        4,
-                    )
-                    if locator and not existing.get("locator"):
-                        existing["locator"] = locator
-                else:
-                    matched = _matched_terms(hit.get("title"), hit.get("summary"))
-                    row = {
-                        "source": "graph",
-                        "id": node_id or hit.get("id"),
-                        "title": hit.get("title") or "node",
-                        "snippet": str(hit.get("summary") or "")[:240],
-                        "kind": hit.get("type") or "node",
-                        "score": round(max(_lexical_score(matched), 0.6 * similarity), 4),
-                        "matched_terms": matched,
-                        "vector_score": similarity,
-                        **({"locator": locator} if locator else {}),
-                        **_visual_fields(hit),
-                    }
-                    results.append(row)
-                    if node_id:
-                        by_node_id[node_id] = row
-
-        # Quality gate: when at least one result carries real evidence
-        # (lexical term hits, or semantic similarity in hybrid mode),
-        # zero-score rows are noise relative to it and are dropped. When
-        # nothing scores (e.g. tokenization mismatch), everything is kept so
-        # the tiers' own search filters still decide — the gate never empties
-        # a recall.
-        candidates = len(results)
-        if query_tokens and any(r.get("score", 0) > 0 for r in results):
-            results = [r for r in results if r.get("score", 0) > 0]
-        for r in results:
-            r["confidence"] = "high" if r.get("score", 0) >= 0.65 else "medium" if r.get("score", 0) >= 0.3 else "low"
-            evidence = []
-            if r.get("matched_terms"):
-                evidence.append("lexical")
-            if r.get("vector_score"):
-                evidence.append("semantic")
-            r["evidence_kinds"] = evidence
-
-        results.sort(key=lambda r: r.get("score", 0), reverse=True)
-        return {
-            "query": q,
-            "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),
-                "filtered": candidates - len(results),
-                "gate": "hybrid-evidence/v2" if vector_used else "lexical-evidence/v1",
-            },
-        }
-
-    # ── inspect a single tier ─────────────────────────────────────────────
-    def inspect(self, source: str, *, user_email: Optional[str] = None, workspace_id: Optional[str] = None, limit: int = 50) -> Dict[str, Any]:
-        if source == "workspace":
-            items = self._workspace_memories(user_email=user_email, workspace_id=workspace_id or "personal")[:limit]
-            return {"source": source, "items": items, "count": len(items)}
-        if source == "project":
-            if workspace_id is None:
-                items = [m for m in self._all_memories() if (m.get("workspace_id") or "personal") != "personal"][:limit]
-            else:
-                items = self._workspace_memories(user_email=user_email, workspace_id=workspace_id)[:limit]
-            return {"source": source, "items": items, "count": len(items)}
-        if source == "agent":
-            items = self._snapshots(workspace_id=workspace_id)[:limit]
-            return {"source": source, "items": items, "count": len(items)}
-        if source == "conversation":
-            convs = self._scoped_conversations(user_email=user_email, workspace_id=workspace_id)
-            items = [{"id": c.get("id"), "title": c.get("title") or c.get("id"), "messages": len(c.get("messages") or [])} for c in convs[:limit]]
-            return {"source": source, "items": items, "count": len(convs)}
-        if source == "graph":
-            return {"source": source, "stats": self._kg_stats() or {}, "available": bool(self._kg_stats())}
-        if source == "vector":
-            return {"source": source, "index": self._kg_index() or {}, "available": bool(self._kg_index())}
-        raise KeyError(source)

package/latticeai/services/memory_service/service.py

@@ -1,48 +0,0 @@
-"""The composed memory service — constructor state plus the six surfaces.
-
-``MemoryService`` owns the state every mixin reads (the workspace store, the
-optional Knowledge Graph, the data directory, and whichever conversation
-backing is wired) and inherits its behaviour from the store-read, manager,
-brief, proof, recall and maintenance mixins. Same public surface, same method
-resolution, in seven readable files instead of one twelve-hundred-line one.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any, Optional
-
-from .brief import MemoryBriefMixin
-from .maintenance import MemoryMaintenanceMixin
-from .manager import MemoryManagerMixin
-from .proof import MemoryProofMixin
-from .recall import MemoryRecallMixin
-from .stores import MemoryStoreReadsMixin
-
-
-class MemoryService(
-    MemoryStoreReadsMixin,
-    MemoryManagerMixin,
-    MemoryBriefMixin,
-    MemoryProofMixin,
-    MemoryRecallMixin,
-    MemoryMaintenanceMixin,
-):
-    def __init__(
-        self,
-        *,
-        store: Any,
-        data_dir: Path,
-        knowledge_graph: Any = None,
-        enable_graph: bool = True,
-        history_file: Optional[Path] = None,
-        conversation_store: Any = None,
-    ):
-        self._store = store
-        self._kg = knowledge_graph
-        self._enable_graph = bool(enable_graph and knowledge_graph is not None)
-        self._data_dir = Path(data_dir)
-        self._history_file = Path(history_file) if history_file else (self._data_dir / "chat_history.json")
-        # v4: the durable SQLite conversation store supersedes the JSON file
-        # as the conversation tier's backing store when provided.
-        self._conversation_store = conversation_store