ltcai 10.0.0 → 10.2.0

package/lattice_brain/graph/discovery.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
-# ruff: noqa: F403,F405
+from ..quiet import quiet
 
+# ruff: noqa: F403,F405
 from ._kg_common import *  # noqa: F403,F401
 
 
@@ -59,7 +60,7 @@ class KnowledgeGraphDiscoveryMixin:
                     ):
                         add(volume.name, volume, "volume", recommended=False)
                 except OSError:
-                    pass
+                    quiet()
         elif os_type == "windows":
             for letter in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
                 drive = Path(f"{letter}:\\")
@@ -87,7 +88,7 @@ class KnowledgeGraphDiscoveryMixin:
                         ):
                             add(mounted.name, mounted, "volume", recommended=False)
                 except OSError:
-                    pass
+                    quiet()
 
         return {
             "os_type": os_type,

package/lattice_brain/graph/discovery_index.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 # ruff: noqa: F403,F405
-
 from ._kg_common import *  # noqa: F403,F401
 
 

package/lattice_brain/graph/documents.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
-# ruff: noqa: F403,F405
+from ..quiet import quiet
 
+# ruff: noqa: F403,F405
 from ._kg_common import *  # noqa: F403,F401
 
 
@@ -287,7 +288,7 @@ class KnowledgeGraphDocumentsMixin:
                                 }
                             )
                     except Exception:
-                        pass
+                        quiet()
                     result["images"].append(image_info)
         except Exception as exc:
             result["error"] = str(exc)

package/lattice_brain/graph/fusion.py

@@ -30,6 +30,8 @@ import os
 import re
 from typing import Any, Dict, Mapping, Optional
 
+from ..quiet import quiet
+
 QUERY_CLASSES = ("fact", "code", "person", "recency")
 
 FUSION_WEIGHTS_ENV = "LATTICEAI_FUSION_WEIGHTS"
@@ -118,6 +120,7 @@ def _env_overrides() -> Dict[str, Dict[str, float]]:
             try:
                 cleaned[key] = max(0.0, min(1.0, float(value)))
             except (TypeError, ValueError):
+                quiet()
                 continue
         if cleaned:
             overrides[str(cls)] = cleaned
@@ -137,6 +140,7 @@ def fusion_weight_table(
                         try:
                             table[cls][key] = max(0.0, min(1.0, float(value)))
                         except (TypeError, ValueError):
+                            quiet()
                             continue
     return table
 

package/lattice_brain/graph/ingest.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
-# ruff: noqa: F403,F405
+from ..quiet import quiet
+from ..sensitivity import stamp_sensitivity
 
+# ruff: noqa: F403,F405
 from ._kg_common import *  # noqa: F403,F401
 
 
@@ -36,7 +38,7 @@ def _triple_edge_metadata(triple: Dict[str, Any]) -> Dict[str, Any]:
         try:
             metadata["confidence"] = round(float(confidence), 4)
         except (TypeError, ValueError):
-            pass
+            quiet()
     return metadata
 
 
@@ -270,6 +272,14 @@ class KnowledgeGraphIngestMixin:
             "extracted": {k: v for k, v in (extracted or {}).items() if k != "content"},
             "structure": doc_meta,
         }
+
+        # Stamp never-leaves at ingestion. Before 10.2.0 the cloud filter looked
+        # for these flags and nothing in the product could set them, so the
+        # guard was unreachable. Deriving it from the path means a user who
+        # indexes a project folder does not have to remember that it contains a
+        # .env — the flag is on the node before any cloud turn can select it.
+        stamp_sensitivity(metadata, source_uri or str(path))
+
         full_text = f"{filename}\n{text}"
         concepts = _extract_concepts(full_text, limit=15)
         triples = _extract_triples(full_text, concepts)

package/lattice_brain/graph/projection.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
-# ruff: noqa: F403,F405
+from ..quiet import quiet
 
