ltcai 11.5.0 → 11.5.2

package/lattice_brain/graph/proactive.py

@@ -644,7 +644,7 @@ def gate_ingest_candidate(
     """Score whether new content should be ingested into the graph.
 
     Pure function — no store access, no side effects. Intended adoption point
-    for the ingestion pipeline (``services/ingestion.py`` /
+    for the ingestion pipeline (``lattice_brain.ingestion`` /
     ``lattice_brain.graph.ingest``), which passes a closure over its own
     scoped search, e.g.::
 

package/lattice_brain/graph/projection/v2_schema.py

@@ -516,31 +516,3 @@ class KnowledgeGraphV2SchemaMixin(_Core):
         except Exception as ex:
             logging.debug("knowledge_graph: v2 edge delete mirror skipped: %s", ex)
 
-    def _v2_sync_report(self) -> Dict[str, Any]:
-        """Diagnose the dual-write invariant: legacy node/edge id sets must equal
-        the v2 projection's. Returns counts + any drift (ids missing from / extra
-        in v2). ``in_sync`` is True only when both id sets match exactly.
-
-        All legacy writes go through _upsert_node/_upsert_edge (which dual-write)
-        and every legacy delete is mirrored, so a non-empty drift signals a
-        bypassed write path — this is the runtime guard for that invariant.
-        """
-        if KGStoreV2 is None:
-            return {"available": False, "in_sync": True}
-        with self._connect() as conn:
-            legacy_nodes = {r[0] for r in conn.execute("SELECT id FROM nodes")}
-            v2_nodes = {r[0] for r in conn.execute("SELECT id FROM nodes_v2")}
-            legacy_edges = {r[0] for r in conn.execute("SELECT id FROM edges")}
-            v2_edges = {r[0] for r in conn.execute("SELECT id FROM edges_v2")}
-        return {
-            "available": True,
-            "in_sync": legacy_nodes == v2_nodes and legacy_edges == v2_edges,
-            "nodes_legacy": len(legacy_nodes),
-            "nodes_v2": len(v2_nodes),
-            "edges_legacy": len(legacy_edges),
-            "edges_v2": len(v2_edges),
-            "nodes_missing_from_v2": sorted(legacy_nodes - v2_nodes),
-            "nodes_extra_in_v2": sorted(v2_nodes - legacy_nodes),
-            "edges_missing_from_v2": sorted(legacy_edges - v2_edges),
-            "edges_extra_in_v2": sorted(v2_edges - legacy_edges),
-        }

package/lattice_brain/graph/vector_index/base.py

@@ -142,9 +142,6 @@ class VectorIndex(Protocol):
     def rebuild(self, items: Iterable[IndexItem]) -> None:
         raise NotImplementedError
 
-    def metadata_for(self, id: str) -> Dict[str, Any]:
-        raise NotImplementedError
-
     def search(
         self,
         query: Sequence[float],

package/lattice_brain/graph/vector_index/brute_force.py

@@ -80,10 +80,6 @@ class BruteForceIndex:
         for item_id, vector, metadata in items:
             self.add(item_id, vector, metadata)
 
-    def metadata_for(self, id: str) -> Dict[str, Any]:
-        """Metadata stored alongside ``id`` (empty dict when unknown)."""
-        return dict(self._metadata.get(str(id), {}))
-
     def search(
         self,
         query: Sequence[float],

package/lattice_brain/graph/vector_index/hnsw.py

@@ -150,9 +150,6 @@ class HnswIndex:
             self.add(item_id, vector, metadata)
         self._dirty = True
 
-    def metadata_for(self, id: str) -> Dict[str, Any]:
-        return dict(self._metadata.get(str(id), {}))
-
     # ── graph construction ───────────────────────────────────────────────────
     def _new_graph(self, module: Any, capacity: int) -> Any:
         graph = module.Index(space=self._space, dim=self._dim)

package/lattice_brain/graph/vector_index/quantized.py

@@ -109,9 +109,6 @@ class QuantizedIndex:
         for item_id, vector, metadata in items:
             self.add(item_id, vector, metadata)
 
-    def metadata_for(self, id: str) -> Dict[str, Any]:
-        return dict(self._metadata.get(str(id), {}))
-
     def search(
         self,
         query: Sequence[float],

package/lattice_brain/ingestion_jobs.py

@@ -351,9 +351,6 @@ class BackgroundIngestionQueue:
     def get(self, job_id: str) -> Optional[BackgroundIngestionJob]:
         return self._jobs.get(job_id)
 
-    def list_pending(self) -> List[BackgroundIngestionJob]:
-        return [j for j in self._jobs.values() if j.status == "queued"]
-
     def list_recent(self, limit: int = 20) -> List[BackgroundIngestionJob]:
         """Most recent jobs first (insertion order is schedule order)."""
         limit = max(1, int(limit))

package/lattice_brain/memory.py

@@ -27,33 +27,6 @@ class BrainMemory:
     def available(self) -> bool:
         return self._pipeline is not None and self._pipeline.available()
 
-    def record_decision(
-        self,
-        title: str,
-        detail: str = "",
-        *,
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-        conversation_id: Optional[str] = None,
-        decided_by: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        if not str(title or "").strip():
-            raise ValueError("a decision needs a title")
-        result = self._pipeline.ingest(
-            IngestionItem(
-                source_type="decision",
-                title=title.strip(),
-                text=detail,
-                owner=user_email,
-                workspace_id=workspace_id,
-                conversation_id=conversation_id,
-                metadata={"decided_by": decided_by or user_email, **(metadata or {})},
-            ),
-            user_email=user_email,
-        )
-        return result.as_dict()
-
     def record_experience(
         self,
         title: str,

package/lattice_brain/portability/sharing.py

@@ -167,10 +167,6 @@ class KGPortabilitySharingMixin(_Core):
                 quiet()
         return result
 
-    def import_from_file(self, path, *, mode: str = "merge", dry_run: bool = False) -> Dict[str, Any]:
-        artifact = json.loads(Path(path).read_text(encoding="utf-8"))
-        return self.import_data(artifact, mode=mode, dry_run=dry_run)
-
     # ── selective subgraph share (opt-in prototype, off by default) ──────────
     def share_status(self) -> Dict[str, Any]:
         """Honest read of the share surface. Safe to call while it is off.

