brainiac-cli 0.20.44__tar.gz → 0.20.46__tar.gz

{brainiac_cli-0.20.44/src/brainiac_cli.egg-info → brainiac_cli-0.20.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brainiac-cli
-Version: 0.20.44
+Version: 0.20.46
 Summary: Brainiac — local any-LLM second-brain core engine + brain CLI (Markdown truth, derived SQLite index).
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/Autopsias/brainiac
@@ -19,11 +19,12 @@ Requires-Dist: cryptography>=49
 Requires-Dist: PyYAML>=6
 Requires-Dist: regex>=2023.0.0
 Requires-Dist: keyring>=24; sys_platform == "win32"
-Requires-Dist: pypdf>=6.15.0
+Requires-Dist: pypdf>=6.21.2
 Requires-Dist: python-docx>=1.1
 Requires-Dist: python-pptx>=0.6.23
 Requires-Dist: openpyxl>=3.1
-Requires-Dist: Pillow>=12.3.0
+Requires-Dist: Pillow>=13.0.0; python_version >= "3.11"
+Requires-Dist: Pillow>=12.3.0; python_version < "3.11"
 Provides-Extra: vec
 Requires-Dist: sqlite-vec>=0.1.6; extra == "vec"
 Provides-Extra: audit
@@ -43,11 +44,12 @@ Requires-Dist: PyYAML>=6; extra == "corporate"
 Provides-Extra: yaml
 Requires-Dist: PyYAML>=6; extra == "yaml"
 Provides-Extra: ingest
-Requires-Dist: pypdf>=6.15.0; extra == "ingest"
+Requires-Dist: pypdf>=6.21.2; extra == "ingest"
 Requires-Dist: python-docx>=1.1; extra == "ingest"
 Requires-Dist: python-pptx>=0.6.23; extra == "ingest"
 Requires-Dist: openpyxl>=3.1; extra == "ingest"
-Requires-Dist: Pillow>=12.3.0; extra == "ingest"
+Requires-Dist: Pillow>=13.0.0; python_version >= "3.11" and extra == "ingest"
+Requires-Dist: Pillow>=12.3.0; python_version < "3.11" and extra == "ingest"
 Provides-Extra: dev
 Requires-Dist: pytest>=7; extra == "dev"
 Requires-Dist: build>=1; extra == "dev"

{brainiac_cli-0.20.44 → brainiac_cli-0.20.46}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "setuptools.build_meta"
 # check. The IMPORT package stays `brain` and the console script stays
 # `brain` — only the distribution/project name changes.
 name = "brainiac-cli"
-version = "0.20.44"
+version = "0.20.46"
 description = "Brainiac — local any-LLM second-brain core engine + brain CLI (Markdown truth, derived SQLite index)."
 readme = "README.md"
 license = "Apache-2.0"
@@ -42,7 +42,7 @@ dependencies = [
     # because requirements.lock is CI/audit-only -- a plain
     # `pip install brainiac-cli` reads THIS constraint, and >=4.0 let the
     # vulnerable 6.14.2 survive an upgrade to 0.20.5 on a real host.
-    "pypdf>=6.15.0",
+    "pypdf>=6.21.2",
     "python-docx>=1.1",
     "python-pptx>=0.6.23",
     "openpyxl>=3.1",
@@ -50,7 +50,10 @@ dependencies = [
     # binary is present — the pytesseract binding itself stays a fully
     # OPTIONAL, NOT-a-pip-dependency probe: OCR degrades gracefully absent
     # it, matching the ADR's "system binaries are never pip deps" rule).
-    "Pillow>=12.3.0",
+    # >=13.0.0 fixes 37 advisories (one a FlashPix heap overflow); 13 needs
+    # Python 3.11+, and no fixed 12.x exists, so 3.10 keeps the old floor.
+    "Pillow>=13.0.0; python_version >= '3.11'",
+    "Pillow>=12.3.0; python_version < '3.11'",
 ]
 
 [project.optional-dependencies]
@@ -94,7 +97,7 @@ yaml = ["PyYAML>=6"]
 # message hints valid even though a default install already has these. Absent,
 # `brain ingest` degrades per-handler (reports which extensions are
 # unavailable) rather than crashing.
-ingest = ["pypdf>=6.15.0", "python-docx>=1.1", "python-pptx>=0.6.23", "openpyxl>=3.1", "Pillow>=12.3.0"]
+ingest = ["pypdf>=6.21.2", "python-docx>=1.1", "python-pptx>=0.6.23", "openpyxl>=3.1", "Pillow>=13.0.0; python_version >= '3.11'", "Pillow>=12.3.0; python_version < '3.11'"]
 # pytest-xdist/-timeout back the documented parallel suite run (AGENTS.md §8,
 # "Running the test suite"): ~15 min sequential -> ~6 min at `-n 8`. Both are
 # pytest-dev org, actively maintained. Declared here so a fresh checkout can
@@ -296,3 +299,20 @@ python-platform = "linux"
 # `_assets` is the generated mirror of tools/ + scripts/ inside src/brain/.
 include = ["src", "tools", "eval", "scripts", "packaging"]
 exclude = ["**/_plans", "**/_archive", "**/_evidence", "**/_assets"]
+
+[tool.uv]
+# Wait 7 days before resolving a newly published version (a new release can be
+# malicious or broken). shortcut: pypdf 6.21.2, filelock 4.2.4 and certifi
+# 2026.10.23 are security fixes under 7 days old on 2026-10-24, so they are
+# exempt; remove the exemptions after 2026-10-31.
+exclude-newer = "7 days"
+exclude-newer-package = { pypdf = false, filelock = false, certifi = false }
+# fastembed (the optional `embed` extra, not installed by default) caps
+# pillow<13 in every release up to 0.9.0, but pillow 13.0.0 is the first
+# release fixing 37 advisories (one a FlashPix heap overflow). fastembed uses
+# pillow only for IMAGE embeddings; this repo embeds text only.
+# shortcut: drop this once a fastembed release allows pillow>=13.
+override-dependencies = [
+    "pillow>=13.0.0; python_version >= '3.11'",
+    "pillow>=12.3.0; python_version < '3.11'",
+]

{brainiac_cli-0.20.44 → brainiac_cli-0.20.46}/src/brain/_assets/scripts/brain-brief.sh

@@ -61,6 +61,21 @@ if [ -z "$BRAIN_BIN" ]; then
   exit 1
 fi
 
+# YIELD TO THE NIGHTLY MAIL RUN (2026-10-19). Both do model work, and the
+# machine runs at most $BRAIN_MODEL_SLOTS (2) model processes at once. On
+# run374 an hourly maintain ran 02:06-03:04 across the run's grounding window
+# and 58 of 72 sender lookups timed out (0 of 122 the night before). The night
+# runs its own broker after its child exits, so skipping an hour loses
+# nothing: the next hourly run catches up. A hung night also stops this job;
+# the WAT-01 stale-feed alert names it after 2 days.
+# ponytail: process-name match, a pid lock if the night ever runs under
+# another name.
+YIELD_TO="${BRAIN_BRIEF_YIELD_TO:-tools/cos_nightly.sh}"
+if pgrep -f "$YIELD_TO" >/dev/null 2>&1; then
+  echo "=== brain-daily-brief / brain-nightly $(date -u +%Y-%m-%dT%H:%M:%SZ) === SKIP: the nightly mail run is running ($YIELD_TO); next hour catches up" >> "$LOG"
+  exit 0
+fi
+
 # The RUN VALIDATOR needs the mutation toolchain, and the wheel does not carry
 # it (2026-08-22). `brain.cos_runverify.check_plan_binding` imports
 # `cos_mutate.load_frozen_plan` to re-hash a run's frozen plan — one definition

{brainiac_cli-0.20.44 → brainiac_cli-0.20.46}/src/brain/_version.py

@@ -9,4 +9,4 @@ pip-installed host, importlib.metadata stays primary; brain/__init__.py reads
 this file only as the fallback before 0.0.0+unknown.
 """
 
-__version__ = "0.20.44"
+__version__ = "0.20.46"

{brainiac_cli-0.20.44 → brainiac_cli-0.20.46}/src/brain/audit_drift.py

@@ -6,6 +6,7 @@ import os
 from datetime import date
 from pathlib import Path
 from typing import TYPE_CHECKING
+from .atomic_temp import atomic_temp_path
 
 if TYPE_CHECKING:  # annotation-only; a runtime import here would be a cycle
     from .audit_chain import AuditChain
@@ -32,7 +33,7 @@ def _write_dispositions(path: Path, payload: dict) -> None:
     turn every explained finding back into an unexplained one. `os.replace` is
     atomic within a filesystem, so a reader sees the old file or the new one.
     """
-    tmp = path.with_name(path.name + ".tmp")
+    tmp = atomic_temp_path(path)
     tmp.write_text(json.dumps(payload, indent=2), encoding="utf-8")
     os.replace(tmp, path)
 

{brainiac_cli-0.20.44 → brainiac_cli-0.20.46}/src/brain/core/_maintenance_state.py

@@ -1,5 +1,6 @@
 """Maintenance state methods for BrainCore."""
 from __future__ import annotations
+from ..atomic_temp import atomic_temp_path
 
 from ._shared import (
     Any,
@@ -130,7 +131,7 @@ class _MaintenanceStateMixin:
 
         path = config.maintain_state_path(self.vault)
         path.parent.mkdir(parents=True, exist_ok=True)
-        tmp = path.with_suffix(path.suffix + ".tmp")
+        tmp = atomic_temp_path(path)
         tmp.write_text(_json.dumps(state, indent=2, sort_keys=True), encoding="utf-8")
         _os.replace(tmp, path)
     def _note_graphify_build_outcome(

{brainiac_cli-0.20.44 → brainiac_cli-0.20.46}/src/brain/embed.py

@@ -50,18 +50,21 @@ ARCTIC_FULL_DIM = 768
 MRL_DIM = 256
 
 
+# Measured 2026-10-19: 4 threads match the all-cores wall time at ~40% of the CPU.
+_DEFAULT_THREADS = 4
+
+
 def _ort_threads() -> int | None:
     """Intra-op thread count for the ONNX session (S11 speed fix).
 
-    Default: all physical cores (Apple Silicon has no SMT, so logical ==
-    physical — on the M4 Pro that is 12). Saturating the batch dimension
-    across cores is the biggest ORT knob for bulk embedding throughput.
+    Default: 4 threads (capped at the core count). More threads spin without
+    cutting wall time; raise it for bulk work.
     Override via ``$BRAIN_EMBED_THREADS``."""
     raw = os.environ.get("BRAIN_EMBED_THREADS")
     if raw and raw.strip().isdigit():
         return int(raw)
     try:
-        return os.cpu_count() or None
+        return min(_DEFAULT_THREADS, os.cpu_count() or _DEFAULT_THREADS)
     except Exception:
         return None
 

{brainiac_cli-0.20.44 → brainiac_cli-0.20.46}/src/brain/embed_onnx.py

@@ -8,6 +8,8 @@ import sys as sys
 from dataclasses import dataclass
 from typing import Sequence
 
+from .model_slot import model_slot
+
 # --- Direct-ONNX models (DIST-01: eliminates fastembed) ---------------------
 # Each model owns its pooling, prefixes, dimension and exact file. Keeping the
 # contract here prevents a future model swap from inheriting another model's
@@ -255,9 +257,10 @@ class OnnxEmbedder:
                 t = _ort_threads()
                 if t:
                     so.intra_op_num_threads = t
-                self._sess = ort.InferenceSession(
-                    onnx_path, sess_options=so, providers=_ort_providers()
-                )
+                with model_slot():  # loading peaks well above the weights' size
+                    self._sess = ort.InferenceSession(
+                        onnx_path, sess_options=so, providers=_ort_providers()
+                    )
                 self._in_names = [i.name for i in self._sess.get_inputs()]
                 self._tok = Tokenizer.from_file(os.path.join(base, "tokenizer.json"))
                 # Truncate to the engine's calibrated chunk window BEFORE padding.
@@ -387,7 +390,8 @@ class OnnxEmbedder:
                 feed[nm] = am
             elif "token_type" in low:
                 feed[nm] = np.zeros_like(ii)
-        hidden = self._sess.run(None, feed)[0]  # [batch, seq, dim] float32
+        with model_slot():
+            hidden = self._sess.run(None, feed)[0]  # [batch, seq, dim] float32
         if self._pooling == "cls":
             pooled = hidden[:, 0, :]
         else:

{brainiac_cli-0.20.44 → brainiac_cli-0.20.46}/src/brain/exceptions_page.py

@@ -60,6 +60,7 @@ from . import maintenance as _maintenance
 from . import maintenance_notify as _notify
 from . import remediation as _rem
 from . import remediation_exceptions as _rex
+from .atomic_temp import atomic_temp_path
 from .exceptions_render import render_page  # re-exported: the page's one
 # renderer, split out on 2026-08-22 when this file hit the 500-line bound.
 
@@ -287,7 +288,7 @@ def maybe_ping(vault: Path, keys: list[str], full_path: Path) -> str | None:
     if not str(out or "").startswith("skipped"):  # a SKIP defers, never spends
         try:
             state_path.parent.mkdir(parents=True, exist_ok=True)
-            tmp = state_path.with_name(state_path.name + ".tmp")
+            tmp = atomic_temp_path(state_path)
             tmp.write_text(json.dumps({"hash": current_hash}), encoding="utf-8")
             os.replace(tmp, state_path)
         except OSError:
@@ -364,6 +365,6 @@ def generate(core: Any, today: datetime.date | None = None) -> dict[str, Any]:
 
 
 def _atomic_write(path: Path, text: str) -> None:
-    tmp = path.with_name(path.name + ".tmp")
+    tmp = atomic_temp_path(path)
     tmp.write_text(text, encoding="utf-8")
     os.replace(tmp, path)

{brainiac_cli-0.20.44 → brainiac_cli-0.20.46}/src/brain/exceptions_verify.py

@@ -78,6 +78,7 @@ from pathlib import Path
 from typing import Any
 
 from . import config as _config
+from .atomic_temp import atomic_temp_path
 
 PINNED_FILENAME = "pinned-verify.json"
 MOUNT_HTML_FILENAME = "exceptions.html"
@@ -372,7 +373,7 @@ def stage_pin(vault: Path, workspace: Path | None = None) -> dict[str, Any]:
     data = {"vault_id": vid, "public_key_pem": pem}
     path = staging_root(vault, workspace) / PINNED_FILENAME
     path.parent.mkdir(parents=True, exist_ok=True)
-    tmp = path.with_name(path.name + ".tmp")
+    tmp = atomic_temp_path(path)
     tmp.write_text(json.dumps(data, indent=1, sort_keys=True), encoding="utf-8")
     os.replace(tmp, path)
     return data
@@ -413,6 +414,6 @@ def publish_summary(vault: Path, workspace: Path | None = None) -> None:
         if not src.exists():
             continue
         dest = dest_dir / filename
-        tmp = dest.with_name(dest.name + ".tmp")
+        tmp = atomic_temp_path(dest)
         tmp.write_bytes(src.read_bytes())
         os.replace(tmp, dest)

{brainiac_cli-0.20.44 → brainiac_cli-0.20.46}/src/brain/folds/intake.py

@@ -240,12 +240,12 @@ class IntakeFoldsMixin:
             from .. import cos                                   # noqa: PLC0415
 
             ops = cos.run_ops_dir(self.vault)
-            ledgers = sorted(ops.glob("_cos_ingestion_ledger_*.jsonl"),
+            ledgers = sorted(ops.glob(cos.LEDGER_GLOB),
                              key=self._ledger_order)
             if not ledgers:
                 return
             latest = ledgers[-1]
-            run_id = latest.stem[len("_cos_ingestion_ledger_"):]
+            run_id = cos.ledger_run_id(latest)
             rows, seen = [], set()
             for line in latest.read_text(encoding="utf-8").splitlines():
                 if not line.strip():
@@ -268,7 +268,7 @@ class IntakeFoldsMixin:
         """Sort key for `_cos_ingestion_ledger_<date>-run<N>.jsonl`: the date
         as text, then the run number as an INT. A missing or unparseable run
         number sorts first, which keeps a malformed name from winning."""
-        stem = path.stem[len("_cos_ingestion_ledger_"):]
+        stem = path.stem[len("_cos_ingestion_ledger_"):]  # no COS import: this runs unguarded
         date, _, tail = stem.partition("-run")
         return (date, int(tail) if tail.isdigit() else -1)
 
@@ -355,12 +355,12 @@ class IntakeFoldsMixin:
             from .. import cos                                   # noqa: PLC0415
 
             ops = cos.run_ops_dir(self.vault)
-            ledgers = sorted(ops.glob("_cos_ingestion_ledger_*.jsonl"),
+            ledgers = sorted(ops.glob(cos.LEDGER_GLOB),
                              key=self._ledger_order)
             if not ledgers:
                 return
             latest = ledgers[-1]
-            run_id = latest.stem[len("_cos_ingestion_ledger_"):]
+            run_id = cos.ledger_run_id(latest)
             stuck, seen = {}, set()
             for line in latest.read_text(encoding="utf-8").splitlines():
                 if not line.strip():

{brainiac_cli-0.20.44 → brainiac_cli-0.20.46}/src/brain/graph_ops.py

@@ -14,6 +14,7 @@ from . import classification, config, egress
 from . import graphify as graphify_model
 from .graph import build_graph
 from .progress import progress_note
+from .atomic_temp import atomic_temp_path
 
 
 @dataclass(frozen=True)
@@ -186,7 +187,7 @@ def _publish_graph_artifact(
     day: dt.date,
 ) -> None:
     """Atomically publish validated graph and manifest files."""
-    temporary_graph = paths.graph.with_suffix(paths.graph.suffix + ".tmp")
+    temporary_graph = atomic_temp_path(paths.graph)
     temporary_graph.write_text(
         json.dumps(artifact, indent=2, sort_keys=True), encoding="utf-8"
     )
@@ -197,7 +198,7 @@ def _publish_graph_artifact(
         "built_at": day.isoformat(),
         "notes": manifest,
     }
-    temporary_manifest = paths.manifest.with_suffix(paths.manifest.suffix + ".tmp")
+    temporary_manifest = atomic_temp_path(paths.manifest)
     temporary_manifest.write_text(
         json.dumps(new_state, indent=2, sort_keys=True), encoding="utf-8"
     )

{brainiac_cli-0.20.44 → brainiac_cli-0.20.46}/src/brain/index/_search.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 from ._shared import *  # noqa: F401,F403
+from ..model_slot import model_slot
 
 
 class _SearchMixin:
@@ -150,11 +151,14 @@ class _SearchMixin:
 
         Retired versions (``is_latest_version: false``) are hidden unless
         ``include_retired`` — see ``search_ranking.generate_candidates``."""
-        return self._hybrid_search_impl(
-            query, k=k, rrf_k=rrf_k, candidate_factor=candidate_factor,
-            rerank=rerank, reranker=reranker, rerank_top=rerank_top,
-            rerank_gate=rerank_gate, trace=None, include_retired=include_retired,
-        )
+        # The slot is taken HERE, before the reranker's 30 s budget starts, so
+        # a queued search waits instead of silently losing its rerank.
+        with model_slot():
+            return self._hybrid_search_impl(
+                query, k=k, rrf_k=rrf_k, candidate_factor=candidate_factor,
+                rerank=rerank, reranker=reranker, rerank_top=rerank_top,
+                rerank_gate=rerank_gate, trace=None, include_retired=include_retired,
+            )
 
     def hybrid_search_with_trace(
         self,
@@ -187,11 +191,12 @@ class _SearchMixin:
             candidate_limit=n,
             result_limit=max(0, k),
         )
-        hits = self._hybrid_search_impl(
-            query, k=k, rrf_k=rrf_k, candidate_factor=candidate_factor,
-            rerank=rerank, reranker=reranker, rerank_top=rerank_top,
-            rerank_gate=rerank_gate, trace=trace, include_retired=include_retired,
-        )
+        with model_slot():  # see hybrid_search
+            hits = self._hybrid_search_impl(
+                query, k=k, rrf_k=rrf_k, candidate_factor=candidate_factor,
+                rerank=rerank, reranker=reranker, rerank_top=rerank_top,
+                rerank_gate=rerank_gate, trace=trace, include_retired=include_retired,
+            )
         return hits, trace
 
     def _hybrid_search_impl(

{brainiac_cli-0.20.44 → brainiac_cli-0.20.46}/src/brain/ingest/deliverables.py

@@ -49,6 +49,7 @@ from typing import TYPE_CHECKING, Any
 
 from .. import classification as CLS
 from .. import supersede_declared as SUP
+from ..atomic_temp import atomic_temp_path
 
 if TYPE_CHECKING:  # the stage record; a runtime import here would be a cycle
     from .pipeline_stages import ClaimRecord
@@ -423,7 +424,7 @@ def _store(vault: Any, pending: dict[str, dict[str, Any]]) -> None:
     path = journal_path(vault)
     path.parent.mkdir(parents=True, exist_ok=True)
     config.secure_file_permissions(path.parent, 0o700)
-    tmp = path.with_name(path.name + ".tmp")
+    tmp = atomic_temp_path(path)
     tmp.write_text(json.dumps(pending, indent=2, sort_keys=True), encoding="utf-8")
     config.secure_file_permissions(tmp, 0o600)
     tmp.replace(path)

{brainiac_cli-0.20.44 → brainiac_cli-0.20.46}/src/brain/ingest/handlers/concealment_pdf.py

@@ -62,7 +62,10 @@ def page_fonts(page: Any) -> dict[str, Any]:
     """
     fonts: dict[str, Any] = {}
     try:
-        from pypdf._font import Font
+        try:
+            from pypdf.generic._font import Font  # pypdf >= 6.21
+        except ImportError:  # coverage-audit: older pypdf keeps Font here
+            from pypdf._font import Font
 
         resources = page.get_inherited("/Resources", None)
         table = resources.get("/Font") if resources else None

{brainiac_cli-0.20.44 → brainiac_cli-0.20.46}/src/brain/ingest/pipeline_files.py

@@ -10,6 +10,7 @@ import shutil
 import tempfile
 from pathlib import Path
 from typing import Any
+from ..atomic_temp import atomic_temp_path
 
 
 def manifest_path(vault: Path) -> Path:
@@ -32,7 +33,7 @@ def load_manifest(vault: Path) -> dict[str, str]:
 def save_manifest(vault: Path, manifest: dict[str, str]) -> None:
     path = manifest_path(vault)
     path.parent.mkdir(parents=True, exist_ok=True)
-    tmp = path.with_suffix(".tmp")
+    tmp = atomic_temp_path(path)
     tmp.write_text(json.dumps(manifest, indent=2, sort_keys=True), encoding="utf-8")
     os.replace(tmp, path)
 
@@ -57,7 +58,7 @@ def load_failures(vault: Path) -> dict[str, int]:
 def save_failures(vault: Path, failures: dict[str, int]) -> None:
     path = failures_path(vault)
     path.parent.mkdir(parents=True, exist_ok=True)
-    tmp = path.with_suffix(".tmp")
+    tmp = atomic_temp_path(path)
     tmp.write_text(json.dumps(failures, indent=2, sort_keys=True), encoding="utf-8")
     os.replace(tmp, path)
 
@@ -88,7 +89,11 @@ def read_nofollow(path: Path, *, max_bytes: int | None = None) -> bytes:
 
     if path.is_symlink():
         raise ReadRefused(f"{path.name} is a symlink — refused")
-    flags = os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0) | getattr(os, "O_BINARY", 0)
+    # O_NONBLOCK: a FIFO planted at the name would otherwise block the open
+    # until a writer arrives, before the S_ISREG check below can refuse it
+    # (same guard as ``cos._io``). It changes nothing for a regular file.
+    flags = (os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0) | getattr(os, "O_BINARY", 0)
+             | getattr(os, "O_NONBLOCK", 0))
     try:
         fd = os.open(path, flags)
     except OSError as exc:

{brainiac_cli-0.20.44 → brainiac_cli-0.20.46}/src/brain/interview.py

@@ -27,6 +27,7 @@ import os
 import re
 from pathlib import Path
 from typing import Any
+from .atomic_temp import atomic_temp_path
 
 SCHEMA = "brain-interview/1"
 STATE_RELPATH = ".brain/interview/state.json"
@@ -103,7 +104,7 @@ def read_state(vault: Any) -> dict[str, Any]:
 def write_state(vault: Any, state: dict[str, Any]) -> Path:
     p = state_path(vault)
     p.parent.mkdir(parents=True, exist_ok=True)
-    tmp = p.with_suffix(".json.tmp")
+    tmp = atomic_temp_path(p)
     tmp.write_text(json.dumps(state, ensure_ascii=False, sort_keys=True,
                               indent=1) + "\n", encoding="utf-8")
     os.chmod(tmp, 0o600)

{brainiac_cli-0.20.44 → brainiac_cli-0.20.46}/src/brain/invariant_coverage.py

@@ -9,6 +9,7 @@ from pathlib import Path
 from typing import Any
 
 from .invariant_shared import SAMPLE_CAP
+from .atomic_temp import atomic_temp_path
 
 # ---------------------------------------------------------------------------
 # G12 — the exclusion set, defined ONCE here and imported by every consumer
@@ -437,7 +438,7 @@ def write_link_lane(conn: Any, vault: Path, *, limit: int | None = None) -> dict
     except (OSError, ValueError):
         previous = None
     payload.update(lane_consumption(previous, all_ids, payload["generated"]))
-    tmp = out.with_suffix(".json.tmp")
+    tmp = atomic_temp_path(out)
     tmp.write_text(json.dumps(payload, indent=1), encoding="utf-8")
     tmp.replace(out)
     return {"path": str(out), "written": len(payload["candidates"]),

{brainiac_cli-0.20.44 → brainiac_cli-0.20.46}/src/brain/maintenance_notify.py

@@ -13,6 +13,7 @@ import os
 import platform
 import subprocess
 import hashlib
+from .atomic_temp import atomic_temp_path
 
 
 # ---------------------------------------------------------------------------
@@ -138,7 +139,7 @@ def record_current_findings(
     }
     try:
         path.parent.mkdir(parents=True, exist_ok=True)
-        tmp = path.with_name(path.name + ".tmp")
+        tmp = atomic_temp_path(path)
         tmp.write_text(json.dumps(payload, indent=1), encoding="utf-8")
         os.replace(tmp, path)
     except OSError:

brainiac_cli-0.20.46/src/brain/model_slot.py

@@ -0,0 +1,110 @@
+"""Machine-wide cap on concurrent model work (load + inference).
+
+WHY. One `brain search` peaks at ~4 GB for a few seconds: loading the fp32
+reranker alone measures 3.0 GB, a 15-pair rerank adds ~1 GB (measured
+2026-10-18, M4 Pro). On 2026-10-18 three subagents ran ten searches at once on
+a 24 GB Mac; macOS recorded ten Python processes at 4.1-6.8 GB each and the
+machine froze until a forced reset. Jetsam stopped only small system daemons,
+never the searches. Nothing in brain bounded how many ran together.
+
+WHAT. `model_slot()` waits for one of `$BRAIN_MODEL_SLOTS` (default 2) slot
+files under `$BRAIN_MODEL_SLOT_DIR` (default ~/.cache/brain-model-slots) and
+holds an exclusive `flock` on it for the duration of the block. The kernel drops
+the lock when the process dies, so a crash never leaks a slot.
+
+RE-ENTRANT PER PROCESS. A search holds a slot and its reranker worker thread
+runs inside it; that work must not wait for a second slot. So the first
+acquire in a process takes a slot, and nested or concurrent acquires in the
+same process ride on it until the depth returns to zero. The cap is therefore
+"processes doing model work", which is what costs memory.
+
+FAIL OPEN. If the slot directory cannot be created or opened (read-only HOME,
+Windows without fcntl), the work runs unguarded: a guard must never stop a
+search from working. ponytail: no Windows lock — add msvcrt when a Windows
+host runs parallel searches.
+"""
+from __future__ import annotations
+
+import contextlib
+import os
+import sys
+import threading
+import time
+from pathlib import Path
+from typing import Iterator
+
+try:
+    import fcntl
+except ImportError:  # Windows
+    fcntl = None  # type: ignore[assignment]
+
+_POLL_SECONDS = 0.2
+_gate = threading.Lock()  # a second thread waits here while the first acquires
+_state = threading.Lock()
+_depth = 0
+_fd: int | None = None
+
+
+def slot_count() -> int:
+    raw = os.environ.get("BRAIN_MODEL_SLOTS", "").strip()
+    return int(raw) if raw.isdigit() and int(raw) > 0 else 2
+
+
+def slot_dir() -> Path:
+    raw = os.environ.get("BRAIN_MODEL_SLOT_DIR")
+    return Path(raw) if raw else Path.home() / ".cache" / "brain-model-slots"
+
+
+def _try_take(paths: list[Path]) -> int | None:
+    for path in paths:
+        fd = os.open(path, os.O_RDWR | os.O_CREAT, 0o644)
+        try:
+            fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except OSError:
+            os.close(fd)
+            continue
+        return fd
+    return None
+
+
+def _acquire() -> int | None:
+    if fcntl is None:
+        return None
+    try:
+        root = slot_dir()
+        root.mkdir(parents=True, exist_ok=True)
+        paths = [root / f"slot-{i}.lock" for i in range(slot_count())]
+        fd = _try_take(paths)
+        if fd is not None:
+            return fd
+        print(f"brain: waiting for a model slot ({len(paths)} in use on this "
+              "machine; $BRAIN_MODEL_SLOTS sets the cap)", file=sys.stderr, flush=True)
+        while fd is None:
+            time.sleep(_POLL_SECONDS)
+            fd = _try_take(paths)
+        return fd
+    except OSError as exc:
+        print(f"brain: model slot unavailable ({exc}); running unguarded",
+              file=sys.stderr, flush=True)
+        return None
+
+
+@contextlib.contextmanager
+def model_slot() -> Iterator[None]:
+    global _depth, _fd
+    with _gate:
+        with _state:
+            first = _depth == 0
+        fd = _acquire() if first else None  # a KeyboardInterrupt here holds nothing
+        with _state:
+            _depth += 1
+            if first:
+                _fd = fd
+    try:
+        yield
+    finally:
+        with _state:
+            _depth -= 1
+            if _depth == 0 and _fd is not None:
+                os.close(_fd)  # closing the only fd on the file drops the flock
+                _fd = None

{brainiac_cli-0.20.44 → brainiac_cli-0.20.46}/src/brain/overlay_generated.py

@@ -64,6 +64,7 @@ from typing import Any, NamedTuple
 
 from . import frontmatter
 from . import overlay as ov
+from .atomic_temp import atomic_temp_path
 
 #: Sibling of ``keywords/`` — deliberately NOT inside it. See the module
 #: docstring: ``keywords/`` drives ingest classification and this does not.
@@ -223,7 +224,7 @@ def _publish(path: Path, text: str) -> None:
     ``*.md`` glob in :func:`brain.overlay._ring_files` cannot pick a half-written
     temp file up as a ring file of its own.
     """
-    tmp = path.with_name(f".{path.name}.tmp")
+    tmp = atomic_temp_path(path)
     try:
         tmp.write_text(text, encoding="utf-8")
         os.replace(tmp, path)

{brainiac_cli-0.20.44 → brainiac_cli-0.20.46}/src/brain/provision.py

@@ -47,7 +47,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Callable, Optional
 
-from . import workspaces
+from . import atomic_temp, workspaces
 # Wire 5 moved to `provision_mcp` (its own module: the Desktop config is a
 # third-party file with a third party still writing to it). Re-exported here
 # because this module is the one every caller already imports.
@@ -94,7 +94,7 @@ def write_request(vault: str | os.PathLike[str], *, role: str) -> dict[str, Any]
     for zone in ("brain", "raw", "inbox"):
         (vault_p / zone).mkdir(exist_ok=True)
     payload = {"version": 1, "requested_at": _now_iso(), "role": role}
-    tmp = marker.with_suffix(".tmp")
+    tmp = atomic_temp.atomic_temp_path(marker)
     tmp.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
     os.replace(tmp, marker)
     return {"action": "provision-request", "status": "staged",