brainlayer 1.5.83__tar.gz → 1.5.85__tar.gz

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "brainlayer"
-version = "1.5.83"
+version = "1.5.85"
 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.83 → brainlayer-1.5.85}/scripts/hotlane_brainbar_daemon.py

@@ -13,8 +13,11 @@ import argparse
 import inspect
 import json
 import logging
+import math
 import os
 import signal
+import subprocess
+import sys
 import time
 from collections import OrderedDict
 from pathlib import Path
@@ -25,9 +28,10 @@ import sqlite_vec
 
 from brainlayer._helpers import serialize_f32
 from brainlayer.embeddings import get_embedding_model
+from brainlayer.hotlane_budget import HotlaneCpuSampler
 from brainlayer.paths import get_db_path
 from brainlayer.store import embed_hot_chunk, embed_pending_chunks
-from brainlayer.vector_store import VectorStore
+from brainlayer.vector_store import VectorStore, skip_connection_hooks, temporary_write_busy_timeout_ms
 from brainlayer.writer_telemetry import IngestMetrics, start_writer_span
 
 LOGGER = logging.getLogger("brainlayer.hotlane_brainbar")
@@ -40,6 +44,16 @@ 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
+# S17 (2026-11-02): a busy writer slot must never cost an embedded batch. The write retries
+# inside the cycle (each try waits up to the hotlane busy timeout at BEGIN IMMEDIATE), then
+# whatever is still unwritten is carried to the next cycle instead of being discarded.
+HOTLANE_WRITE_ATTEMPTS = 3
+HOTLANE_WRITE_RETRY_BACKOFF_SECONDS = 0.25
+MAX_CARRIED_VECTORS = 64
+# Hooks the hotlane writer never runs in its Connection() constructor. `connection_optimize`
+# runs PRAGMA optimize (a write lock) on every open; `connection_busy_timeout` would reset the
+# constructor's busy timeout to APSW's 100 ms. connection_wal and the rest still run.
+HOTLANE_SKIPPED_CONNECTION_HOOKS = ("connection_optimize", "connection_busy_timeout")
 
 # Incident 2026-08-24: the loop slept a fixed `interval` (1.0s) whether or not a cycle
 # did any work, so an idle hotlane kept probing once per second forever. Idle cycles now
@@ -144,6 +158,8 @@ class CycleResult(NamedTuple):
     enrich_skipped: int = 0
     enrich_failed: int = 0
     enrich_daily_cap_reached: bool = False
+    deferred: int = 0
+    backlog_encoded: int = 0
 
 
 class EmbedCandidate(NamedTuple):
@@ -151,6 +167,59 @@ class EmbedCandidate(NamedTuple):
     content: str
 
 