package/lattice_brain/quality.py

@@ -375,15 +375,6 @@ class GraphEdgeQualityManager:
                 seen[key] = e.get("id")
         return dups
 
-    def merge_duplicate_edges(self, edges: List[Dict]) -> List[Dict]:
-        # keep highest confidence
-        best: Dict[Any, Dict[str, Any]] = {}
-        for e in edges:
-            key = (e.get("source"), e.get("target"), e.get("type"))
-            if key not in best or e.get("confidence", 0) > best[key].get("confidence", 0):
-                best[key] = e
-        return list(best.values())
-
     def compute_quality_metrics(self, edges: List[Dict]) -> Dict[str, float]:
         if not edges:
             return {"avg_conf": 0.0, "avg_evidence": 0.0, "dup_rate": 0.0}
@@ -532,46 +523,6 @@ class LatticeBrainQuality:
         self.context_assembler = StructuredContextAssembler()
         self.benchmark = RetrievalBenchmarkRunner()
 
-    def full_quality_pass(self, payload: Dict[str, Any]) -> Dict[str, Any]:
-        """End-to-end quality pipeline (non-destructive)"""
-        result = {"status": "ok", "timestamp": time.time()}
-
-        # embedding
-        if "embeddings" in payload:
-            labels = [self.embed_labeller.label(e["id"], e.get("vector")) for e in payload["embeddings"]]
-            result["embedding_labels"] = [label.__dict__ for label in labels]
-            result["reindex_plan"] = self.embed_labeller.generate_reindex_plan()
-
-        # hybrid retrieval
-        if "retrieval" in payload:
-            fused = self.hybrid.fuse(payload["retrieval"]["query"], payload["retrieval"]["candidates"])
-            reranked = self.reranker.rerank(payload["retrieval"]["query"], fused)
-            result["retrieval"] = {"fused": fused, "reranked": reranked}
-
-        # memory
-        if "memories" in payload:
-            cands = self.memory_mgr.extract_candidates(payload["memories"])
-            cands = self.memory_mgr.score_candidates(cands, payload.get("query", ""))
-            cands = self.memory_mgr.dedupe(cands)
-            cands = self.memory_mgr.merge(cands)
-            cands = self.memory_mgr.detect_conflicts(cands)
-            cands = self.memory_mgr.apply_retention(cands)
-            result["memory_candidates"] = [c.__dict__ for c in cands]
-
-        # graph
-        if "graph_edges" in payload:
-            eqs = [self.graph_mgr.validate_edge(e) for e in payload["graph_edges"]]
-            result["graph_quality"] = [q.__dict__ for q in eqs]
-            result["graph_metrics"] = self.graph_mgr.compute_quality_metrics(payload["graph_edges"])
-
-        # context
-        if "context_items" in payload:
-            ctx = self.context_assembler.assemble(payload["context_items"])
-            ctx = self.context_assembler.apply_guardrails(ctx)
-            result["structured_context"] = ctx
-
-        return result
-
 
 __all__ = [
     "BM25Scorer",

package/lattice_brain/runtime/agent_runtime.py

@@ -8,7 +8,7 @@
 진입점: app_factory.py:AGENT_RUNTIME (wiring root), api/agents.py, RunExecutor.
 
 Before this module the agent concern was spread across three places: the
-:class:`~latticeai.core.multi_agent.MultiAgentOrchestrator` (role pipeline),
+:class:`~lattice_brain.runtime.multi_agent.MultiAgentOrchestrator` (role pipeline),
 the :class:`~latticeai.services.platform_runtime.PlatformRuntime` (cross-system
 wiring + an ad-hoc ``run_agent``), and ``api/agents.py`` (HTTP transport that
 also owned orchestration + persistence + audit). The frontend reached past all

package/lattice_brain/runtime/hooks.py

@@ -181,16 +181,6 @@ class HookResult:
         }
 
 
