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

{topos_node-1.3.41/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.41
+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.41 → topos_node-1.3.43}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "topos-node"
-version = "1.3.41"
+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.41 → topos_node-1.3.43}/topos/__version__.py

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

{topos_node-1.3.41 → 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",
@@ -154,7 +155,8 @@
     "topic_thread_single_store",
     "unknown_scope",
     "unmatched_route",
-    "unrecognized"
+    "unrecognized",
+    "world_knowledge_no_retrieval"
   ],
   "empty_causes": [
     "gate_vetoed",

{topos_node-1.3.41 → topos_node-1.3.43}/topos/query/game_layer.py

@@ -106,6 +106,75 @@ def _extract_entity_labels(context_packet: Dict[str, Any]) -> List[str]:
     return labels[:10]
 
 
+#: availability:read licenses free/busy ONLY. The three sets below are the
+#: ENTIRE licensed vocabulary of an availability inference answer — a person
+#: name or a meeting title has no slot in it, so enforcement is a closed-set
+#: membership check, never a redaction pattern that has to recognize names.
+_AVAILABILITY_ANSWERS = frozenset({"yes", "conditional", "no", "unknown"})
+_AVAILABILITY_BANDS = frozenset(
+    {"overlap_found", "negotiable_overlap", "no_overlap", "unknown"}
+)
+#: Free text can only leave through a key, so unknown keys are dropped rather
+#: than inspected. Everything listed is either closed-set or pipeline-stamped
+#: metadata (exclusion/truncated/empty_cause carry slugs and integers only).
+_AVAILABILITY_ALLOWED_KEYS = frozenset(
+    {
+        "access_mode",
+        "scope_id",
+        "answer_type",
+        "band",
+        "answer",
+        "confidence",
+        "items",
+        "deferred",
+        "redaction",
+        "exclusion",
+        "truncated",
+        "empty_cause",
+        "packet_resolution",
+        "packet_resolution_reason",
+        "principal_cls",
+    }
+)
+
+
+def is_availability_scope(scope_id: str) -> bool:
+    return "availability" in (scope_id or "")
+
+
+def enforce_availability_inference_contract(payload: Dict[str, Any]) -> Dict[str, Any]:
+    """Free/busy-only egress gate for availability inference payloads.
+
+    The branches in ``DefaultGameLayer.apply`` already emit only closed-set
+    values for this scope — but the pipeline lanes that run AFTER the game
+    layer ``update()`` the payload in place, and any of them can re-open what
+    the game layer refused. Live 2026-09-02 the LLM inference lane did exactly
+    that: the who-guard's ``answer: "unknown"`` left the engine as a contact's
+    full name at confidence 1. This function is the last owner of the payload
+    before it is serialized, so a violation here is scrubbed to "unknown"
+    rather than trusted, and the scrub is declared via ``redaction`` (a
+    closed-set slug) instead of happening silently.
+    """
+    out = {k: v for k, v in payload.items() if k in _AVAILABILITY_ALLOWED_KEYS}
+    scrubbed = len(out) != len(payload)
+    if out.get("answer_type") not in ("band", "list"):
+        out["answer_type"] = "band"
+        scrubbed = True
+    if str(out.get("band") or "unknown") not in _AVAILABILITY_BANDS:
+        out.pop("band", None)
+        scrubbed = True
+    if str(out.get("answer")) not in _AVAILABILITY_ANSWERS:
+        out["answer"] = "unknown"
+        out["confidence"] = 0.0
+        scrubbed = True
+    if out.get("items"):
+        out["items"] = []
+        scrubbed = True
+    if scrubbed:
+        out["redaction"] = "availability_free_busy_only"
+    return out
+
+
 class DefaultGameLayer:
     reveal_strategy: RevealStrategy = RevealStrategy.DIRECT
 

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.41 → 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",
@@ -299,6 +300,7 @@ REASONS = frozenset(
         "source_has_live_tools",
         "source_ref",
         "summary_enrichment",
+        "world_knowledge_no_retrieval",
         # --- control plane: refusals that never reach the node. The human-readable
         # sentence stays on the response's own `deny_reason`; the ledger carries the code.
         "access_mode_above_ceiling",

{topos_node-1.3.41 → topos_node-1.3.43}/topos/query/pipeline.py

@@ -16,7 +16,11 @@ from .ddr import StageTimings, build_disclosure_decision_record, now_ms
 from .disclosure import DisclosureFilterPipeline
 from .fingerprint import compute_retrieval_fingerprint
 from .packet_resolution import effective_packet_resolution
-from .game_layer import DefaultGameLayer
+from .game_layer import (
+    DefaultGameLayer,
+    enforce_availability_inference_contract,
+    is_availability_scope,
+)
 from .inference import run_query_inference
 from .intent import compute_intent_hash
 from .manifest import ScopeResolutionManifest
@@ -779,7 +783,17 @@ class QueryPipelineOrchestrator:
             query_text=query_text,
         )
         timings.game_layer_ms = now_ms() - _t0
-        if access_mode == "inference" and public.payload.get("answer_type") != "band":
+        # availability:read licenses free/busy only, so the game layer's output
+        # (band, or the who-guard's refusal) is FINAL for this scope — same
+        # contract as `band`/`facts` below: deterministic answer_types are
+        # final. The lanes below `update()` the payload in place, and on
+        # 2026-09-02 the LLM lane overwrote the who-guard's "unknown" with a
+        # contact's full name at confidence 1 — the refusal has answer_type
+        # "list", which both lanes treated as an invitation.
+        availability_final = access_mode == "inference" and is_availability_scope(scope_id)
+        if (access_mode == "inference"
+                and not availability_final
+                and public.payload.get("answer_type") != "band"):
             # C7 facts-direct (W3.1): a known-item ask with live facts gets its
             # exact values, validity dates and evidence counts with ZERO LLM —
             # same contract as `band`: deterministic answer_types are final.
@@ -820,6 +834,7 @@ class QueryPipelineOrchestrator:
             if direct is not None:
                 public.payload.update(direct)
         if (access_mode == "inference"
+                and not availability_final
                 and public.payload.get("answer_type") not in ("band", "facts")):
             _t0 = now_ms()
             inf = await asyncio.to_thread(
@@ -831,6 +846,11 @@ class QueryPipelineOrchestrator:
             )
             public.payload.update(inf)
             timings.inference_ms = now_ms() - _t0
+        if availability_final:
+            # Closed-set egress scrub, applied even though the lanes above are
+            # gated off: the payload has one last owner before serialization,
+            # and a lane added later must hit this wall, not the wire.
+            public.payload = enforce_availability_inference_contract(public.payload)
 
         public_dict = public.to_dict()
         # Declared, never silent: every turn says what resolution actually applied and

{topos_node-1.3.41 → 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.41 → topos_node-1.3.43}/topos/query/scope_registry.json

@@ -186,6 +186,110 @@
         "canonical_address_book"
       ]
     },
