superlocalmemory 4.1.13 → 4.1.15

package/src/superlocalmemory/encoding/foresight.py

@@ -1,93 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
-
-"""SuperLocalMemory V3 — Foresight Signal Extraction.
-
-Extracts time-bounded intentions and planned events from conversations.
-V1 extracted foresight signals but NEVER STORED them. Now persisted as TemporalEvents.
-
-Part of Qualixar | Author: Varun Pratap Bhardwaj
-"""
-
-from __future__ import annotations
-
-import logging
-import re
-from datetime import datetime
-
-from superlocalmemory.storage.models import AtomicFact, TemporalEvent
-
-logger = logging.getLogger(__name__)
-
-# Patterns that indicate future intent or planned events
-_FORESIGHT_PATTERNS = [
-    re.compile(r"\b(plan(?:ning|s|ned)?)\s+to\b", re.I),
-    re.compile(r"\b(going)\s+to\b", re.I),
-    re.compile(r"\b(will|shall)\s+\w+", re.I),
-    re.compile(r"\b(schedul(?:e|ed|ing))\b", re.I),
-    re.compile(r"\b(appointment|reservation|booking)\b", re.I),
-    re.compile(r"\b(remind(?:er)?|don't forget)\b", re.I),
-    re.compile(r"\b(taking|starting|beginning)\s+\w+\s+(next|tomorrow|soon)\b", re.I),
-    re.compile(r"\b(deadline|due date|due by)\b", re.I),
-    re.compile(r"\bnext\s+(week|month|year|monday|tuesday|wednesday|thursday|friday|saturday|sunday)\b", re.I),
-]
-
-
-def extract_foresight_signals(fact: AtomicFact) -> list[dict]:
-    """Extract foresight signals from a fact's content.
-
-    Returns list of dicts with: content, pattern_matched.
-    These get converted to TemporalEvents by the encoding pipeline.
-    """
-    signals = []
-    for pattern in _FORESIGHT_PATTERNS:
-        match = pattern.search(fact.content)
-        if match:
-            signals.append({
-                "content": fact.content,
-                "pattern": match.group(0),
-                "fact_id": fact.fact_id,
-            })
-            break  # One signal per fact is sufficient
-
-    return signals
-
-
-def foresight_to_temporal_events(
-    fact: AtomicFact,
-    entity_ids: list[str],
-    profile_id: str,
-) -> list[TemporalEvent]:
-    """Convert foresight signals into TemporalEvents for persistence.
-
-    Each signal becomes a temporal event linked to the fact's entities.
-    The temporal_parser handles actual date extraction — we just mark
-    the fact as having foresight intent.
-    """
-    signals = extract_foresight_signals(fact)
-    if not signals:
-        return []
-
-    events = []
-    for eid in entity_ids:
-        event = TemporalEvent(
-            profile_id=profile_id,
-            scope=fact.scope,
-            shared_with=fact.shared_with,
-            entity_id=eid,
-            fact_id=fact.fact_id,
-            observation_date=fact.observation_date,
-            referenced_date=fact.referenced_date,
-            interval_start=fact.interval_start,
-            interval_end=fact.interval_end,
-            description=f"Foresight: {fact.content[:200]}",
-        )
-        events.append(event)
-
-    return events
-
-
-def has_foresight(text: str) -> bool:
-    """Quick check if text contains foresight signals."""
-    return any(p.search(text) for p in _FORESIGHT_PATTERNS)

package/src/superlocalmemory/encoding/graph_builder.py