-def hook_context(kind: str, event: str = "", **kwargs: Any) -> HookContext:
-    """Factory for a :class:`HookContext` (matches the public hook vocabulary)."""
-    return HookContext(kind, event, **kwargs)
-
-
-def hook_result(**kwargs: Any) -> HookResult:
-    """Factory for a :class:`HookResult`."""
-    return HookResult(**kwargs)
-
-
 def dispatch_tool(
     hooks: Any,
     tool_name: str,
@@ -525,9 +515,6 @@ class HooksRegistry:
     # Alias — descriptive name used by the wiring layer.
     register_runtime_hook = register_hook
 
-    def unregister_hook(self, hook_id: str) -> None:
-        self._runtime_runners.pop(hook_id, None)
-
     def has_runner(self, hook_id: str) -> bool:
         return hook_id in self._runtime_runners
 

package/lattice_brain/runtime/multi_agent.py

@@ -49,7 +49,7 @@ from typing import Any, Callable, Dict, List, Optional
 from ..utils import now_iso as _now
 from .contracts import multi_agent_contract
 
-MULTI_AGENT_VERSION = "11.5.0"
+MULTI_AGENT_VERSION = "11.5.2"
 
 AGENT_ROLES = ("researcher", "planner", "executor", "reviewer", "release")
 CORE_PIPELINE = ("planner", "executor", "reviewer")

package/lattice_brain/sealed_box.py

@@ -212,10 +212,6 @@ class RecipientIdentity:
             "path": str(self._key_file),
         }
 
-    def seal_to_self(self, plaintext: bytes) -> Dict[str, Any]:
-        """Seal to this Brain's own key — the honest way to test a round trip."""
-        return seal(plaintext, recipient_public_key=self.public_key_b64)
-
     def unseal(self, block: Dict[str, Any]) -> bytes:
         return unseal(block, self._private)
 

package/latticeai/__init__.py

@@ -1,3 +1,3 @@
 """Lattice AI - modular server package."""
 
-__version__ = "11.5.0"
+__version__ = "11.5.2"

package/latticeai/api/admin.py

@@ -8,6 +8,8 @@ from typing import Any, Callable, Dict, List, Optional
 from fastapi import APIRouter, Query, Request
 from pydantic import BaseModel
 
+from latticeai.api.workspace_scope import requested_workspace
+from latticeai.core.http_origin import request_external_origin
 from latticeai.core.messages import http_error, resolve_language
 from latticeai.core.workspace_os import DEFAULT_WORKSPACE_ID
 
@@ -65,13 +67,6 @@ def create_admin_router(
 ) -> APIRouter:
     router = APIRouter()
 
-    def _workspace_scope(request: Request) -> Optional[str]:
-        header = request.headers.get("X-Workspace-Id")
-        if header and header.strip():
-            return header.strip()
-        query = request.query_params.get("workspace_id")
-        return query.strip() if query and query.strip() else None
-
     def _matches_scope(item: Dict[str, object], workspace_id: Optional[str]) -> bool:
         if not workspace_id:
             return True
@@ -81,11 +76,11 @@ def create_admin_router(
         return str(item_scope or "") == str(workspace_id)
 
     def _scoped_history(request: Request) -> List[Dict]:
-        scope = _workspace_scope(request)
+        scope = requested_workspace(request)
         return [item for item in get_history() if _matches_scope(item, scope)]
 
     def _scoped_audit_log(request: Request) -> List[Dict]:
-        scope = _workspace_scope(request)
+        scope = requested_workspace(request)
         return [item for item in get_audit_log() if _matches_scope(item, scope)]
 
     def _filter_audit_log(
@@ -427,9 +422,14 @@ def create_admin_router(
     @router.get("/admin/invite-link")
     async def admin_invite_link(request: Request):
         require_admin(request)
-        host = request.headers.get("host", f"localhost:{default_port}")
-        scheme = "https" if request.headers.get("x-forwarded-proto") == "https" else "http"
-        url = f"{scheme}://{host}/?code={invite_code}" if invite_gate_enabled else f"{scheme}://{host}/"
+        # The link is *mailed to a person*, so it has to name the door they can
+        # actually knock on. Behind the desktop gateway ``Host`` is the internal
+        # worker authority, which meant every invite emitted through the front
+        # door pointed at a port only the gateway can reach.
+        origin = request_external_origin(
+            request, fallback=f"http://localhost:{default_port}",
+        )
+        url = f"{origin}/?code={invite_code}" if invite_gate_enabled else f"{origin}/"
         return {"invite_url": url, "invite_code": invite_code, "gate_enabled": invite_gate_enabled}
 
     @router.get("/admin/sso")