brainlayer 1.5.85__tar.gz → 1.5.87__tar.gz

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "brainlayer"
-version = "1.5.85"
+version = "1.5.87"
 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.85 → brainlayer-1.5.87}/scripts/launchd/com.brainlayer.maintenance.plist

@@ -53,7 +53,7 @@
 	<key>Nice</key>
 	<integer>10</integer>
 	<key>ProcessType</key>
-	<string>Background</string>
+	<string>Standard</string>
 	<key>LowPriorityIO</key>
 	<true/>
 	<key>SoftResourceLimits</key>

{brainlayer-1.5.85 → brainlayer-1.5.87}/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.85",
+  "version": "1.5.87",
   "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.85",
+      "version": "1.5.87",
       "runtimeHint": "pipx",
       "transport": {
         "type": "stdio"

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

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

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

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

@@ -96,8 +96,10 @@ BACKUP_LOCAL_MAX_AGE_HOURS_ENV = "BRAINLAYER_BACKUP_LOCAL_MAX_AGE_HOURS"
 BACKUP_REUSE_VERIFIED_MAX_AGE_HOURS_ENV = "BRAINLAYER_BACKUP_REUSE_VERIFIED_MAX_AGE_HOURS"
 BACKUP_SUPERVISED_CHILD_ENV = "BRAINLAYER_BACKUP_SUPERVISED_CHILD"
 BACKUP_INVOCATION_ENV = "BRAINLAYER_BACKUP_INVOCATION_ID"
-# Fields supervisor_child.backup_io_policy() measures for the current process (S3).
-_IO_POLICY_KEYS = frozenset({"io_policy", "io_policy_errors", "iopol", "darwin_background", "nice"})
+# Policy fields are measured for the current process (S3) and upload thread.
+_POLICY_RECEIPT_KEYS = frozenset(
+    {"io_policy", "io_policy_errors", "iopol", "darwin_background", "nice", "upload_thread_policy"}
+)
 BACKUP_SQLITE_CHECK_TIMEOUT_ENV = "BRAINLAYER_BACKUP_SQLITE_CHECK_TIMEOUT_SECONDS"
 BACKUP_DRIVE_RETENTION_ENV = "BRAINLAYER_BACKUP_DRIVE_RETENTION"
 DRIVE_UPLOAD_DEADLINE_FLOOR_ENV = "BRAINLAYER_DRIVE_UPLOAD_DEADLINE_FLOOR_SECONDS"
@@ -615,11 +617,26 @@ def _execute_drive_read(request: Any, *, what: str) -> Any:
     return _retry_transient_drive_call(request.execute, what=what)
 
 
-def _drive_put_with_deadline(session: Any, url: str, *, headers: dict[str, str], data: bytes, deadline: float):
+def _drive_put_with_deadline(
+    session: Any,
+    url: str,
+    *,
+    headers: dict[str, str],
+    data: bytes,
+    deadline: float,
+    policy_callback: Callable[[dict[str, Any]], None] | None = None,
+):
     outcome: queue.Queue[tuple[bool, Any]] = queue.Queue(maxsize=1)
 
     def perform() -> None:
         try:
+            # Record the scheduling state of the socket-owning thread; process-level
+            # I/O readbacks do not expose launchd's effective thread priority.
+            from brainlayer.supervisor_child import backup_upload_thread_policy
+
+            upload_policy = backup_upload_thread_policy()
+            if policy_callback is not None:
+                policy_callback(upload_policy)
             outcome.put((True, session.put(url, headers=headers, data=data, timeout=deadline + 5)))
         except Exception as exc:
             outcome.put((False, exc))
@@ -2424,6 +2441,7 @@ def upload_file_to_drive_raw(
     max_attempts: int = 30,
     resume_session_url: str | None = None,
     progress_callback: Callable[[str, int], None] | None = None,
+    policy_callback: Callable[[dict[str, Any]], None] | None = None,
     run_deadline: float | None = None,
 ) -> dict[str, Any]:
     """Upload unchanged bytes; probe ambiguous writes before retransmitting them."""
@@ -2533,6 +2551,7 @@ def upload_file_to_drive_raw(
                         },
                         data=chunk,
                         deadline=request_deadline(max(deadline_floor, len(chunk) / minimum_rate)),
+                        policy_callback=policy_callback,
                     )
                     if response.status_code in {200, 201}:
                         return response.json()
@@ -3577,7 +3596,7 @@ def run_backup(
             get_drive_credentials()
         attempted_at = result["attempted_at"]
         # The receipt records THIS run's process policy (S3); an earlier run's must not leak in.
-        dropped = {"backup_invocation_id", "drive_auth_probe", *_IO_POLICY_KEYS}
+        dropped = {"backup_invocation_id", "drive_auth_probe", *_POLICY_RECEIPT_KEYS}
         result.update({k: v for k, v in receipt.items() if k not in dropped})
         result.update(io_policy or {"io_policy": "unknown"})
         result.update(status="reused", attempted_at=attempted_at)
@@ -3831,6 +3850,9 @@ def run_backup(
                         },
                     )
 
