brainlayer 1.5.80__tar.gz → 1.5.82__tar.gz

{brainlayer-1.5.80 → brainlayer-1.5.82}/PKG-INFO

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

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

{brainlayer-1.5.80 → brainlayer-1.5.82}/src/brainlayer/__init__.py

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

@@ -0,0 +1 @@
+BUILD_SHA = "9b6e1c75b4bed7440161989df15eb49ccabca0db"

{brainlayer-1.5.80 → brainlayer-1.5.82}/src/brainlayer/backup_daily.py

@@ -16,6 +16,7 @@ import inspect
 import json
 import math
 import os
+import plistlib
 import queue
 import re
 import shutil
@@ -37,6 +38,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 from urllib.parse import urlsplit
+from xml.parsers.expat import ExpatError
 
 import requests
 
@@ -45,6 +47,7 @@ from .paths import get_db_path, resolve_db_path
 from .socket_hygiene import refuse_production_brainbar_socket
 
 _sleep = time.sleep
+_reclaim_clock = time.monotonic
 
 DEFAULT_TOKEN_PATH = drive_credentials.DEFAULT_TOKEN_PATH
 DEFAULT_CLIENT_PATH = drive_credentials.DEFAULT_CLIENT_PATH
@@ -61,6 +64,8 @@ DEFAULT_STAGING_DIR = Path.home() / ".local" / "share" / "brainlayer" / "backups
 MIN_RAW_FREE_BYTES = 2 * 1024 * 1024 * 1024
 COPY_CHUNK_BYTES = 1024 * 1024
 RECLAIM_CHUNK_BYTES = 64 * 1024 * 1024
+RECLAIM_WINDOW_SECONDS = 2.0
+RECLAIM_MAX_SAMPLES = 5
 FRAME_OVERHEAD_BYTES = 64 * 1024
 POST_PURGE_POLL_SECONDS = 0.5  # 60 polls give APFS up to 30s to release reclaimed bytes.
 DEFAULT_LOG_PATH = Path.home() / ".local" / "share" / "brainlayer" / "logs" / "backup-daily.log"
@@ -170,6 +175,7 @@ class SQLiteBackupArtifact:
     compressor_fallback: str | None = None
     compress_duration_seconds: float | None = None
     raw_sha256: str | None = None
+    reclaim_basis: str | None = None
 
     @property
     def archive_path(self) -> Path:
@@ -1442,7 +1448,102 @@ def _archive_stream_sha256(source: Any, *, zstd: bool) -> str:
         return _stream_sha256(restored).hex()
 
 
