brainlayer 1.5.87__tar.gz → 1.5.89__tar.gz

{brainlayer-1.5.87 → brainlayer-1.5.89}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: brainlayer
-Version: 1.5.87
+Version: 1.5.89
 Summary: Persistent local memory for AI agents — 16 BrainBar MCP tools, semantic search, knowledge graph, SQLite
 Project-URL: Homepage, https://brainlayer.etanheyman.com
 Project-URL: Repository, https://github.com/EtanHey/brainlayer

{brainlayer-1.5.87 → brainlayer-1.5.89}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "brainlayer"
-version = "1.5.87"
+version = "1.5.89"
 description = "Persistent local memory for AI agents — 16 BrainBar MCP tools, semantic search, knowledge graph, SQLite"
 license = {text = "Apache-2.0"}
 readme = "README.md"

{brainlayer-1.5.87 → brainlayer-1.5.89}/server.json

@@ -3,7 +3,7 @@
   "name": "io.github.etanhey/brainlayer",
   "title": "BrainLayer",
   "description": "Persistent local memory for AI agents \u2014 semantic search, knowledge graph, and 16 BrainBar MCP tools with ToolAnnotations over SQLite.",
-  "version": "1.5.87",
+  "version": "1.5.89",
   "websiteUrl": "https://brainlayer.etanheyman.com",
   "repository": {
     "url": "https://github.com/EtanHey/brainlayer",
@@ -14,7 +14,7 @@
       "registryType": "pypi",
       "registryBaseUrl": "https://pypi.org",
       "identifier": "brainlayer",
-      "version": "1.5.87",
+      "version": "1.5.89",
       "runtimeHint": "pipx",
       "transport": {
         "type": "stdio"

{brainlayer-1.5.87 → brainlayer-1.5.89}/src/brainlayer/__init__.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-__version__ = "1.5.87"
+__version__ = "1.5.89"
 # Git sha the distributed package was built from; stamped by the release build, None in a source tree.
 # scripts/sprint_gate.py reads it in "keg" mode to prove the served package is the code under test.
 # No runtime `str | None` annotation: launchd/install.sh imports this under /usr/bin/python3 (3.9).

brainlayer-1.5.89/src/brainlayer/_build.py

@@ -0,0 +1 @@
+BUILD_SHA = "4e5c275f01698d443a6727f30d54638b22ac7797"

{brainlayer-1.5.87 → brainlayer-1.5.89}/src/brainlayer/backup_daily.py

@@ -3373,6 +3373,7 @@ def _serialized_backup_run(func: Callable[..., dict[str, Any]]) -> Callable[...,
                     },
                 )
                 raise BackupAlreadyRunningError(error) from exc
+            _record_backup_lock_time(staging_dir)
             try:
                 # Weekly maintenance's first receipt check precedes this lock. A daily
                 # backup can finish in that gap, so recheck before copying the DB.
@@ -3395,6 +3396,22 @@ def _serialized_backup_run(func: Callable[..., dict[str, Any]]) -> Callable[...,
     return wrapped
 
 
+def _record_backup_lock_time(staging_dir: Path) -> None:
+    """Write the current local/upload phase start beside the held backup flock."""
+    descriptor = -1
+    try:
+        descriptor = os.open(staging_dir / ".backup.lock", os.O_WRONLY | os.O_NOFOLLOW)
+        value = dt.datetime.now(dt.UTC).isoformat(timespec="seconds").encode("ascii") + b"\n"
+        os.ftruncate(descriptor, 0)
+        os.write(descriptor, value)
+    except OSError:
+        # No reader may treat this lock-file content as a lock signal; only the held flock is authoritative.
+        pass  # The display timestamp is best effort.
+    finally:
+        if descriptor >= 0:
+            os.close(descriptor)
+
+
 def _upload_identity(path: Path) -> dict[str, Any]:
     with path.open("rb") as handle:
         digest = hashlib.file_digest(handle, "sha256").hexdigest()
@@ -3809,6 +3826,7 @@ def run_backup(
                 folder_id = ensure_drive_folder_chain(service, resolved_folder_parts)
                 break  # Completed session: retry verification, never POST another upload.
             result["upload_state"] = "in_progress"
+            _record_backup_lock_time(snapshot.parent)
             credentials = get_drive_credentials()
             service = build_drive_service()
             folder_id = ensure_drive_folder_chain(service, resolved_folder_parts)

{brainlayer-1.5.87 → brainlayer-1.5.89}/src/brainlayer/cli/__init__.py

@@ -3142,7 +3142,15 @@ def wal_checkpoint(
         console.print(
             f"Checkpoint ({result['mode']}): {result['checkpointed_pages']}/{result['log_pages']} pages{suffix}"
         )
+        if result.get("deferred"):
+            console.print(
+                "TRUNCATE deferred after bounded retries; PASSIVE checkpoint attempted; "
+                "the WAL remains available for the next checkpoint."
+            )
 
+    if result.get("deferred"):
+        report_job_alert("wal-checkpoint", None)
+        return
     if result["busy"]:
         report_job_alert("wal-checkpoint", "BrainLayer WAL checkpoint was busy; check the job log")
         raise typer.Exit(1)

brainlayer-1.5.89/src/brainlayer/job_alerts.py

@@ -0,0 +1,156 @@
+"""Durable, deduplicated backup/maintenance failure notices."""
+
+from __future__ import annotations
+
+import fcntl
+import json
+import logging
+import os
+import subprocess
+from contextlib import contextmanager
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Callable, Mapping
+
+from brainlayer.paths import get_db_path
+
+LOG = logging.getLogger(__name__)
+ALERT_PATH_ENV = "BRAINLAYER_JOB_ALERT_PATH"
+
+
+def alert_path(*, env: Mapping[str, str] | None = None, db_path: Path | None = None) -> Path:
+    env = os.environ if env is None else env
+    return Path(env.get(ALERT_PATH_ENV) or (db_path or get_db_path()).with_name("job-alerts.json")).expanduser()
+
+
+def _times_path(path: Path) -> Path:
+    return path.with_name(f"{path.stem}.times.json")
+
+
+def _notify(message: str) -> None:
+    if os.environ.get("BRAINLAYER_TEST_PATH_PROVENANCE") == "pytest":
+        return
+    subprocess.run(
+        [
+            "osascript",
+            "-e",
+            'on run argv\n display notification (item 1 of argv) with title "BrainLayer"\nend run',
+            message,
+        ],
+        timeout=8,
+        check=True,
+        capture_output=True,
+    )
+
+
+@contextmanager
+def _locked(path: Path):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd = os.open(path.with_suffix(".lock"), os.O_CREAT | os.O_RDWR | os.O_NOFOLLOW, 0o600)
+    try:
+        fcntl.flock(fd, fcntl.LOCK_EX)
+        yield
+    finally:
+        fcntl.flock(fd, fcntl.LOCK_UN)
+        os.close(fd)
+
+
+def _alert_records(path: Path | None = None) -> dict[str, dict[str, str | None]]:
+    try:
+        value = json.loads((path or alert_path()).read_text(encoding="utf-8"))
+        if not isinstance(value, dict):
+            return {}
+        records = {}
+        for key, item in value.items():
+            if isinstance(item, str):  # Read pre-S32 files without losing their live alerts.
+                records[str(key)] = {"reason": item, "reported_at": None}
+            elif isinstance(item, dict) and isinstance(item.get("reason"), str):
+                records[str(key)] = {
+                    "reason": item["reason"],
+                    "reported_at": None,
+                }
+        times = _alert_times(_times_path(path or alert_path()))
+        for key, reported_at in times.items():
+            if key in records:
+                records[key]["reported_at"] = reported_at
+        return records
+    except (FileNotFoundError, OSError, ValueError):
+        return {}
+
+
+def _alert_times(path: Path) -> dict[str, str]:
+    """Read optional timestamps; absent or malformed metadata never hides an alert."""
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+        if not isinstance(value, dict) or not all(isinstance(item, str) for item in value.values()):
+            return {}
+        return {str(key): item for key, item in value.items()}
+    except (FileNotFoundError, OSError, ValueError):
+        return {}
+
+
+def active_alerts(path: Path | None = None) -> dict[str, str]:
+    """Return current reasons, accepting both legacy strings and timestamped records."""
+    return {key: record["reason"] for key, record in _alert_records(path).items()}
+
+
+def alert_reported_at(path: Path | None = None) -> dict[str, str]:
+    """Return alert occurrence times where available; legacy records have no timestamp."""
+    return {key: at for key, record in _alert_records(path).items() if (at := record["reported_at"]) is not None}
+
+
+def report(
+    key: str,
+    reason: str | None,
+    *,
+    path: Path | None = None,
+    notify: Callable[[str], None] = _notify,
+) -> bool:
+    """Set or clear one episode. Return true only when the visible state changes.
+
+    Only a new failure posts a notification, and only when no other active key already
+    carries the identical message (one incident fanned out across keys posts once).
+    Recovery updates the alert file and the health log but never notifies.
+    """
+    destination = path or alert_path()
+    with _locked(destination):
+        records = _alert_records(destination)
+        before = records.get(key, {}).get("reason")
+        if reason is None:
+            if before is None:
+                return False
+            records.pop(key)
+            message = f"BrainLayer {key} recovered"
+            post = False
+        else:
+            if before is not None and before == reason:
+                records[key]["reported_at"] = datetime.now(UTC).isoformat(timespec="microseconds")
+                _write_records(destination, records)
+                return False
+            if before is not None and key != "drive-consent":
+                return False
+            post = reason not in (record["reason"] for other, record in records.items() if other != key)
+            records[key] = {"reason": reason, "reported_at": datetime.now(UTC).isoformat(timespec="microseconds")}
+            message = reason
+        _write_records(destination, records)
+    LOG.warning("health event job=%s state=%s reason=%s", key, "recovered" if reason is None else "failed", message)
+    if not post:
+        return True
+    try:
+        notify(message)
+    except (OSError, subprocess.SubprocessError) as exc:
+        LOG.warning("macOS notification failed for %s: %s", key, type(exc).__name__)
+    return True
+
+
+def _write_records(path: Path, records: dict[str, dict[str, str | None]]) -> None:
+    """Atomically replace both files under the caller's shared alert lock.
+
+    The public alerts file intentionally stays a map of strings for older BrainBar readers.
+    """
+    from brainlayer.drive_credentials import _atomic_write
+
+    alerts = {key: record["reason"] for key, record in records.items()}
+    times = {key: record["reported_at"] for key, record in records.items() if record["reported_at"]}
+    _atomic_write(_times_path(path), times)
+    _atomic_write(path, alerts)

{brainlayer-1.5.87 → brainlayer-1.5.89}/src/brainlayer/launchd_consolidation.py

@@ -1,11 +1,13 @@
 """Explicit launchd migration with durable archive custody and checked rollback."""
 
+import fcntl
 import hashlib
 import json
 import os
 import plistlib
 import re
 import stat
+import sys
 import time
 import uuid
 from pathlib import Path
@@ -21,6 +23,8 @@ from .consolidation_plan import (
     rendered_launchers,
     snapshot_legacy,
 )
+from .launcher_policy_reconcile import transition as launcher_policy_transition
+from .launcher_policy_reconcile import validate as validate_launcher_policy
 from .migration_custody import migration_lock, write_launch_agent
 from .migration_custody import write_new_file as write_file
 from .migration_journal import archive_replace as update
@@ -80,6 +84,41 @@ def wait_custody(directory, *, clock=time, grace=30):
         clock.sleep(0.1)
 
 
+def _acquire_maintenance_idle(home):
+    """Hold nonblocking maintenance leases through a policy-only launcher restart."""
+    paths = (
+        home / ".local/share/brainlayer/supervisor/maintenance.lock",
+        home / ".local/share/brainlayer/.maintenance.lock",
+        home / ".local/share/brainlayer/backups/.backup.lock",
+    )
+    held = []
+    try:
+        for path in paths:
+            if not os.path.lexists(path):
+                continue
+            fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK)
+            held.append(fd)
+            info = os.fstat(fd)
+            if not stat.S_ISREG(info.st_mode) or info.st_uid != os.getuid() or info.st_nlink != 1:
+                raise RuntimeError("maintenance lock identity refused; retry later")
+            try:
+                fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            except BlockingIOError:
+                raise RuntimeError("maintenance is busy; retry later") from None
+        return held
+    except BaseException:
+        _release_maintenance_locks(held)
+        raise
+
+
+def _release_maintenance_locks(held):
+    for fd in held:
+        try:
+            fcntl.flock(fd, fcntl.LOCK_UN)
+        finally:
+            os.close(fd)
+
+
 def migrate(*, home, **options):
     with migration_lock(home) as control:
         receipt, *destinations = publication_paths(home)
@@ -198,6 +237,65 @@ def _migrate(
             if label in NEW:
                 remember_started(label, current)
 
+    def reconcile_launchers(journal, expected_receipt, pending, *, recovering, held_locks=None):
+        validate_launcher_policy(pending)
+        changed = set(pending["diff"])
+        own_locks = held_locks is None and "com.brainlayer.maintenance" in changed
+        locks = _acquire_maintenance_idle(home) if own_locks else (held_locks or [])
+        try:
+            if "com.brainlayer.maintenance" in changed:
+                _, calendar_pid = observe(NEW[1])
+                if calendar_pid is not None and alive(calendar_pid):
+                    raise RuntimeError("calendar is active; maintenance busy, retry later")
+            if not recovering:
+                journal_update(journal, expected_receipt)
+                expected_receipt = json.dumps(journal).encode()
+        except BaseException:
+            if own_locks:
+                _release_maintenance_locks(locks)
+            raise
+        publications = {}
+        try:
+            for name, item in pending["files"].items():
+                path = agents / name
+                old, new = bytes.fromhex(item["old_bytes"]), bytes.fromhex(item["new_bytes"])
+                current = read_owned(path)
+                if current not in {old, new}:
+                    raise RuntimeError(f"launcher policy recovery found foreign plist: {name}")
+                label = name.removesuffix(".plist")
+                state = runtime.observe(label)
+                if current == old and state["loaded"]:
+                    stop(label, state)
+                if current == old:
+                    update(path, old, new, Path(journal["archive"]), write_launch_agent)
+                if not runtime.observe(label)["loaded"]:
+                    bootstrap(label, path)
+                publications[name] = new.hex()
+
+            result = journal.get("restart_preimage", journal).copy()
+            result.pop("launcher_policy_reconcile", None)
+            files = dict(result["published_files"])
+            files.update(publications)
+            result.update(
+                phase="migrated",
+                published_files=files,
+                published_sha256={name: hashlib.sha256(bytes.fromhex(raw)).hexdigest() for name, raw in files.items()},
+                configuration_sha256={
+                    **result["configuration_sha256"],
+                    **{name.removesuffix(".plist"): item["new_sha256"] for name, item in pending["files"].items()},
+                },
+                launcher_policy_reconciliations=result.get("launcher_policy_reconciliations", [])
+                + [{"diff": pending["diff"], "files": pending["files"]}],
+            )
+            journal_update(result, expected_receipt)
+            for label, changes in pending["diff"].items():
+                for key, values in changes.items():
+                    print(f"{label}: {key} {values['old']} → {values['new']}", file=sys.stderr)
+            return result
+        finally:
+            if own_locks:
+                _release_maintenance_locks(locks)
+
     def verify_daemon():
         if NEW[0] not in disabled:
             if verify is not None:
@@ -542,17 +640,38 @@ def _migrate(
             )
         if pending:
             try:
+                if "launcher_policy_reconcile" in previous:
+                    return reconcile_launchers(
+                        previous, previous_bytes, previous["launcher_policy_reconcile"], recovering=True
+                    )
                 if "requested_keg" in previous:
                     return restart_daemon(previous, previous_bytes, recovering=True)
                 return restore_first(previous, previous_bytes, recovering=True)
             except BaseException as failure:
                 if not isinstance(failure, Exception):
                     raise
+                if "busy, retry later" in str(failure) or "busy; retry later" in str(failure):
+                    raise
                 raise RuntimeError(
                     f"interrupted migration; rollback incomplete; operator reconciliation: {failure}"
                 ) from failure
         if previous.get("phase") != "migrated":
             raise RuntimeError("unknown migration phase; operator reconciliation required")
+        try:
+            launcher_policy = launcher_policy_transition(previous, prepared)
+        except ValueError as failure:
+            raise RuntimeError(str(failure)) from failure
+        if launcher_policy:
+            restarting = previous | dict(phase="migrating", launcher_policy_reconcile=launcher_policy)
+            changes_maintenance = "com.brainlayer.maintenance" in launcher_policy["diff"]
+            locks = _acquire_maintenance_idle(home) if changes_maintenance else []
+            try:
+                previous = reconcile_launchers(
+                    restarting, previous_bytes, launcher_policy, recovering=False, held_locks=locks
+                )
+                previous_bytes = json.dumps(previous).encode()
+            finally:
+                _release_maintenance_locks(locks)
         if any(os.path.lexists(agents / name) for name in previous["files"]):
             raise RuntimeError("legacy files reappeared after consolidation")
         for name, original in previous["files"].items():

brainlayer-1.5.89/src/brainlayer/launcher_policy_reconcile.py

@@ -0,0 +1,75 @@
+"""Journal launcher plist transitions that change policy keys only."""
+
+import hashlib
+import plistlib
+
+POLICY_KEYS = frozenset({"ProcessType", "Nice", "LowPriorityIO", "SoftResourceLimits"})
+
+
+def _transition(previous, prepared):
+    """Return a verifiable policy-only transition, or raise for any other edit."""
+    files = {}
+    diff = {}
+    for label, new in prepared.items():
+        name = f"{label}.plist"
+        old = bytes.fromhex(previous["published_files"][name])
+        before, after = plistlib.loads(old), plistlib.loads(new)
+        if before.get("Label") != label or after.get("Label") != label:
+            raise ValueError(f"launcher identity changed: {label}")
+        old_nonpolicy = {key: value for key, value in before.items() if key not in POLICY_KEYS}
+        new_nonpolicy = {key: value for key, value in after.items() if key not in POLICY_KEYS}
+        if old_nonpolicy != new_nonpolicy:
+            raise ValueError("launcher configuration changed; explicit replan required")
+        changes = {
+            key: {"old": before.get(key), "new": after.get(key)}
+            for key in sorted(POLICY_KEYS)
+            if before.get(key) != after.get(key)
+        }
+        if changes:
+            files[name] = {
+                "old_bytes": old.hex(),
+                "new_bytes": new.hex(),
+                "old_sha256": hashlib.sha256(old).hexdigest(),
+                "new_sha256": hashlib.sha256(new).hexdigest(),
+            }
+            diff[label] = changes
+    if not diff:
+        return None
+    return {"files": files, "diff": diff}
+
+
+def transition(previous, prepared):
+    """Collect policy-only changes per launcher.
+
+    A launcher whose non-policy keys differ from its published bytes is left out, not refused:
+    the existing journal checks own that case (a restart fallback pins a different daemon than
+    the requested configuration, and a real configuration change must still refuse there).
+    """
+    files, diff = {}, {}
+    for label, new in prepared.items():
+        try:
+            one = _transition(previous, {label: new})
+        except ValueError as failure:
+            if "explicit replan required" in str(failure):
+                continue
+            raise
+        if one:
+            files.update(one["files"])
+            diff.update(one["diff"])
+    return {"files": files, "diff": diff} if diff else None
+
+
+def validate(pending):
+    """Validate journal custody without consulting mutable templates."""
+    if set(pending) != {"files", "diff"} or set(pending["files"]) != {f"{label}.plist" for label in pending["diff"]}:
+        raise ValueError("invalid launcher policy journal")
+    for name, item in pending["files"].items():
+        old, new = bytes.fromhex(item["old_bytes"]), bytes.fromhex(item["new_bytes"])
+        if hashlib.sha256(old).hexdigest() != item["old_sha256"]:
+            raise ValueError("invalid old launcher policy hash")
+        if hashlib.sha256(new).hexdigest() != item["new_sha256"]:
+            raise ValueError("invalid new launcher policy hash")
+        label = name.removesuffix(".plist")
+        candidate = _transition({"published_files": {name: old.hex()}}, {label: new})
+        if candidate != {"files": {name: item}, "diff": {label: pending["diff"][label]}}:
+            raise ValueError("invalid launcher policy transition")

{brainlayer-1.5.87 → brainlayer-1.5.89}/src/brainlayer/mcp_stdio_bridge.py

@@ -159,7 +159,7 @@ def _jsonrpc_error_for_frame(frame: InFlightFrame) -> bytes:
             "id": frame.request_id,
             "error": {
                 "code": -32000,
-                "message": "BrainLayer backend disconnected before responding; request was not acknowledged",
+                "message": "BrainLayer backend disconnected before responding; request outcome is unknown",
             },
         },
         separators=(",", ":"),
@@ -263,6 +263,14 @@ def run_bridge(
     eof_response_deadline: float | None = None
     pending_responses = 0
     stdout_failed = False
+    has_connected_once = False
+
+    def log_reconnect() -> None:
+        nonlocal has_connected_once
+        if has_connected_once:
+            stderr.write(f"brainlayer-mcp-stdio-bridge: reconnected to socket {config.socket_path!r}\n".encode("utf-8"))
+            stderr.flush()
+        has_connected_once = True
 
     def fail_in_flight_requests() -> None:
         nonlocal pending_responses, stdout_failed
@@ -316,6 +324,7 @@ def run_bridge(
         connecting = False
         connect_started_at = None
         reconnect_delay = config.reconnect_ms / 1000
+        log_reconnect()
 
     def mark_connected() -> None:
         nonlocal connected, connecting, connect_started_at, reconnect_delay
@@ -323,6 +332,7 @@ def run_bridge(
         connecting = False
         connect_started_at = None
         reconnect_delay = config.reconnect_ms / 1000
+        log_reconnect()
 
     try:
         while True:

{brainlayer-1.5.87 → brainlayer-1.5.89}/src/brainlayer/wal_checkpoint.py

@@ -20,6 +20,7 @@ from .paths import get_db_path, supervisor_socket_path
 _VALID_CHECKPOINT_MODES = {"PASSIVE", "FULL", "RESTART", "TRUNCATE"}
 _DEFAULT_GUARD_TIMEOUT_SECONDS = 10.0
 _GUARD_POLL_SECONDS = 0.1
+_WAL_CHECKPOINT_HARD_CEILING_BYTES = 4 * 1024**3
 
 
 class CheckpointGuardTimeout(TimeoutError):
@@ -155,6 +156,11 @@ def run_wal_checkpoint(
 
     mode = mode.upper()
     wal_before = get_wal_size(db_path)
+    if retry_busy and wal_before > _WAL_CHECKPOINT_HARD_CEILING_BYTES:
+        raise RuntimeError(
+            f"WAL is above the checkpoint safety ceiling ({format_size(wal_before)} > "
+            f"{format_size(_WAL_CHECKPOINT_HARD_CEILING_BYTES)})"
+        )
     attempts = 0
     max_attempts = max(1, int(max_attempts))
     delay = max(0.0, retry_base_seconds)
@@ -165,9 +171,16 @@ def run_wal_checkpoint(
             break
         sleep_fn(delay)
         delay = min(max(delay * 2, retry_base_seconds), max(retry_max_seconds, retry_base_seconds))
+    deferred = bool(busy and mode == "TRUNCATE" and retry_busy)
+    passive_result = None
+    if deferred:
+        # A held reader can prevent TRUNCATE from resetting the WAL. Make any safe
+        # progress without waiting for exclusive access, then leave truncation to
+        # the periodic fallback after that reader closes.
+        passive_result = checkpoint(db_path, "PASSIVE")
     wal_after = get_wal_size(db_path)
 
-    return {
+    result = {
         "db": db_path,
         "mode": mode,
         "wal_before_bytes": wal_before,
@@ -178,7 +191,12 @@ def run_wal_checkpoint(
         "log_pages": log_pages,
         "checkpointed_pages": checkpointed_pages,
         "attempts": attempts,
+        "deferred": deferred,
     }
+    if passive_result is not None:
+        result["passive_log_pages"] = passive_result[1]
+        result["passive_checkpointed_pages"] = passive_result[2]
+    return result
 
 
 def _fallback_defer_reason(directory):
@@ -331,6 +349,10 @@ def periodic_checkpoint(*, high_water_bytes=256_000_000, busy_timeout_seconds=0.
             f"{detail}. See wal-fallback.json for progress and diagnostics."
         )
     job_alerts.report("wal-checkpoint-fallback", reason, path=job_alerts.alert_path(db_path=Path(db)))
+    if reason is None:
+        # The 15-minute fallback is an equivalent successful checkpoint: retire a busy
+        # scheduled-checkpoint alert durably before BrainBar reads its next status snapshot.
+        job_alerts.report("wal-checkpoint", None, path=job_alerts.alert_path(db_path=Path(db)))
     return result
 
 

brainlayer-1.5.87/src/brainlayer/_build.py

@@ -1 +0,0 @@
-BUILD_SHA = "5fcad968fe3ef58c7d5309909b23c6d4d3ad572c"