topos-node 1.3.42__tar.gz → 1.3.43__tar.gz

{topos_node-1.3.42/topos_node.egg-info → topos_node-1.3.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.3.42
+Version: 1.3.43
 Summary: Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://topos.dialogues.ai

{topos_node-1.3.42 → topos_node-1.3.43}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "topos-node"
-version = "1.3.42"
+version = "1.3.43"
 description = "Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client"
 readme = "README.md"
 license = "Apache-2.0"

{topos_node-1.3.42 → topos_node-1.3.43}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.3.42"
-__version_info__ = (1, 3, 42)
+__version__ = "1.3.43"
+__version_info__ = (1, 3, 43)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-1.3.42 → topos_node-1.3.43}/topos/protocol/narrowing_vocabulary.json

@@ -88,6 +88,7 @@
     "expand_boundary",
     "expand_boundary_downgrade",
     "first_source_ref_only",
+    "graph_lane",
     "gate_vetoed",
     "grantee_scrub_facts",
     "grantee_scrub_scores",

topos_node-1.3.43/topos/query/graph_lane.py

@@ -0,0 +1,152 @@
+"""The graph retrieval lane (S6, PLAN_QUERY_LOOP.md): edges as evidence.
+
+Before this lane, 272 of 38,060 live edges were readable at query time — one
+edge type, one cohort resolver. The relations the derivation layer builds
+(``communicates_with``, ``co_occurrence``, ``pursues``, ``participates_in``,
+``located_at``, ``semantic_affinity``) had no reader on the answer path: the
+"Who works on this with me?" probe returned topic-cluster fragments while a
+528-degree project hub sat unread one table away.
+
+This lane contributes 1-hop neighborhoods of the query's linked entities as
+ordinary fusion candidates — at canonical weight, never above (a lane reached
+by a different key but carrying ordinary evidence fuses AT the canonical
+weight; see the lane table in retrieval.py).
+
+Privacy posture, deliberately minimal for v1:
+
+* **Owner-only.** The lane runs only at ``disclosure_tier == "owner_raw"`` —
+  the same proxy the blackhole summary policy trusts, sound because
+  ``resolve_disclosure_tier`` never elevates a grantee there. For any other
+  tier the lane returns nothing and writes NO ledger receipt: a receipt for a
+  withheld lane is itself an existence signal.
+* **Blackhole rides the exit wire.** Items carry the neighbor as
+  ``entity_id`` and the anchor as ``subject_entity_id`` — both members of
+  ``_BLACKHOLE_ENTITY_ID_KEYS`` — so ``_blackhole_policy_for_summary`` can
+  match EITHER endpoint: a black-holed entity can neither appear as a
+  neighbor nor be reached through as an anchor. (Owner items are stamped
+  ``blackhole_protected``, the taint feed Gate C needs; nothing is silently
+  dropped from the owner's own view.)
+* **Anchor admission is the thread lane's.** Callers pass anchor ids that
+  already went through ``_entity_thread_entities`` — is_self dropped,
+  selector policy honored, fail-closed on an unreadable is_self.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional
+
+from ..features.entities.edges import top_edges
+from . import narrowing as _N
+
+logger = logging.getLogger(__name__)
+
+#: Neighbors fetched per anchor before the global cap ranks by weight.
+GRAPH_LANE_PER_ANCHOR_LIMIT = 10
+#: Total items the lane may contribute to fusion (SUMMARY_ITEM_CAP is 25;
+#: a graph that floods the packet would drown the content lanes).
+GRAPH_LANE_MAX_ITEMS = 8
+
+_EDGE_SENTENCES: Dict[str, str] = {
+    "communicates_with": "{a} communicates with {b}",
+    "co_occurrence": "{a} and {b} appear together",
+    "pursues": "{a} pursues {b}",
+    "participates_in": "{a} participates in {b}",
+    "located_at": "{a} is located at {b}",
+    "semantic_affinity": "{a} is closely related to {b}",
+}
+
+
+def _edge_sentence(anchor_name: str, neighbor_name: str, edge: Dict[str, Any]) -> str:
+    template = _EDGE_SENTENCES.get(
+        str(edge.get("edge_type") or ""), "{a} is linked to {b}"
+    )
+    sentence = template.format(a=anchor_name, b=neighbor_name)
+    evidence = edge.get("evidence_count")
+    if evidence:
+        sentence += f" ({evidence}×)"
+    return sentence
+
+
+def graph_neighborhood_items(
+    conn: Any,
+    *,
+    anchor_ids: List[str],
+    anchor_names: Dict[str, str],
+    scope_id: str,
+    manifest: Any,
+    disclosure_tier: str,
+    ledger: Optional[Any] = None,
+) -> List[Dict[str, Any]]:
+    """1-hop neighborhoods of the anchors, as fusion-ready summary items.
+
+    Returns [] — with no ledger receipt — unless the tier is owner_raw and
+    the scope warrants relationship structure.
+    """
+    if str(disclosure_tier or "") != "owner_raw":
+        return []
+    tables = list(getattr(manifest, "canonical_tables", None) or [])
+    # relationship_context:read is the deliberate exception: its declared
+    # table is conversation_messages, but relationship STRUCTURE is exactly
+    # what the scope's own card advertises ("Who works on this with me?") —
+    # the same explicit-scope pattern the goals and emotions lanes use.
+    if "entity_edges" not in tables and str(scope_id) != "relationship_context:read":
+        return []
+    if conn is None or not anchor_ids:
+        return []
+
+    seen: set = set()
+    collected: List[Dict[str, Any]] = []
+    for anchor_id in anchor_ids:
+        anchor_name = anchor_names.get(anchor_id) or anchor_id
+        try:
+            edges = top_edges(conn, anchor_id, limit=GRAPH_LANE_PER_ANCHOR_LIMIT)
+        except Exception as exc:  # noqa: BLE001 — one bad anchor must not kill the lane
+            logger.debug("graph lane: top_edges failed for %s: %s", anchor_id, exc)
+            continue
+        for edge in edges:
+            neighbor_id = str(edge.get("entity_id") or "")
+            edge_type = str(edge.get("edge_type") or "")
+            if not neighbor_id or not edge_type:
+                continue
+            key = (anchor_id, neighbor_id, edge_type)
+            if key in seen:
+                continue
+            seen.add(key)
+            neighbor_name = str(edge.get("entity_name") or neighbor_id)
+            event_at = edge.get("last_event_at") or edge.get("valid_from")
+            item: Dict[str, Any] = {
+                "topic": neighbor_name[:120],
+                "summary_text": _edge_sentence(anchor_name, neighbor_name, edge),
+                # Neighbor and anchor: both endpoints must be matchable by the
+                # blackhole exit wire (_BLACKHOLE_ENTITY_ID_KEYS).
+                "entity_id": neighbor_id,
+                "subject_entity_id": anchor_id,
+                "entity_type": edge.get("entity_type"),
+                "edge_type": edge_type,
+                "relevance_score": float(edge.get("weight") or 0.0),
+                "retrieval_source": f"graph:{edge_type}",
+            }
+            if event_at:
+                item["event_at"] = event_at
+            collected.append(item)
+
+    collected.sort(key=lambda i: i.get("relevance_score") or 0.0, reverse=True)
+    dropped = max(0, len(collected) - GRAPH_LANE_MAX_ITEMS)
+    items = collected[:GRAPH_LANE_MAX_ITEMS]
+    if items and ledger is not None:
+        try:
+            ledger.record(
+                _N.STAGE_RETRIEVAL,
+                "contributed",
+                "graph_lane",
+                dropped=dropped,
+                detail={
+                    "anchors": len(anchor_ids),
+                    "contributed": len(items),
+                    "edge_types": sorted({i["edge_type"] for i in items}),
+                },
+            )
+        except Exception:  # noqa: BLE001 — the ledger never breaks a turn
+            pass
+    return items

{topos_node-1.3.42 → topos_node-1.3.43}/topos/query/narrowing.py

@@ -195,6 +195,7 @@ REASONS = frozenset(
         "embedded_subject_not_instruction",
         "entity_thread_is_self",
         "entity_thread_lane",
+        "graph_lane",
         "entity_thread_selector_not_accessible",
         "entity_thread_self_check_unavailable",
         "entity_thread_unresolved",

{topos_node-1.3.42 → topos_node-1.3.43}/topos/query/retrieval.py

@@ -4716,7 +4716,10 @@ _NO_DECAY_FUSION_SOURCES = frozenset(
     # a RelationshipEdge or a dossier is a statement about how things ARE, not
     # an event that happened at a time. Decaying it would rank the owner's
     # mother below last night's chatter.
-    {"stat_insights", "facts_store", "entities", "briefs", "goals", "derived_objects"}
+    # S6 "graph": an edge is a statement about how things stand between two
+    # entities, not an event — decayed by created_at, the owner's closest
+    # collaborator would rank below last night's chatter.
+    {"stat_insights", "facts_store", "entities", "briefs", "goals", "derived_objects", "graph"}
 )
 
 
@@ -5634,6 +5637,7 @@ def _build_summary_items_unfiltered(
     entity_items: List[Dict[str, Any]] = []
     entity_thread_items: List[Dict[str, Any]] = []
     fact_store_items: List[Dict[str, Any]] = []
+    graph_items: List[Dict[str, Any]] = []
     if query_text:
         try:
             from ..core.state import get_db_connection
@@ -5688,6 +5692,32 @@ def _build_summary_items_unfiltered(
                     ledger=ledger,
                     thread_sink=thread_sink,
                 )
+                # S6: the graph lane — the same resolution, one join outward.
+                # `entity_context_items` says what the graph KNOWS about the
+                # entity; the thread lane fetches its RECORDS; this contributes
+                # its RELATIONS — the edges no lane could previously read. Own
+                # try/except: a graph failure must not also kill the thread
+                # lane (this block's outer except swallows everything).
+                try:
+                    from .graph_lane import graph_neighborhood_items
+
+                    anchor_ids, _skipped = _entity_thread_entities(
+                        conn, linked, manifest=manifest
+                    )
+                    graph_items = graph_neighborhood_items(
+                        conn,
+                        anchor_ids=anchor_ids,
+                        anchor_names={
+                            str(e.get("entity_id")): str(e.get("canonical_name") or "")
+                            for e in linked
+                        },
+                        scope_id=str(getattr(manifest, "scope_id", "") or ""),
+                        manifest=manifest,
+                        disclosure_tier=disclosure_tier,
+                        ledger=ledger,
+                    )
+                except Exception as graph_exc:  # noqa: BLE001
+                    logger.debug("graph lane skipped: %s", graph_exc)
         except Exception as exc:
             logger.debug("entity linking skipped: %s", exc)
 
@@ -5803,6 +5833,15 @@ def _build_summary_items_unfiltered(
         if ai_scope and canonical_items:
             min_per = dict(min_per or {})
             min_per["canonical"] = max(int(min_per.get("canonical") or 0), 3)
+        # S6: the graph lane only produces items under the scopes that
+        # advertise relationship STRUCTURE (relationship_context:read,
+        # graph:read) — and on a rich corpus its RRF share at canonical
+        # weight loses the top-25 to sixteen content lanes (measured on the
+        # owner snapshot: 8 lane items, 0 survivors). Structure is the
+        # product there, so it keeps a two-slot spine, same as goals.
+        if graph_items:
+            min_per = dict(min_per or {})
+            min_per["graph"] = max(int(min_per.get("graph") or 0), 2)
         # NOTE: cosine similarity must NOT waive the zero-df gate — a strong hit
         # on the generic half of a query ("compiler rewrite") cannot evidence a
         # name the corpus does not contain ("Threnody-7"). The N-lane found
@@ -5822,6 +5861,11 @@ def _build_summary_items_unfiltered(
                 # ordinary canonical evidence that arrived by a different key, so
                 # it fuses at the canonical lane's own weight.
                 ("entity_thread", 1.0, entity_thread_items),
+                # S6: edges are ordinary evidence that arrived by the entity
+                # key instead of a content key — the same argument as the
+                # thread lane, so the same weight: beside the scope routes,
+                # never above them.
+                ("graph", 1.0, graph_items),
                 # Q1. Same argument, same weight: evidence for a stated goal is
                 # ordinary canonical evidence that arrived keyed to that goal's ids.
                 # It is a joined minority lane beside the scope routes, never above
@@ -5858,6 +5902,7 @@ def _build_summary_items_unfiltered(
         + entity_items
         + derived_items
         + entity_thread_items
+        + graph_items
         + commitment_items
         + goal_items
         + emotion_items
@@ -6638,6 +6683,16 @@ class DefaultSignalRetrievalAdapter:
                 )
                 if summaries:
                     touched.append("signal")
+                # S6: the graph store is declared touched when the graph lane
+                # actually contributed — the Shortfall probe's assertion target
+                # ("Who works on this with me?" must consult the graph, not
+                # topic-cluster noise). Checked on items rather than threaded
+                # through a sink: the lane's provenance prefix IS the signal.
+                if any(
+                    str(item.get("retrieval_source") or "").startswith("graph:")
+                    for item in summaries
+                ):
+                    touched.append("graph")
                 # Surface the planner's parsed window so synthesis can state
                 # which dates were searched ("nothing from 2026-07-16") instead
                 # of inferring it from per-item timestamps. Summary mode only:

{topos_node-1.3.42 → topos_node-1.3.43}/topos/query/scope_registry.json

@@ -288,7 +288,7 @@
       "summary_objects": [],
       "inference_objects": [],
       "default_mode_ceiling": "raw",
-      "implementation_status": "stub"
+      "implementation_status": "live"
     },
     {
       "scope_id": "health:read",

{topos_node-1.3.42 → topos_node-1.3.43}/topos/sources/install_service.py

@@ -929,6 +929,15 @@ def _is_rehydratable_source_definition(source_def: Dict[str, Any]) -> bool:
 # proves a legacy-scope gdrive_files row is retired, not merely missing.
 _LEGACY_SOURCE_SUCCESSORS: Dict[str, str] = {"gdrive_files": "drive_files"}
 
+# Going forward the Drive connector converges back on the bundled id: the CP
+# registry republish (2026-09-02) made gdrive_files the installable card, so a
+# fresh connect leaves a node with BOTH ids active under the same canonical
+# scope. Not a contradiction with _LEGACY_SOURCE_SUCCESSORS: that map proves
+# LEGACY-scope rows dead against the July replacement that was live at the
+# time; this one retires a canonical-scope row once a healthy canonical-scope
+# install of its successor exists for the same user+topos.
+_CANONICAL_SOURCE_SUCCESSORS: Dict[str, str] = {"drive_files": "gdrive_files"}
+
 _LEGACY_DATASET_SEGMENT = "default"
 _CANONICAL_DATASET_SEGMENT = "topos"
 
@@ -938,9 +947,16 @@ def _dataset_scope_segment(scope: Dict[str, str]) -> str:
     return parts[1] if len(parts) == 3 else ""
 
 
-def _canonical_active_index(records: List[InstallRecord]) -> Set[Tuple[str, str, str]]:
+def _canonical_active_index(
+    records: List[InstallRecord], *, healthy_only: bool = False
+) -> Set[Tuple[str, str, str]]:
     """(user_id, topos_id, source_id) for active installs under the canonical