+# ruff: noqa: F403,F405
 from ._kg_common import *  # noqa: F403,F401
 
 # ── promotion review mode (review 2026-07-25 Wave 4) ─────────────────────────
@@ -364,7 +365,7 @@ class KnowledgeGraphProjectionMixin:
                 if EdgeType.from_legacy(leg_type).value == leg_type:
                     leg_type = ""
             except ValueError:
-                pass
+                quiet()
         norm_type = (
             EdgeType.from_legacy(edge_type).value if EdgeType is not None else edge_type
         )

package/lattice_brain/graph/provenance.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 # ruff: noqa: F403,F405
-
 from ._kg_common import *  # noqa: F403,F401
 
 
@@ -188,7 +187,8 @@ class KnowledgeGraphProvenanceMixin:
     def schema_versions(self) -> Dict[str, Any]:
         """Versions an exporter stamps and an importer validates against."""
         try:
-            from .schema import EMBED_DIM as _EMBED_DIM, KG_SCHEMA_V2_VERSION as _V2
+            from .schema import EMBED_DIM as _EMBED_DIM
+            from .schema import KG_SCHEMA_V2_VERSION as _V2
         except Exception:  # pragma: no cover - kg_schema always importable in practice
             _EMBED_DIM, _V2 = 1024, 2
         return {
@@ -421,7 +421,9 @@ class KnowledgeGraphProvenanceMixin:
         dest.parent.mkdir(parents=True, exist_ok=True)
         if dest.exists():
             dest.unlink()  # VACUUM INTO requires the target to not exist
-        conn = self._connect()
+        # Raw connection, not ``_connect()``: VACUUM cannot run inside a
+        # transaction, and ``_connect()`` wraps its block in one.
+        conn = self.storage_engine.connect()
         try:
             conn.execute("PRAGMA wal_checkpoint(FULL)")
             conn.execute("VACUUM INTO ?", (str(dest),))

package/lattice_brain/graph/rerank.py

@@ -111,7 +111,10 @@ def cross_encoder_rerank(
         return result
 
     ranked = list(candidates)
-    for item, score in zip(ranked, scores):
+    # strict=False on purpose: a cross-encoder that returns fewer scores than
+    # candidates leaves the tail un-reranked at its fused score, which is a
+    # better outcome than dropping the whole rerank.
+    for item, score in zip(ranked, scores, strict=False):
         item["rerank_score"] = float(score)
         # Surface the rerank score as the primary ranking key while keeping
         # the pre-rerank fused score under scores.fused for audit.

package/lattice_brain/graph/retrieval.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 # ruff: noqa: F403,F405
-
 from ._kg_common import *  # noqa: F403,F401
 
 # --- Compat seam (v9.9.5 decomposition) -------------------------------------

package/lattice_brain/graph/retrieval_docgen.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 # ruff: noqa: F403,F405
-
 from ._kg_common import *  # noqa: F403,F401
 
 

package/lattice_brain/graph/retrieval_reads.py

@@ -12,7 +12,6 @@ calls (e.g. ``search`` → ``filter_scoped_nodes``) behave exactly as before.
 from __future__ import annotations
 
 # ruff: noqa: F403,F405
-
 from ._kg_common import *  # noqa: F403,F401
 
 

package/lattice_brain/graph/retrieval_vector.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 # ruff: noqa: F403,F405
-
 from ._kg_common import *  # noqa: F403,F401
 
 

package/lattice_brain/graph/schema.py

@@ -43,13 +43,14 @@ print(store.stats())       # {"nodes": ..., "by_node_type": {...}, ...}
 from __future__ import annotations
 
 import json
-import os
 import logging
+import os
 import sqlite3
 from contextlib import contextmanager
 from enum import Enum
 from typing import Any, Dict, Optional
 
+from ..quiet import quiet
 
 # ── Schema version ──────────────────────────────────────────────────────────
 KG_SCHEMA_V2_VERSION = 2
@@ -129,7 +130,7 @@ class NodeType(str, Enum):
         try:
             return cls(m.upper())
         except ValueError:
-            pass
+            quiet()
         return _LEGACY_NODE_MAP.get(m.lower(), cls.CONCEPT)
 
 
@@ -189,7 +190,7 @@ class EdgeType(str, Enum):
         try:
             return cls(m.upper())
         except ValueError:
-            pass
+            quiet()
         return _LEGACY_EDGE_MAP.get(m.lower(), cls.MENTIONS)
 
 

package/lattice_brain/graph/store.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
 # ruff: noqa: F403,F405
-
 from ._kg_common import *  # noqa: F403,F401
-from .documents import KnowledgeGraphDocumentsMixin
 from .discovery import KnowledgeGraphDiscoveryMixin
 from .discovery_index import KnowledgeGraphLocalIndexMixin
+from .documents import KnowledgeGraphDocumentsMixin
 from .ingest import KnowledgeGraphIngestMixin
 from .projection import KnowledgeGraphProjectionMixin
 from .provenance import KnowledgeGraphProvenanceMixin
@@ -81,8 +80,23 @@ class KnowledgeGraphStore(
             return ("kgv2_nodes", "kgv2_edges")
         return ("nodes", "edges")
 
-    def _connect(self) -> sqlite3.Connection:
-        return self.storage_engine.connect()
+    @contextmanager
+    def _connect(self) -> Iterator[sqlite3.Connection]:
+        """Transactional connection that is closed when the block exits.
+
+        This used to return the raw connection, so ``with self._connect() as
+        conn`` inherited sqlite3's context-manager semantics: commit on success,
+        rollback on error, **never close**. Each of the ~58 call sites therefore
+        held a descriptor open until garbage collection reclaimed it. That is
+        invisible while CPython refcounting frees the local immediately, and
+        fatal as soon as anything keeps the frame alive — a coverage tracer, a
+        profiler, or a traceback captured by ``logger.exception``.
+
+        Use ``storage_engine.connect()`` directly only for statements that
+        cannot run inside a transaction, and close it yourself.
+        """
+        with self.storage_engine.session() as conn:
+            yield conn
 
     def _init_db(self) -> None:
         with self._connect() as conn:

package/lattice_brain/graph/write_master.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 # ruff: noqa: F403,F405
-
 from ._kg_common import *  # noqa: F403,F401
 
 
@@ -250,3 +249,49 @@ class KnowledgeGraphWriteMixin:
             text=text,
             metadata={**metadata, "parent_source_node": source_node},
         )
+
+    def set_node_sensitivity(
+        self,
+        node_id: str,
+        *,
+        local_only: bool,
+        reason: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Mark (or unmark) one node as never-leaving.
+
+        The cloud filter has always looked for this flag; until 10.2.0 nothing
+        could set it, so the guard was unreachable. This is the user-driven
+        half — ingestion stamps secret-bearing paths automatically, and this
+        covers everything a path cannot tell you, like a note whose *content*
+        is private.
+
+        Unmarking is allowed and audited by the caller: a user who flagged
+        something by mistake must be able to undo it, but the reason is cleared
+        with the flag so a stale justification cannot linger.
+        """
+        with self._connect() as conn:
+            row = conn.execute(
+                "SELECT metadata_json FROM nodes WHERE id=?", (node_id,)
+            ).fetchone()
+            if row is None:
+                return {"ok": False, "node_id": node_id, "reason": "node not found"}
+            try:
+                metadata = json.loads(row[0] or "{}")
+            except Exception:
+                metadata = {}
+            if local_only:
+                metadata["local_only"] = True
+                metadata["local_only_reason"] = reason or "marked by the user"
+            else:
+                metadata.pop("local_only", None)
+                metadata.pop("local_only_reason", None)
+            conn.execute(
+                "UPDATE nodes SET metadata_json=?, updated_at=? WHERE id=?",
+                (json.dumps(metadata, ensure_ascii=False), _now(), node_id),
+            )
+        return {
+            "ok": True,
+            "node_id": node_id,
+            "local_only": bool(local_only),
+            "reason": metadata.get("local_only_reason"),
+        }

package/lattice_brain/ingestion.py

@@ -360,6 +360,9 @@ from .ingestion_jobs import (  # noqa: E402,F401 — re-export for existing impo
     BackgroundIngestionJob,
     BackgroundIngestionQueue,
 )
+from .quiet import (  # noqa: E402 — imported after the module constants it depends on
+    quiet,  # noqa: E402 — imported after the module constants it depends on
+)
 
 
 @dataclass
@@ -577,7 +580,7 @@ class IngestionPipeline:
                     user_email,
                 )
             except Exception:  # noqa: BLE001 — audit must never break ingestion
-                pass
+                quiet()
 
         extraction_quality = self._assess_item_quality(
             item, source_type=source_type, text=quality_text, chunk_ids=chunk_ids,

package/lattice_brain/portability.py

@@ -20,10 +20,12 @@ import shutil
 import sqlite3
 import tempfile
 import zipfile
+from contextlib import closing
 from pathlib import Path, PurePosixPath
 from typing import Any, Dict, Optional
 
 from .archive import BrainArchivePaths, EncryptedBrainArchive
+from .quiet import quiet
 from .storage import (
     DockerPostgresWizard,
     PostgresEngine,
@@ -66,7 +68,7 @@ def _checkpoint_sqlite(db_path: Path) -> None:
     if not db_path.exists():
         return
     try:
-        with sqlite3.connect(str(db_path)) as conn:
+        with closing(sqlite3.connect(str(db_path))) as conn, conn:
             conn.execute("PRAGMA wal_checkpoint(FULL)")
     except sqlite3.Error:
         # Best-effort only. Existing sibling backup/restore still preserves
@@ -99,6 +101,7 @@ def _replace_sqlite_atomically(src: Path, dest: Path, backup_dir: Path) -> None:
             try:
                 shutil.copy2(sibling, backup)
             except FileNotFoundError:
+                quiet()
                 continue
             backups[sibling] = backup
         for sibling in _sqlite_siblings(dest)[1:]:
@@ -247,7 +250,7 @@ class KGPortabilityService:
                               "counts": (artifact.get("header") or {}).get("counts")},
                 )
             except Exception:
-                pass
+                quiet()
         return result
 
     def import_from_file(self, path, *, mode: str = "merge", dry_run: bool = False) -> Dict[str, Any]:

package/lattice_brain/quality.py

@@ -7,13 +7,15 @@ Pure Python Quality Layer for Lattice Brain (v6.4+ hardening)
 """
 
 from __future__ import annotations
+
+import hashlib
 import math
+import re
 import time
-import hashlib
+from collections import defaultdict
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional
-from collections import defaultdict
-import re
+
 
 # -----------------------------
 # 1. Embedding Fallback Labelling + Drift/Reindex Plan
@@ -41,7 +43,12 @@ class EmbeddingFallbackLabeller:
             conf = 0.3
         else:
             # Simple hash-based pseudo-label for determinism
-            h = hashlib.md5(str(embedding[:4]).encode()).hexdigest()[:8]
+            # Not a security hash: a short, stable label for grouping
+            # vectors in reports. usedforsecurity=False states that and
+            # keeps it working on FIPS builds where md5 is restricted.
+            h = hashlib.md5(
+                str(embedding[:4]).encode(), usedforsecurity=False
+            ).hexdigest()[:8]
             label = f"emb_cluster_{h}"
             conf = 0.85
 
@@ -63,7 +70,7 @@ class EmbeddingFallbackLabeller:
     def _cosine_distance(self, a: List[float], b: List[float]) -> float:
         if not a or not b or len(a) != len(b):
             return 1.0
-        dot = sum(x*y for x,y in zip(a,b))
+        dot = sum(x * y for x, y in zip(a, b, strict=True))
         na = math.sqrt(sum(x*x for x in a))
         nb = math.sqrt(sum(x*x for x in b))
         return 1.0 - (dot / (na*nb + 1e-9))

package/lattice_brain/quiet.py

@@ -0,0 +1,43 @@
+"""Deliberately-ignored exceptions, recorded instead of erased (Brain Core).
+
+Mirror of :mod:`latticeai.core.quiet`. Brain Core cannot import from the app
+package (``tests/unit/test_import_guard.py``), and the alternative — leaving
+Brain Core's suppressions silent while the app layer's are visible — would make
+the quieter half the harder one to debug.
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+from typing import Optional
+
+logger = logging.getLogger("lattice_brain.suppressed")
+
+
+def quiet(reason: Optional[str] = None, *, level: int = logging.DEBUG) -> None:
+    """Record the exception currently being handled, then continue."""
+    exc_type, exc, tb = sys.exc_info()
+    if exc is None:
+        return
+    where = "<unknown>"
+    if tb is not None:
+        deepest = tb
+        while deepest.tb_next is not None:
+            deepest = deepest.tb_next
+        frame = deepest.tb_frame
+        where = f"{frame.f_code.co_filename}:{frame.f_lineno} in {frame.f_code.co_name}"
+    label = f" ({reason})" if reason else ""
+    if logger.isEnabledFor(level):
+        logger.log(
+            level,
+            "suppressed %s at %s%s: %s",
+            getattr(exc_type, "__name__", "Exception"),
+            where,
+            label,
+            exc,
+            exc_info=exc,
+        )
+
+
+__all__ = ["quiet"]

package/lattice_brain/runtime/agent_runtime.py

@@ -30,12 +30,8 @@ from __future__ import annotations
 
 from typing import Any, Callable, Dict, List, Optional
 
-from .multi_agent import (
-    AGENT_ROLES,
-    CORE_PIPELINE,
-    MULTI_AGENT_VERSION,
-    ROLE_AGENT_IDS,
-)
+from ..quiet import quiet
+from ..utils import now_iso as _now
 from .contracts import (
     contract_view,
     contract_views,
@@ -44,11 +40,18 @@ from .contracts import (
     run_record_contract,
     runtime_boundary_contract,
 )
+from .multi_agent import (
+    AGENT_ROLES,
+    CORE_PIPELINE,
+    MULTI_AGENT_VERSION,
+    ROLE_AGENT_IDS,
+)
 from .statuses import (
     RUN_ACTIVE_STATUSES as _ACTIVE_STATUSES,
+)
+from .statuses import (
     RUN_TERMINAL_STATUSES as _TERMINAL_STATUSES,
 )
-from ..utils import now_iso as _now
 
 ROLE_DESCRIPTIONS = {
     "researcher": "Gathers workspace context and memory for the goal.",
@@ -494,7 +497,7 @@ class AgentRuntime:
                 )
         except Exception:
             # Synthesis must never break the run record.
-            pass
+            quiet()
 
     @staticmethod
     def _format_synthesis_section(title: str, items: List[str]) -> str:
@@ -569,6 +572,7 @@ class AgentRuntime:
                     workspace_id=scope,
                 )
             except Exception:
+                quiet()
                 continue
 
     def _post_run_hooks(

package/lattice_brain/runtime/hooks.py

@@ -36,9 +36,9 @@ from collections import deque
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional
 
+from ..quiet import quiet
 from ..utils import now_iso as _now
 
-
 LOGGER = logging.getLogger(__name__)
 
 
@@ -454,6 +454,7 @@ class HooksRegistry:
             try:
                 self.set_order(hook_id, (idx + 1) * 10)
             except KeyError:
+                quiet()
                 continue
         return self.list(kind=kind)
 

package/lattice_brain/runtime/multi_agent.py

@@ -44,11 +44,10 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Any, Callable, Dict, List, Optional
 
-from .contracts import multi_agent_contract
 from ..utils import now_iso as _now
+from .contracts import multi_agent_contract
 
-
-MULTI_AGENT_VERSION = "10.0.0"
+MULTI_AGENT_VERSION = "10.2.0"
 
 AGENT_ROLES = ("researcher", "planner", "executor", "reviewer", "release")
 CORE_PIPELINE = ("planner", "executor", "reviewer")

package/lattice_brain/sensitivity.py

@@ -0,0 +1,94 @@
+"""Which local sources are never allowed to leave the machine.
+
+This lives in Brain Core rather than in the app layer because it is a property
+of the *data*, not of any transport: a node stamped never-leaves stays that way
+whether it is read by the cloud path, an export, or a future surface nobody has
+written yet. Brain Core cannot import from ``latticeai`` (see
+``tests/unit/test_import_guard.py``), so the app-layer network boundary imports
+this, not the other way round.
+
+Deliberately narrow. These are locations whose *entire purpose* is to hold
+secrets, so a match is a fact about the path rather than a guess about content.
+A broader heuristic — scanning text for things that look like keys — would
+produce false confidence in both directions: it would miss secrets in unusual
+shapes and quarantine ordinary notes that merely discuss credentials.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+# Path fragments checked case-insensitively against the POSIX form of the path.
+SENSITIVE_PATH_FRAGMENTS: tuple = (
+    "/.ssh/",
+    "/.gnupg/",
+    "/.aws/",
+    "/.kube/",
+    "/.docker/config.json",
+    "/.netrc",
+    "/.npmrc",
+    "/.pypirc",
+    "/.git-credentials",
+    "id_rsa",
+    "id_ed25519",
+    ".pem",
+    ".p12",
+    ".pfx",
+    ".keystore",
+)
+
+# Exact filenames (in any directory) that are secret-bearing by convention.
+SENSITIVE_FILENAMES: frozenset = frozenset({
+    ".env",
+    ".env.local",
+    ".env.production",
+    ".env.development",
+    "credentials",
+    "secrets.yaml",
+    "secrets.yml",
+    "secrets.json",
+})
+
+#: Metadata key stamped on a node that must never leave the machine.
+LOCAL_ONLY_FLAG = "local_only"
+#: Companion key holding the human-readable reason.
+LOCAL_ONLY_REASON = "local_only_reason"
+
+
+def sensitive_reason_for_path(path: Any) -> Optional[str]:
+    """Return why ``path`` is never-leaves, or ``None`` if it is ordinary."""
+    if not path:
+        return None
+    lowered = str(path).replace("\\", "/").lower()
+    name = lowered.rsplit("/", 1)[-1]
+    if name in SENSITIVE_FILENAMES:
+        return f"{name!r} is a secret-bearing filename"
+    for fragment in SENSITIVE_PATH_FRAGMENTS:
+        if fragment in lowered:
+            return f"path contains {fragment!r}"
+    return None
+
+
+def stamp_sensitivity(metadata: dict, path: Any) -> Optional[str]:
+    """Stamp never-leaves onto ``metadata`` when ``path`` warrants it.
+
+    Returns the reason it stamped, or ``None``. Never clears an existing flag —
+    a user or another rule may have set it for a reason this function cannot
+    see, and downgrading a never-leaves marker is not a decision code should
+    make on its own.
+    """
+    reason = sensitive_reason_for_path(path)
+    if reason:
+        metadata[LOCAL_ONLY_FLAG] = True
+        metadata.setdefault(LOCAL_ONLY_REASON, reason)
+    return reason
+
+
+__all__ = [
+    "SENSITIVE_PATH_FRAGMENTS",
+    "SENSITIVE_FILENAMES",
+    "LOCAL_ONLY_FLAG",
+    "LOCAL_ONLY_REASON",
+    "sensitive_reason_for_path",
+    "stamp_sensitivity",
+]