+def _sysctl(name: str) -> str:
+    return subprocess.check_output(["/usr/sbin/sysctl", "-n", name], text=True, timeout=5).strip()
+
+
+def _performance_cores() -> int:
+    if sys.platform == "darwin":
+        return max(1, int(_sysctl("hw.perflevel0.physicalcpu")))
+    return os.cpu_count() or 1
+
+
+def _backlog_max_load() -> float:
+    value = float(os.environ.get("BRAINLAYER_HOTLANE_BACKLOG_MAX_LOAD", "") or _performance_cores())
+    if not math.isfinite(value) or value < 0:
+        raise ValueError("BRAINLAYER_HOTLANE_BACKLOG_MAX_LOAD must be finite and nonnegative")
+    return value
+
+
+def setup_cpu_budget(db_path: Path) -> dict:
+    """CPU-only priority: never request Darwin background or a disk I/O policy."""
+    policy = {"policy": "not applicable", "platform": sys.platform}
+    if sys.platform == "darwin":
+        os.setpriority(os.PRIO_PROCESS, 0, 20)
+        policy.update(policy="nice", nice=os.getpriority(os.PRIO_PROCESS, 0))
+    default_threads = 1 if sys.platform == "darwin" and "Apple M1" in _sysctl("machdep.cpu.brand_string") else 2
+    threads = int(os.environ.get("BRAINLAYER_HOTLANE_THREADS", str(default_threads)))
+    if threads < 1:
+        raise ValueError("BRAINLAYER_HOTLANE_THREADS must be positive")
+    for name in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "VECLIB_MAXIMUM_THREADS", "OPENBLAS_NUM_THREADS"):
+        os.environ[name] = str(threads)
+    # embeddings.py imports sentence_transformers/torch only when the model first encodes.
+    import torch
+
+    torch.set_num_threads(threads)
+    policy.update(threads=torch.get_num_threads(), backlog_max_load=_backlog_max_load(), pid=os.getpid())
+    receipt = db_path.parent / "hotlane-budget.json"
+    receipt.parent.mkdir(parents=True, exist_ok=True)
+    temporary = receipt.with_suffix(".tmp")
+    temporary.write_text(json.dumps(policy, sort_keys=True) + "\n")
+    temporary.replace(receipt)
+    LOGGER.info("hotlane CPU budget %s receipt=%s", json.dumps(policy, sort_keys=True), receipt)
+    return policy
+
+
+def _backlog_yield_reason(db_path: Path, max_load: float) -> str:
+    if (db_path.parent / "hotlane.pause").exists():
+        return "pause marker"
+    try:
+        load = os.getloadavg()[0]
+    except OSError:
+        return "load unavailable"
+    return "high load" if load > max_load else ""
+
+
 class PendingCandidateScanState:
     def __init__(self) -> None:
         self.active = False
@@ -169,6 +238,70 @@ class EmbeddedVector(NamedTuple):
     embedding: list[float]
 
 
+class HotlaneVectorWriteDeferred(apsw.BusyError):
+    """A busy write with progress for cycle carry-over.
+
+    Remains a BusyError so callers using the writer's existing lock-error contract
+    can retry after contention; the split cycle also retains ``remaining``.
+    """
+
+    def __init__(self, *, written: int, remaining: list[EmbeddedVector], attempts: int, cause: BaseException):
+        super().__init__(f"{type(cause).__name__}: {cause} (after {attempts} attempts, {len(remaining)} unwritten)")
+        self.written = written
+        self.remaining = remaining
+        self.attempts = attempts
+        self.cause = cause
+
+
+class VectorCarryover:
+    """Computed vectors whose write was deferred by a busy writer slot (S17).
+
+    Held in memory for the next cycle so a lock never costs the embedding work. The
+    writer re-checks each chunk's content and vector state at write time, so a stale
+    entry (content edited, or vectorized meanwhile) is skipped, never written wrongly.
+    Bounded: past ``capacity`` the oldest entries are dropped, loudly and counted. A
+    dropped vector loses only compute; its chunk stays unvectored and is re-embedded.
+    """
+
+    def __init__(self, capacity: int = MAX_CARRIED_VECTORS) -> None:
+        self.capacity = capacity
+        self._vectors: OrderedDict[str, EmbeddedVector] = OrderedDict()
+        self.carried_total = 0
+        self.dropped_total = 0
+
+    def __len__(self) -> int:
+        return len(self._vectors)
+
+    def put(self, vectors: list[EmbeddedVector]) -> int:
+        for vector in vectors:
+            self._vectors.pop(vector.chunk_id, None)
+            self._vectors[vector.chunk_id] = vector
+        self.carried_total += len(vectors)
+        dropped = 0
+        while len(self._vectors) > self.capacity:
+            self._vectors.popitem(last=False)
+            dropped += 1
+        if dropped:
+            self.dropped_total += dropped
+            LOGGER.warning(
+                "hotlane carry-over full; dropped %d oldest computed vectors (chunks stay unvectored and "
+                "will be re-embedded) capacity=%d dropped_total=%d",
+                dropped,
+                self.capacity,
+                self.dropped_total,
+            )
+        return dropped
+
+    def peek(self) -> list[EmbeddedVector]:
+        return list(self._vectors.values())
+
+    def clear(self) -> None:
+        self._vectors.clear()
+
+
+VECTOR_CARRYOVER = VectorCarryover()
+
+
 def _candidates_from_scanned_rows(
     rows: list[tuple], *, limit: int, exclude_ids: set[str] | None = None
 ) -> tuple[list[EmbedCandidate], int | None, int | None, bool]:
