brainiac-cli 0.20.48__tar.gz → 0.20.49__tar.gz

{brainiac_cli-0.20.48/src/brainiac_cli.egg-info → brainiac_cli-0.20.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brainiac-cli
-Version: 0.20.48
+Version: 0.20.49
 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,7 +19,7 @@ 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.21.2
+Requires-Dist: pypdf>=6.21.4
 Requires-Dist: python-docx>=1.1
 Requires-Dist: python-pptx>=0.6.23
 Requires-Dist: openpyxl>=3.1
@@ -44,7 +44,7 @@ Requires-Dist: PyYAML>=6; extra == "corporate"
 Provides-Extra: yaml
 Requires-Dist: PyYAML>=6; extra == "yaml"
 Provides-Extra: ingest
-Requires-Dist: pypdf>=6.21.2; extra == "ingest"
+Requires-Dist: pypdf>=6.21.4; 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"
@@ -63,6 +63,7 @@ Provides-Extra: quant-tools
 Requires-Dist: onnx>=1.14; extra == "quant-tools"
 Provides-Extra: mcp
 Requires-Dist: mcp<2,>=1.30.0; extra == "mcp"
+Requires-Dist: PyJWT>=2.15.0; extra == "mcp"
 Provides-Extra: index
 Requires-Dist: regex>=2023.0.0; extra == "index"
 Dynamic: license-file

{brainiac_cli-0.20.48 → brainiac_cli-0.20.49}/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.48"
+version = "0.20.49"
 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.21.2",
+    "pypdf>=6.21.4",
     "python-docx>=1.1",
     "python-pptx>=0.6.23",
     "openpyxl>=3.1",
@@ -97,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.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'"]
+ingest = ["pypdf>=6.21.4", "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
@@ -128,7 +128,9 @@ quant-tools = ["onnx>=1.14"]
 # >=1.30.0: CVE-2026-59951 (Streamable HTTP stateful sessions never reclaimed,
 # unbounded memory) is fixed there. The FLOOR, not just the lock, for the same
 # reason as pypdf above: a plain `pip install` reads this, not requirements.lock.
-mcp = ["mcp>=1.30.0,<2"]
+# PyJWT>=2.15.0: the floor mcp pulls in, stated here so a plain install
+# cannot resolve an older PyJWT (public PR #36).
+mcp = ["mcp>=1.30.0,<2", "PyJWT>=2.15.0"]
 # Timeout-bounded regex engine (mrab-regex) used by BrainIndex.grep's --regex
 # path (RET-04 hardening) as a ReDoS guard: regex.search(text, timeout=...)
 # genuinely bounds catastrophic backtracking, unlike stdlib `re`. Absent ->
@@ -183,7 +185,7 @@ known_first_party = ["brain", "workspace_registry", "framework_sync", "qwen3_emb
 # package_module_name_map: the 4 real import-name mismatches (distribution
 # name vs. the name actually imported).
 package_module_name_map = { PyYAML = "yaml", "python-docx" = "docx", "python-pptx" = "pptx", Pillow = "PIL" }
-per_rule_ignores = { DEP001 = ["llama_cpp", "lxml"], DEP002 = ["pytest", "pytest-xdist", "pytest-timeout", "ruff", "build", "onnx", "ranx"] }
+per_rule_ignores = { DEP001 = ["llama_cpp", "lxml"], DEP002 = ["pytest", "pytest-xdist", "pytest-timeout", "ruff", "build", "onnx", "ranx", "PyJWT"] }
 # DEP001 llama_cpp/lxml: both are optional accelerants guarded by
 # try/except ImportError (src/brain/context.py, src/brain/ingest/handlers/html.py)
 # — the code degrades gracefully absent either, same pattern as the existing
@@ -195,12 +197,15 @@ per_rule_ignores = { DEP001 = ["llama_cpp", "lxml"], DEP002 = ["pytest", "pytest
 # src/brain package. ranx is a real [eval] runtime import, but its only
 # import site is eval/, which extend_exclude drops above for the DEP001
 # noise reason — excluding it flips ranx to a false DEP002.
+# DEP002 PyJWT: a deliberate floor pin for mcp (see the mcp extra above,
+# public PR #36); never imported by our own code.
 
 [tool.claude-quality]
 # Trees the size gates skip: frozen plan/archive/evidence dirs and the
 # generated _assets mirror of tools/ + scripts/ (re-synced by
 # tools/package_clients.py). Not authored source.
-exclude = ["_plans", "_archive", "_evidence", "_assets"]
+# eval/ holds frozen, one-off experiment scripts, not shipped source (owner choice 2026-11-03).
+exclude = ["_plans", "_archive", "_evidence", "_assets", "eval"]
 
 [tool.ruff]
 # CORRECTNESS ONLY — this is not a style gate. The repo already has three
@@ -257,6 +262,9 @@ select = ["F", "E9", "E722"]
 # exists to express that.
 ignore = ["F403", "F405"]
 
+[tool.ruff.lint.mccabe]
+max-complexity = 12  # matches the complexity ratchet limit (tools/check_complexity.py, limit=12)
+
 [tool.ruff.lint.per-file-ignores]
 # F811 cannot see pytest. A module-level `@pytest.fixture def text()` and a test
 # that takes `text` as a parameter is the framework's core idiom, and this rule
@@ -264,6 +272,10 @@ ignore = ["F403", "F405"]
 # real F811s all live outside tests/.
 "tests/**" = ["F811"]
 
+# eval/ is out of the size and complexity gates (see [tool.claude-quality]); the
+# correctness lint still runs on it.
+"eval/**" = ["C901"]
+
 
 [tool.pytest.ini_options]
 # Scope collection to tests/ so pytest never descends into a local model venv
@@ -302,9 +314,9 @@ 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
+# malicious or broken). shortcut: pypdf 6.21.4 (fixes 7 DoS advisories, 2026-10-31), 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.
+# exempt; re-check the exemptions after 2026-11-08.
 exclude-newer = "7 days"
 exclude-newer-package = { pypdf = false, filelock = false, certifi = false }
 # fastembed (the optional `embed` extra, not installed by default) caps

{brainiac_cli-0.20.48 → brainiac_cli-0.20.49}/src/brain/_assets/AGENTS.md

@@ -449,7 +449,7 @@ gates.
    signal (`emitter_output`, 2026-08-20).** The paragraph above is right and
    is not weakened: `proposal`, `report`, `analysis` and `review` stay OUT of
    `OPERATIONAL_SOURCE_TYPES` because a human writes those about the
-   business. The gap it leaves is narrower — when `_log_rotation.py` emits
+   business. The gap it leaves is narrower — when a log-rotation script (not tracked here) emits
    `type: proposal` once a day, type says "keep" and nothing else disagrees.
    The reference vault carried **22** daily `Log rotation proposal` files
    from one script, each counted as a source awaiting a note. So the second

{brainiac_cli-0.20.48 → brainiac_cli-0.20.49}/src/brain/_assets/scripts/brain_synthesis_codex.py

@@ -58,7 +58,11 @@ existing-note link suggestions, or missing watchdogs in action_required rather
 than changing existing notes. This runner never edits or retires existing notes.
 Do not create a duplicate of a supplied existing note. If there is no honest
 new synthesis, return notes=[] and explain why in summary/action_required.
+Maintenance status="ok" with a recent last_run is success; last_success and rc
+are optional fields on many folds. Missing optional fields are not failures.
 Note bodies must be 120–8000 characters; titles 1–200 characters.
+Use each distinct set of source_ids for at most one note. Combine related
+claims from the same source set rather than repeating that set in several notes.
 
 UNTRUSTED DATA PACKET:
 {packet}
@@ -113,8 +117,10 @@ def make_packet(args, core):
     lane = link_lane_candidates(core.index.conn, args.vault, limit=100000)
     gate = classification.ClassificationFilter(args.max_tier)
     eligible = [x for x in lane["candidates"] if gate.allows(x.get("classification"))]
+    offset = getattr(args, "source_offset", 0) % max(len(eligible), 1)
+    ordered = eligible[offset:] + eligible[:offset]
     sources, remaining = [], args.packet_chars
-    for row in eligible:
+    for row in ordered:
         if len(sources) >= args.source_budget or remaining < 120:
             break
         note = get_gated(args, row["id"])
@@ -145,7 +151,7 @@ def make_packet(args, core):
     except (OSError, ValueError):
         state = {}
     # Diagnostics expose cadence/status, not arbitrary strings from host stores.
-    diagnostics = {key: {k: value.get(k) for k in ("last_run", "last_success", "date", "rc")}
+    diagnostics = {key: {k: value.get(k) for k in ("last_run", "last_success", "date", "rc", "status", "failed", "consecutive_failures")}
                    for key, value in state.items() if isinstance(value, dict)}
     return {"sources": sources, "knowledge_context": knowledge,
             "diagnostics": diagnostics,
@@ -322,6 +328,8 @@ def parser():
     p.add_argument("--model", default=None)
     p.add_argument("--max-tier", choices=classification.TIERS, default="Internal")
     p.add_argument("--source-budget", type=int, default=40)
+    p.add_argument("--source-offset", type=int, default=0,
+                   help="Rotate the canonical eligible lane for an operator-run backfill; no exclusions")
     p.add_argument("--note-budget", type=int, default=8)
     p.add_argument("--packet-chars", type=int, default=120000)
     p.add_argument("--timeout", type=int, default=1200)
@@ -337,7 +345,7 @@ def parser():
 
 
 def validate_args(args):
-    if not (1 <= args.source_budget <= 40 and 1 <= args.note_budget <= 8
+    if not (0 <= args.source_offset <= 100000 and 1 <= args.source_budget <= 40 and 1 <= args.note_budget <= 8
             and 1000 <= args.packet_chars <= 120000 and 30 <= args.timeout <= 1800):
         raise SystemExit("Bounds refused")
     for binary in (args.brain_bin, args.codex_bin):
@@ -441,6 +449,11 @@ def main():
     # A dry-run/smoke test must never earn the production watchdog heartbeat.
     if not args.smoke_test and not args.dry_run:
         update_state(args, outcome)
+    # Numbers only: summary/action_required/error carry vault-derived text and
+    # stay in the owner-only run_dir, never in the launchd log this lands in.
+    print(json.dumps({"rc": outcome["rc"], "run_dir": outcome["run_dir"],
+                      "created": len(outcome.get("created") or []),
+                      **{k: outcome.get(k) for k in ("tokens", "duration_s", "est_cost_usd")}}))
     return outcome["rc"]
 
 

{brainiac_cli-0.20.48 → brainiac_cli-0.20.49}/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.48"
+__version__ = "0.20.49"

{brainiac_cli-0.20.48 → brainiac_cli-0.20.49}/src/brain/alerts.py

@@ -79,7 +79,7 @@ SYNTHESIS_STALE_DAYS = 8
 STUCK_DRAFT_HOURS = 48
 
 # The feed's `findings[].key` vocabulary is closed (see maintenance_notify.py:
-# "blocked", "synthesis-watchdog", "trend:<metric>", "invariant:<metric>",
+# "blocked", "synthesis-watchdog", "trend:<metric>", "invariant:<metric>",  # noqa: ERA001
 # "branch-escalate:<branch>", "ingest_quarantine*", ...). The dir is on the
 # VirtioFS mount the Cowork VM can write, so a key failing this shape must
 # never reach the rendered alert text — it is the one thing standing between
@@ -91,7 +91,7 @@ def _read_json(path: Path) -> Any:
     try:
         with open(path, encoding="utf-8") as fh:
             return json.load(fh)
-    except Exception:
+    except Exception:  # fail-open: missing or corrupt feed file reads as no data
         return None
 
 

brainiac_cli-0.20.49/src/brain/atomic_temp.py

@@ -0,0 +1,49 @@
+"""Durable-write temp-name helper and the one write-then-replace helper."""
+from __future__ import annotations
+
+import errno
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from .lock import _atomic_temp_path
+
+atomic_temp_path = _atomic_temp_path
+
+
+def _fsync_dir(d: Path) -> None:
+    """fsync a directory so a rename in it survives a crash; unsupported is fine."""
+    if os.name == "nt":
+        return  # no directory descriptors on Windows
+    fd = os.open(d, os.O_RDONLY)
+    try:
+        os.fsync(fd)
+    except OSError as exc:
+        if exc.errno not in (errno.EINVAL, errno.ENOTSUP, errno.EBADF):
+            raise
+    finally:
+        os.close(fd)
+
+
+def write_text_atomic(path: Path, text: str) -> None:
+    """Write ``text`` to a sibling temp file, fsync, then ``os.replace`` it in.
+
+    The temp file is removed on any error, so the target keeps its old content.
+    """
+    tmp = atomic_temp_path(path)
+    try:
+        with open(tmp, "w", encoding="utf-8") as fh:
+            fh.write(text)
+            fh.flush()
+            os.fsync(fh.fileno())
+        os.replace(tmp, path)
+    except BaseException:
+        tmp.unlink(missing_ok=True)
+        raise
+    _fsync_dir(path.parent)  # after the replace: the target must not be unlinked on failure
+
+
+def write_json_atomic(path: Path, obj: Any) -> None:
+    """``write_text_atomic`` of ``json.dumps(obj, indent=2)`` plus a newline."""
+    write_text_atomic(path, json.dumps(obj, indent=2) + "\n")

{brainiac_cli-0.20.48 → brainiac_cli-0.20.49}/src/brain/audit.py

@@ -18,6 +18,7 @@ Resolution precedence (first hit wins, all yield identical PEM bytes):
 """
 from __future__ import annotations
 
+import logging
 import base64 as base64
 import contextlib
 import hashlib
@@ -31,6 +32,8 @@ from datetime import datetime as datetime, timezone as timezone
 from pathlib import Path
 from typing import Iterator, Optional
 
+logger = logging.getLogger(__name__)
+
 JSONL_FORMAT = "brain-audit-chain-jsonl-v1"
 NULL_PREV_HASH = "0" * 64
 _REQUIRED_KEYS = frozenset({"format", "ts", "verb", "path", "reason", "prev_hash", "sig"})
@@ -137,7 +140,7 @@ def _pem_from_credential_manager(service: str, account: str) -> Optional[bytes]:
 
         secret = keyring.get_password(service, account)
         return secret.encode("utf-8") if secret else None
-    except Exception:
+    except Exception:  # fail-open: keyring is optional; None means no key from this source
         return None
 
 
@@ -334,7 +337,8 @@ def _exclusive_lock(log_path: Path) -> Iterator[None]:
 
                 msvcrt.locking(fd, msvcrt.LK_LOCK, 1)
                 locked_with = "msvcrt"
-            except Exception:
+            except Exception:  # fail-open: best-effort lock; locked_with=None records that none was taken
+                logger.warning("audit lock not taken (msvcrt locking failed); writing unlocked", exc_info=True)
                 locked_with = None  # best-effort fallback
         yield
     finally:
@@ -348,7 +352,7 @@ def _exclusive_lock(log_path: Path) -> Iterator[None]:
 
                 os.lseek(fd, 0, os.SEEK_SET)
                 msvcrt.locking(fd, msvcrt.LK_UNLCK, 1)
-            except Exception:
+            except Exception:  # fail-open: unlock failure is harmless, the fd is closed next
                 pass
         os.close(fd)
 

{brainiac_cli-0.20.48 → brainiac_cli-0.20.49}/src/brain/audit_drift.py

@@ -1,12 +1,11 @@
 """Host-private audit drift-disposition triage (INT-02)."""
 from __future__ import annotations
+from .atomic_temp import write_text_atomic
 
 import json
-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
@@ -33,9 +32,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 = atomic_temp_path(path)
-    tmp.write_text(json.dumps(payload, indent=2), encoding="utf-8")
-    os.replace(tmp, path)
+    write_text_atomic(path, json.dumps(payload, indent=2))
 
 
 def drift_dispositions_path(vault: Path) -> Path:

{brainiac_cli-0.20.48 → brainiac_cli-0.20.49}/src/brain/autolink.py

@@ -45,16 +45,18 @@ def _fold(text: str) -> str:
     return re.sub(r"[^a-z0-9]+", "-", folded).strip("-")
 
 
-def _typed_notes(vault: Path, types: tuple[str, ...]) -> list[tuple[str, str]]:
-    """[(note_id, folded-title-slug)] for every brain/ note of one of ``types``."""
+def _typed_notes(vault: Path, types: tuple[str, ...], notes=None) -> list[tuple[str, str]]:
+    """[(note_id, folded-title-slug)] for every brain/ note of one of ``types``.
+
+    ``notes`` is an already-scanned vault (one scan shared by both finders)."""
     out: list[tuple[str, str]] = []
-    for note in scan_vault(vault):
+    for note in (scan_vault(vault) if notes is None else notes):
         if note.zone == "brain" and note.type in types:
             out.append((note.id, _fold(note.title)))
     return out
 
 
-def find_person_links(text: str, vault: Path) -> list[str]:
+def find_person_links(text: str, vault: Path, notes=None) -> list[str]:
     """Full-name matches of existing ``type: person`` notes in ``text``.
 
     A person note's title must fold to at least two hyphen-separated parts
@@ -63,7 +65,7 @@ def find_person_links(text: str, vault: Path) -> list[str]:
     ``text`` never links on its own."""
     folded_text = _fold(text)
     hits: list[str] = []
-    for note_id, name_slug in _typed_notes(vault, ("person",)):
+    for note_id, name_slug in _typed_notes(vault, ("person",), notes):
         parts = [p for p in name_slug.split("-") if p]
         if len(parts) < 2:
             continue
@@ -72,7 +74,7 @@ def find_person_links(text: str, vault: Path) -> list[str]:
     return hits
 
 
-def find_project_link(text: str, vault: Path) -> list[str]:
+def find_project_link(text: str, vault: Path, notes=None) -> list[str]:
     """Origin-context match against ``type: project``/``type: moc`` notes.
 
     Returns a match only when exactly one candidate's folded title is a
@@ -80,7 +82,7 @@ def find_project_link(text: str, vault: Path) -> list[str]:
     nothing."""
     folded_text = _fold(text)
     candidates = [
-        note_id for note_id, title_slug in _typed_notes(vault, ("project", "moc"))
+        note_id for note_id, title_slug in _typed_notes(vault, ("project", "moc"), notes)
         if title_slug and title_slug in folded_text
     ]
     return candidates if len(candidates) == 1 else []
@@ -109,8 +111,9 @@ def apply_autolinks(
         return body, []
     try:
         search_text = "\n".join(t for t in (title, body) if t)
-        candidates = list(find_person_links(search_text, vault))
-        candidates.extend(find_project_link("\n".join(t for t in (title, origin) if t), vault))
+        notes = list(scan_vault(vault))  # one scan per record; no cross-record cache
+        candidates = list(find_person_links(search_text, vault, notes))
+        candidates.extend(find_project_link("\n".join(t for t in (title, origin) if t), vault, notes))
         existing = set(parse_wikilinks(body))
         new_ids = [nid for nid in dict.fromkeys(candidates) if nid not in existing]
         if not new_ids:

{brainiac_cli-0.20.48 → brainiac_cli-0.20.49}/src/brain/backup.py

@@ -21,17 +21,28 @@ from __future__ import annotations
 import hashlib
 import io
 import json
+import os
 import tarfile
 import time
 from dataclasses import asdict, dataclass
 from pathlib import Path
 from typing import Any
 
+from . import config
 from . import encryption as enc
 
 EXCLUDE_DIRS = {".brain", ".git", "__pycache__", ".pytest_cache"}
 
 
+
+def _write_owner_only(path: Path, data: bytes) -> None:
+    """Create the archive 0600 from the first byte: a plaintext backup is the
+    whole vault, and the default umask left it readable by every local user."""
+    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    config.secure_file_permissions(path, 0o600)  # O_CREAT ignores mode on an existing file
+    with os.fdopen(fd, "wb") as fh:
+        fh.write(data)
+
 @dataclass
 class BackupManifest:
     schema_version: str
@@ -88,11 +99,11 @@ def create_backup(vault: Path, dest_dir: Path, *, name: str | None = None,
     if encrypt:
         token = enc.encrypt_bytes(plaintext, force=True)  # force: off-device => encrypt
         archive = dest_dir / f"{stamp}.tar.gz.enc"
-        archive.write_bytes(token)
+        _write_owner_only(archive, token)
         ct_bytes = len(token)
     else:
         archive = dest_dir / f"{stamp}.tar.gz"
-        archive.write_bytes(plaintext)
+        _write_owner_only(archive, plaintext)
         ct_bytes = len(plaintext)
 
     manifest = BackupManifest(

{brainiac_cli-0.20.48 → brainiac_cli-0.20.49}/src/brain/brief.py

@@ -137,7 +137,26 @@ def format_brief(brief: dict[str, Any]) -> str:
     elif brief.get("pending_before_drain", 0) == 0:
         lines.append("  ✓ no pending captures")
 
-    live = brief.get("cos_liveness") or {}
+    lines.extend(_cos_liveness_lines(brief.get("cos_liveness") or {}))
+
+    snap = brief.get("snapshot_age")
+    if snap:
+        lines.append(f"  snapshot age: {snap}")
+
+    if brief.get("recent"):
+        lines.append("  recent:")
+        for n in brief["recent"]:
+            lines.append(
+                f"    {str(n.get('updated', ''))[:10]}  {n.get('id', '')}  "
+                f"({n.get('classification') or 'UNLABELLED'})"
+            )
+
+    return "\n".join(lines)
+
+
+def _cos_liveness_lines(live: dict[str, Any]) -> list[str]:
+    """COS liveness banner lines for the text brief."""
+    lines: list[str] = []
     if live.get("alert"):
         lines.append(f"  ⚠ {live['alert_text']}")
     elif live.get("pending_behind_backpressure"):
@@ -158,20 +177,7 @@ def format_brief(brief: dict[str, Any]) -> str:
     # VALID run. Loud here for the same reason the line above is.
     if live.get("quarantine_text"):
         lines.append(f"  ⚠ {live['quarantine_text']}")
-
-    snap = brief.get("snapshot_age")
-    if snap:
-        lines.append(f"  snapshot age: {snap}")
-
-    if brief.get("recent"):
-        lines.append("  recent:")
-        for n in brief["recent"]:
-            lines.append(
-                f"    {str(n.get('updated', ''))[:10]}  {n.get('id', '')}  "
-                f"({n.get('classification') or 'UNLABELLED'})"
-            )
-
-    return "\n".join(lines)
+    return lines
 
 
 def _maintain_alert_lines(maintain_alert: dict[str, Any] | None) -> list[str]:

{brainiac_cli-0.20.48 → brainiac_cli-0.20.49}/src/brain/chunk.py

@@ -200,25 +200,8 @@ def _pack(heading: str, text: str, ordinal_start: int, lang_of) -> list[Chunk]:
     return out
 
 
-def chunk_text(body: str, *, lang_of=detect_language) -> list[Chunk]:
-    """Chunk a note body at section/block level with a soft size budget.
-
-    Strategy: split into heading-scoped blocks, then greedily merge adjacent
-    blocks under the same heading up to TARGET_CHARS, splitting any single block
-    over MAX_CHARS. Each chunk's language is detected on its own text.
-
-    Dual-granularity (RET-03): a short note (whole body ≤ ``_whole_note_max()``)
-    is returned as ONE whole-note chunk — its sections are NOT split — so its
-    cross-lingual signal stays concentrated in a single vector. See
-    ``WHOLE_NOTE_MAX_CHARS``.
-    """
-    whole_max = _whole_note_max()
-    stripped = body.strip()
-    if whole_max > 0 and stripped and len(stripped) <= whole_max:
-        return [Chunk(0, "", stripped, lang_of(stripped))]
-    blocks = _split_blocks(body)
-    if not blocks:
-        return []
+def _merge_blocks(blocks: list[tuple[str, str]], lang_of) -> list[Chunk]:
+    """Greedily merge adjacent same-heading blocks up to TARGET_CHARS and pack."""
     chunks: list[Chunk] = []
     ordinal = 0
     pending_heading = blocks[0][0]
@@ -247,3 +230,25 @@ def chunk_text(body: str, *, lang_of=detect_language) -> list[Chunk]:
     if pending_text:
         emit(pending_heading, pending_text)
     return chunks
+
+
+def chunk_text(body: str, *, lang_of=detect_language) -> list[Chunk]:
+    """Chunk a note body at section/block level with a soft size budget.
+
+    Strategy: split into heading-scoped blocks, then greedily merge adjacent
+    blocks under the same heading up to TARGET_CHARS, splitting any single block
+    over MAX_CHARS. Each chunk's language is detected on its own text.
+
+    Dual-granularity (RET-03): a short note (whole body ≤ ``_whole_note_max()``)
+    is returned as ONE whole-note chunk — its sections are NOT split — so its
+    cross-lingual signal stays concentrated in a single vector. See
+    ``WHOLE_NOTE_MAX_CHARS``.
+    """
+    whole_max = _whole_note_max()
+    stripped = body.strip()
+    if whole_max > 0 and stripped and len(stripped) <= whole_max:
+        return [Chunk(0, "", stripped, lang_of(stripped))]
+    blocks = _split_blocks(body)
+    if not blocks:
+        return []
+    return _merge_blocks(blocks, lang_of)

{brainiac_cli-0.20.48 → brainiac_cli-0.20.49}/src/brain/cli.py

@@ -389,7 +389,10 @@ def _prepare_invocation(args: Any, config: Any) -> str:
         # the session's own shell, so it can never raise a VM ceiling.
         from . import vm_ceiling
 
-        ceiling, _provenance = vm_ceiling.resolved_ceiling()
+        # The ceiling of the vault this command OPENS, not $BRAIN_VAULT's (SEC-04).
+        explicit = getattr(args, "vault", None)
+        ceiling, _provenance = vm_ceiling.resolved_ceiling(
+            config.vault_root(explicit, allow_missing=True) if explicit else None)
         args.max_tier = cls.clamp_to(str(args.max_tier), ceiling)
     config.apply_role_embedder_policy(role)
     return role