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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.3.41
+Version: 1.3.42
 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.42}/pyproject.toml

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

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

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

@@ -154,7 +154,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.42}/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.41 → topos_node-1.3.42}/topos/query/narrowing.py

@@ -299,6 +299,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.42}/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.42}/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": "stub"
+    },
     {
       "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.42}/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.

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

@@ -8,7 +8,7 @@ import uuid
 from contextlib import contextmanager
 from dataclasses import dataclass
 from datetime import datetime, timezone
-from typing import Any, Dict, Iterator, List, Optional, Tuple
+from typing import Any, Dict, Iterator, List, Optional, Set, Tuple
 
 from ..config.settings import settings
 from ..core.state import get_db_connection
@@ -16,7 +16,7 @@ from ..enrichment.jobs import CANONICAL_JOBS, RAW_JOBS
 from ..ingestion.parsers import PARSER_REGISTRY
 from ..storage.db.postgres import connect_postgres, execute_query, fetch_all, fetch_one
 from ..storage.db.write_gate import commit_connection, with_db_write
-from .bundled_canonical_triples import bundled_lane_conflict
+from .bundled_canonical_triples import bundled_lane_conflict, bundled_schema_drift
 from .runtime_install import RuntimeInstallHandle, install_source_definition
 from .scrub_attribution import scrub_attributed_rows
 
@@ -924,6 +924,68 @@ def _is_rehydratable_source_definition(source_def: Dict[str, Any]) -> bool:
     return source_kind_from_payload(source_def) == SOURCE_KIND_INGESTION
 
 
+# drive_files is gdrive_files republished under a new source id — the runtime
+# definitions are identical except source_id — so an active drive_files install
+# proves a legacy-scope gdrive_files row is retired, not merely missing.
+_LEGACY_SOURCE_SUCCESSORS: Dict[str, str] = {"gdrive_files": "drive_files"}
+
+_LEGACY_DATASET_SEGMENT = "default"
+_CANONICAL_DATASET_SEGMENT = "topos"
+
+
+def _dataset_scope_segment(scope: Dict[str, str]) -> str:
+    parts = str(scope.get("dataset_id") or "").split(":")
+    return parts[1] if len(parts) == 3 else ""
+
+
+def _canonical_active_index(records: List[InstallRecord]) -> Set[Tuple[str, str, str]]:
+    """(user_id, topos_id, source_id) for active installs under the canonical
+    {owner}:topos:{topos_id} dataset scope."""
+    index: Set[Tuple[str, str, str]] = set()
+    for rec in records:
+        scope = _normalize_scope(rec.scope)
+        if _dataset_scope_segment(scope) != _CANONICAL_DATASET_SEGMENT:
+            continue
+        if scope["user_id"] == "*" or scope["topos_id"] == "*":
+            continue
+        index.add((scope["user_id"], scope["topos_id"], rec.source_id))
+    return index
+
+
+def _has_bundled_replacement(source_id: str) -> bool:
+    """True when the engine ships a bundled definition for this source_id, so
+    retiring its runtime install row leaves the source available."""
+    from .registry import BUNDLED_REGISTRY
+
+    return str(source_id or "").strip() in BUNDLED_REGISTRY
+
+
+def _legacy_scope_superseded_reason(
+    rec: InstallRecord, canonical_active: Set[Tuple[str, str, str]]
+) -> Optional[str]:
+    """Reason to retire an active legacy {owner}:default:{key-hash} scope row, or None.
+
+    Readers query the canonical {owner}:topos:{topos_id} scope only, so a legacy
+    row duplicated there is dead weight — and poison for any reader that ever
+    matches the legacy scope, which would see a partial install list. Demote only
+    when an active canonical row proves the same install is live for the same
+    user+topos, under the same source_id or its declared successor.
+    """
+    scope = _normalize_scope(rec.scope)
+    if _dataset_scope_segment(scope) != _LEGACY_DATASET_SEGMENT:
+        return None
+    if scope["user_id"] == "*" or scope["topos_id"] == "*":
+        return None
+    candidates = [rec.source_id]
+    successor = _LEGACY_SOURCE_SUCCESSORS.get(rec.source_id)
+    if successor:
+        candidates.append(successor)
+    for sid in candidates:
+        if (scope["user_id"], scope["topos_id"], sid) in canonical_active:
+            return f"legacy dataset scope superseded by active canonical-scope install source_id={sid}"
+    return None
+
+
 def _supersede_install(*, scope_key: str, source_id: str, reason: str) -> None:
     """Retire an active install row that can never install again.
 
@@ -955,12 +1017,22 @@ def rehydrate_active_installs_runtime(*, source_id: Optional[str] = None) -> Dic
     """
     ensure_install_schema()
     records = [rec for rec in list_installs(source_id=source_id) if rec.is_active]
+    # Successor demotion (gdrive_files -> drive_files) must see peers that a
+    # 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)
     rehydrated = 0
     failed = 0
     # (scope_key, source_id, reason) for rows retired after the locked pass.
     superseded: List[Tuple[str, str, str]] = []
     with _LOCK:
         for rec in records:
+            # Before contract checks: a legacy-scope duplicate retires even if
+            # its stored definition is stale or incomplete.
+            legacy_reason = _legacy_scope_superseded_reason(rec, canonical_active)
+            if legacy_reason:
+                superseded.append((_scope_key(rec.scope), rec.source_id, legacy_reason))
+                continue
             source_def = rec.source_definition_json if isinstance(rec.source_definition_json, dict) else {}
             if not source_def:
                 continue
@@ -974,9 +1046,13 @@ def rehydrate_active_installs_runtime(*, source_id: Optional[str] = None) -> Dic
             # A runtime install predating the bundled source keeps a lane the
             # bundled triple contradicts. Retrying it warns on every sources
             # list; the bundled definition wins, so retire the row instead.
+            # A drift-variant schema (BUNDLED_SCHEMA_ALIASES) retires the same
+            # way only when the engine bundles a replacement for the source_id;
+            # otherwise retiring would orphan a live connector.
             conflict = bundled_lane_conflict(source_def)
-            if conflict:
-                superseded.append((_scope_key(rec.scope), rec.source_id, conflict))
+            drift = None if conflict else bundled_schema_drift(source_def)
+            if conflict or (drift and _has_bundled_replacement(rec.source_id)):
+                superseded.append((_scope_key(rec.scope), rec.source_id, conflict or drift))
                 continue
             try:
                 scope_key = _scope_key(rec.scope)
@@ -992,6 +1068,12 @@ def rehydrate_active_installs_runtime(*, source_id: Optional[str] = None) -> Dic
                 runtime_missing = runtime_key not in _ACTIVE_HANDLES or any(parser_id not in PARSER_REGISTRY for parser_id in parser_ids)
                 if not runtime_missing:
                     continue
+                if drift:
+                    logger.warning(
+                        "Tolerating bundled-schema drift on active install (no bundled replacement): source_id=%s %s",
+                        rec.source_id,
+                        drift,
+                    )
                 _ACTIVE_HANDLES[runtime_key] = install_source_definition(source_def)
                 rehydrated += 1
             except Exception as exc:  # noqa: BLE001

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

@@ -757,6 +757,12 @@
       "steps": [],
       "notes": []
     },
+    {
+      "version": "1.3.42",
+      "summary": "Release 1.3.42.",
+      "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.41 → topos_node-1.3.42/topos_node.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.3.41
+Version: 1.3.42
 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