brainlayer 1.5.78__tar.gz → 1.5.79__tar.gz

{brainlayer-1.5.78 → brainlayer-1.5.79}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: brainlayer
-Version: 1.5.78
+Version: 1.5.79
 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.78 → brainlayer-1.5.79}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "brainlayer"
-version = "1.5.78"
+version = "1.5.79"
 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.78 → brainlayer-1.5.79}/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.78",
+  "version": "1.5.79",
   "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.78",
+      "version": "1.5.79",
       "runtimeHint": "pipx",
       "transport": {
         "type": "stdio"

{brainlayer-1.5.78 → brainlayer-1.5.79}/src/brainlayer/__init__.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-__version__ = "1.5.78"
+__version__ = "1.5.79"
 # 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.79/src/brainlayer/_build.py

@@ -0,0 +1 @@
+BUILD_SHA = "d13c7d37d66306b8b40e04c320893e621145d74e"

{brainlayer-1.5.78 → brainlayer-1.5.79}/src/brainlayer/brainbar_auto_activation.py

@@ -31,12 +31,15 @@ def brew_processes():
     # Include brew's Ruby entrypoint and Homebrew-owned child executables, even
     # after reparenting. Unknown/unreadable process tables defer activation.
     rows = process_table().splitlines()
-    matches = []
+    matches, readable = [], 0
     for row in rows:
         fields = row.split(None, 3)
-        if len(fields) != 4 or not fields[0].isascii() or not fields[0].isdecimal():
-            raise ValueError("unreadable process table")
-        tokens = fields[3].split()
+        # A process exiting or exec-ing mid-scan can tear one row: empty args
+        # are still checked by comm, a row without a pid and comm is skipped.
+        if len(fields) < 3 or not fields[0].isascii() or not fields[0].isdecimal():
+            continue
+        readable += 1
+        tokens = fields[3].split() if len(fields) == 4 else []
         if Path(fields[2]).name == "brew" or any(
             Path(token).name in {"brew", "brew.rb"} or "/Homebrew/" in token or "/homebrew/Library/Homebrew/" in token
             for token in tokens
@@ -44,6 +47,8 @@ def brew_processes():
             # argv is detection-only: Homebrew curl headers can carry tokens.
             executable = scrub_secrets(Path(fields[2]).name).text[:128]
             matches.append(f"{fields[0]} {executable}")
+    if not readable:
+        raise ValueError("unreadable process table")
     return matches
 
 
@@ -85,6 +90,9 @@ class AutoActivator:
             processes = brew_processes()
         except (OSError, subprocess.SubprocessError) as exc:
             raise ProcessScanUnavailable(type(exc).__name__) from None
+        except ValueError:
+            # Counted and alerted only after 12 ticks, never an immediate refusal.
+            raise ProcessScanUnavailable("unreadable process table") from None
         # Recover before activation can report a new failure on the same alert key.
         self.state.with_suffix(".scan.json").unlink(missing_ok=True)
         reason = active_alerts().get("brainbar-activation", "")
@@ -97,6 +105,7 @@ class AutoActivator:
             (
                 "BrainBar activation process scan failed for >=12 ticks:",
                 "BrainBar activation monitor refused: Command '['/bin/ps',",
+                "BrainBar activation monitor refused: unreadable process table",
             )
         ):
             report("brainbar-activation", None)

{brainlayer-1.5.78 → brainlayer-1.5.79}/src/brainlayer/job_alerts.py

@@ -65,7 +65,12 @@ def report(
     path: Path | None = None,
     notify: Callable[[str], None] = _notify,
 ) -> bool:
-    """Set or clear one episode. Return true only when the visible state changes."""
+    """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):
         current = active_alerts(destination)
@@ -75,15 +80,19 @@ def report(
                 return False
             current.pop(key)
             message = f"BrainLayer {key} recovered"
+            post = False
         else:
             if before is not None and (before == reason or key != "drive-consent"):
                 return False
+            post = reason not in (value for other, value in current.items() if other != key)
             current[key] = reason
             message = reason
         from brainlayer.drive_credentials import _atomic_write
 
         _atomic_write(destination, current)
     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:

{brainlayer-1.5.78 → brainlayer-1.5.79}/src/brainlayer/maintenance_calendar.py

@@ -28,7 +28,16 @@ from .drive_credentials import _atomic_write
 from .index_budget import CALENDAR_INDEX_UNWIND_S, calendar_index_budget_s
 from .job_alerts import active_alerts, report
 from .maintenance_control import MaintenanceHold
-from .supervisor_guard import Custody, gated_spawn, guard_lease, launch_guard, start_time, stop_group
+from .supervisor_guard import (
+    MAX_STALL_GRACE_S,
+    Custody,
+    configured_guard_timeout,
+    gated_spawn,
+    guard_lease,
+    launch_guard,
+    start_time,
+    stop_group,
+)
 from .supervisor_jobs import TRANSCRIPT_RECOVERY_EXIT_TIMEOUT, TRANSCRIPT_RECOVERY_RUN_TIMEOUT
 
 LOG = logging.getLogger(__name__)
@@ -636,12 +645,14 @@ async def _admit_calendar(steps, directory, date, transcript_recovery, guard_tim
             if len(recovery) != 1:
                 raise ValueError("full calendar admission requires one bounded transcript step")
             # Cover the actual step bound, the supervisor backstop and its exit grace,
-            # plus guard startup/expiry and group/guard shutdown. The suspend-aware
-            # elapsed clock cannot be extended by a wall-clock change or sleep.
+            # plus guard startup/expiry (its host-stall grace ends at an absolute
+            # missed-deadline + MAX_STALL_GRACE_S) and group/guard shutdown. The
+            # suspend-aware elapsed clock cannot be extended by a wall-clock change or sleep.
             deadline += (
                 max(recovery[0].timeout, TRANSCRIPT_RECOVERY_RUN_TIMEOUT)
                 + TRANSCRIPT_RECOVERY_EXIT_TIMEOUT
                 + guard_timeout
+                + MAX_STALL_GRACE_S
                 + 2 * shutdown_timeout
                 + 30
             )
@@ -681,7 +692,7 @@ async def run_calendar(
     directory,
     logs,
     *,
-    guard_timeout=30,
+    guard_timeout=None,
     shutdown_timeout=15,
     operation_timeout=120,
     install_signals=False,
@@ -691,6 +702,8 @@ async def run_calendar(
     defer_after=3,
     transcript_recovery=False,
 ):
+    if guard_timeout is None:
+        guard_timeout = await _blocking(configured_guard_timeout)
     if (
         not all(math.isfinite(v) and v > 0 for v in (guard_timeout, shutdown_timeout, operation_timeout))
         or defer_after < 1

{brainlayer-1.5.78 → brainlayer-1.5.79}/src/brainlayer/service_supervisor.py

@@ -90,13 +90,15 @@ class Supervisor:
         path: Path | None = None,
         *,
         backoff: float = 10,
-        guard_timeout: float = 30,
+        guard_timeout: float | None = None,
         shutdown_timeout: float = 15,
         stable_uptime: float = 60,
         operation_timeout: float = 120,
     ):
         if any(name.removeprefix("com.brainlayer.") in {"enrich", "enrichment"} for name in components):
             raise ValueError("enrichment is retired")
+        if guard_timeout is None:
+            guard_timeout = supervisor_guard.configured_guard_timeout()
         if not all(
             math.isfinite(v) and v > 0
             for v in (backoff, guard_timeout, shutdown_timeout, stable_uptime, operation_timeout)

{brainlayer-1.5.78 → brainlayer-1.5.79}/src/brainlayer/supervisor_guard.py

@@ -23,6 +23,40 @@ from pathlib import Path
 
 from .supervisor_diagnostics import DiagnosticSink, emit
 
+STALL_OVERSHOOT_S = 5.0
+MAX_STALL_REARMS = 3
+MAX_STALL_GRACE_S = 300.0
+GUARD_TIMEOUT_ENV = "BRAINLAYER_SUPERVISOR_GUARD_TIMEOUT_SECONDS"
+# Background launchd jobs under host load stalled 31-36 s on 2026-10-28; 30 s killed live parents.
+# A dead parent is still caught at once by pipe EOF, so this only bounds an alive-but-silent one.
+DEFAULT_GUARD_TIMEOUT_SECONDS = 120.0
+GUARD_TIMEOUT_BOUNDS = (10.0, 900.0)
+
+
+def configured_guard_timeout() -> float:
+    """Heartbeat budget for the daemon and calendar guards; an invalid override raises, never falls back."""
+    from .config import _split_launchd_env_assignment, configured_brainlayer_env_value, get_user_env_path
+
+    path = Path(os.environ.get("BRAINLAYER_ENV_FILE", get_user_env_path()))
+    configured = configured_brainlayer_env_value(GUARD_TIMEOUT_ENV, path)
+    if path.exists():
+        # The shared parser skips a substitution line as absent; here that would be a silent fallback.
+        for line in path.read_text(encoding="utf-8").splitlines():
+            assignment = _split_launchd_env_assignment(line)
+            if assignment and assignment[0] == GUARD_TIMEOUT_ENV and ("$(" in assignment[1] or "`" in assignment[1]):
+                raise ValueError(f"{GUARD_TIMEOUT_ENV} in {path} uses unsupported command substitution")
+    raw = configured if configured is not None else os.environ.get(GUARD_TIMEOUT_ENV)
+    if raw is None:
+        return DEFAULT_GUARD_TIMEOUT_SECONDS
+    low, high = GUARD_TIMEOUT_BOUNDS
+    try:
+        value = float(raw)
+    except ValueError:
+        value = math.nan
+    if not (math.isfinite(value) and low <= value <= high):
+        raise ValueError(f"{GUARD_TIMEOUT_ENV} must be a finite number of seconds in [{low:g}, {high:g}]: {raw!r}")
+    return value
+
 
 @contextmanager
 def component_gate(directory: Path, *, exclusive=False):
@@ -248,14 +282,48 @@ def run_guard(
     os.close(ready)
     groups, buffer, quiesced = set(), b"", False
     timed_out = False
+    stall_rearms = 0
+    stall_grace_end = None  # Absolute end of this incident's grace: missed deadline + MAX_STALL_GRACE_S.
     last_heartbeat = time.monotonic()
     deadline = last_heartbeat + timeout
     channel = socket.socket(fileno=lease_control) if lease_control is not None else None
     lease = None
     try:
         while True:
-            remaining = max(0, deadline - time.monotonic())
+            wait_started = time.monotonic()
+            remaining = max(0, deadline - wait_started)
             readable = select.select([0, channel] if channel else [0], [], [], remaining)[0]
+            now = time.monotonic()
+            overshoot = now - wait_started - remaining
+            data = os.read(0, 65536) if 0 in readable else None
+            if data == b"":
+                break  # A dead parent needs cleanup, never stall grace.
+            # A starved guard cannot judge parent liveness. Give it a fresh window,
+            # bounded by both incident caps; only a real heartbeat resets them. The
+            # grace is an absolute end, so stall overshoots count against it too.
+            if not quiesced and overshoot > STALL_OVERSHOOT_S and stall_grace_end is None:
+                stall_grace_end = deadline + MAX_STALL_GRACE_S
+            if (
+                not quiesced
+                and overshoot > STALL_OVERSHOOT_S
+                and stall_rearms < MAX_STALL_REARMS
+                and now < stall_grace_end
+            ):
+                stall_rearms += 1
+                deadline = min(now + timeout, stall_grace_end)
+                stall_grace_used = deadline - (stall_grace_end - MAX_STALL_GRACE_S)
+                emit(
+                    diagnostics,
+                    event="guard-stall-rearm",
+                    parent_pid=parent,
+                    parent_start_time=parent_birth,
+                    guard_pid=os.getpid(),
+                    wait_overshoot_s=overshoot,
+                    stall_rearms=stall_rearms,
+                    grace_used_s=stall_grace_used,
+                )
+                if not readable:
+                    continue
             timeout_event = dict(
                 event="guard-timeout",
                 health_event="supervisor_guard_timeout",
@@ -264,7 +332,7 @@ def run_guard(
                 guard_pid=os.getpid(),
                 mode="shutdown" if quiesced else "heartbeat",
                 guard_mode="Q" if quiesced else "H",
-                last_heartbeat_age_s=time.monotonic() - last_heartbeat,
+                last_heartbeat_age_s=now - last_heartbeat,
                 registered_pgids=sorted(groups),
                 reason="shutdown-timeout" if quiesced else "heartbeat-timeout",
             )
@@ -293,13 +361,12 @@ def run_guard(
                 channel.sendall(b"R")
                 if 0 not in readable:
                     continue
-            data = os.read(0, 65536)
-            if not data:
-                break  # Even Q cannot abandon groups if shutdown itself was killed.
             buffer += data
             while b"\n" in buffer:
                 line, buffer = buffer.split(b"\n", 1)
                 if line == b"H" and not quiesced:
+                    stall_rearms = 0
+                    stall_grace_end = None
                     last_heartbeat = time.monotonic()
                     deadline = last_heartbeat + timeout
                 elif line == b"Q" and not quiesced:

brainlayer-1.5.78/src/brainlayer/_build.py

@@ -1 +0,0 @@
-BUILD_SHA = "67a98f996619eb35ed4358610757936f5c5ef583"