@@ -546,11 +679,20 @@ def _hotlane_write_busy_timeout_ms() -> int:
 
 
 def _open_hotlane_write_connection(db_path: Path) -> apsw.Connection:
-    conn = apsw.Connection(str(db_path), flags=apsw.SQLITE_OPEN_READWRITE)
-    conn.setbusytimeout(_hotlane_write_busy_timeout_ms())
-    conn.enableloadextension(True)
-    conn.loadextension(sqlite_vec.loadable_path())
-    conn.enableloadextension(False)
+    timeout_ms = _hotlane_write_busy_timeout_ms()
+    # S17: the constructor runs the connection hooks. Without this, PRAGMA optimize took the
+    # write lock on every cycle at APSW's 100 ms timeout and threw away the embedded batch
+    # (1,264 of 1,430 logged cycle failures). The hotlane timeout covers the hooks that do run.
+    with skip_connection_hooks(*HOTLANE_SKIPPED_CONNECTION_HOOKS), temporary_write_busy_timeout_ms(timeout_ms):
+        conn = apsw.Connection(str(db_path), flags=apsw.SQLITE_OPEN_READWRITE)
+    try:
+        conn.setbusytimeout(timeout_ms)
+        conn.enableloadextension(True)
+        conn.loadextension(sqlite_vec.loadable_path())
+        conn.enableloadextension(False)
+    except BaseException:
+        conn.close()
+        raise
     return conn
 
 
@@ -592,9 +734,56 @@ def _upsert_chunk_vector_raw(
         )
 
 
+class _WriteProgress:
+    def __init__(self) -> None:
+        self.written = 0
+        self.processed = 0
+
+
 def _write_embedded_vectors(store_or_path: VectorStore | Path | str, vectors: list[EmbeddedVector]) -> int:
+    """Write vectors one transaction each; retry busy/locked failures, never drop the batch.
+
+    Each vector is its own transaction, so a lock error part-way leaves earlier vectors
+    committed; the retry resumes at the first unprocessed vector. After
+    ``HOTLANE_WRITE_ATTEMPTS`` busy failures it raises ``HotlaneVectorWriteDeferred``
+    carrying what is still unwritten, for the caller to keep for the next cycle.
+    """
+    remaining = list(vectors)
+    written = 0
+    for attempt in range(1, HOTLANE_WRITE_ATTEMPTS + 1):
+        if not remaining:
+            break
+        progress = _WriteProgress()
+        try:
+            _write_embedded_vectors_once(store_or_path, remaining, progress)
+        except (apsw.BusyError, apsw.LockedError) as exc:
+            written += progress.written
+            remaining = remaining[progress.processed :]
+            if attempt == HOTLANE_WRITE_ATTEMPTS:
+                raise HotlaneVectorWriteDeferred(
+                    written=written, remaining=remaining, attempts=attempt, cause=exc
+                ) from exc
+            LOGGER.info(
+                "hotlane vector write busy; retrying attempt=%d/%d unwritten=%d error_type=%s",
+                attempt + 1,
+                HOTLANE_WRITE_ATTEMPTS,
+                len(remaining),
+                type(exc).__name__,
+            )
+            _sleep(HOTLANE_WRITE_RETRY_BACKOFF_SECONDS * (2 ** (attempt - 1)))
+            continue
+        written += progress.written
+        remaining = []
+    return written
+
+
+def _write_embedded_vectors_once(
+    store_or_path: VectorStore | Path | str,
+    vectors: list[EmbeddedVector],
+    progress: _WriteProgress,
+) -> None:
     if not vectors:
-        return 0
+        return
 
     conn: apsw.Connection | None = None
     db_path: Path | None
