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

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

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

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

{topos_node-1.3.40 → topos_node-1.3.41}/topos/__version__.py

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

{topos_node-1.3.40 → topos_node-1.3.41}/topos/core/handlers/graph_summary.py

@@ -44,8 +44,12 @@ def _counts() -> Dict[str, Any]:
         except Exception:  # noqa: BLE001
             out[key] = None
     try:
+        # The column is `last_run_at` -- what _mark_materialized writes. This read
+        # `materialized_at`, which does not exist, and the per-field try/except
+        # turned that into a permanent null rather than an error: shipped in
+        # 1.3.40 and noticed only because the live reply carried the null.
         row = conn.execute(
-            "SELECT MAX(materialized_at) FROM graph_materialization_state"
+            "SELECT MAX(last_run_at) FROM graph_materialization_state"
         ).fetchone()
         out["materialized_at"] = row[0] if row else None
     except Exception:  # noqa: BLE001

{topos_node-1.3.40 → topos_node-1.3.41}/topos/features/complexity/projection.py

@@ -401,7 +401,15 @@ class EvidenceCache:
             for row in conn.execute(
                 f"""
                 SELECT src_entity_id, dst_entity_id, edge_type, weight, evidence_count,
-                       COALESCE(last_event_at, valid_from, created_at) AS event_at
+                       -- last_event_at ONLY. valid_from is when the node started
+                       -- believing the relation (a recompute's clock for part_of
+                       -- and other structural edges) and created_at is the row's
+                       -- own birth; neither is an event. The fallback made an
+                       -- undated edge report activity at rebuild time, which is
+                       -- the defect fixed for the graph window in edges.py.
+                       -- EvidenceCache.add tolerates None: weight still counts,
+                       -- no date is invented.
+                       last_event_at AS event_at
                 FROM entity_edges
                 WHERE valid_to IS NULL
                   AND LOWER(TRIM(edge_type)) IN ({placeholders})

{topos_node-1.3.40 → topos_node-1.3.41}/topos/features/entities/edges.py

@@ -562,11 +562,21 @@ def graph_snapshot(
         clause = ""
     else:
         clause = " AND valid_to IS NULL"
+    # A TIME window asks "did anything happen between these dates". Only
+    # last_event_at answers that. valid_from is when the node started BELIEVING
+    # the relation -- for a structural edge written by a recompute (semantic
+    # affinity, part_of) that is the recompute's clock, and it carries no event
+    # at all. The old COALESCE fallback read that clock as activity, so every
+    # entity touched by a rebuild appeared in "the last 11 days" no matter when
+    # it was last mentioned: 69 of 4,602 dormant entities on the reference node,
+    # 60 of them through exactly these undated edges. An undated edge is no
+    # evidence of activity in any window; it stays in the unwindowed views,
+    # where valid_from remains the right recency key for ORDER BY.
     if after:
-        clause += " AND COALESCE(last_event_at, valid_from) >= ?"
+        clause += " AND last_event_at IS NOT NULL AND last_event_at >= ?"
         where_params.append(after)
     if before:
-        clause += " AND COALESCE(last_event_at, valid_from) <= ?"
+        clause += " AND last_event_at IS NOT NULL AND last_event_at <= ?"
         where_params.append(before)
 
     where_sql = (

{topos_node-1.3.40 → topos_node-1.3.41}/topos/features/entities/graph_refresh.py

@@ -28,6 +28,7 @@ import asyncio
 import logging
 import os
 import threading
+from typing import Any, Dict
 from datetime import datetime, timezone
 from typing import Any, Callable, Dict, Optional
 
@@ -253,6 +254,60 @@ def gc_status() -> Dict[str, Any]:
         return {"enabled": _gc_enabled(), "pending": _GC_TIMER is not None, **_GC_LAST}
 
 
+def refresh_now_if_dirty() -> Dict[str, Any]:
+    """Rebuild the graph inline, right now, if it is dirty and nothing is deriving.
+
+    Written for one caller: the post-canonical pipeline, at the point between
+    canonical enrichment and signal derivation. The debounced mark cannot do
+    this job there -- its timer fires ~90s later, by which time signal
+    derivation has raised the in-flight counter and _fire re-arms the timer
+    instead of rebuilding (DEBUG-logged). It keeps re-arming until derivation
+    ends, so the mid-import refresh collapses into the end-of-pipeline one. On
+    a file import that phase runs for hours, so "the graph fills before the
+    long phase" never happened. Measured on a 20-stage import: zero mid-import
+    rebuilds.
+
+    Costs a rebuild (~7-9 minutes on a 17k-edge node) inside the import, which
+    is the point. Skipped when the graph is not dirty, so a re-import that
+    changed nothing pays nothing.
+    """
+    from ...core.state import get_db_connection
+    from ...enrichment.pipeline_activity import is_derivation_in_flight
+
+    if not _enabled():
+        return {"skipped": "disabled"}
+    if is_derivation_in_flight():
+        return {"skipped": "derivation in flight"}
+    conn = get_db_connection()
+    if conn is None:
+        return {"skipped": "no database"}
+    try:
+        row = conn.execute(
+            "SELECT dirty_generation, materialized_generation FROM graph_materialization_state WHERE id=1"
+        ).fetchone()
+    except Exception as exc:  # noqa: BLE001
+        return {"skipped": f"state unreadable: {exc}"}
+    if not row or int(row[0]) <= int(row[1]):
+        return {"skipped": "not dirty"}
+    logger.info("graph refresh: inline, before signal derivation")
+    try:
+        _refresher._rebuild_fn()
+        return {"ran": True}
+    except WriteGateDeferred as exc:
+        _refresher.mark()
+        return {"skipped": f"deferred: {exc}"}
+    finally:
+        # This runs on an asyncio.to_thread worker. Pooled threads are reused;
+        # the rebuild route closes its thread-local connection for the same
+        # reason, or every call leaks one.
+        try:
+            from ...core.state import close_thread_db_connection
+
+            close_thread_db_connection()
+        except Exception:  # noqa: BLE001 — cleanup must not mask the result
+            pass
+
+
 def mark_graph_dirty() -> None:
     """Enrichment completed for a source — schedule a debounced graph rebuild."""
     try:

{topos_node-1.3.40 → topos_node-1.3.41}/topos/ingestion/canonical_pipeline.py

@@ -893,30 +893,6 @@ async def run_post_canonical_pipeline(
             logger.error("[PIPELINE:ENRICHMENT] post-canonical failed: %s", exc, exc_info=True)
             outcome["canonical_enrichment"] = {"errors": [str(exc)]}
 
-        # Materialise the graph HERE, not only at the end of the pipeline.
-        #
-        # The entity data lands early -- the entities job writes entities,
-        # message_entities and entity_mentions batch by batch -- but the graph
-        # a person actually looks at is derived by rebuild_entity_graph, and
-        # the only mark was after signal derivation. On a file import that is
-        # 13 more stages and hours of model work, so everything landed in the
-        # database with no visible change to the graph until the very end.
-        #
-        # One mark here, one at the end: two rebuilds per import. Deliberately
-        # NOT one per job. graph_refresh is single-flight and a mark landing
-        # mid-rebuild schedules exactly one follow-up, so marking per job would
-        # chain rebuilds back to back for the whole import and take CPU from
-        # the model work that is already the slow part.
-        try:
-            from ..features.entities.graph_refresh import mark_graph_dirty
-
-            mark_graph_dirty()
-            logger.info(
-                "[PIPELINE:ENRICHMENT] graph marked dirty after canonical enrichment "
-                "so the graph fills before signal derivation runs"
-            )
-        except Exception as exc:  # noqa: BLE001 — refresh must never break ingest
-            logger.debug("mid-import graph refresh mark skipped: %s", exc)
     elif canonical_jobs and enrichment_trigger == "manual":
         logger.debug(
             "[PIPELINE:ENRICHMENT] Skipping canonical enrichment (manual trigger): source_id=%s records=%d",
@@ -930,6 +906,32 @@ async def run_post_canonical_pipeline(
     signal_gate_open = (
         enrichment_trigger == "automatic" or force_signal or job_names is not None
     )
+    # Fill the graph HERE, before the long phase -- and actually do it.
+    #
+    # The entity data lands early; the graph a person looks at is derived by
+    # rebuild_entity_graph. The first version of this marked the graph dirty
+    # after canonical enrichment and left the rebuild to the debounced
+    # refresher. Two things defeated it, both measured on a live 20-stage
+    # import: the mark sat inside the enrichment guard, so an import with
+    # nothing left to enrich never marked at all; and the refresher's timer
+    # fires ~90s later, by which time signal derivation has raised its
+    # in-flight counter and the refresh re-arms itself until derivation ends
+    # -- collapsing into the end-of-pipeline rebuild. Zero mid-import
+    # rebuilds, every time.
+    #
+    # So: mark, then rebuild inline while nothing is deriving. ~7-9 minutes on
+    # a 17k-edge node, inside the import, which is the point. Skipped when the
+    # graph is not dirty, so a re-import that changed nothing pays nothing.
+    if canonical_records:
+        try:
+            from ..features.entities.graph_refresh import mark_graph_dirty, refresh_now_if_dirty
+
+            mark_graph_dirty()
+            outcome["graph_fill"] = await asyncio.to_thread(refresh_now_if_dirty)
+            logger.info("[PIPELINE:GRAPH] mid-import graph fill: %s", outcome["graph_fill"])
+        except Exception as exc:  # noqa: BLE001 -- the graph must never break ingest
+            logger.warning("mid-import graph fill skipped: %s", exc)
+
     if run_signal and signal_jobs and not signal_gate_open:
         logger.debug(
             "[PIPELINE:SIGNAL_DERIVE] Skipping signal derivation (manual trigger): source_id=%s records=%d",

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

@@ -751,6 +751,12 @@
         "Retrieval, progress reporting, the sharded export reader and the graph-timing change are code-only and apply on restart; none rewrites stored rows."
       ]
     },
+    {
+      "version": "1.3.41",
+      "summary": "Release 1.3.41.",
+      "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.40 → topos_node-1.3.41/topos_node.egg-info}/PKG-INFO

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