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

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

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

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

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

{topos_node-1.2.0 → topos_node-1.2.2}/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.2}/topos/api/signal.py

@@ -388,6 +388,51 @@ 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))
+
+
+class EntityMergeBody(BaseModel):
+    absorb_entity_id: str = Field(..., min_length=1, max_length=80)
+
+
+@router.post("/entities/{entity_id}/merge")
+async def merge_entity_into(
+    entity_id: str,
+    body: EntityMergeBody,
+    _api_key: str = Depends(require_api_key),
+):
+    """Owner link: merge another entity into this one (drawer-driven inverse
+    of split; see consolidation.merge_entity_pair)."""
+    from ..features.entities.consolidation import merge_entity_pair
+
+    try:
+        return merge_entity_pair(_entities_conn(), entity_id, body.absorb_entity_id)
+    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.0 → topos_node-1.2.2}/topos/api/ui_config.py

@@ -24,8 +24,11 @@ ALLOWED_WIDGETS = {
 MAX_PINNED = 3
 
 
+GRAPH_WINDOW_MAX_DAYS = 3650
+
+
 def _default_ui_config() -> dict[str, Any]:
-    return {"version": 1, "topbar": {"pinnedAnalytics": []}}
+    return {"version": 1, "topbar": {"pinnedAnalytics": []}, "graph": {}}
 
 
 def _normalize_ui_config(value: Any) -> dict[str, Any]:
@@ -35,7 +38,24 @@ def _normalize_ui_config(value: Any) -> dict[str, Any]:
     out = {
         "version": int(value.get("version", 1)) if str(value.get("version", "")).isdigit() else 1,
         "topbar": {"pinnedAnalytics": []},
+        "graph": {},
     }
+    # Graph view prefs: the temporal window is personal (data volume/velocity
+    # dependent — 2 days for some owners, 2 months for others). timeWindowDays
+    # is a whole-day count; explicit null = all time; absent = unset.
+    graph = value.get("graph")
+    if isinstance(graph, dict) and "timeWindowDays" in graph:
+        window = graph.get("timeWindowDays")
+        if window is None:
+            out["graph"]["timeWindowDays"] = None
+        elif isinstance(window, (int, float)) and not isinstance(window, bool):
+            days = int(window)
+            if 1 <= days <= GRAPH_WINDOW_MAX_DAYS:
+                out["graph"]["timeWindowDays"] = days
+    if isinstance(graph, dict):
+        mode = graph.get("nodeColorMode")
+        if mode in ("type", "community"):
+            out["graph"]["nodeColorMode"] = mode
     topbar = value.get("topbar")
     pinned = topbar.get("pinnedAnalytics") if isinstance(topbar, dict) else []
     if not isinstance(pinned, list):

topos_node-1.2.2/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.2}/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.2}/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.2}/topos/core/handlers/config.py

@@ -21,45 +21,15 @@ from .registry import handles
 
 UI_CONFIG_KEY = "ui_config"
 
-ALLOWED_PINNED_WIDGETS = {
-    "umaAllTime",
-    "uma24h",
-    "mcpRows",
-    "mcp24h",
-    "topConnector",
-    "umaStatusMix",
-    "topConnectors",
-    "mcpSources",
-}
-
-MAX_PINNED_WIDGETS = 3
-
-def _default_ui_config() -> Dict[str, Any]:
-    return {"version": 1, "topbar": {"pinnedAnalytics": []}}
-
-def _normalize_ui_config(value: Any) -> Dict[str, Any]:
-    if not isinstance(value, dict):
-        return _default_ui_config()
-    out: Dict[str, Any] = {
-        "version": int(value.get("version", 1)) if str(value.get("version", "")).isdigit() else 1,
-        "topbar": {"pinnedAnalytics": []},
-    }
-    topbar = value.get("topbar")
-    pinned = topbar.get("pinnedAnalytics") if isinstance(topbar, dict) else []
-    if not isinstance(pinned, list):
-        return out
-    seen: set[str] = set()
-    final: List[str] = []
-    for item in pinned:
-        wid = str(item or "").strip()
-        if not wid or wid in seen or wid not in ALLOWED_PINNED_WIDGETS:
-            continue
-        seen.add(wid)
-        final.append(wid)
-        if len(final) >= MAX_PINNED_WIDGETS:
-            break
-    out["topbar"]["pinnedAnalytics"] = final
-    return out
+# SINGLE SOURCE: this module used to keep its own copy of the ui-config
+# normalizer, which silently drifted — the HTTP endpoint accepted new fields
+# (graph.timeWindowDays) that this WS path (the CP proxy route) stripped.
+from ...api.ui_config import (  # noqa: E402
+    ALLOWED_WIDGETS as ALLOWED_PINNED_WIDGETS,
+    MAX_PINNED as MAX_PINNED_WIDGETS,
+    _default_ui_config,
+    _normalize_ui_config,
+)
 
 @handles("migrate_browser_plugin_app_id")
 async def handle_migrate_browser_plugin_app_id(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
@@ -349,6 +319,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.2}/topos/core/handlers/signal_features.py

