topos-node 1.2.0__tar.gz → 1.2.1__tar.gz

{topos_node-1.2.0/topos_node.egg-info → topos_node-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.2.0
+Version: 1.2.1
 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.2.0 → topos_node-1.2.1}/pyproject.toml

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

{topos_node-1.2.0 → topos_node-1.2.1}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.2.0"
-__version_info__ = (1, 2, 0)
+__version__ = "1.2.1"
+__version_info__ = (1, 2, 1)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-1.2.0 → topos_node-1.2.1}/topos/api/enrichment.py

@@ -672,7 +672,7 @@ def _load_canonical_messages_for_enrichment(
             if title:
                 rec["content"] = str(title)
         if not rec.get("event_at"):
-            for key in ("occurred_at", "entry_at", "starts_at", "posted_at", "visited_at"):
+            for key in ("occurred_at", "starts_at", "entry_at", "posted_at", "visited_at"):
                 if rec.get(key):
                     rec["event_at"] = rec[key]
                     break
@@ -1056,6 +1056,15 @@ async def _process_enrichment_core(
         progress_callback=progress_callback,
     )
 
+    # Canonical jobs changed the derived layers even when the signal lane is
+    # skipped below — mark the graph for a debounced rebuild either way.
+    try:
+        from ..features.entities.graph_refresh import mark_graph_dirty
+
+        mark_graph_dirty()
+    except Exception:  # noqa: BLE001 — refresh must never break enrichment
+        pass
+
     # Manual processing is the deliberate counterpart of the automatic ingest
     # path, so it must also run the signal-derivation lane (embeddings,
     # clusters, facts, ...) that the ingest path skips for manual sources.

{topos_node-1.2.0 → topos_node-1.2.1}/topos/api/signal.py

@@ -388,6 +388,29 @@ async def dismiss_entity_review(review_id: str, _api_key: str = Depends(require_
         raise HTTPException(status_code=400, detail=str(exc))
 
 
+class EntitySplitBody(BaseModel):
+    surface: str = Field(..., min_length=1, max_length=200)
+
+
+@router.post("/entities/{entity_id}/split")
+async def split_entity_surface(
+    entity_id: str,
+    body: EntitySplitBody,
+    _api_key: str = Depends(require_api_key),
+):
+    """Owner unbind: split a surface's mentions out of this entity into a
+    fresh one, with a permanent no-bind guard so the resolver never re-merges
+    the pair (accidental-merge reversal; see consolidation.split_surface)."""
+    from ..features.entities.consolidation import split_surface
+
+    try:
+        return split_surface(_entities_conn(), entity_id, body.surface)
+    except LookupError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
 @router.post("/entities/{entity_id}/exclude")
 async def exclude_entity_from_intelligence(
     entity_id: str,

topos_node-1.2.1/topos/api/upgrades.py

@@ -0,0 +1,30 @@
+"""Upgrade status surface: what the runner + graph refresher are doing.
+
+Read-only. The UI shows "Upgrading your intelligence…" instead of a
+mysteriously thin graph while re-derivation runs.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from fastapi import APIRouter, Depends
+
+from ..auth import require_api_key
+
+router = APIRouter()
+
+
+def _status_payload() -> Dict[str, Any]:
+    from ..core.state import get_db_connection
+    from ..features.entities.graph_refresh import status as refresh_status
+    from ..upgrades.runner import runner_status
+
+    conn = get_db_connection()
+    upgrade = runner_status(conn) if conn is not None else {"enabled": False, "error": "no database"}
+    return {"upgrade": upgrade, "graph_refresh": refresh_status()}
+
+
+@router.get("/v1/upgrade/status", dependencies=[Depends(require_api_key)])
+async def get_upgrade_status() -> Dict[str, Any]:
+    return _status_payload()

{topos_node-1.2.0 → topos_node-1.2.1}/topos/app.py

@@ -45,6 +45,7 @@ from .api import (
     home_chat as home_chat_routes,
     privacy_disclose as privacy_disclose_routes,
     signal as signal_routes,
+    upgrades as upgrades_routes,
 )
 from .config.settings import settings
 from .core.logging import align_uvicorn_loggers, configure_logging
@@ -93,6 +94,7 @@ app.add_middleware(
 )
 
 app.include_router(health_routes.router)
+app.include_router(upgrades_routes.router)
 app.include_router(local_mcp_routes.router)
 app.include_router(llm_routes.router)
 app.include_router(db_routes.router)
@@ -157,6 +159,19 @@ async def startup_event() -> None:
                 logger.info("Stage 9 migrations applied at startup: %d renames", len(result["applied"]))
     except Exception as e:
         logger.debug("Stage 9 migrations at startup (non-fatal): %s", e)
+    # Upgrade runner: compare the stamped derivation baseline against the
+    # shipped version and re-derive what this release invalidated (manifest in
+    # topos/upgrades). Heavy steps run in a daemon thread; the node serves
+    # stale derived data meanwhile. Fresh installs stamp-and-skip.
+    try:
+        from .core.state import get_db_connection as _get_conn_for_upgrades
+        from .upgrades.runner import start_background as _start_upgrades
+
+        _upgrade_conn = state.db_conn if state.db_conn is not None else _get_conn_for_upgrades()
+        if _upgrade_conn is not None:
+            _start_upgrades(_upgrade_conn)
+    except Exception as e:
+        logger.warning("Upgrade runner at startup failed (non-fatal): %s", e)
     try:
         from .sources import install_service
 

{topos_node-1.2.0 → topos_node-1.2.1}/topos/control_plane_client.py

@@ -141,7 +141,8 @@ class ControlPlaneClient:
         try:
             await asyncio.wait_for(self._ready.wait(), timeout=max(0.1, timeout))
             return True
-        except TimeoutError:
+        except (TimeoutError, asyncio.TimeoutError):
+            # Py3.10: asyncio.TimeoutError is not builtins.TimeoutError.
             return False
 
     async def stop(self) -> None:
@@ -253,7 +254,10 @@ class ControlPlaneClient:
     async def _wait_for_stop_or_timeout(self, timeout_s: float) -> None:
         try:
             await asyncio.wait_for(self._stop.wait(), timeout=timeout_s)
-        except TimeoutError:
+        except (TimeoutError, asyncio.TimeoutError):
+            # Expected path: backoff elapsed. Must not escape — on Py3.10
+            # asyncio.TimeoutError is distinct from builtins.TimeoutError and
+            # would otherwise kill the reconnect loop task.
             return
 
     async def _schedule_inbound_message(self, ws, data: Dict[str, Any]) -> None:

{topos_node-1.2.0 → topos_node-1.2.1}/topos/core/handlers/config.py

@@ -349,6 +349,20 @@ async def handle_delete_signal_extraction_config(message: Dict[str, Any]) -> Opt
 # ---- Exposure-profile visibility (P1.5): the owner's toggle for whether the
 # labeled "what you've been exposed to" profile surfaces on interest/identity
 # answers. Default ON; the engine read path is config.settings.exposure_profile_visible.
+@handles("get_upgrade_status")
+async def handle_get_upgrade_status(message):
+    """Upgrade runner + graph-refresh status (read-only; UI progress banner)."""
+    req_id = message.get("id")
+    if not req_id:
+        return None
+    try:
+        from ...api.upgrades import _status_payload
+
+        return {"id": req_id, "status": "ok", "payload": _status_payload()}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}
+
+
 @handles("get_exposure_profile_config")
 async def handle_get_exposure_profile_config(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     req_id = message.get("id")

{topos_node-1.2.0 → topos_node-1.2.1}/topos/core/handlers/signal_features.py

@@ -651,6 +651,29 @@ async def handle_signal_entity_review_action(message: Dict[str, Any]) -> Optiona
         return {"id": req_id, "status": "error", "error": str(exc)}
 
 
+@handles("signal_entity_split")
+async def handle_signal_entity_split(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    req_id = message.get("id")
+    if not req_id:
+        return None
+    payload = message.get("payload") or {}
+    entity_id = str(payload.get("entity_id") or "").strip()
+    surface = str(payload.get("surface") or "").strip()
+    if not entity_id or not surface:
+        return {"id": req_id, "status": "error", "error": "entity_id and surface required", "code": 400}
+    try:
+        from ...features.entities.consolidation import split_surface
+
+        conn = hub.get_db_connection()
+        return {"id": req_id, "status": "ok", "payload": split_surface(conn, entity_id, surface)}
+    except LookupError as exc:
+        return {"id": req_id, "status": "error", "error": str(exc), "code": 404}
+    except ValueError as exc:
+        return {"id": req_id, "status": "error", "error": str(exc), "code": 400}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}
+
+
 @handles("signal_exclude_entity")
 async def handle_signal_exclude_entity(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     req_id = message.get("id")

{topos_node-1.2.0 → topos_node-1.2.1}/topos/features/entities/consolidation.py

@@ -18,6 +18,7 @@ Dismissed pairs are never re-proposed.
 
 from __future__ import annotations
 
+import json
 import logging
 import sqlite3
 import uuid
@@ -386,3 +387,100 @@ def resolve_review(
     conn.commit()
     refresh_dossiers(conn)
     return {"review_id": review_id, "status": "approved", "kept": str(candidate_id), "absorbed": str(subject_id)}
+
+
+def split_surface(conn: sqlite3.Connection, entity_id: str, surface: str) -> Dict[str, Any]:
+    """Owner unbind: split a surface's mentions OUT of an entity, permanently.
+
+    The reverse of an accidental merge/bind (e.g. the resolver's unique-contact
+    tier binding "Claire" to the contact "Claire Duncombe"):
+
+      * mentions whose surface_text normalizes to ``surface`` move to a fresh
+        entity named after the surface (created only when mentions exist);
+      * a matching alias is removed from the source entity;
+      * a permanent ``no_bind`` guard row is written — the resolver consults it
+        so this surface can never resolve back to the source entity (token-
+        subset names score 1.0, so every tier would otherwise re-merge them);
+      * both mention counts recount. Edges/dossiers correct on the next graph
+        rebuild.
+    """
+    from .resolver import EntityResolver, normalize_name
+
+    row = conn.execute(
+        "SELECT canonical_name, normalized_name, entity_type, aliases_json "
+        "FROM entities WHERE entity_id=?",
+        (str(entity_id),),
+    ).fetchone()
+    if row is None:
+        raise LookupError(f"entity not found: {entity_id}")
+    canonical_name, normalized_name, entity_type, aliases_json = row
+
+    normalized = normalize_name(surface)
+    if not normalized:
+        raise ValueError(f"unresolvable surface: {surface!r}")
+    if normalized == str(normalized_name):
+        raise ValueError(
+            "surface is the entity's own name — use exclude to stop tracking it entirely"
+        )
+
+    # Move matching mentions to a fresh entity.
+    mention_rows = conn.execute(
+        "SELECT mention_id, surface_text FROM entity_mentions WHERE entity_id=?",
+        (str(entity_id),),
+    ).fetchall()
+    moved_ids = [
+        str(mid) for mid, stext in mention_rows if normalize_name(str(stext or "")) == normalized
+    ]
+
+    new_entity_id: Optional[str] = None
+    if moved_ids:
+        resolver = EntityResolver(conn)
+        new_entity_id = resolver._create_entity(str(surface).strip(), str(entity_type))
+        placeholders = ",".join("?" for _ in moved_ids)
+        conn.execute(
+            f"UPDATE entity_mentions SET entity_id=? WHERE mention_id IN ({placeholders})",
+            (new_entity_id, *moved_ids),
+        )
+
+    # Remove a matching alias from the source entity.
+    alias_removed = False
+    try:
+        aliases = [a for a in (json.loads(aliases_json or "[]")) if isinstance(a, str)]
+    except json.JSONDecodeError:
+        aliases = []
+    kept_aliases = [a for a in aliases if normalize_name(a) != normalized]
+    if len(kept_aliases) != len(aliases):
+        alias_removed = True
+        conn.execute(
+            "UPDATE entities SET aliases_json=?, updated_at=datetime('now') WHERE entity_id=?",
+            (json.dumps(kept_aliases), str(entity_id)),
+        )
+
+    # Permanent guard: this surface never binds to the source entity again.
+    conn.execute(
+        """
+        INSERT INTO entity_review
+            (review_id, surface_text, candidate_entity_id, score, record_id,
+             status, created_at, kind, subject_entity_id, reason)
+        VALUES (?, ?, ?, 1.0, NULL, 'approved', datetime('now'), 'no_bind', ?, 'owner split')
+        """,
+        (f"rev_{uuid.uuid4().hex[:16]}", normalized, str(entity_id), new_entity_id),
+    )
+
+    # Recount both sides.
+    for eid in filter(None, [str(entity_id), new_entity_id]):
+        conn.execute(
+            "UPDATE entities SET mention_count = ("
+            " SELECT COUNT(*) FROM entity_mentions m WHERE m.entity_id = entities.entity_id"
+            "), updated_at=datetime('now') WHERE entity_id=?",
+            (eid,),
+        )
+    conn.commit()
+
+    return {
+        "entity_id": str(entity_id),
+        "surface": str(surface).strip(),
+        "new_entity_id": new_entity_id,
+        "mentions_moved": len(moved_ids),
+        "alias_removed": alias_removed,
+    }

{topos_node-1.2.0 → topos_node-1.2.1}/topos/features/entities/fact_materializer.py

@@ -100,11 +100,14 @@ def _upsert_materialized_edge(
     source_object_id: str,
     asserted_by: Optional[str] = None,
     actor_role: Optional[str] = None,
+    last_event_at: Optional[str] = None,
 ) -> None:
     """Idempotent directed edge with a materialized marker + carried validity.
 
     ``actor_role`` overrides the asserted_by-derived tier — used by enrichers
     whose provenance isn't an assertion (presence, participation, witnessing).
+    ``last_event_at`` defaults to valid_from — pass explicitly when the edge's
+    evidence spans a window (e.g. a goal recurring across months).
     """
     if not src or not dst or src == dst:
         return
@@ -126,6 +129,7 @@ def _upsert_materialized_edge(
         """,
         (src, dst, edge_type),
     ).fetchone()
+    effective_last = last_event_at or valid_from
     if row is None:
         conn.execute(
             """
@@ -137,17 +141,18 @@ def _upsert_materialized_edge(
             (
                 f"fmz_{uuid.uuid4().hex[:16]}",
                 src, dst, edge_type, float(weight),
-                valid_from, valid_from or _now_iso(), valid_to, meta,
+                effective_last, valid_from or _now_iso(), valid_to, meta,
             ),
         )
     else:
         conn.execute(
             """
             UPDATE entity_edges
-            SET weight=?, valid_from=?, valid_to=?, metadata_json=?, updated_at=datetime('now')
+            SET weight=?, valid_from=?, valid_to=?, last_event_at=?, metadata_json=?,
+                updated_at=datetime('now')
             WHERE edge_id=?
             """,
-            (float(weight), valid_from, valid_to, meta, row[0]),
+            (float(weight), valid_from, valid_to, effective_last, meta, row[0]),
         )