@@ -1,346 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
-
-"""Knowledge graph construction — 4 edge types, zero memory limits.
-
-Builds edges between AtomicFacts at encoding time. V1 only checked the
-last 50 memories; this version searches ALL facts per canonical entity.
-
-Edge types: ENTITY (shared entity, weight 1.0), TEMPORAL (exp-decay,
-1-week window), SEMANTIC (ANN cosine > 0.7), CAUSAL (causal markers,
-weight 0.8). CONTRADICTION exposed for external Sheaf module (added in v3.5).
-
-Part of Qualixar | Author: Varun Pratap Bhardwaj
-License: AGPL-3.0-or-later
-"""
-from __future__ import annotations
-
-import logging
-import math
-import re
-from datetime import datetime
-from typing import Any, Protocol, runtime_checkable
-
-from superlocalmemory.storage.database import DatabaseManager
-from superlocalmemory.storage.models import AtomicFact, EdgeType, GraphEdge
-
-logger = logging.getLogger(__name__)
-
-# Constants
-_TEMPORAL_MAX_HOURS: float = 168.0   # 1 week
-_TEMPORAL_DECAY_DAYS: float = 30.0   # exp(-delta_days / 30)
-_SEMANTIC_THRESHOLD: float = 0.7
-_SEMANTIC_TOP_K: int = 5
-_CAUSAL_WEIGHT: float = 0.8
-_ENTITY_WEIGHT: float = 1.0
-
-# Causal cue patterns — longer phrases first to avoid partial matches.
-_CAUSAL_CUES: tuple[re.Pattern[str], ...] = (
-    re.compile(r"\bbecause of\b", re.I),
-    re.compile(r"\bas a result\b", re.I),
-    re.compile(r"\bresulted in\b", re.I),
-    re.compile(r"\bin order to\b", re.I),
-    re.compile(r"\bso that\b", re.I),
-    re.compile(r"\bcaused by\b", re.I),
-    re.compile(r"\bdue to\b", re.I),
-    re.compile(r"\bled to\b", re.I),
-    re.compile(r"\btherefore\b", re.I),
-    re.compile(r"\bconsequently\b", re.I),
-    re.compile(r"\bbecause\b", re.I),
-)
-
-
-@runtime_checkable
-class ANNSearchable(Protocol):
-    """Minimal protocol for approximate-nearest-neighbor search."""
-
-    def search(self, query: Any, top_k: int = 5) -> list[tuple[str, float]]:
-        """Return (fact_id, similarity_score) pairs."""
-        ...  # pragma: no cover
-
-
-class GraphBuilder:
-    """Build knowledge-graph edges for newly stored facts.
-
-    Searches the ENTIRE corpus per canonical entity (not just last 50).
-    Adds semantic similarity edges via optional ANN index and detects
-    causal language for directed cause/effect edges.
-    """
-
-    def __init__(self, db: DatabaseManager, ann_index: ANNSearchable | None = None) -> None:
-        self._db = db
-        self._ann = ann_index
-
-    # -- Public API --------------------------------------------------------
-
-    def build_edges(self, new_fact: AtomicFact, profile_id: str) -> list[GraphEdge]:
-        """Create ALL relevant edges for *new_fact*. Persists and returns them."""
-        hub_cache: dict[str, int] = {}  # shared across edge types to avoid redundant queries
-        edges: list[GraphEdge] = []
-        edges.extend(self._build_entity_edges(new_fact, profile_id, hub_cache))
-        edges.extend(self._build_temporal_edges(new_fact, profile_id))
-        edges.extend(self._build_semantic_edges(new_fact, profile_id))
-        edges.extend(self._build_causal_edges(new_fact, profile_id, hub_cache))
-
-        for edge in edges:
-            self._db.store_edge(edge)
-
-        if edges:
-            logger.debug(
-                "GraphBuilder: %d edges for %s (E=%d T=%d S=%d C=%d)",
-                len(edges), new_fact.fact_id,
-                sum(1 for e in edges if e.edge_type == EdgeType.ENTITY),
-                sum(1 for e in edges if e.edge_type == EdgeType.TEMPORAL),
-                sum(1 for e in edges if e.edge_type == EdgeType.SEMANTIC),
-                sum(1 for e in edges if e.edge_type == EdgeType.CAUSAL),
-            )
-        return edges
-
-    def add_contradiction_edge(
-        self, fact_id_a: str, fact_id_b: str, profile_id: str,
-        severity: float = 1.0,
-    ) -> GraphEdge:
-        """Add a contradiction edge. Called by the Sheaf module (introduced in v3.5)."""
-        edge = GraphEdge(
-            profile_id=profile_id,
-            source_id=fact_id_a,
-            target_id=fact_id_b,
-            edge_type=EdgeType.CONTRADICTION,
-            weight=max(0.0, min(1.0, severity)),
-        )
-        self._db.store_edge(edge)
-        logger.info("Contradiction %s -> %s (%.2f)", fact_id_a, fact_id_b, severity)
-        return edge
-
-    def get_graph_stats(self, profile_id: str) -> dict[str, Any]:
-        """Edge counts by type, node count, average degree."""
-        rows = self._db.execute(
-            "SELECT edge_type, COUNT(*) AS cnt FROM graph_edges "
-            "WHERE profile_id = ? GROUP BY edge_type", (profile_id,),
-        )
-        edge_counts: dict[str, int] = {
-            dict(r)["edge_type"]: int(dict(r)["cnt"]) for r in rows
-        }
-        total_edges = sum(edge_counts.values())
-
-        node_rows = self._db.execute(
-            "SELECT COUNT(DISTINCT n) AS c FROM ("
-            "  SELECT source_id AS n FROM graph_edges WHERE profile_id = ? "
-            "  UNION "
-            "  SELECT target_id AS n FROM graph_edges WHERE profile_id = ?"
-            ")", (profile_id, profile_id),
-        )
-        node_count = int(dict(node_rows[0])["c"]) if node_rows else 0
-        avg_degree = (2.0 * total_edges / node_count) if node_count > 0 else 0.0
-
-        return {
-            "edge_counts": edge_counts,
-            "total_edges": total_edges,
-            "node_count": node_count,
-            "avg_degree": round(avg_degree, 2),
-        }
-
-    # -- Edge builders (private) -------------------------------------------
-
-    # v3.4.59: Lowered from 20→5. At 17K facts, 20 edges × many entities per fact
-    # produces 1.4M+ entity edges and 13s recalls. 5 is sufficient graph signal.
-    _MAX_ENTITY_EDGES_PER_ENTITY: int = 5
-    # v3.4.59: Hub filter — nodes with > 200 total edges are "gravity wells"
-    # (e.g. every fact mentions "SLM"). Skip adding more edges to them.
-    _MAX_HUB_DEGREE: int = 200
-
-    def _node_degree(self, fact_id: str, profile_id: str, cache: dict[str, int]) -> int:
-        """Cached total degree (in + out) for a node."""
-        if fact_id not in cache:
-            rows = self._db.execute(
-                "SELECT COUNT(*) as cnt FROM graph_edges "
-                "WHERE profile_id = ? AND (source_id = ? OR target_id = ?)",
-                (profile_id, fact_id, fact_id),
-            )
-            cache[fact_id] = int(dict(rows[0])["cnt"]) if rows else 0
-        return cache[fact_id]
-
-    def _build_entity_edges(
-        self, new_fact: AtomicFact, profile_id: str,
-        hub_cache: dict[str, int] | None = None,
-    ) -> list[GraphEdge]:
-        """ENTITY edges: shared canonical entity — capped to most recent per entity."""
-        if not new_fact.canonical_entities:
-            return []
-        if hub_cache is None:
-            hub_cache = {}
-        edges: list[GraphEdge] = []
-        seen: set[str] = set()
-
-        for entity_id in new_fact.canonical_entities:
-            entity_edge_count = 0
-            for other in self._db.get_facts_by_entity(entity_id, profile_id):
-                if entity_edge_count >= self._MAX_ENTITY_EDGES_PER_ENTITY:
-                    break
-                if other.fact_id == new_fact.fact_id or other.fact_id in seen:
-                    continue
-                if self._node_degree(other.fact_id, profile_id, hub_cache) >= self._MAX_HUB_DEGREE:
-                    continue  # skip hub nodes — they link everything to everything
-                if self._edge_exists(new_fact.fact_id, other.fact_id, EdgeType.ENTITY, profile_id):
-                    continue
-                seen.add(other.fact_id)
-                edges.append(GraphEdge(
-                    profile_id=profile_id, source_id=new_fact.fact_id,
-                    target_id=other.fact_id, edge_type=EdgeType.ENTITY,
-                    weight=_ENTITY_WEIGHT,
-                ))
-                entity_edge_count += 1
-        return edges
-
-    def _build_temporal_edges(
-        self, new_fact: AtomicFact, profile_id: str,
-    ) -> list[GraphEdge]:
-        """TEMPORAL edges: bidirectional, exp-decay, 1-week window per entity.
-
-        Only creates temporal edges when an explicit observation_date is set.
-        Falling back to created_at would produce spurious temporal edges for
-        facts that have no real temporal context.
-        """
-        if not new_fact.observation_date or not new_fact.canonical_entities:
-            return []
-        new_dt = _parse_date(new_fact.observation_date)
-        if new_dt is None:
-            return []
-
-        edges: list[GraphEdge] = []
-        seen_pairs: set[tuple[str, str]] = set()
-
-        for entity_id in new_fact.canonical_entities:
-            temporal_edge_count = 0
-            for other in self._db.get_facts_by_entity(entity_id, profile_id):
-                if temporal_edge_count >= self._MAX_ENTITY_EDGES_PER_ENTITY:
-                    break  # V3.3.12: cap temporal edges like entity edges
-                if other.fact_id == new_fact.fact_id:
-                    continue
-                other_dt = _parse_date(other.observation_date)
-                if other_dt is None:
-                    continue
-
-                delta_hours = abs((new_dt - other_dt).total_seconds()) / 3600.0
-                if delta_hours > _TEMPORAL_MAX_HOURS:
-                    continue
-
-                pair_key = (min(new_fact.fact_id, other.fact_id),
-                            max(new_fact.fact_id, other.fact_id))
-                if pair_key in seen_pairs:
-                    continue
-                if self._edge_exists(new_fact.fact_id, other.fact_id, EdgeType.TEMPORAL, profile_id):
-                    seen_pairs.add(pair_key)
-                    continue
-
-                weight = round(max(math.exp(-(delta_hours / 24.0) / _TEMPORAL_DECAY_DAYS), 0.01), 4)
-                seen_pairs.add(pair_key)
-
-                # Forward: new -> other
-                edges.append(GraphEdge(
-                    profile_id=profile_id, source_id=new_fact.fact_id,
-                    target_id=other.fact_id, edge_type=EdgeType.TEMPORAL,
-                    weight=weight,
-                ))
-                temporal_edge_count += 1
-                # Reverse: other -> new
-                if not self._edge_exists(other.fact_id, new_fact.fact_id, EdgeType.TEMPORAL, profile_id):
-                    edges.append(GraphEdge(
-                        profile_id=profile_id, source_id=other.fact_id,
-                        target_id=new_fact.fact_id, edge_type=EdgeType.TEMPORAL,
-                        weight=weight,
-                    ))
-        return edges
-
-    def _build_semantic_edges(
-        self, new_fact: AtomicFact, profile_id: str,
-    ) -> list[GraphEdge]:
-        """SEMANTIC edges: ANN embedding similarity > 0.7 threshold."""
-        if self._ann is None or new_fact.embedding is None:
-            return []
-        try:
-            import numpy as np
-            query_vec = np.asarray(new_fact.embedding, dtype=np.float32)
-        except (ImportError, ValueError):
-            return []
-
-        edges: list[GraphEdge] = []
-        for fact_id, score in self._ann.search(query_vec, top_k=_SEMANTIC_TOP_K + 1):
-            if fact_id == new_fact.fact_id or score < _SEMANTIC_THRESHOLD:
-                continue
-            if self._edge_exists(new_fact.fact_id, fact_id, EdgeType.SEMANTIC, profile_id):
-                continue
-            edges.append(GraphEdge(
-                profile_id=profile_id, source_id=new_fact.fact_id,
-                target_id=fact_id, edge_type=EdgeType.SEMANTIC,
-                weight=round(float(score), 4),
-            ))
-            if len(edges) >= _SEMANTIC_TOP_K:
-                break
-        return edges
-
-    # v3.4.59: Lowered from 20→5, same reasoning as entity cap.
-    _MAX_CAUSAL_EDGES_PER_ENTITY: int = 5
-
-    def _build_causal_edges(
-        self, new_fact: AtomicFact, profile_id: str,
-        hub_cache: dict[str, int] | None = None,
-    ) -> list[GraphEdge]:
-        """CAUSAL edges: causal markers + shared entity. Direction: cause -> effect."""
-        if not any(p.search(new_fact.content) for p in _CAUSAL_CUES):
-            return []
-        if not new_fact.canonical_entities:
-            return []
-        if hub_cache is None:
-            hub_cache = {}
-
-        edges: list[GraphEdge] = []
-        seen: set[str] = set()
-        for entity_id in new_fact.canonical_entities:
-            causal_edge_count = 0
-            for other in self._db.get_facts_by_entity(entity_id, profile_id):
-                if causal_edge_count >= self._MAX_CAUSAL_EDGES_PER_ENTITY:
-                    break
-                if other.fact_id == new_fact.fact_id or other.fact_id in seen:
-                    continue
-                if self._node_degree(other.fact_id, profile_id, hub_cache) >= self._MAX_HUB_DEGREE:
-                    continue
-                if self._edge_exists(other.fact_id, new_fact.fact_id, EdgeType.CAUSAL, profile_id):
-                    continue
-                seen.add(other.fact_id)
-                edges.append(GraphEdge(
-                    profile_id=profile_id, source_id=other.fact_id,
-                    target_id=new_fact.fact_id, edge_type=EdgeType.CAUSAL,
-                    weight=_CAUSAL_WEIGHT,
-                ))
-                causal_edge_count += 1
-        return edges
-
-    # -- Helpers -----------------------------------------------------------
-
-    def _edge_exists(
-        self, source_id: str, target_id: str,
-        edge_type: EdgeType, profile_id: str,
-    ) -> bool:
-        """Check if an edge already exists (prevents duplicates)."""
-        rows = self._db.execute(
-            "SELECT 1 FROM graph_edges "
-            "WHERE profile_id = ? AND source_id = ? AND target_id = ? "
-            "AND edge_type = ? LIMIT 1",
-            (profile_id, source_id, target_id, edge_type.value),
-        )
-        return len(rows) > 0
-
-
-def _parse_date(raw: str | None) -> datetime | None:
-    """Best-effort ISO-8601 datetime parse."""
-    if not raw:
-        return None
-    for fmt in ("%Y-%m-%dT%H:%M:%S.%f", "%Y-%m-%dT%H:%M:%S",
-                "%Y-%m-%d %H:%M:%S", "%Y-%m-%d"):
-        try:
-            return datetime.strptime(raw, fmt)
-        except ValueError:
-            continue
-    return None