@@ -651,6 +651,61 @@ 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_entity_merge")
+async def handle_signal_entity_merge(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()
+    absorb_entity_id = str(payload.get("absorb_entity_id") or "").strip()
+    if not entity_id or not absorb_entity_id:
+        return {
+            "id": req_id,
+            "status": "error",
+            "error": "entity_id and absorb_entity_id required",
+            "code": 400,
+        }
+    try:
+        from ...features.entities.consolidation import merge_entity_pair
+
+        conn = hub.get_db_connection()
+        return {
+            "id": req_id,
+            "status": "ok",
+            "payload": merge_entity_pair(conn, entity_id, absorb_entity_id),
+        }
+    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.2}/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,187 @@ 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,
+    }
+
+
+def merge_entity_pair(
+    conn: sqlite3.Connection, keep_id: str, absorb_id: str
+) -> Dict[str, Any]:
+    """Owner link: merge absorb_id into keep_id (drawer-driven inverse of split).
+
+    Reuses EntityResolver.merge_entities for mentions/aliases/edges, then clears
+    any no_bind guards between the pair so an explicit re-link after Unlink
+    works. Pending reviews that touched the absorbed entity are marked stale.
+    """
+    from .dossier import refresh_dossiers
+    from .resolver import EntityResolver
+
+    keep_id = str(keep_id).strip()
+    absorb_id = str(absorb_id).strip()
+    if not keep_id or not absorb_id:
+        raise ValueError("keep_id and absorb_id are required")
+    if keep_id == absorb_id:
+        raise ValueError("cannot merge an entity into itself")
+
+    keep_row = conn.execute(
+        "SELECT entity_type, canonical_name FROM entities WHERE entity_id=?",
+        (keep_id,),
+    ).fetchone()
+    absorb_row = conn.execute(
+        "SELECT entity_type, canonical_name FROM entities WHERE entity_id=?",
+        (absorb_id,),
+    ).fetchone()
+    if keep_row is None:
+        raise LookupError(f"entity not found: {keep_id}")
+    if absorb_row is None:
+        raise LookupError(f"entity not found: {absorb_id}")
+    if str(keep_row[0]) != str(absorb_row[0]):
+        raise ValueError(
+            f"entity types must match (keep={keep_row[0]!r}, absorb={absorb_row[0]!r})"
+        )
+
+    mentions_moved = int(
+        conn.execute(
+            "SELECT COUNT(*) FROM entity_mentions WHERE entity_id=?",
+            (absorb_id,),
+        ).fetchone()[0]
+    )
+    absorb_name = str(absorb_row[1] or "")
+
+    # Clear no_bind guards between this pair (either direction) so the owner
+    # can reverse a prior Unlink by explicitly linking again.
+    conn.execute(
+        """
+        DELETE FROM entity_review
+        WHERE kind='no_bind'
+          AND (
+            (candidate_entity_id=? AND subject_entity_id=?)
+            OR (candidate_entity_id=? AND subject_entity_id=?)
+          )
+        """,
+        (keep_id, absorb_id, absorb_id, keep_id),
+    )
+    # Pending reviews that referenced the absorbed entity are now stale.
+    conn.execute(
+        """
+        UPDATE entity_review SET status='stale'
+        WHERE status='pending'
+          AND (subject_entity_id=? OR candidate_entity_id=?)
+        """,
+        (absorb_id, absorb_id),
+    )
+
+    resolver = EntityResolver(conn)
+    resolver.merge_entities(keep_id, absorb_id)
+
+    # Also drop any leftover no_bind rows that still point at the deleted
+    # absorb id as the blocked candidate (surface → absorb).
+    conn.execute(
+        "DELETE FROM entity_review WHERE kind='no_bind' AND candidate_entity_id=?",
+        (absorb_id,),
+    )
+    conn.commit()
+    refresh_dossiers(conn)
+
+    return {
+        "kept": keep_id,
+        "absorbed": absorb_id,
+        "absorbed_name": absorb_name,
+        "mentions_moved": mentions_moved,
+    }

{topos_node-1.2.0 → topos_node-1.2.2}/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]),
         )