@@ -666,6 +855,8 @@ def _write_embedded_vectors(store_or_path: VectorStore | Path | str, vectors: li
                     metrics.committed([{"queued_at": metadata.get("ingest_queued_at"), "metadata": metadata}])
                 metrics.finish("commit")
                 count += rows_touched
+                progress.written = count
+                progress.processed = vector_index + 1
                 telemetry_span.finish("commit", rows_touched=rows_touched)
                 if vector_index < len(vectors) - 1:
                     _sleep(VECTOR_WRITE_YIELD_SECONDS)
@@ -676,6 +867,7 @@ def _write_embedded_vectors(store_or_path: VectorStore | Path | str, vectors: li
                 telemetry_span.finish("rollback", error=f"{type(exc).__name__}: {exc}")
                 if isinstance(exc, (apsw.BusyError, apsw.LockedError)):
                     raise
+                progress.processed = vector_index + 1
                 LOGGER.error(
                     "hotlane vector write skipped chunk_id=%s error_type=%s error=%s",
                     chunk_id,
@@ -691,7 +883,6 @@ def _write_embedded_vectors(store_or_path: VectorStore | Path | str, vectors: li
             from brainlayer.search_repo import clear_hybrid_search_cache
 
             clear_hybrid_search_cache(db_path)
-    return count
 
 
 def _open_store(
@@ -751,9 +942,14 @@ def _run_split_cycle(
     candidate_rows_fn: Callable[..., list[EmbedCandidate]] = _candidate_chunk_rows,
     pending_rows_fn: Callable[..., list[EmbedCandidate]] = _pending_chunk_rows_with_resume,
     write_vectors_fn: Callable[..., int] = _write_embedded_vectors,
+    carryover: VectorCarryover | None = None,
 ) -> CycleResult:
+    carryover = VECTOR_CARRYOVER if carryover is None else carryover
     metrics = IngestMetrics("hotlane", "hotlane")
     embedded = 0
+    # Peek, not take: a scan or encode failure later in this cycle must not lose them.
+    carried = carryover.peek()
+    carried_by_id = {vector.chunk_id: vector for vector in carried}
     hot_rows: list[EmbedCandidate] = []
     pending_rows: list[EmbedCandidate] = []
     pending_scan_state = PENDING_CANDIDATE_SCAN_STATE if pending_rows_fn is _pending_chunk_rows_with_resume else None
@@ -778,15 +974,28 @@ def _run_split_cycle(
 
     seen_hot_ids = {candidate.chunk_id for candidate in hot_rows}
     pending_rows = [candidate for candidate in pending_rows if candidate.chunk_id not in seen_hot_ids]
+
+    def needs_embedding(candidate: EmbedCandidate) -> bool:
+        # A carried vector for the same content is reused, not recomputed.
+        carried_vector = carried_by_id.get(candidate.chunk_id)
+        return carried_vector is None or carried_vector.content != candidate.content
+
+    hot_rows = [candidate for candidate in hot_rows if needs_embedding(candidate)]
+    pending_rows = [candidate for candidate in pending_rows if needs_embedding(candidate)]
     vectors = metrics.run("encode", _embed_candidates, hot_rows, embed_fn=embed_fn, embed_batch_fn=embed_batch_fn)
-    vectors.extend(
-        metrics.run("encode", _embed_candidates, pending_rows, embed_fn=embed_fn, embed_batch_fn=embed_batch_fn)
+    backlog_vectors = metrics.run(
+        "encode", _embed_candidates, pending_rows, embed_fn=embed_fn, embed_batch_fn=embed_batch_fn
     )
+    vectors.extend(backlog_vectors)
+    fresh_ids = {vector.chunk_id for vector in vectors}
+    vectors = [vector for vector in carried if vector.chunk_id not in fresh_ids] + vectors
     if vectors:
         try:
             embedded += metrics.run("write", write_vectors_fn, db_path, vectors)
+            carryover.clear()
         except Exception as exc:
-            is_lock_error = isinstance(exc, (apsw.BusyError, apsw.LockedError))
+            deferred = exc if isinstance(exc, HotlaneVectorWriteDeferred) else None
+            is_lock_error = deferred is not None or isinstance(exc, (apsw.BusyError, apsw.LockedError))
             if is_lock_error and pending_scan_checkpoint is not None and pending_scan_state is not None:
                 # Earlier one-row commits stay indexed; retry only rows still missing vectors.
                 pending_scan_state.active, pending_scan_state.after_created_at, pending_scan_state.after_rowid = (
@@ -798,12 +1007,33 @@ def _run_split_cycle(
                     [candidate.chunk_id for candidate in pending_rows],
                     type(exc).__name__,
                 )
-            metrics.finish("error")
-            raise
+            if not is_lock_error:
+                metrics.finish("error")
+                raise
+            # S17: a busy writer slot never costs the embedded batch. A writer that does not
+            # report progress gets all of its vectors carried; its writes are idempotent
+            # because each one re-checks that the chunk still lacks a vector.
+            unwritten = deferred.remaining if deferred is not None else vectors
+            embedded += deferred.written if deferred is not None else 0
+            carryover.clear()
+            carryover.put(unwritten)
+            LOGGER.warning(
+                "hotlane vector write deferred: writer slot busy; carrying %d computed vectors to the next "
+                "cycle written=%d carried_now=%d carried_total=%d dropped_total=%d error=%s",
+                len(unwritten),
+                embedded,
+                len(carryover),
+                carryover.carried_total,
+                carryover.dropped_total,
+                exc,
+            )
+            metrics.finish("deferred")
+            _warn_retired_enrichment(enrich_limit, enrich_since_hours, enrich_fn)
+            return CycleResult(embedded=embedded, deferred=len(unwritten), backlog_encoded=len(backlog_vectors))
 
     _warn_retired_enrichment(enrich_limit, enrich_since_hours, enrich_fn)
     metrics.finish()
-    return CycleResult(embedded=embedded)
+    return CycleResult(embedded=embedded, backlog_encoded=len(backlog_vectors))
 
 
 def _warn_retired_enrichment(limit: int, since_hours: int, callback: object) -> None:
@@ -891,6 +1121,7 @@ def run(
     queue_dir: Path | None = None,
     queue_depth_fn: Callable[[Path], int] = _queue_depth,
     high_priority_queue_depth_fn: Callable[[Path], int] = _high_priority_queue_depth,
+    cpu_sampler: HotlaneCpuSampler | None = None,
 ) -> None:
     model = _create_embedding_model(model_factory, device=embedding_device)
     embed_batch_fn = getattr(model, "embed_texts", None)
@@ -907,10 +1138,16 @@ def run(
     queue_dir_was_explicit = queue_dir is not None
     queue_dir = queue_dir or _default_queue_dir()
     last_backlog = time_fn() - backlog_interval
+    last_backlog_duty = last_backlog + backlog_interval
+    max_backlog_wait = float(os.environ.get("BRAINLAYER_HOTLANE_BACKLOG_MAX_WAIT_SECONDS", "300"))
+    if not math.isfinite(max_backlog_wait) or max_backlog_wait <= 0:
+        raise ValueError("BRAINLAYER_HOTLANE_BACKLOG_MAX_WAIT_SECONDS must be finite and positive")
     _warn_retired_enrichment(enrich_limit, enrich_since_hours, None)
     if enrich_limit > 0:
         LOGGER.warning("Ignoring retired hotlane enrichment interval=%s", enrich_interval)
     queue_backpressure_active = False
+    backlog_max_load = _backlog_max_load()
+    backlog_yield_reason = ""
     backlog_slice_logged = False
     hot_candidate_scanner = HotCandidateScanner()
     cycles = 0
@@ -927,11 +1164,23 @@ def run(
             queue_has_high_priority_backlog = queue_has_backlog and high_priority_queue_depth_fn(queue_dir) > 0
             cycle_backlog_batch = backlog_batch if backlog_batch > 0 and now - last_backlog >= backlog_interval else 0
             cycle_recent_limit = recent_limit
+            reason = _backlog_yield_reason(db_path, backlog_max_load) if backlog_batch else ""
+            if reason == "high load" and now - last_backlog_duty >= max_backlog_wait:
+                # Reserve the existing backlog lane; never lift store-queue backpressure.
+                reason = ""
+                cycle_backlog_batch = backlog_batch
+            if reason != backlog_yield_reason:
+                LOGGER.info("backlog embedding %s", f"yielding: {reason}" if reason else "resumed")
+                backlog_yield_reason = reason
+            if reason:
+                cycle_backlog_batch = 0
             if queue_has_high_priority_backlog:
                 if not queue_backpressure_active:
                     LOGGER.info("durable high-priority queue has backlog; suppressing hot embedding")
                 queue_backpressure_active = True
                 if cycle_backlog_batch <= 0:
+                    if cpu_sampler is not None:
+                        cpu_sampler.observe("store queue")
                     cycles += 1
                     # Backpressure is not idleness: hold the configured cadence so the
                     # reserved backlog slice resumes on time.
@@ -950,6 +1199,8 @@ def run(
                 backlog_slice_logged = False
             if cycle_backlog_batch > 0:
                 last_backlog = now
+                last_backlog_duty = now
+            cycle_start = cpu_sampler.begin_cycle() if cpu_sampler is not None else None
             if cycle_fn is run_cycle:
                 result = _run_split_cycle(
                     db_path=db_path,
@@ -980,10 +1231,15 @@ def run(
             # nothing (the hot slice is deliberately suppressed to yield to the drain),
             # so it must not be treated as idle -- backing off there would slow recovery.
             did_work = bool(result.embedded) or queue_has_backlog
+            if cpu_sampler is not None:
+                state = reason or ("running" if result.backlog_encoded else "waiting")
+                cpu_sampler.observe(state, result.backlog_encoded, cycle_start=cycle_start)
             if result.embedded:
                 LOGGER.info("embedded=%d", result.embedded)
         except Exception:
             LOGGER.exception("hotlane adapter cycle failed")
+            if cpu_sampler is not None:
+                cpu_sampler.observe("error")
             cycles += 1
             # A raised cycle is a RETRY, not an idle cycle (PR #735 review, macroscope):
             # it already slept its own backoff here, and letting it fall through to the
@@ -1021,16 +1277,23 @@ def main() -> None:
         LOGGER.warning("Hotlane enrichment options are retired and ignored; continuing local embedding")
     signal.signal(signal.SIGTERM, _stop)
     signal.signal(signal.SIGINT, _stop)
-    run(
-        db_path=args.db,
-        interval=max(args.interval, 0.25),
-        recent_limit=max(args.recent_limit, 1),
-        backlog_interval=max(args.backlog_interval, 1.0),
-        backlog_batch=min(max(args.backlog_batch, 0), MAX_BACKLOG_BATCH),
-        enrich_interval=0.0,
-        enrich_limit=0,
-        enrich_since_hours=0,
-    )
+    setup_cpu_budget(args.db)
+    sampler = HotlaneCpuSampler(args.db)
+    sampler.start()
+    try:
+        run(
+            db_path=args.db,
+            interval=max(args.interval, 0.25),
+            recent_limit=max(args.recent_limit, 1),
+            backlog_interval=max(args.backlog_interval, 1.0),
+            backlog_batch=min(max(args.backlog_batch, 0), MAX_BACKLOG_BATCH),
+            enrich_interval=0.0,
+            enrich_limit=0,
+            enrich_since_hours=0,
+            cpu_sampler=sampler,
+        )
+    finally:
+        sampler.close()
 
 
 if __name__ == "__main__":

{brainlayer-1.5.83 → brainlayer-1.5.85}/scripts/launchd/com.brainlayer.hotlane-brainbar.plist

@@ -54,7 +54,7 @@
 	<key>ExitTimeOut</key>
 	<integer>30</integer>
 	<key>LowPriorityIO</key>
-	<true/>
+	<false/>
 	<key>SoftResourceLimits</key>
 	<dict>
 		<key>NumberOfFiles</key>

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

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

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

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