+    {
+      "scope_id": "facts:read",
+      "description": "Derived facts about the owner from standard packs (work, interests, preferences, places, behavior): predicate/value pairs with validity windows. Excludes special-class packs \u2014 health, inner-state and finances live behind facts_sensitive:read.",
+      "example_questions": [
+        "What do the derivation packs know about my work?",
+        "Which projects am I recorded as pursuing?",
+        "What are my stated preferences?"
+      ],
+      "primary_dimensions": [
+        "Profile"
+      ],
+      "raw_tables": [],
+      "canonical_tables": [],
+      "signal_objects": [
+        "fact"
+      ],
+      "summary_objects": [
+        "fact"
+      ],
+      "inference_objects": [
+        "fact"
+      ],
+      "default_mode_ceiling": "inference",
+      "implementation_status": "stub",
+      "fact_classes": [
+        "standard"
+      ]
+    },
+    {
+      "scope_id": "facts_sensitive:read",
+      "description": "Derived facts from special-class packs: health, inner state (mind.*), and finances (money.*). Split from facts:read so a grant can carry everyday facts without carrying these; mirrors the engine's facts vs facts_all packet distinction.",
+      "example_questions": [
+        "What medications am I recorded as taking?",
+        "What does the pack record about my reported state?"
+      ],
+      "primary_dimensions": [
+        "Profile"
+      ],
+      "raw_tables": [],
+      "canonical_tables": [],
+      "signal_objects": [
+        "fact"
+      ],
+      "summary_objects": [
+        "fact"
+      ],
+      "inference_objects": [
+        "fact"
+      ],
+      "default_mode_ceiling": "inference",
+      "implementation_status": "stub",
+      "fact_classes": [
+        "special"
+      ]
+    },
+    {
+      "scope_id": "goals:read",
+      "description": "Stated and derived goals: the user_goals store and Goal signal objects, with their dates and status. Aspirations are sensitive; answers are summaries and bands, not raw dumps.",
+      "example_questions": [
+        "What goals have I set this quarter?",
+        "Which goals went quiet?"
+      ],
+      "primary_dimensions": [
+        "Profile"
+      ],
+      "raw_tables": [],
+      "canonical_tables": [
+        "user_goals"
+      ],
+      "signal_objects": [
+        "Goal",
+        "user_goals"
+      ],
+      "summary_objects": [
+        "Goal"
+      ],
+      "inference_objects": [
+        "Goal"
+      ],
+      "default_mode_ceiling": "inference",
+      "implementation_status": "stub"
+    },
+    {
+      "scope_id": "graph:read",
+      "description": "The entity graph: people, projects, places and topics as nodes, and the derived relations between them (communicates_with, co_occurrence, pursues, participates_in, located_at). Structure and strength, resolved through aliases; not message text.",
+      "example_questions": [
+        "Who is connected to this project?",
+        "What links me to this person?",
+        "Which people bridge my communities?"
+      ],
+      "primary_dimensions": [
+        "Relationships"
+      ],
+      "raw_tables": [
+        "entities",
+        "entity_edges"
+      ],
+      "canonical_tables": [],
+      "signal_objects": [],
+      "summary_objects": [],
+      "inference_objects": [],
+      "default_mode_ceiling": "raw",
+      "implementation_status": "live"
+    },
     {
       "scope_id": "health:read",
       "description": "Wellbeing signals from journal entries and role-filtered message emotions: moods, wellness summaries, and wellness scores.",
@@ -381,6 +485,31 @@
         "calendar_stub"
       ]
     },
