brainlayer 1.5.2__tar.gz → 1.5.4__tar.gz

{brainlayer-1.5.2 → brainlayer-1.5.4}/.gitignore

@@ -98,3 +98,5 @@ site/
 
 # render-verification ephemeral logs
 brain-bar/.render-logs/
+.worktrees/
+.cmux/worktrees/

{brainlayer-1.5.2 → brainlayer-1.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brainlayer
-Version: 1.5.2
+Version: 1.5.4
 Summary: Persistent memory MCP server for AI agents — 13 tools, semantic search, knowledge graph, on-device SQLite
 Project-URL: Homepage, https://brainlayer.etanheyman.com
 Project-URL: Repository, https://github.com/EtanHey/brainlayer
@@ -23,7 +23,8 @@ Requires-Dist: abydos>=0.5.0
 Requires-Dist: apsw>=3.45.0
 Requires-Dist: google-api-python-client>=2.0.0
 Requires-Dist: google-auth>=2.0.0
-Requires-Dist: mcp>=1.0.0
+Requires-Dist: jsonschema>=4.20.0
+Requires-Dist: mcp<3.0.0,>=2.0.0
 Requires-Dist: numpy<3.0,>=1.22
 Requires-Dist: orjson>=3.9.0
 Requires-Dist: pydantic>=2.0.0

{brainlayer-1.5.2 → brainlayer-1.5.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "brainlayer"
-version = "1.5.2"
+version = "1.5.4"
 description = "Persistent memory MCP server for AI agents — 13 tools, semantic search, knowledge graph, on-device SQLite"
 license = {text = "Apache-2.0"}
 readme = "README.md"
@@ -16,7 +16,8 @@ dependencies = [
     "sentence-transformers>=2.2.0",
 
     # MCP server
-    "mcp>=1.0.0",
+    "mcp>=2.0.0,<3.0.0",
+    "jsonschema>=4.20.0",  # MCP v2 low-level handlers require explicit schema validation
 
     # CLI
     "typer>=0.9.0",

{brainlayer-1.5.2 → brainlayer-1.5.4}/scripts/hotlane_brainbar_daemon.py

@@ -15,6 +15,7 @@ import logging
 import os
 import signal
 import time
+from collections import OrderedDict
 from pathlib import Path
 from typing import Callable, NamedTuple
 
@@ -37,12 +38,94 @@ LOGGER = logging.getLogger("brainlayer.hotlane_brainbar")
 STOP = False
 DEFAULT_HOTLANE_ENRICH_LIMIT = 5
 DEFAULT_BACKLOG_BATCH = 4
+DEFAULT_HOTLANE_EMBED_DEVICE = "cpu"
 MAX_BACKLOG_BATCH = 16
 DEFAULT_HOTLANE_WRITE_BUSY_TIMEOUT_MS = 1000
 MAX_APSW_BUSY_TIMEOUT_MS = 2_147_483_647
 VECTOR_WRITE_YIELD_SECONDS = 0.005
+MAX_PENDING_CANDIDATE_SCAN_PAGES = 16
+HOT_CANDIDATE_SCAN_LIMIT = 256
+HOT_CANDIDATE_HEAD_LIMIT = HOT_CANDIDATE_SCAN_LIMIT // 2
+MAX_HOT_CANDIDATE_RETRIES = 256
 _sleep = time.sleep
 
+HOT_CANDIDATE_SCAN_SQL = """
+    SELECT
+        c.id,
+        c.content,
+        c.source_file,
+        c.source,
+        c.archived_at,
+        c.superseded_by,
+        c.aggregated_into,
+        COALESCE(c.archived, 0),
+        COALESCE(c.status, 'active'),
+        r.id
+    FROM chunks c
+    LEFT JOIN chunk_vectors_rowids r ON r.id = c.id
+    ORDER BY c.created_at DESC
+    LIMIT ?
+"""
+
+HOT_CANDIDATE_ROWID_SCAN_SQL = """
+    SELECT
+        c.rowid,
+        c.id,
+        c.content,
+        c.source_file,
+        c.source,
+        c.archived_at,
+        c.superseded_by,
+        c.aggregated_into,
+        COALESCE(c.archived, 0),
+        COALESCE(c.status, 'active'),
+        r.id
+    FROM chunks c
+    LEFT JOIN chunk_vectors_rowids r ON r.id = c.id
+    ORDER BY c.rowid DESC
+    LIMIT ?
+"""
+
+HOT_CANDIDATE_ROWID_PAGE_SQL = """
+    SELECT
+        c.rowid,
+        c.id,
+        c.content,
+        c.source_file,
+        c.source,
+        c.archived_at,
+        c.superseded_by,
+        c.aggregated_into,
+        COALESCE(c.archived, 0),
+        COALESCE(c.status, 'active'),
+        r.id
+    FROM chunks c
+    LEFT JOIN chunk_vectors_rowids r ON r.id = c.id
+    WHERE c.rowid < ?
+    ORDER BY c.rowid DESC
+    LIMIT ?
+"""
+
+HOT_CANDIDATE_ROWID_FORWARD_SQL = """
+    SELECT
+        c.rowid,
+        c.id,
+        c.content,
+        c.source_file,
+        c.source,
+        c.archived_at,
+        c.superseded_by,
+        c.aggregated_into,
+        COALESCE(c.archived, 0),
+        COALESCE(c.status, 'active'),
+        r.id
+    FROM chunks c
+    LEFT JOIN chunk_vectors_rowids r ON r.id = c.id
+    WHERE c.rowid > ?
+    ORDER BY c.rowid ASC
+    LIMIT ?
+"""
+
 
 class CycleResult(NamedTuple):
     embedded: int = 0
@@ -58,12 +141,201 @@ class EmbedCandidate(NamedTuple):
     content: str
 
 
+class PendingCandidateScanState:
+    def __init__(self) -> None:
+        self.active = False
+        self.after_created_at: str | None = None
+        self.after_rowid = 0
+
+    def reset(self) -> None:
+        self.active = False
+        self.after_created_at = None
+        self.after_rowid = 0
+
+
 class EmbeddedVector(NamedTuple):
     chunk_id: str
     content: str
     embedding: list[float]
 
 
+def _candidates_from_scanned_rows(
+    rows: list[tuple], *, limit: int, exclude_ids: set[str] | None = None
+) -> tuple[list[EmbedCandidate], int | None, int | None, bool]:
+    if limit <= 0:
+        return [], None, None, False
+    candidates: list[EmbedCandidate] = []
+    exclude_ids = exclude_ids or set()
+    first_candidate_rowid: int | None = None
+    last_inspected_rowid: int | None = None
+    for index, row in enumerate(rows):
+        (
+            rowid,
+            chunk_id,
+            content,
+            source_file,
+            source,
+            archived_at,
+            superseded_by,
+            aggregated_into,
+            archived,
+            status,
+            vector_id,
+        ) = row
+        last_inspected_rowid = int(rowid)
+        eligible = (
+            vector_id is None
+            and source_file == "brainbar-store"
+            and source == "mcp"
+            and content
+            and archived_at is None
+            and superseded_by is None
+            and aggregated_into is None
+            and not archived
+            and status == "active"
+        )
+        if eligible:
+            if first_candidate_rowid is None:
+                first_candidate_rowid = int(rowid)
+            if str(chunk_id) in exclude_ids:
+                continue
+            candidates.append(EmbedCandidate(str(chunk_id), str(content)))
+            if len(candidates) >= limit:
+                return candidates, first_candidate_rowid, last_inspected_rowid, index == len(rows) - 1
+    return candidates, first_candidate_rowid, last_inspected_rowid, True
+
+
+class HotCandidateScanner:
+    """Scan bounded rowid lanes while retaining returned candidates for retry."""
+
+    def __init__(self) -> None:
+        self._before_rowid: int | None = None
+        self._newest_seen_rowid: int | None = None
+        self._retries: OrderedDict[str, EmbedCandidate] = OrderedDict()
+        self._retry_turn = True
+        self._retry_buffer_full_logged = False
+
+    def _refresh_retries(self, cursor: apsw.Cursor) -> None:
+        if not self._retries:
+            return
+        placeholders = ",".join("?" for _ in self._retries)
+        rows = cursor.execute(
+            f"""
+            SELECT c.id, c.content
+            FROM chunks c
+            LEFT JOIN chunk_vectors_rowids r ON r.id = c.id
+            WHERE c.id IN ({placeholders})
+              AND r.id IS NULL
+              AND c.source_file = 'brainbar-store'
+              AND c.source = 'mcp'
+              AND c.content IS NOT NULL
+              AND c.content != ''
+              AND c.archived_at IS NULL
+              AND c.superseded_by IS NULL
+              AND c.aggregated_into IS NULL
+              AND COALESCE(c.archived, 0) = 0
+              AND COALESCE(c.status, 'active') = 'active'
+            """,
+            tuple(self._retries),
+        )
+        active = {str(chunk_id): EmbedCandidate(str(chunk_id), str(content)) for chunk_id, content in rows}
+        for chunk_id in list(self._retries):
+            if chunk_id not in active:
+                del self._retries[chunk_id]
+            else:
+                self._retries[chunk_id] = active[chunk_id]
+        if len(self._retries) < MAX_HOT_CANDIDATE_RETRIES:
+            self._retry_buffer_full_logged = False
+
+    def _take_retries(self, *, limit: int) -> list[EmbedCandidate]:
+        selected: list[EmbedCandidate] = []
+        for _ in range(min(limit, len(self._retries))):
+            chunk_id, candidate = self._retries.popitem(last=False)
+            self._retries[chunk_id] = candidate
+            selected.append(candidate)
+        return selected
+
+    def _retain(self, candidates: list[EmbedCandidate]) -> None:
+        for candidate in candidates:
+            if candidate.chunk_id in self._retries:
+                continue
+            if len(self._retries) >= MAX_HOT_CANDIDATE_RETRIES:
+                if not self._retry_buffer_full_logged:
+                    LOGGER.warning("hot candidate retry buffer full; pausing new retry retention")
+                    self._retry_buffer_full_logged = True
+                break
+            self._retries[candidate.chunk_id] = candidate
+
+    def __call__(self, store: VectorStore, *, limit: int) -> list[EmbedCandidate]:
+        cursor = store.conn.cursor()
+        self._refresh_retries(cursor)
+        if limit <= 0:
+            return []
+        if limit == 1 and self._retries:
+            retry_limit = 1 if self._retry_turn else 0
+            self._retry_turn = not self._retry_turn
+        else:
+            retry_limit = min(len(self._retries), max(1, limit // 2))
+        candidates = self._take_retries(limit=retry_limit)
+        retention_slots = MAX_HOT_CANDIDATE_RETRIES - len(self._retries)
+        scan_limit = min(limit - len(candidates), retention_slots)
+        if scan_limit <= 0:
+            return candidates
+        retry_ids = set(self._retries)
+        head_rows = list(cursor.execute(HOT_CANDIDATE_ROWID_SCAN_SQL, (HOT_CANDIDATE_HEAD_LIMIT,)))
+        head_candidates, _, last_inspected_rowid, _ = _candidates_from_scanned_rows(
+            head_rows,
+            limit=scan_limit,
+            exclude_ids=retry_ids,
+        )
+        candidates.extend(head_candidates)
+        retention_slots -= len(head_candidates)
+        if not head_rows:
+            self._retain(candidates)
+            return candidates
+        if self._newest_seen_rowid is None:
+            self._newest_seen_rowid = last_inspected_rowid
+        if self._before_rowid is None and last_inspected_rowid is not None:
+            self._before_rowid = last_inspected_rowid
+        if len(candidates) >= limit or retention_slots <= 0:
+            self._retain(candidates)
+            return candidates
+
+        page_limit = HOT_CANDIDATE_SCAN_LIMIT - HOT_CANDIDATE_HEAD_LIMIT
+        forward_rows = list(
+            cursor.execute(
+                HOT_CANDIDATE_ROWID_FORWARD_SQL,
+                (self._newest_seen_rowid, page_limit),
+            )
+        )
+        if forward_rows:
+            forward_candidates, _, last_inspected_rowid, _ = _candidates_from_scanned_rows(
+                forward_rows,
+                limit=min(limit - len(candidates), retention_slots),
+                exclude_ids=retry_ids | {candidate.chunk_id for candidate in candidates},
+            )
+            candidates.extend(forward_candidates)
+            retention_slots -= len(forward_candidates)
+            self._newest_seen_rowid = last_inspected_rowid
+        if len(candidates) >= limit or retention_slots <= 0 or self._before_rowid is None:
+            self._retain(candidates)
+            return candidates[:limit]
+
+        page_rows = list(cursor.execute(HOT_CANDIDATE_ROWID_PAGE_SQL, (self._before_rowid, page_limit)))
+        if page_rows:
+            page_candidates, _, last_inspected_rowid, fully_scanned = _candidates_from_scanned_rows(
+                page_rows,
+                limit=min(limit - len(candidates), retention_slots),
+                exclude_ids=retry_ids | {candidate.chunk_id for candidate in candidates},
+            )
+            candidates.extend(page_candidates)
+            self._before_rowid = last_inspected_rowid
+            if fully_scanned and len(page_rows) < page_limit:
+                self._before_rowid = None
+        self._retain(candidates)
+        return candidates[:limit]
+
+
 def _stop(_signum: int, _frame: object) -> None:
     global STOP
     STOP = True
@@ -95,48 +367,135 @@ def _candidate_chunk_ids(store: VectorStore, *, limit: int) -> list[str]:
 
 def _candidate_chunk_rows(store: VectorStore, *, limit: int) -> list[EmbedCandidate]:
     rows = store.conn.cursor().execute(
-        """
-        SELECT c.id, c.content
-        FROM chunks c
-        LEFT JOIN chunk_vectors_rowids r ON r.id = c.id
-        WHERE r.id IS NULL
-          AND c.source_file = 'brainbar-store'
-          AND c.source = 'mcp'
-          AND c.content IS NOT NULL
-          AND c.content != ''
-          AND c.archived_at IS NULL
-          AND c.superseded_by IS NULL
-          AND c.aggregated_into IS NULL
-          AND COALESCE(c.archived, 0) = 0
-          AND COALESCE(c.status, 'active') = 'active'
-        ORDER BY c.created_at DESC
-        LIMIT ?
-        """,
-        (limit,),
+        HOT_CANDIDATE_SCAN_SQL,
+        (HOT_CANDIDATE_SCAN_LIMIT,),
     )
-    return [EmbedCandidate(str(row[0]), str(row[1])) for row in rows]
+    candidates: list[EmbedCandidate] = []
+    for row in rows:
+        (
+            chunk_id,
+            content,
+            source_file,
+            source,
+            archived_at,
+            superseded_by,
+            aggregated_into,
+            archived,
+            status,
+            vector_id,
+        ) = row
+        if (
+            vector_id is None
+            and source_file == "brainbar-store"
+            and source == "mcp"
+            and content
+            and archived_at is None
+            and superseded_by is None
+            and aggregated_into is None
+            and not archived
+            and status == "active"
+        ):
+            candidates.append(EmbedCandidate(str(chunk_id), str(content)))
+            if len(candidates) >= limit:
+                break
+    return candidates
+
+
+def _pending_chunk_rows(
+    store: VectorStore,
+    *,
+    limit: int,
+    scan_state: PendingCandidateScanState | None = None,
+) -> list[EmbedCandidate]:
+    if limit <= 0:
+        return []
 
+    scan_limit = limit
+    candidates: list[EmbedCandidate] = []
+    after_created_at = scan_state.after_created_at if scan_state and scan_state.active else None
+    after_rowid = scan_state.after_rowid if scan_state and scan_state.active else 0
+    first_page = not scan_state or not scan_state.active
+    exhausted = False
+
+    for _page in range(MAX_PENDING_CANDIDATE_SCAN_PAGES):
+        if first_page:
+            page_filter = ""
+            bindings: tuple[object, ...] = (scan_limit,)
+        elif after_created_at is None:
+            page_filter = "AND ((c.created_at IS NULL AND c.rowid > ?) OR c.created_at IS NOT NULL)"
+            bindings = (after_rowid, scan_limit)
+        else:
+            page_filter = """
+              AND (c.created_at, c.rowid) > (?, ?)
+            """
+            bindings = (after_created_at, after_rowid, scan_limit)
+
+        id_rows = list(
+            store.conn.cursor().execute(
+                f"""
+                SELECT c.id, c.created_at, c.rowid
+                FROM chunks c
+                LEFT JOIN chunk_vectors_rowids r ON c.id = r.id
+                WHERE r.id IS NULL
+                  {page_filter}
+                ORDER BY c.created_at ASC
+                LIMIT ?
+                """,
+                bindings,
+            )
+        )
+        if not id_rows:
+            exhausted = True
+            break
 
-def _pending_chunk_rows(store: VectorStore, *, limit: int) -> list[EmbedCandidate]:
-    rows = store.conn.cursor().execute(
-        """
-        SELECT c.id, c.content
-        FROM chunks c
-        LEFT JOIN chunk_vectors_rowids r ON c.id = r.id
-        WHERE r.id IS NULL
-          AND c.content IS NOT NULL
-          AND c.content != ''
-          AND c.archived_at IS NULL
-          AND c.superseded_by IS NULL
-          AND c.aggregated_into IS NULL
-          AND COALESCE(c.archived, 0) = 0
-          AND COALESCE(c.status, 'active') = 'active'
-        ORDER BY c.created_at ASC
-        LIMIT ?
-        """,
-        (limit,),
-    )
-    return [EmbedCandidate(str(row[0]), str(row[1])) for row in rows]
+        candidate_ids = [str(row[0]) for row in id_rows]
+        placeholders = ", ".join("?" for _chunk_id in candidate_ids)
+        content_rows = store.conn.cursor().execute(
+            f"""
+            SELECT
+                id,
+                content,
+                archived_at,
+                superseded_by,
+                aggregated_into,
+                COALESCE(archived, 0),
+                COALESCE(status, 'active')
+            FROM chunks
+            WHERE id IN ({placeholders})
+            """,
+            tuple(candidate_ids),
+        )
+        content_by_id = {
+            str(row[0]): str(row[1])
+            for row in content_rows
+            if row[1] and row[2] is None and row[3] is None and row[4] is None and not row[5] and row[6] == "active"
+        }
+        candidates.extend(
+            EmbedCandidate(chunk_id, content_by_id[chunk_id]) for chunk_id in candidate_ids if chunk_id in content_by_id
+        )
+
+        after_created_at = id_rows[-1][1]
+        after_rowid = int(id_rows[-1][2])
+        first_page = False
+        if len(candidates) >= limit or len(id_rows) < scan_limit:
+            exhausted = len(id_rows) < scan_limit
+            break
+
+    if scan_state is not None:
+        if exhausted:
+            scan_state.reset()
+        else:
+            scan_state.active = True
+            scan_state.after_created_at = after_created_at
+            scan_state.after_rowid = after_rowid
+    return candidates[:limit]
+
+
+PENDING_CANDIDATE_SCAN_STATE = PendingCandidateScanState()
+
+
+def _pending_chunk_rows_with_resume(store: VectorStore, *, limit: int) -> list[EmbedCandidate]:
+    return _pending_chunk_rows(store, limit=limit, scan_state=PENDING_CANDIDATE_SCAN_STATE)
 
 
 def _embed_candidates(
@@ -335,9 +694,11 @@ def _callable_accepts_keyword(func: Callable[..., object], keyword: str) -> bool
         signature = inspect.signature(func)
     except (TypeError, ValueError):
         return True
-    return keyword in signature.parameters or any(
-        parameter.kind == inspect.Parameter.VAR_KEYWORD for parameter in signature.parameters.values()
-    )
+    parameter = signature.parameters.get(keyword)
+    return (
+        parameter is not None
+        and parameter.kind in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY)
+    ) or any(parameter.kind == inspect.Parameter.VAR_KEYWORD for parameter in signature.parameters.values())
 
 
 def _type_error_rejects_keyword(exc: TypeError, keyword: str) -> bool:
@@ -349,6 +710,12 @@ def _type_error_rejects_keyword(exc: TypeError, keyword: str) -> bool:
     )
 
 
+def _create_embedding_model(model_factory: Callable[..., object], *, device: str) -> object:
+    if _callable_accepts_keyword(model_factory, "device"):
+        return model_factory(device=device)
+    return model_factory()
+
+
 def _run_split_cycle(
     *,
     db_path: Path,
@@ -361,7 +728,7 @@ def _run_split_cycle(
     embed_batch_fn: Callable[[list[str]], list[list[float]]] | None = None,
     enrich_fn: Callable[..., object] = enrich_realtime,
     candidate_rows_fn: Callable[..., list[EmbedCandidate]] = _candidate_chunk_rows,
-    pending_rows_fn: Callable[..., list[EmbedCandidate]] = _pending_chunk_rows,
+    pending_rows_fn: Callable[..., list[EmbedCandidate]] = _pending_chunk_rows_with_resume,
     write_vectors_fn: Callable[..., int] = _write_embedded_vectors,
 ) -> CycleResult:
     embedded = 0
@@ -419,9 +786,13 @@ def _queue_depth(queue_dir: Path) -> int:
         return 0
 
 
+def _is_enrichment_queue_file(path: Path) -> bool:
+    return path.name.startswith("enrichment-") or path.name.startswith("queue-enrichment")
+
+
 def _high_priority_queue_depth(queue_dir: Path) -> int:
     try:
-        return sum(1 for path in queue_dir.glob("*.jsonl") if not path.name.startswith("enrichment-"))
+        return sum(1 for path in queue_dir.glob("*.jsonl") if not _is_enrichment_queue_file(path))
     except OSError:
         return 0
 
@@ -479,7 +850,8 @@ def run(
     enrich_limit: int,
     enrich_since_hours: int,
     vector_store_cls: Callable[[Path], VectorStore] = VectorStore,
-    model_factory: Callable[[], object] = get_embedding_model,
+    model_factory: Callable[..., object] = get_embedding_model,
+    embedding_device: str = DEFAULT_HOTLANE_EMBED_DEVICE,
     cycle_fn: Callable[..., CycleResult] = run_cycle,
     time_fn: Callable[[], float] = time.monotonic,
     sleep_fn: Callable[[float], None] = time.sleep,
@@ -488,7 +860,7 @@ def run(
     queue_depth_fn: Callable[[Path], int] = _queue_depth,
     high_priority_queue_depth_fn: Callable[[Path], int] = _high_priority_queue_depth,
 ) -> None:
-    model = model_factory()
+    model = _create_embedding_model(model_factory, device=embedding_device)
     embed_batch_fn = getattr(model, "embed_texts", None)
     if embed_batch_fn is not None:
 
@@ -505,6 +877,9 @@ def run(
     last_backlog = time_fn() - backlog_interval
     last_enrich = 0.0
     enrich_disabled = False
+    queue_backpressure_active = False
+    backlog_slice_logged = False
+    hot_candidate_scanner = HotCandidateScanner()
     cycles = 0
     backlog_batch = min(max(backlog_batch, 0), MAX_BACKLOG_BATCH)
     LOGGER.info("hotlane adapter started db=%s", db_path)
@@ -515,23 +890,34 @@ def run(
             now = time_fn()
             queue_has_backlog = queue_depth_fn(queue_dir) > 0
             queue_has_high_priority_backlog = queue_has_backlog and high_priority_queue_depth_fn(queue_dir) > 0
-            if queue_has_backlog:
-                if queue_has_high_priority_backlog:
-                    LOGGER.info("durable high-priority queue has backlog; yielding all hotlane writer work")
-                else:
-                    LOGGER.info("durable queue has backlog; yielding all hotlane writer work")
-                cycles += 1
-                sleep_fn(interval)
-                continue
+            cycle_backlog_batch = backlog_batch if backlog_batch > 0 and now - last_backlog >= backlog_interval else 0
+            cycle_recent_limit = recent_limit
+            if queue_has_high_priority_backlog:
+                if not queue_backpressure_active:
+                    LOGGER.info("durable high-priority queue has backlog; suppressing hot embedding and enrichment")
+                queue_backpressure_active = True
+                if cycle_backlog_batch <= 0:
+                    cycles += 1
+                    sleep_fn(interval)
+                    continue
+                cycle_recent_limit = 0
+                if not backlog_slice_logged:
+                    LOGGER.info(
+                        "durable high-priority queue has backlog; reserving backlog embedding slice batch=%d",
+                        cycle_backlog_batch,
+                    )
+                    backlog_slice_logged = True
             else:
-                cycle_backlog_batch = (
-                    backlog_batch if backlog_batch > 0 and now - last_backlog >= backlog_interval else 0
-                )
-                cycle_enrich_limit = (
-                    enrich_limit
-                    if not enrich_disabled and enrich_limit > 0 and now - last_enrich >= enrich_interval
-                    else 0
-                )
+                queue_backpressure_active = False
+                backlog_slice_logged = False
+            cycle_enrich_limit = (
+                enrich_limit
+                if not queue_has_backlog
+                and not enrich_disabled
+                and enrich_limit > 0
+                and now - last_enrich >= enrich_interval
+                else 0
+            )
             if cycle_backlog_batch > 0:
                 last_backlog = now
             if cycle_enrich_limit > 0:
@@ -541,11 +927,12 @@ def run(
                     db_path=db_path,
                     vector_store_cls=vector_store_cls,
                     embed_fn=embed_fn,
-                    recent_limit=recent_limit,
+                    recent_limit=cycle_recent_limit,
                     backlog_batch=cycle_backlog_batch,
                     embed_batch_fn=embed_batch_fn,
                     enrich_limit=cycle_enrich_limit,
                     enrich_since_hours=enrich_since_hours,
+                    candidate_rows_fn=hot_candidate_scanner,
                 )
             else:
                 store = vector_store_cls(db_path)
@@ -553,7 +940,7 @@ def run(
                     result = cycle_fn(
                         store=store,
                         embed_fn=embed_fn,
-                        recent_limit=recent_limit,
+                        recent_limit=cycle_recent_limit,
                         backlog_batch=cycle_backlog_batch,
                         embed_batch_fn=embed_batch_fn,
                         enrich_limit=cycle_enrich_limit,

{brainlayer-1.5.2 → brainlayer-1.5.4}/scripts/launchd/backup-daily.sh

@@ -3,8 +3,14 @@ set -euo pipefail
 
 export PATH="/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:$HOME/.local/bin"
 export PYTHONUNBUFFERED=1
-: "${BRAINLAYER_BACKUP_TIMEOUT_SECONDS:=300}"
+: "${BRAINLAYER_BACKUP_CLIENT_TIMEOUT_SECONDS:=0}"
+export BRAINLAYER_BACKUP_CLIENT_TIMEOUT_SECONDS
+: "${BRAINLAYER_BACKUP_TIMEOUT_SECONDS:=21600}"
 export BRAINLAYER_BACKUP_TIMEOUT_SECONDS
+: "${BRAINLAYER_BACKUP_SQLITE_CHECK_TIMEOUT_SECONDS:=0}"
+export BRAINLAYER_BACKUP_SQLITE_CHECK_TIMEOUT_SECONDS
+: "${BRAINLAYER_BACKUP_ATTEMPT_MAX_AGE_SECONDS:=86400}"
+export BRAINLAYER_BACKUP_ATTEMPT_MAX_AGE_SECONDS
 : "${BRAINLAYER_BACKUP_LOG_PROVENANCE:=real}"
 export BRAINLAYER_BACKUP_LOG_PROVENANCE
 BRAINLAYER_DIR="${BRAINLAYER_DIR:-__BRAINLAYER_DIR_VALUE__}"