-def _compress_reclaiming_raw(raw: Path, archive: Path, *, zstd_binary: str | None) -> str:
+def _staging_snapshots_may_exist(path: Path) -> bool | None:
+    """Read the staging volume's APFS snapshot inventory; uncertainty keeps the volume gate."""
+    if sys.platform != "darwin":
+        return None
+    try:
+        # df resolves the device even through macOS firmlinks (/Users is on Data).
+        # Use only its device identity, never its free/purgeable space accounting.
+        rows = (
+            subprocess.run(["/bin/df", "-P", str(path)], capture_output=True, check=True, timeout=5)
+            .stdout.decode()
+            .splitlines()
+        )
+        device = rows[1].split()[0] if len(rows) == 2 else ""
+        if not re.fullmatch(r"/dev/disk\d+s\d+", device):
+            raise ValueError("staging device is ambiguous")
+        result = subprocess.run(
+            ["/usr/sbin/diskutil", "apfs", "listSnapshots", device.removeprefix("/dev/"), "-plist"],
+            capture_output=True,
+            check=True,
+            timeout=5,
+        )
+        inventory = plistlib.loads(result.stdout)
+        if not isinstance(inventory, dict) or inventory.get("Error") or inventory.get("ExitCode", 0) != 0:
+            raise ValueError("snapshot inventory reported an error")
+        snapshots = inventory.get("Snapshots")
+        if not isinstance(snapshots, list):
+            raise ValueError("snapshot inventory is ambiguous")
+        return bool(snapshots)
+    except BackupTimeoutError:
+        raise  # Preserve the enclosing backup deadline, rather than treating it as probe uncertainty.
+    except (OSError, subprocess.SubprocessError, ValueError, IndexError, ExpatError) as exc:
+        print(f"Backup snapshot probe unknown: {type(exc).__name__}; retaining volume reclaim check", flush=True)
+        return None
+
+
+class RawReclaimUnconfirmedError(RuntimeError):
+    error_type = "raw_reclaim_unconfirmed"
+
+    def __init__(self, measurements: dict[str, Any]):
+        self.measurements = measurements
+        best_delta = max(
+            (
+                sample["delta_bytes"]
+                for sample in measurements["samples"]
+                if sample["elapsed_seconds"] <= measurements["window_seconds"]
+            ),
+            default=0,
+        )
+        mib = 1024 * 1024
+        super().__init__(
+            "Database backup stopped: raw file blocks were released, but free space rose only "
+            f"{best_delta / mib:g} MiB of the required {measurements['threshold_bytes'] / mib:g} MiB "
+            f"within {measurements['window_seconds']:g} s "
+            "(another process may be writing, or macOS is slow to report freed space)."
+        )
+
+
+def _confirm_raw_reclaim(
+    path: Path, *, offset: int, length: int, before_blocks: int, after_blocks: int, before_free: int
+) -> None:
+    """Keep one pre-punch baseline; bound both sample count and elapsed waiting."""
+    started = _reclaim_clock()
+    samples = []
+    threshold = length - length // 2
+    for index in range(RECLAIM_MAX_SAMPLES):
+        elapsed = _reclaim_clock() - started
+        if index and elapsed > RECLAIM_WINDOW_SECONDS:
+            break
+        free = shutil.disk_usage(path).free
+        elapsed = _reclaim_clock() - started
+        samples.append({"elapsed_seconds": elapsed, "free_bytes": free, "delta_bytes": free - before_free})
+        if free - before_free >= threshold and elapsed <= RECLAIM_WINDOW_SECONDS:
+            return
+        remaining = RECLAIM_WINDOW_SECONDS - elapsed
+        if remaining <= 0 or index == RECLAIM_MAX_SAMPLES - 1:
+            break
+        _sleep(min(RECLAIM_WINDOW_SECONDS / (RECLAIM_MAX_SAMPLES - 1), remaining))
+    raise RawReclaimUnconfirmedError(
+        {
+            "reclaim_basis": "volume_delta",
+            "chunk_offset": offset,
+            "chunk_length": length,
+            "blocks_before": before_blocks,
+            "blocks_after": after_blocks,
+            "free_before": before_free,
+            "samples": samples,
+            "threshold_bytes": threshold,
+            "window_seconds": RECLAIM_WINDOW_SECONDS,
+            "elapsed_seconds": _reclaim_clock() - started,
+        }
+    )
+
+
+def _compress_reclaiming_raw(
+    raw: Path, archive: Path, *, zstd_binary: str | None, reclaim_basis: str = "volume_delta"
+) -> str:
     """Write durable independent frames, then release their raw extents; hash before punching.
 
     Concatenated gzip members and zstd frames decode to the original byte stream. A failed
@@ -1480,7 +1581,6 @@ def _compress_reclaiming_raw(raw: Path, archive: Path, *, zstd_binary: str | Non
             # because no unread bytes follow it. APFS may retain its final partial block.
             before_free = shutil.disk_usage(archive.parent).free
             _punch_raw_hole(source.fileno(), offset, len(chunk))
-            freed = shutil.disk_usage(archive.parent).free - before_free
             after_blocks = os.fstat(source.fileno()).st_blocks
             if after_blocks >= before_blocks:
                 raise RuntimeError("punched raw extents not reclaimed (filesystem allocation pin)")
@@ -1488,10 +1588,15 @@ def _compress_reclaiming_raw(raw: Path, archive: Path, *, zstd_binary: str | Non
             # accumulate against reclaim. Allow half a chunk for concurrent volume activity.
             # Short tails can free less than this tolerance due to APFS accounting; they
             # retain the per-file block check above and the raw free-space floor below.
-            tolerance = len(chunk) // 2
-            if len(chunk) == RECLAIM_CHUNK_BYTES and freed < len(chunk) - tolerance:
-                raise RuntimeError(
-                    "punched raw extents not reclaimed (possible APFS snapshot pin or delayed volume reclaim)"
+            # With no snapshots, the block drop proves reclaim despite unrelated writers.
+            if len(chunk) == RECLAIM_CHUNK_BYTES and reclaim_basis != "block_drop_no_snapshot":
+                _confirm_raw_reclaim(
+                    archive.parent,
+                    offset=offset,
+                    length=len(chunk),
+                    before_blocks=before_blocks,
+                    after_blocks=after_blocks,
+                    before_free=before_free,
                 )
             offset += len(chunk)
             _require_raw_floor(archive.parent)
@@ -1707,11 +1812,18 @@ def create_sqlite_backup_artifact(
             temp_archive = Path(tmp) / final_archive.name
             compress_started = time.monotonic()
             raw_sha256 = None
+            reclaim_basis = None
             if reclaim_raw:
+                # Cache once for this backup, before compression starts, never per chunk.
+                snapshots = _staging_snapshots_may_exist(output_dir)
+                reclaim_basis = "block_drop_no_snapshot" if snapshots is False else "volume_delta"
+                print(f"Backup raw reclaim_basis={reclaim_basis}; snapshots_may_exist={snapshots}", flush=True)
                 # Keep consumed extents inside the owned attempt, never at the published raw path.
                 consumed_raw = _consume_raw_in_attempt(raw_snapshot, Path(tmp))
                 print("Backup consuming verified raw snapshot; a failed attempt requires a fresh snapshot", flush=True)
-                raw_sha256 = _compress_reclaiming_raw(consumed_raw, temp_archive, zstd_binary=zstd_binary)
+                raw_sha256 = _compress_reclaiming_raw(
+                    consumed_raw, temp_archive, zstd_binary=zstd_binary, reclaim_basis=reclaim_basis
+                )
             elif zstd_binary is not None:
                 _compress_zstd(zstd_binary, raw_snapshot, temp_archive, output_dir)
             else:
@@ -1755,6 +1867,7 @@ def create_sqlite_backup_artifact(
         compressor_fallback=compressor_fallback,
         compress_duration_seconds=compress_duration,
         raw_sha256=raw_sha256,
+        reclaim_basis=reclaim_basis,
     )
 
 
@@ -3425,6 +3538,7 @@ def run_backup(
                     snapshot_duration_seconds=resume.get("snapshot_duration_seconds"),
                     integrity_duration_seconds=resume.get("integrity_duration_seconds"),
                     raw_sha256=resume.get("raw_sha256"),
+                    reclaim_basis=resume.get("reclaim_basis"),
                 )
             for suffix in DB_SNAPSHOT_SUFFIXES:
                 target = Path(staging_dir) / f"{resolved_date_stamp}{suffix}"
@@ -3488,6 +3602,7 @@ def run_backup(
                     "snapshot_duration_seconds": getattr(artifact, "snapshot_duration_seconds", None),
                     "integrity_duration_seconds": getattr(artifact, "integrity_duration_seconds", None),
                     "raw_sha256": getattr(artifact, "raw_sha256", None),
+                    "reclaim_basis": getattr(artifact, "reclaim_basis", None),
                     "compressor": getattr(artifact, "compressor", None)
                     or ("zstd" if snapshot.name.endswith(ZSTD_SNAPSHOT_SUFFIX) else "gzip"),
                     "compress_duration_seconds": getattr(artifact, "compress_duration_seconds", None),
@@ -3715,6 +3830,8 @@ def run_backup(
             {"error_type": getattr(exc, "error_type", type(exc).__name__), "error": _redact_upload_secrets(str(exc))}
         )
         error_code = getattr(exc, "error_code", None)
+        if isinstance(exc, RawReclaimUnconfirmedError):
+            result["raw_reclaim"] = exc.measurements
         if isinstance(error_code, str):
             result["error_code"] = error_code
         if isinstance(exc, DriveUploadStalledError):

brainlayer-1.5.82/src/brainlayer/linkedin_import.py

@@ -0,0 +1,365 @@
+"""LinkedIn KG import with an explicit copy or SHA-confirmed live mode. Output contains counts, never contact records.
+
+Run: python -m brainlayer.linkedin_import EXPORT.json --db-copy COPY.db
+Identity matching is exact: LinkedIn URL, email, then normalized full name.
+First/last names stay in metadata; name aliases must contain multiple tokens.
+"""
+
+import argparse
+import hashlib
+import json
+import logging
+import os
+import re
+import time
+from collections import Counter, defaultdict
+from pathlib import Path
+from urllib.parse import urlsplit
+from uuid import uuid4
+
+from .disk_space import measure_disk_space
+from .kg_repo import KGMixin
+from .paths import resolve_db_path
+from .pipeline.entity_resolution import _normalize_name
+from .runtime_store import RuntimeStoreModeError, open_writer_store
+
+SOURCE = "linkedin-export 2026-10-31 (portfolio scrub)"
+ATTRIBUTES = (
+    "first_name",
+    "last_name",
+    "linkedin_url",
+    "company",
+    "position",
+    "connected_on",
+    "relationship_strength",
+    "has_messages",
+)
+
+
+class ImportRefusal(ValueError):
+    """An importer-owned static reason; never carries source values."""
+
+    def __init__(self, reason):
+        if reason not in {
+            "copy_refusal",
+            "invalid_export",
+            "disk_floor",
+            "confirmation_required",
+            "confirmation_sha256_mismatch",
+        }:
+            raise ValueError("unknown_import_reason")
+        self.reason = reason
+        super().__init__(reason)
+
+
+def normalized(value):
+    return " ".join(_normalize_name(value or "").split())
+
+
+def email_key(value):
+    return (value or "").strip().casefold()
+
+
+def linkedin_key(value):
+    if not value:
+        return ""
+    parsed = urlsplit(value if "://" in value else "https://" + value)
+    if not re.fullmatch(r"(?:www\.|[a-z]{2}\.)?linkedin\.com", parsed.hostname or "") or not parsed.path.startswith(
+        "/in/"
+    ):
+        raise ValueError("invalid_linkedin_url")
+    return "https://linkedin.com" + parsed.path.rstrip("/").casefold()
+
+
+def require_copy(path, live=None):
+    """Refuse canonical, configured-live, symlink and hardlink aliases before opening."""
+    from .paths import get_db_path
+
+    path = Path(path).expanduser().resolve(strict=True)
+    protected = [Path.home() / ".local/share/brainlayer/brainlayer.db", get_db_path()]
+    if live is not None:
+        protected.append(Path(live))
+    if any(path == p.expanduser().resolve() or (p.exists() and os.path.samefile(path, p)) for p in protected):
+        raise ImportRefusal("copy_refusal")
+    return path
+
+
+class _ImportGraph(KGMixin):
+    """Use the supported KG writers on one connection, including read-your-writes."""
+
+    def __init__(self, store):
+        self.conn, self.db_path = store.conn, store.db_path
+
+    def _read_cursor(self):
+        return self.conn.cursor()
+
+
+def import_connections(store, export):
+    """Import atomically on the caller's supported writer; never opens a database."""
+    started = time.monotonic()
+    raw = export if isinstance(export, bytes) else Path(export).read_bytes()
+    rows = json.loads(raw)
+    if not isinstance(rows, list):
+        raise ImportRefusal("invalid_export")
+    store.conn.execute("BEGIN IMMEDIATE")
+    try:
+        result = _import_rows(_ImportGraph(store), rows, hashlib.sha256(raw).hexdigest(), started)
+        store.conn.execute("COMMIT")
+        return result
+    except BaseException:
+        store.conn.execute("ROLLBACK")
+        raise
+
+
+def _import_rows(store, rows, sha256, started):
+    provenance = {"source": SOURCE, "sha256": sha256}
+    counts = {key: {"new": 0, "merged": 0} for key in ("persons", "companies", "relations")}
+    counts["persons"].update(merged_by=dict.fromkeys(("linkedin_url", "email", "name"), 0), new_name_conflict=0)
+    counts["companies"]["merged_by"] = {"name": 0}
+    skipped = Counter()
+    invalid_existing_alias = 0
+    identities = defaultdict(lambda: defaultdict(set))
+
+    def index_identity(kind, key, eid):
+        if key:
+            indexes[kind][key].add(eid)
+            identities[eid][kind].add(key)
+
+    indexes = {kind: defaultdict(set) for kind in ("person", "company", "linkedin_url", "email")}
+    for eid, kind, name, meta in store.conn.execute(
+        "SELECT id, entity_type, name, metadata FROM kg_entities WHERE entity_type IN ('person','company')"
+    ):
+        indexes[kind][normalized(name)].add(eid)
+        if kind == "person":
+            metadata = json.loads(meta or "{}")
+            if metadata.get("linkedin_full_name"):
+                indexes[kind][normalized(metadata["linkedin_full_name"])].add(eid)
+            try:
+                index_identity("linkedin_url", linkedin_key(metadata.get("linkedin_url")), eid)
+            except ValueError:
+                pass
+            contact = metadata.get("contact_info") or {}
+            for value in (metadata.get("email"), contact.get("email")):
+                index_identity("email", email_key(value), eid)
+    for alias, eid, kind in store.conn.execute(
+        "SELECT a.alias, a.entity_id, a.alias_type FROM kg_entity_aliases a "
+        "JOIN kg_entities e ON e.id=a.entity_id WHERE e.entity_type='person' "
+        "AND a.alias_type IN ('name','linkedin_url','email')"
+    ):
+        if kind == "name":
+            indexes["person"][normalized(alias)].add(eid)
+            continue
+        try:
+            key = linkedin_key(alias) if kind == "linkedin_url" else email_key(alias)
+        except ValueError:
+            invalid_existing_alias += 1
+            continue
+        index_identity(kind, key, eid)
+    owner_ids = indexes["person"].get(normalized("Etan Heyman"), set())
+    owner = next(iter(owner_ids)) if len(owner_ids) == 1 else None
+    seen_people, seen_companies, seen_relations = set(), set(), set()
+
+    def upsert(kind, name, eid, attributes, row_number=None, name_conflict=False, identity_key=None):
+        old = store.get_entity(eid) if eid else None
+        metadata = dict(old["metadata"]) if old else {}
+        metadata.update({k: v for k, v in attributes.items() if v is not None and v != ""})
+        evidence = dict(provenance)
+        if row_number is not None:
+            evidence["row_number"] = row_number
+        sources = list(metadata.get("linkedin_imports", []))
+        if evidence not in sources:
+            sources.append(evidence)
+        metadata["linkedin_imports"] = sources
+        storage_name = old["name"] if old else name
+        if name_conflict:
+            # The KG enforces UNIQUE(type, name). Keep the original as a full-name alias.
+            suffix = hashlib.sha256(identity_key.encode()).hexdigest()[:16]
+            storage_name = f"{name} [linkedin-{suffix}]"
+            metadata["linkedin_full_name"] = name
+        stored = store.upsert_entity(eid or f"{kind}-{uuid4().hex}", kind, storage_name, metadata=metadata)
+        indexes[kind][normalized(name)].add(stored)
+        if kind == "person" and len(name.split()) > 1:
+            store.add_entity_alias(name, stored)
+        return stored
+
+    def relation(source, target, kind, properties):
+        key = (source, target, kind)
+        if key in seen_relations:
+            return
+        seen_relations.add(key)
+        existing = next(
+            (
+                r
+                for r in store.get_entity_relations(source, direction="outgoing")
+                if r["target_id"] == target and r["relation_type"] == kind
+            ),
+            None,
+        )
+        props = dict(existing["properties"]) if existing else {}
+        props.update({k: v for k, v in properties.items() if v is not None and v != ""})
+        sources = list(props.get("linkedin_imports", []))
+        if provenance not in sources:
+            sources.append(provenance)
+        props["linkedin_imports"] = sources
+        store.add_relation(
+            f"rel-{uuid4().hex}",
+            source,
+            target,
+            kind,
+            properties=props,
+            confidence=existing["confidence"] if existing else 1.0,
+            importance=existing["importance"] if existing else 0.5,
+        )
+        counts["relations"]["merged" if existing else "new"] += 1
+
+    for number, row in enumerate(rows, 1):
+        if measure_disk_space(store.db_path.parent, include_available=False).free_now_bytes < 2 * 1024**3:
+            raise ImportRefusal("disk_floor")
+        if (
+            not isinstance(row, dict)
+            or any(
+                value is not None and not isinstance(value, str) for key, value in row.items() if key != "has_messages"
+            )
+            or row.get("has_messages") not in (None, True, False)
+        ):
+            skipped["invalid_row"] += 1
+            continue
+        name = " ".join((row.get("full_name") or "").split())
+        if not name:
+            skipped["missing_name"] += 1
+            continue
+        try:
+            url = linkedin_key(row.get("linkedin_url"))
+        except ValueError:
+            skipped["invalid_linkedin_url"] += 1
+            continue
+        email = email_key(row.get("email"))
+        url_owners = indexes["linkedin_url"].get(url, set()) if url else set()
+        email_owners = indexes["email"].get(email, set()) if email else set()
+        if url_owners and email_owners and url_owners != email_owners:
+            # The URL and email already belong to different people: never join them.
+            skipped["ambiguous_identity"] += 1
+            continue
+        match_kind, matches = next(
+            (
+                (kind, indexes[kind][key])
+                for kind, key in (("linkedin_url", url), ("email", email))
+                if key and indexes[kind].get(key)
+            ),
+            ("name", set()),
+        )
+        # One person has one LinkedIn profile: a candidate holding a different URL is a different person.
+        if matches and url and any(identities[eid]["linkedin_url"] - {url} for eid in matches):
+            skipped["ambiguous_identity"] += 1
+            continue
+        name_candidates = indexes["person"].get(normalized(name), set())
+        name_conflict = False
+        if not matches:
+            matches = {
+                eid
+                for eid in name_candidates
+                if not any(
+                    key and identities[eid][kind] and identities[eid][kind] != {key}
+                    for kind, key in (("linkedin_url", url), ("email", email))
+                )
+            }
+            name_conflict = bool(name_candidates and not matches)
+        if matches and name_candidates - matches:
+            skipped["ambiguous_identity"] += 1
+            continue
+        if len(matches) > 1:
+            skipped["ambiguous_identity"] += 1
+            continue
+        eid = next(iter(matches), None)
+        if eid and indexes["person"].get(normalized(store.get_entity(eid)["name"]), set()) - {eid}:
+            skipped["ambiguous_identity"] += 1
+            continue
+        if eid in seen_people:
+            skipped["duplicate_in_file"] += 1
+            continue
+        eid = upsert("person", name, eid, {k: row.get(k) for k in ATTRIBUTES}, number, name_conflict, url or email)
+        counts["persons"]["merged" if matches else "new"] += 1
+        counts["persons"]["new_name_conflict"] += int(name_conflict)
+        if matches:
+            counts["persons"]["merged_by"][match_kind] += 1
+        seen_people.add(eid)
+        for kind, key in (("linkedin_url", url), ("email", email)):
+            if key:
+                index_identity(kind, key, eid)
+                store.add_entity_alias(key, eid, alias_type=kind)
+        if owner and owner != eid:
+            relation(
+                eid,
+                owner,
+                "linkedin_connection",
+                {k: row.get(k) for k in ("connected_on", "relationship_strength", "has_messages")},
+            )
+        company = " ".join((row.get("company_normalized") or row.get("company") or "").split())
+        if not company:
+            continue
+        key = normalized(company)
+        matches = indexes["company"].get(key, set())
+        if len(matches) > 1:
+            skipped["ambiguous_company"] += 1
+            continue
+        cid = next(iter(matches), None)
+        if key not in seen_companies:
+            cid = upsert("company", company, cid, {})
+            counts["companies"]["merged" if matches else "new"] += 1
+            counts["companies"]["merged_by"]["name"] += int(bool(matches))
+            seen_companies.add(key)
+        relation(eid, cid, "works_at", {"position": row.get("position")})
+    return {
+        **counts,
+        "rows": len(rows),
+        "invalid_existing_alias": invalid_existing_alias,
+        "skipped": dict(skipped),
+        "owner_found": owner is not None,
+        "duplicates_within_file": skipped["duplicate_in_file"],
+        "rows_missing_name": skipped["missing_name"],
+        "seconds": round(time.monotonic() - started, 3),
+        "sha256": provenance["sha256"],
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("export", type=Path)
+    mode = parser.add_mutually_exclusive_group(required=True)
+    mode.add_argument("--db-copy", type=Path)
+    mode.add_argument("--live", action="store_true")
+    parser.add_argument("--confirm-sha256")
+    args = parser.parse_args()
+    previous_logging_level = logging.root.manager.disable
+    logging.disable(logging.CRITICAL)  # Library diagnostics can contain personal data.
+    store = None
+    try:
+        if args.live and not args.confirm_sha256:
+            raise ImportRefusal("confirmation_required")
+        raw = args.export.read_bytes()  # Hash and import these same bytes; never reopen the export.
+        if args.live and hashlib.sha256(raw).hexdigest() != args.confirm_sha256:
+            raise ImportRefusal("confirmation_sha256_mismatch")
+        path = resolve_db_path() if args.live else require_copy(args.db_copy)
+        store = open_writer_store(path)
+        print(json.dumps(import_connections(store, raw), sort_keys=True))
+    except Exception as exc:
+        reason = (
+            exc.reason
+            if isinstance(exc, ImportRefusal)
+            else "invalid_export"
+            if isinstance(exc, json.JSONDecodeError)
+            else "invalid_store_mode"
+            if isinstance(exc, RuntimeStoreModeError)
+            else "import_failed"
+        )
+        print(json.dumps({"error_type": type(exc).__name__, "reason": reason}))
+        return 1
+    finally:
+        if store is not None:
+            store.close()
+        logging.disable(previous_logging_level)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{brainlayer-1.5.80 → brainlayer-1.5.82}/src/brainlayer/observability_backup.py

@@ -131,7 +131,11 @@ def _daily_snapshot(records: list[dict[str, Any]]) -> tuple[dict[str, Any] | Non
                 error_type = str(pending.get("error_type") or pending.get("error_code") or "backup_error")
                 error_reason = pending.get("error") or pending.get("verification_error")
                 break
-    if error_type in {"BrainBarDatabaseIdentityError", "BrainBarDatabaseIdentityUnavailableError"} and error_reason:
+    if (
+        error_type
+        in {"BrainBarDatabaseIdentityError", "BrainBarDatabaseIdentityUnavailableError", "raw_reclaim_unconfirmed"}
+        and error_reason
+    ):
         error_type = f"{error_type}: {error_reason}"
     if "google-drive-mcp/tokens.json" in str(latest.get("error", "")):
         error_type = "drive_credentials_missing"
@@ -489,7 +493,14 @@ def build_backups_section(
     resolved_alert_path = alert_path(env=env, db_path=db_path)
     job_alerts = active_alerts(resolved_alert_path)
     if job_alerts:
-        error_type = "job_alert:" + next(iter(job_alerts.values()))
+        # The generic DB job alert must not replace this attempt's measured diagnostic.
+        reclaim_failure = (error_type or "").startswith("raw_reclaim_unconfirmed:")
+        generic_db_alerts = all(
+            key in {"backup-daily", "backup-snapshot"} and reason == "Database backup failed; check the backup log"
+            for key, reason in job_alerts.items()
+        )
+        if not (reclaim_failure and generic_db_alerts):
+            error_type = "job_alert:" + next(iter(job_alerts.values()))
         alert_input = record_input(resolved_alert_path, status="read", rows_or_bytes=None)
         inputs.append(alert_input)
         if alert_input.get("status") == "future":

brainlayer-1.5.80/src/brainlayer/_build.py

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