+            def record_upload_thread_policy(policy: dict[str, Any]) -> None:
+                result["upload_thread_policy"] = policy
+
             try:
                 uploaded = upload_file_to_drive_raw(
                     snapshot,
@@ -3838,6 +3860,7 @@ def run_backup(
                     credentials,
                     machine_id=resolved_machine_id,
                     progress_callback=record_upload_progress,
+                    policy_callback=record_upload_thread_policy,
                     run_deadline=run_deadline,
                     **({"resume_session_url": saved_session["url"]} if saved_session else {}),
                 )
@@ -3850,6 +3873,7 @@ def run_backup(
                         credentials,
                         machine_id=resolved_machine_id,
                         progress_callback=record_upload_progress,
+                        policy_callback=record_upload_thread_policy,
                         run_deadline=run_deadline,
                     )
                     break

{brainlayer-1.5.85 → brainlayer-1.5.87}/src/brainlayer/supervisor_child.py

@@ -7,6 +7,81 @@ import resource
 import sys
 
 
+class _ProcThreadInfo(ctypes.Structure):
+    """Darwin proc_threadinfo fields used to read the live scheduler priority."""
+
+    _fields_ = [
+        ("user_time", ctypes.c_uint64),
+        ("system_time", ctypes.c_uint64),
+        ("cpu_usage", ctypes.c_int32),
+        ("policy", ctypes.c_int32),
+        ("run_state", ctypes.c_int32),
+        ("flags", ctypes.c_int32),
+        ("sleep_time", ctypes.c_int32),
+        ("curpri", ctypes.c_int32),
+        ("priority", ctypes.c_int32),
+        ("maxpriority", ctypes.c_int32),
+        ("name", ctypes.c_char * 64),
+    ]
+
+
+def backup_upload_thread_policy():
+    """Measure the socket-owning thread's effective priority and requested QoS."""
+    result = {
+        "thread_curpri": None,
+        "thread_qos_class": None,
+        "thread_qos_relative_priority": None,
+        "thread_policy_errors": [],
+    }
+    if sys.platform != "darwin":
+        result["thread_policy_errors"].append("unsupported")
+        return result
+
+    try:
+        lib = ctypes.CDLL(None, use_errno=True)
+        lib.pthread_self.restype = ctypes.c_void_p
+        lib.pthread_get_qos_class_np.argtypes = [
+            ctypes.c_void_p,
+            ctypes.POINTER(ctypes.c_uint32),
+            ctypes.POINTER(ctypes.c_int),
+        ]
+        lib.pthread_get_qos_class_np.restype = ctypes.c_int
+        qos_class, relative_priority = ctypes.c_uint32(), ctypes.c_int()
+        rc = lib.pthread_get_qos_class_np(lib.pthread_self(), ctypes.byref(qos_class), ctypes.byref(relative_priority))
+        if rc:
+            raise OSError(rc, "pthread_get_qos_class_np")
+        result["thread_qos_class"] = qos_class.value
+        result["thread_qos_relative_priority"] = relative_priority.value
+    except Exception as exc:
+        result["thread_policy_errors"].append(f"qos: {exc}")
+
+    try:
+        lib = ctypes.CDLL(None, use_errno=True)
+        thread_id = ctypes.c_uint64()
+        lib.pthread_threadid_np.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_uint64)]
+        lib.pthread_threadid_np.restype = ctypes.c_int
+        rc = lib.pthread_threadid_np(None, ctypes.byref(thread_id))
+        if rc:
+            raise OSError(rc, "pthread_threadid_np")
+        info = _ProcThreadInfo()
+        # PROC_PIDTHREADID64INFO returns pth_curpri, matching `ps -M`'s PRI.
+        lib.proc_pidinfo.argtypes = [
+            ctypes.c_int,
+            ctypes.c_int,
+            ctypes.c_uint64,
+            ctypes.c_void_p,
+            ctypes.c_int,
+        ]
+        lib.proc_pidinfo.restype = ctypes.c_int
+        count = lib.proc_pidinfo(os.getpid(), 15, thread_id.value, ctypes.byref(info), ctypes.sizeof(info))
+        if count != ctypes.sizeof(info):
+            raise OSError(ctypes.get_errno(), f"proc_pidinfo returned {count} bytes")
+        result["thread_curpri"] = info.curpri
+    except Exception as exc:
+        result["thread_policy_errors"].append(f"priority: {exc}")
+    return result
+
+
 def set_disk_io_policy(value):
     """Set this process's Darwin disk policy (DEFAULT=0, THROTTLE=3)."""
     library = ctypes.CDLL(None, use_errno=True)

brainlayer-1.5.85/src/brainlayer/_build.py

@@ -1 +0,0 @@
-BUILD_SHA = "48d9df608550988faa3c8a67a505f3c9751f9adc"