+    {
+      "scope_id": "topics:read",
+      "description": "Derived topic clusters and their membership: what themes the owner's activity organizes into, by dimension. Labels and counts; member pointers stay on the node.",
+      "example_questions": [
+        "What themes does my work cluster into?",
+        "How big is each interest cluster?"
+      ],
+      "primary_dimensions": [
+        "Interests"
+      ],
+      "raw_tables": [],
+      "canonical_tables": [
+        "topic_clusters",
+        "topic_cluster_members"
+      ],
+      "signal_objects": [
+        "message_topics"
+      ],
+      "summary_objects": [
+        "message_topics"
+      ],
+      "inference_objects": [],
+      "default_mode_ceiling": "summary",
+      "implementation_status": "stub"
+    },
     {
       "scope_id": "work_context:read",
       "description": "Work goals and context: roles, skills and employment history from profile records, plus goals extracted from AI conversations and owner journals.",

{topos_node-1.3.41 → topos_node-1.3.43}/topos/sources/bundled_canonical_triples.py

@@ -32,6 +32,17 @@ BUNDLED_CANONICAL_TRIPLES: Dict[str, Tuple[str, str]] = {
     "gcal.events.v1": ("google_calendar", "schedule"),
 }
 
+# Known drift variants of bundled schema ids, seen in the wild: a 2026-07
+# operator install template invented "gdrive.files.v1" (the bundled id is
+# "gdrive.file.v1"). Deliberately NOT keys of BUNDLED_CANONICAL_TRIPLES: an
+# exact key makes normalize_canonical_source_payload raise and rehydrate
+# demote, and the live drive_files install carries this schema with no bundled
+# replacement to fall back to — enforcement would orphan a working connector.
+# Callers use bundled_schema_drift() and decide per source_id.
+BUNDLED_SCHEMA_ALIASES: Dict[str, str] = {
+    "gdrive.files.v1": "gdrive.file.v1",
+}
+
 VALID_CANONICAL_GROUP_IDS = frozenset(
     {
         "ai_messages",
@@ -97,6 +108,32 @@ def bundled_lane_conflict(payload: Dict[str, Any]) -> Optional[str]:
     )
 
 
+def bundled_schema_drift(payload: Dict[str, Any]) -> Optional[str]:
+    """Reason when the payload's schema is a drift variant of a bundled id and
+    its declared lane contradicts the bundled triple, else None.
+
+    Advisory, unlike bundled_lane_conflict: the caller decides whether the row
+    can be retired (its source_id has a bundled replacement) or only reported.
+    """
+    group_id = str(payload.get("canonical_group_id") or "").strip()
+    if not group_id:
+        return None
+    for key in (
+        str(payload.get("schema_id") or "").strip(),
+        str(payload.get("parser_id") or "").strip(),
+    ):
+        bundled_key = BUNDLED_SCHEMA_ALIASES.get(key)
+        if not bundled_key:
+            continue
+        _, bundled_lane = BUNDLED_CANONICAL_TRIPLES[bundled_key]
+        if group_id != bundled_lane:
+            return (
+                f"schema {key!r} is a drift variant of bundled {bundled_key!r} and "
+                f"canonical_group_id {group_id!r} contradicts bundled lane {bundled_lane!r}"
+            )
+    return None
+
+
 def normalize_canonical_source_payload(payload: Dict[str, Any]) -> Dict[str, Any]:
     """
     Fill bundled canonical_mapper_id from schema/parser; drop deprecated connected flag.