package/src/superlocalmemory/encoding/observation_builder.py

@@ -1,177 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
-
-"""SuperLocalMemory V3 — Observation Builder (Entity Profiles).
-
-Builds and updates accumulated knowledge profiles per entity.
-When a new fact mentions an entity, the entity's profile is updated.
-
-V1 had this module but NEVER CALLED it. Now wired into the encoding pipeline.
-
-Part of Qualixar | Author: Varun Pratap Bhardwaj
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-from datetime import UTC, datetime
-
-from superlocalmemory.storage.models import AtomicFact, EntityProfile
-
-logger = logging.getLogger(__name__)
-
-
-class ObservationBuilder:
-    """Build and maintain entity knowledge profiles.
-
-    Each canonical entity gets a running profile that accumulates
-    all facts known about it. Used for:
-    - Entity-centric retrieval (return profile as context)
-    - Consolidation (detect when new info conflicts with profile)
-    - Answer generation (entity profiles provide rich context)
-    """
-
-    def __init__(self, db) -> None:
-        self._db = db
-
-    def update_profile(
-        self,
-        entity_id: str,
-        new_fact: AtomicFact,
-        profile_id: str,
-    ) -> EntityProfile:
-        """Update (or create) entity profile with new fact.
-
-        Appends fact to profile's fact list and regenerates summary.
-        """
-        existing = self._get_profile(entity_id, profile_id)
-
-        if existing is not None:
-            fact_ids = existing.fact_ids
-            if new_fact.fact_id not in fact_ids:
-                fact_ids = [*fact_ids, new_fact.fact_id]
-            summary = self._build_summary(entity_id, fact_ids, profile_id)
-            updated = EntityProfile(
-                profile_entry_id=existing.profile_entry_id,
-                entity_id=entity_id,
-                profile_id=profile_id,
-                knowledge_summary=summary,
-                fact_ids=fact_ids,
-                last_updated=datetime.now(UTC).isoformat(),
-            )
-        else:
-            summary = self._build_summary(entity_id, [new_fact.fact_id], profile_id)
-            updated = EntityProfile(
-                entity_id=entity_id,
-                profile_id=profile_id,
-                knowledge_summary=summary,
-                fact_ids=[new_fact.fact_id],
-                last_updated=datetime.now(UTC).isoformat(),
-            )
-
-        self._save_profile(updated)
-        return updated
-
-    def get_profile(self, entity_id: str, profile_id: str) -> EntityProfile | None:
-        """Get the current knowledge profile for an entity."""
-        return self._get_profile(entity_id, profile_id)
-
-    def build_all_profiles(self, profile_id: str) -> list[EntityProfile]:
-        """Rebuild all entity profiles from scratch. Use after migration."""
-        rows = self._db.execute(
-            "SELECT DISTINCT entity_id FROM canonical_entities WHERE profile_id = ?",
-            (profile_id,),
-        )
-        profiles = []
-        for row in rows:
-            eid = dict(row)["entity_id"]
-            facts = self._db.get_facts_by_entity(eid, profile_id)
-            if facts:
-                fact_ids = [f.fact_id for f in facts]
-                summary = self._build_summary(eid, fact_ids, profile_id)
-                ep = EntityProfile(
-                    entity_id=eid,
-                    profile_id=profile_id,
-                    knowledge_summary=summary,
-                    fact_ids=fact_ids,
-                    last_updated=datetime.now(UTC).isoformat(),
-                )
-                self._save_profile(ep)
-                profiles.append(ep)
-        return profiles
-
-    # -- Internal ----------------------------------------------------------
-
-    def _get_profile(self, entity_id: str, profile_id: str) -> EntityProfile | None:
-        """Load entity profile from DB."""
-        rows = self._db.execute(
-            "SELECT * FROM entity_profiles WHERE entity_id = ? AND profile_id = ?",
-            (entity_id, profile_id),
-        )
-        if not rows:
-            return None
-        d = dict(rows[0])
-        return EntityProfile(
-            profile_entry_id=d["profile_entry_id"],
-            entity_id=d["entity_id"],
-            profile_id=d["profile_id"],
-            knowledge_summary=d.get("knowledge_summary", ""),
-            fact_ids=json.loads(d.get("fact_ids_json", "[]")),
-            last_updated=d.get("last_updated", ""),
-        )
-
-    def _save_profile(self, profile: EntityProfile) -> None:
-        """Upsert entity profile to DB."""
-        self._db.execute(
-            """INSERT OR REPLACE INTO entity_profiles
-               (profile_entry_id, entity_id, profile_id,
-                knowledge_summary, fact_ids_json, last_updated)
-               VALUES (?, ?, ?, ?, ?, ?)""",
-            (
-                profile.profile_entry_id,
-                profile.entity_id,
-                profile.profile_id,
-                profile.knowledge_summary,
-                json.dumps(profile.fact_ids),
-                profile.last_updated,
-            ),
-        )
-
-    # V3.4.40 (2026-05-09): bounded summary to prevent unbounded growth.
-    # Pre-V3.4.40 builds concatenated full fact content. Hubs accumulated
-    # 60+ KB summaries that polluted recall and bloated entity_profiles.
-    _SUMMARY_MAX_FACTS = 10           # Last N facts (was 20)
-    _SUMMARY_MAX_CHARS_PER_FACT = 200  # Truncate each fact (NEW)
-    _SUMMARY_MAX_TOTAL_CHARS = 2048    # Hard cap on full summary (NEW)
-
-    def _build_summary(
-        self, entity_id: str, fact_ids: list[str], profile_id: str
-    ) -> str:
-        """Build a knowledge summary from all facts about an entity.
-
-        V3.4.40: bounded — last 10 facts, 200 chars each, 2048 total.
-        Older builds produced 60KB summaries on hub entities.
-        Mode B/C could use LLM rollup for higher-quality compression.
-        """
-        facts = []
-        for fid in fact_ids[-self._SUMMARY_MAX_FACTS:]:
-            rows = self._db.execute(
-                "SELECT content FROM atomic_facts WHERE fact_id = ? AND profile_id = ?",
-                (fid, profile_id),
-            )
-            if rows:
-                content = dict(rows[0])["content"]
-                # Truncate per-fact to bound the join below
-                if len(content) > self._SUMMARY_MAX_CHARS_PER_FACT:
-                    content = content[: self._SUMMARY_MAX_CHARS_PER_FACT - 1] + "…"
-                facts.append(content)
-
-        if not facts:
-            return ""
-        joined = " | ".join(facts)
-        # Hard cap as final safety net
-        if len(joined) > self._SUMMARY_MAX_TOTAL_CHARS:
-            joined = joined[: self._SUMMARY_MAX_TOTAL_CHARS - 1] + "…"
-        return joined