-    {owner}:topos:{topos_id} dataset scope."""
+    {owner}:topos:{topos_id} dataset scope.
+
+    healthy_only drops rows this same pass would retire (lane conflict or
+    schema drift): a row being demoted must never count as the proof that
+    demotes its predecessor, or one pass could unwire a connector entirely.
+    """
     index: Set[Tuple[str, str, str]] = set()
     for rec in records:
         scope = _normalize_scope(rec.scope)
@@ -948,6 +964,10 @@ def _canonical_active_index(records: List[InstallRecord]) -> Set[Tuple[str, str,
             continue
         if scope["user_id"] == "*" or scope["topos_id"] == "*":
             continue
+        if healthy_only:
+            source_def = rec.source_definition_json if isinstance(rec.source_definition_json, dict) else {}
+            if bundled_lane_conflict(source_def) or bundled_schema_drift(source_def):
+                continue
         index.add((scope["user_id"], scope["topos_id"], rec.source_id))
     return index
 
@@ -986,6 +1006,28 @@ def _legacy_scope_superseded_reason(
     return None
 
 
+def _canonical_successor_superseded_reason(
+    rec: InstallRecord, healthy_canonical: Set[Tuple[str, str, str]]
+) -> Optional[str]:
+    """Reason to retire a canonical-scope row whose declared successor is live.
+
+    Only fires for source_ids in _CANONICAL_SOURCE_SUCCESSORS, and only when
+    the successor's canonical-scope row is healthy — a successor this pass is
+    itself retiring proves nothing.
+    """
+    successor = _CANONICAL_SOURCE_SUCCESSORS.get(rec.source_id)
+    if not successor:
+        return None
+    scope = _normalize_scope(rec.scope)
+    if _dataset_scope_segment(scope) != _CANONICAL_DATASET_SEGMENT:
+        return None
+    if scope["user_id"] == "*" or scope["topos_id"] == "*":
+        return None
+    if (scope["user_id"], scope["topos_id"], successor) in healthy_canonical:
+        return f"superseded by active canonical-scope install of successor source_id={successor}"
+    return None
+
+
 def _supersede_install(*, scope_key: str, source_id: str, reason: str) -> None:
     """Retire an active install row that can never install again.
 
@@ -1021,6 +1063,7 @@ def rehydrate_active_installs_runtime(*, source_id: Optional[str] = None) -> Dic
     # source_id-filtered listing excludes.
     peers = records if source_id is None else [rec for rec in list_installs() if rec.is_active]
     canonical_active = _canonical_active_index(peers)
+    healthy_canonical = _canonical_active_index(peers, healthy_only=True)
     rehydrated = 0
     failed = 0
     # (scope_key, source_id, reason) for rows retired after the locked pass.
@@ -1033,6 +1076,12 @@ def rehydrate_active_installs_runtime(*, source_id: Optional[str] = None) -> Dic
             if legacy_reason:
                 superseded.append((_scope_key(rec.scope), rec.source_id, legacy_reason))
                 continue
+            # A canonical-scope duplicate left behind by an id convergence
+            # (drive_files -> gdrive_files) retires once the successor is live.
+            successor_reason = _canonical_successor_superseded_reason(rec, healthy_canonical)
+            if successor_reason:
+                superseded.append((_scope_key(rec.scope), rec.source_id, successor_reason))
+                continue
             source_def = rec.source_definition_json if isinstance(rec.source_definition_json, dict) else {}
             if not source_def:
                 continue

{topos_node-1.3.42 → topos_node-1.3.43}/topos/upgrades/manifests.json

@@ -763,6 +763,12 @@
       "steps": [],
       "notes": []
     },
+    {
+      "version": "1.3.43",
+      "summary": "Release 1.3.43.",
+      "steps": [],
+      "notes": []
+    },
     {
       "version": "unreleased",
       "summary": "Staging entry for in-flight PRs. cut_release.py stamps this with the next version at release cut. Never executed by steps_between.",

{topos_node-1.3.42 → topos_node-1.3.43/topos_node.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.3.42
+Version: 1.3.43
 Summary: Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://topos.dialogues.ai

{topos_node-1.3.42 → topos_node-1.3.43}/topos_node.egg-info/SOURCES.txt

@@ -556,6 +556,7 @@ topos/query/facts_direct.py
 topos/query/fingerprint.py
 topos/query/game_layer.py
 topos/query/grant_cache.py
+topos/query/graph_lane.py
 topos/query/inference.py
 topos/query/intent.py
 topos/query/manifest.py