superlocalmemory 3.7.8 → 3.8.0

package/src/superlocalmemory/core/graph_analyzer.py

@@ -211,6 +211,43 @@ class GraphAnalyzer:
                 result[node] = comm_id
         return result
 
+    def detect_communities_louvain(
+        self,
+        graph: Any = None,
+        profile_id: str = "",
+    ) -> dict[str, int]:
+        """Detect communities via Louvain (modularity-optimizing).
+
+        Higher quality than Label Propagation (deterministic with a seed,
+        no giant-community collapse), pure-Python via networkx — no extra
+        binary deps. Falls back to Label Propagation if unavailable.
+        """
+        import networkx as nx
+
+        if graph is None:
+            graph = self._build_networkx_graph(profile_id)
+        if graph.number_of_nodes() == 0:
+            return {}
+
+        undirected = graph.to_undirected()
+        try:
+            from networkx.algorithms.community import louvain_communities
+
+            communities = louvain_communities(
+                undirected, weight="weight", seed=42,
+            )
+        except Exception as exc:
+            logger.debug(
+                "Louvain unavailable/failed (%s); using Label Propagation", exc,
+            )
+            return self.detect_communities(graph, profile_id)
+
+        result: dict[str, int] = {}
+        for comm_id, community in enumerate(communities):
+            for node in community:
+                result[node] = comm_id
+        return result
+
     # ── v3.4.1: Leiden Community Detection ────────────────────────
 
     def detect_communities_leiden(
@@ -234,9 +271,9 @@ class GraphAnalyzer:
             import igraph
         except ImportError:
             logger.info(
-                "leidenalg not installed, using Label Propagation fallback",
+                "leidenalg not installed, using Louvain fallback",
             )
-            return self.detect_communities(graph, profile_id)
+            return self.detect_communities_louvain(graph, profile_id)
 
         # Convert DiGraph -> undirected -> igraph
         undirected = graph.to_undirected()

package/src/superlocalmemory/core/graph_pruner.py

@@ -350,8 +350,12 @@ def _cap_node_degree(
     Algorithm (single-pass window function — no Python loops):
       1. ROW_NUMBER() OVER (PARTITION BY source_id ORDER BY weight DESC) ranks
          every edge per node in one full table scan.
-      2. Edges with rn > max_degree are deleted in a single DELETE statement.
-      Requires SQLite 3.25+ (window functions). System is on 3.53.1.
+      2. Excess edge IDs are collected in a reusable temp table.
+      3. A single DELETE statement removes them; rowcount is returned.
+      4. The temp table is created once and cleared via DELETE (not DROP) —
+         DROP TABLE acquires an EXCLUSIVE lock that conflicts with concurrent
+         writers, causing "database is locked".  Using CREATE...IF NOT EXISTS
+         plus DELETE FROM avoids that conflict while preserving rowcount.
     """
     # gi-03: cap BOTH out-degree (PARTITION BY source_id) AND in-degree
     # (PARTITION BY target_id). Previously only out-degree was capped, so hub
@@ -379,9 +383,13 @@ def _cap_node_degree(
         )
         return excess
 
-    # Step 1: collect edges exceeding the cap in either direction (one pass).
-    c.execute("DROP TABLE IF EXISTS _slm_cap_del")
-    c.execute("CREATE TEMP TABLE _slm_cap_del (edge_id TEXT PRIMARY KEY)")
+    # CREATE IF NOT EXISTS + DELETE FROM instead of DROP + CREATE.
+    # DROP TABLE acquires EXCLUSIVE which conflicts with concurrent writers.
+    # CREATE IF NOT EXISTS is idempotent; DELETE FROM clears prior contents.
+    c.execute(
+        "CREATE TEMP TABLE IF NOT EXISTS _slm_cap_del (edge_id TEXT PRIMARY KEY)"
+    )
+    c.execute("DELETE FROM _slm_cap_del")
     c.execute(
         """
         INSERT OR IGNORE INTO _slm_cap_del (edge_id)
@@ -396,7 +404,6 @@ def _cap_node_degree(
         (profile_id, max_degree, max_degree),
     )
 
-    # Step 2: delete the over-cap edges (single DELETE).
     c.execute(
         """
         DELETE FROM graph_edges
@@ -407,8 +414,6 @@ def _cap_node_degree(
     )
     deleted = c.rowcount
 
-    c.execute("DROP TABLE IF EXISTS _slm_cap_del")
-
     logger.info(
         "_cap_node_degree: deleted %d low-weight edges (max_degree=%d, in+out capped)",
         deleted, max_degree,

package/src/superlocalmemory/core/key_expander.py

@@ -0,0 +1,138 @@
+# 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
+
+"""Fact-augmented key expansion (Phase 4, T3b).
+
+Generates *alternate keys* for a fact — synonyms, aliases, and paraphrases —
+that get indexed in ``fact_expansion_fts`` and UNION'd into BM25 retrieval, so a
+query for "automobile" or "the Big Apple" can match a fact that only says "car"
+or "NYC".
+
+Two tiers, matching the rest of SLM:
+  * Mode A (zero-LLM): pulls the fact's resolved entities' canonical names and
+    aliases from SLM's own entity graph — no model, no cost, and it reuses the
+    entity resolution already done at ingest.
+  * Mode B/C: additionally asks the LLM for a few paraphrase keywords (own
+    prompt, fail-open, bounded).
+
+Keys already present in the fact's content are dropped — indexing them twice
+adds nothing. Returns a single space-joined string ready for the FTS row.
+
+Part of Qualixar | Author: Varun Pratap Bhardwaj
+License: AGPL-3.0-or-later
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from superlocalmemory.storage.database import DatabaseManager
+    from superlocalmemory.storage.models import AtomicFact
+
+logger = logging.getLogger(__name__)
+
+# Bound the LLM enrichment so a pathological response can't bloat the index.
+_MAX_LLM_KEYS = 8
+_MAX_KEY_LEN = 60
+
+
+class KeyExpander:
+    """Produces alternate search keys for a fact (T3b)."""
+
+    __slots__ = ("_db", "_llm")
+
+    def __init__(self, db: DatabaseManager, llm: Any = None) -> None:
+        self._db = db
+        self._llm = llm
+
+    def expand(self, fact: AtomicFact, profile_id: str, mode: str = "a") -> str:
+        """Return space-joined alternate keys for ``fact`` (may be empty)."""
+        keys: set[str] = set()
+        keys |= self._alias_keys(fact, profile_id)
+        if mode in ("b", "c") and self._llm_available():
+            keys |= self._llm_keys(fact)
+
+        content_low = (getattr(fact, "content", "") or "").lower()
+        cleaned = {
+            k.strip() for k in keys
+            if k and k.strip() and len(k.strip()) <= _MAX_KEY_LEN
+            and k.strip().lower() not in content_low
+        }
+        return " ".join(sorted(cleaned))
+
+    # -- Mode A: entity aliases from SLM's own entity graph ------------------
+
+    def _alias_keys(self, fact: AtomicFact, profile_id: str) -> set[str]:
+        out: set[str] = set()
+        for name in (getattr(fact, "canonical_entities", None) or []):
+            if not name:
+                continue
+            try:
+                ent = self._db.get_entity_by_name(name, profile_id)
+            except Exception:
+                ent = None
+            if ent is None:
+                continue
+            canonical = getattr(ent, "canonical_name", None)
+            if canonical:
+                out.add(canonical)
+            entity_id = getattr(ent, "entity_id", None)
+            if not entity_id:
+                continue
+            try:
+                for alias in self._db.get_aliases_for_entity(entity_id, profile_id):
+                    a = getattr(alias, "alias", None)
+                    if a:
+                        out.add(a)
+            except Exception:
+                continue
+        return out
+
+    # -- Mode B/C: LLM paraphrases (own prompt, fail-open) -------------------
+
+    def _llm_available(self) -> bool:
+        if self._llm is None:
+            return False
+        check = getattr(self._llm, "is_available", None)
+        try:
+            return bool(check()) if callable(check) else bool(check)
+        except Exception:
+            return False
+
+    def _llm_keys(self, fact: AtomicFact) -> set[str]:
+        content = getattr(fact, "content", "") or ""
+        if not content:
+            return set()
+        prompt = (
+            "Give 3-6 short alternative search terms (synonyms, aliases, or "
+            "paraphrases) that a person might use to look up the memory below. "
+            "Output ONLY a comma-separated list, no numbering, no explanation.\n\n"
+            f"Memory: {content}"
+        )
+        raw = self._invoke_llm(prompt)
+        if not raw:
+            return set()
+        seen: list[str] = []
+        for part in raw.replace("\n", ",").split(","):
+            p = part.strip()
+            if p and p not in seen:
+                seen.append(p)
+            if len(seen) >= _MAX_LLM_KEYS:
+                break
+        return set(seen)
+
+    def _invoke_llm(self, prompt: str) -> str:
+        """Call whatever generation method the injected LLM exposes; fail-open."""
+        for meth in ("generate", "complete", "chat"):
+            fn = getattr(self._llm, meth, None)
+            if callable(fn):
+                try:
+                    out = fn(prompt)
+                    return out if isinstance(out, str) else str(out or "")
+                except Exception as exc:
+                    logger.debug("KeyExpander LLM (%s) failed: %s", meth, exc)
+                    return ""
+        return ""

package/src/superlocalmemory/core/maintenance.py

@@ -127,6 +127,7 @@ def run_maintenance(
         "sheaf_checked": 0,
         "entity_summaries_consolidated": 0,  # V3.4.40
         "orphan_metadata_gc": 0,             # v3.6.4 (P1-3)
+        "expansion_backfilled": 0,           # T3b
     }
 
     # P1-3 (embeddings-vector-02): sweep orphaned embedding_metadata left by
@@ -141,6 +142,28 @@ def run_maintenance(
     if not facts:
         return counts
 
+    # T3b: backfill fact-expansion alt-keys (Mode A, entity-alias based) for
+    # facts stored before expansion existed. Bounded per run + skips already-
+    # populated and entity-less facts, so it converges without re-work churn.
+    try:
+        from superlocalmemory.core.key_expander import KeyExpander
+        populated = {
+            dict(r)["fact_id"]
+            for r in db.execute("SELECT DISTINCT fact_id FROM fact_expansion_fts")
+        }
+        expander = KeyExpander(db)
+        for f in facts:
+            if counts["expansion_backfilled"] >= 500:
+                break
+            if f.fact_id in populated or not f.canonical_entities:
+                continue
+            alt = expander.expand(f, profile_id, mode="a")
+            if alt:
+                db.upsert_fact_expansion(f.fact_id, alt)
+                counts["expansion_backfilled"] += 1
+    except Exception as exc:  # pragma: no cover — legacy DB / missing FTS
+        logger.debug("expansion backfill skipped: %s", exc)
+
     # 1a. Backfill: seed uninitialized facts with metadata-aware positions (B+C)
     if config.math.langevin_persist_positions:
         try:

package/src/superlocalmemory/core/modes.py

@@ -109,7 +109,7 @@ MODE_C = ModeCapabilities(
     data_stays_local=False,
     description=(
         "FULL POWER — UNRESTRICTED. Best embeddings (text-embedding-3-large, 3072-dim). "
-        "Best LLMs (GPT-5.2, Claude Opus). Agentic multi-round retrieval. "
+        "Best configured cloud LLMs (e.g. GPT-5, Claude Opus 4). Agentic multi-round retrieval. "
         "Cohere reranker option. No EU restriction. Target: 90%+"
     ),
 )

package/src/superlocalmemory/core/mutations.py

@@ -59,7 +59,7 @@ def delete_fact_authorized(
     if not rows:
         return {"ok": False, "error": f"Memory {fact_id} not found"}
     content_preview = dict(rows[0]).get("content", "")[:80]
-    engine._db.delete_fact(fact_id)
+    engine._db.delete_fact(fact_id, profile_id=profile_id)
     try:
         from superlocalmemory.core.backend_orchestrator import get_orchestrator
         orchestrator = get_orchestrator()
@@ -120,7 +120,7 @@ def update_fact_authorized(
                 updates["fisher_variance"] = fisher_variance
         except Exception as exc:
             logger.warning("UPDATE embedding refresh failed: %s", exc)
-    engine._db.update_fact(fact_id, updates)
+    engine._db.update_fact(fact_id, updates, profile_id=profile_id)
     try:
         from superlocalmemory.core.backend_orchestrator import get_orchestrator
         orchestrator = get_orchestrator()

package/src/superlocalmemory/core/pii.py

@@ -0,0 +1,105 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory V3 — PII redaction on ingest (C4)
+
+"""Opt-in PII redaction for ingested memory content.
+
+For team / company deployments an operator may need memory to never persist
+personal identifiers (email, phone, national ID, payment card, IP). This
+module provides a pure, well-bounded scrubber that replaces detected PII with
+``[PII:TYPE]`` markers. It is complementary to ``security_primitives.
+redact_secrets`` (which handles API keys / tokens and always runs).
+
+Design goals:
+* **Low false-positive rate.** Card numbers are Luhn-validated; SSNs use the
+  canonical grouping; phone matching requires a plausible separator shape.
+* **Deterministic + pure.** No I/O, no config — the caller decides when to run
+  it (gated by SLM_PII_REDACTION / config), so it is trivially testable.
+* **Order matters.** Emails are redacted before phone/number sweeps so an
+  email's local part is never mistaken for a number.
+"""
+
+from __future__ import annotations
+
+import re
+
+# Order-sensitive: earlier patterns win over later ones on overlapping spans.
+_EMAIL = re.compile(r"\b[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}\b")
+_SSN = re.compile(r"\b\d{3}-\d{2}-\d{4}\b")
+_IPV4 = re.compile(
+    r"\b(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|1?\d?\d)\b"
+)
+# Phone: conservative to avoid eating ISO dates (4-2-2) / version strings.
+# Only unambiguous shapes match:
+#   * international  +CC then grouped digits
+#   * parenthesized  (415) 555-0132
+#   * strict US      415-555-0132 / 415.555.0132  (3-3-4, dot/dash only — a
+#     space separator is excluded so "2026-07-22 12" style runs never match).
+_PHONE = re.compile(
+    r"(?<!\w)(?:"
+    r"\+\d{1,3}[\s.\-]?\d{1,4}[\s.\-]?\d{2,4}[\s.\-]?\d{2,4}"
+    r"|\(\d{3}\)[\s.\-]?\d{3}[\s.\-]?\d{4}"
+    r"|\d{3}[.\-]\d{3}[.\-]\d{4}"
+    r")(?!\w)"
+)
+# Candidate card: 13–19 digits, optionally grouped by space/dash. Luhn-checked.
+_CARD_CANDIDATE = re.compile(r"(?<!\w)(?:\d[ -]?){13,19}(?!\w)")
+
+
+def _luhn_ok(digits: str) -> bool:
+    """Return True if ``digits`` (0-9 only) passes the Luhn checksum."""
+    if not (13 <= len(digits) <= 19):
+        return False
+    total = 0
+    parity = len(digits) % 2
+    for i, ch in enumerate(digits):
+        d = ord(ch) - 48
+        if i % 2 == parity:
+            d *= 2
+            if d > 9:
+                d -= 9
+        total += d
+    return total % 10 == 0
+
+
+def _redact_cards(text: str, counter: list[int]) -> str:
+    def _sub(m: re.Match[str]) -> str:
+        raw = m.group(0)
+        digits = re.sub(r"\D", "", raw)
+        if _luhn_ok(digits):
+            counter[0] += 1
+            return "[PII:CARD]"
+        return raw
+    return _CARD_CANDIDATE.sub(_sub, text)
+
+
+def redact_pii(text: str) -> tuple[str, int]:
+    """Return ``(redacted_text, num_redactions)``.
+
+    Never raises; a non-string or empty input is returned unchanged with 0.
+    """
+    if not isinstance(text, str) or not text:
+        return text, 0
+
+    counter = [0]
+
+    def _count_sub(pattern: re.Pattern[str], label: str, s: str) -> str:
+        def _sub(_m: re.Match[str]) -> str:
+            counter[0] += 1
+            return label
+        return pattern.sub(_sub, s)
+
+    out = text
+    # Email first (protects local parts from the number sweeps).
+    out = _count_sub(_EMAIL, "[PII:EMAIL]", out)
+    # Payment cards before generic phone/number matching (Luhn-gated).
+    out = _redact_cards(out, counter)
+    out = _count_sub(_SSN, "[PII:SSN]", out)
+    out = _count_sub(_IPV4, "[PII:IP]", out)
+    out = _count_sub(_PHONE, "[PII:PHONE]", out)
+    return out, counter[0]
+
+
+def redact_pii_text(text: str) -> str:
+    """Convenience wrapper returning only the redacted string."""
+    return redact_pii(text)[0]

package/src/superlocalmemory/core/progressive_abstraction.py

@@ -0,0 +1,208 @@
+# 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
+
+"""Progressive abstraction (Wave Q3) — the top persona tier + drill-down.
+
+Completes the abstraction hierarchy on the ONE principled backbone (rather
+than a fourth divergent clustering):
+
+    atoms (atomic_facts)
+      -> entity communities        (Wave Q backbone)
+        -> community summaries      (Wave Q2)
+          -> persona roll-up        (this module)
+
+The persona is one bounded roll-up per profile that consumes the top community
+summaries. It is recall-GATED (never auto-injected into the hot recall path —
+avoids the V3.4.40 summary-pollution regression) and SIZE-bounded. Drill-down
+(``get_sources``) walks the hierarchy back down to the source atoms, matching
+the market bar for summary->source provenance (Zep-style).
+
+Runs in the background consolidation lane after community summaries.
+Fail-open throughout; recompute replaces a profile's row.
+
+Part of Qualixar | Author: Varun Pratap Bhardwaj
+License: AGPL-3.0-or-later
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+from superlocalmemory.core.community_summary import CommunitySummaryBuilder
+
+logger = logging.getLogger(__name__)
+
+_PERSONA_MAX_CHARS = 2048
+
+
+class ProgressiveAbstraction:
+    """Build + persist the persona tier; provide hierarchy drill-down."""
+
+    def __init__(
+        self,
+        db: Any,
+        summarizer: Any = None,
+        max_communities_in_persona: int = 8,
+        persona_max_chars: int = _PERSONA_MAX_CHARS,
+        max_keywords: int = 12,
+    ) -> None:
+        self._db = db
+        self._summarizer = summarizer
+        self._max_communities = max(1, int(max_communities_in_persona))
+        self._persona_max_chars = max(256, int(persona_max_chars))
+        self._max_keywords = max(1, int(max_keywords))
+
+    # ------------------------------------------------------------------
+    # Build
+    # ------------------------------------------------------------------
+
+    def compute_and_store(self, profile_id: str) -> dict[str, Any]:
+        summaries = CommunitySummaryBuilder(self._db).get_summaries(profile_id)
+        try:
+            self._db.execute(
+                "DELETE FROM persona_summary WHERE profile_id = ?",
+                (profile_id,),
+            )
+        except Exception as exc:
+            logger.debug("persona_summary clear failed: %s", exc)
+        if not summaries:
+            return {"built": False, "communities_in_persona": 0}
+
+        top = summaries[: self._max_communities]
+        summary = self._persona_summary(top)
+        keywords = self._merge_keywords(top)
+        community_ids = [int(s["community_id"]) for s in top]
+
+        try:
+            self._db.execute(
+                "INSERT OR REPLACE INTO persona_summary "
+                "(profile_id, summary, keywords, community_ids_json, computed_at) "
+                "VALUES (?, ?, ?, ?, datetime('now'))",
+                (profile_id, summary, keywords, json.dumps(community_ids)),
+            )
+        except Exception as exc:
+            logger.debug("persona_summary write failed: %s", exc)
+            return {"built": False, "communities_in_persona": 0}
+
+        return {"built": True, "communities_in_persona": len(top)}
+
+    # ------------------------------------------------------------------
+    # Read API
+    # ------------------------------------------------------------------
+
+    def get_persona(self, profile_id: str) -> dict | None:
+        try:
+            rows = self._db.execute(
+                "SELECT * FROM persona_summary WHERE profile_id = ?",
+                (profile_id,),
+            )
+        except Exception as exc:
+            logger.debug("get_persona failed: %s", exc)
+            return None
+        if not rows:
+            return None
+        d = dict(rows[0])
+        try:
+            community_ids = json.loads(d.get("community_ids_json") or "[]")
+        except (ValueError, TypeError):
+            community_ids = []
+        return {
+            "profile_id": d.get("profile_id", profile_id),
+            "summary": d.get("summary", ""),
+            "keywords": d.get("keywords", ""),
+            "community_ids": community_ids,
+            "computed_at": d.get("computed_at", ""),
+        }
+
+    def get_sources(self, profile_id: str, node_id: Any) -> dict:
+        """Drill-down: a tier node -> its child communities + source atoms.
+
+        node_id == "persona"  -> the persona's member communities + their facts.
+        node_id == <community> -> that community's member facts.
+        Unknown node -> empty (never raises).
+        """
+        result: dict[str, Any] = {
+            "node_id": node_id, "node_type": "unknown",
+            "communities": [], "fact_ids": [],
+        }
+        try:
+            if isinstance(node_id, str) and node_id.lower() == "persona":
+                persona = self.get_persona(profile_id)
+                cids = persona["community_ids"] if persona else []
+                fact_ids: list[str] = []
+                seen: set[str] = set()
+                for cid in cids:
+                    for fid in self._community_fact_ids(profile_id, cid):
+                        if fid not in seen:
+                            seen.add(fid)
+                            fact_ids.append(fid)
+                result.update(
+                    node_type="persona", communities=list(cids), fact_ids=fact_ids,
+                )
+                return result
+
+            # Otherwise treat node_id as a community id.
+            cid = int(node_id)
+            fids = self._community_fact_ids(profile_id, cid)
+            result.update(
+                node_type="community", communities=[cid], fact_ids=fids,
+            )
+            return result
+        except (ValueError, TypeError):
+            return result
+        except Exception as exc:
+            logger.debug("get_sources failed: %s", exc)
+            return result
+
+    # ------------------------------------------------------------------
+    # Internal
+    # ------------------------------------------------------------------
+
+    def _community_fact_ids(self, profile_id: str, community_id: Any) -> list[str]:
+        try:
+            rows = self._db.execute(
+                "SELECT fact_ids_json FROM community_summaries "
+                "WHERE profile_id = ? AND community_id = ?",
+                (profile_id, int(community_id)),
+            )
+        except Exception as exc:
+            logger.debug("_community_fact_ids failed: %s", exc)
+            return []
+        if not rows:
+            return []
+        try:
+            return [str(f) for f in json.loads(dict(rows[0]).get("fact_ids_json") or "[]")]
+        except (ValueError, TypeError):
+            return []
+
+    def _persona_summary(self, top: list[dict]) -> str:
+        if self._summarizer is not None:
+            try:
+                text = self._summarizer.summarize_cluster(
+                    [{"content": s.get("summary", "")} for s in top],
+                )
+                if text and text.strip():
+                    return text.strip()[: self._persona_max_chars]
+            except Exception as exc:
+                logger.debug("persona summarizer failed (fail-open): %s", exc)
+        # Mode A keyword-dense fallback: stitch the top community summaries.
+        heads = [s.get("summary", "").strip() for s in top if s.get("summary")]
+        base = " ".join(heads) if heads else "No persona yet."
+        return base[: self._persona_max_chars]
+
+    def _merge_keywords(self, top: list[dict]) -> str:
+        seen: set[str] = set()
+        merged: list[str] = []
+        for s in top:
+            for kw in (s.get("keywords", "") or "").split(","):
+                k = kw.strip()
+                low = k.lower()
+                if k and low not in seen:
+                    seen.add(low)
+                    merged.append(k)
+                    if len(merged) >= self._max_keywords:
+                        return ", ".join(merged)
+        return ", ".join(merged)

package/src/superlocalmemory/core/recall_pipeline.py

@@ -623,6 +623,7 @@ def run_recall(
     fast: bool = False,
     include_global: bool = False,
     include_shared: bool = False,
+    window: str | tuple[str, str] | None = None,
 ) -> RecallResponse:
     """Recall relevant facts for a query.
 
@@ -663,6 +664,7 @@ def run_recall(
         extra_disabled_channels=extra_disabled,
         include_global=include_global,
         include_shared=include_shared,
+        window=window,
     )
     _mark("retrieval(chan+rerank)")