topos-node 1.3.7__tar.gz → 1.3.8__tar.gz

{topos_node-1.3.7/topos_node.egg-info → topos_node-1.3.8}/PKG-INFO

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

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

{topos_node-1.3.7 → topos_node-1.3.8}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.3.7"
-__version_info__ = (1, 3, 7)
+__version__ = "1.3.8"
+__version_info__ = (1, 3, 8)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-1.3.7 → topos_node-1.3.8}/topos/cli/tray.py

@@ -329,6 +329,8 @@ class ToposTray:
             items.append("Show Logs")
         if self.update.get("applying"):
             items.append("Installing update…")
+        elif self.update.get("last_result") == "failed":
+            items.append("Update failed — click to retry")
         elif self.update.get("last_result") == "success":
             items.append("Update installed — restart to finish")
         elif self.update.get("available"):
@@ -368,6 +370,10 @@ class ToposTray:
             items.append(pystray.MenuItem("Show Logs", self._show_logs))
         if self.update.get("applying"):
             items.append(pystray.MenuItem("Installing update…", None, enabled=False))
+        elif self.update.get("last_result") == "failed":
+            # Clickable: a failed update that renders nothing is
+            # indistinguishable from a click that never registered.
+            items.append(pystray.MenuItem("Update failed — click to retry", self._apply_update))
         elif self.update.get("last_result") == "success":
             items.append(pystray.MenuItem("Update installed — restart to finish", None, enabled=False))
         elif self.update.get("available"):

{topos_node-1.3.7 → topos_node-1.3.8}/topos/control_plane_client.py

@@ -29,6 +29,12 @@ logger = logging.getLogger("topos.control_plane_client")
 
 # Lightweight CP RPCs that must stay responsive while ingest/enrichment runs.
 # UI-critical reads and scheduler ops only — no ingest/enrichment writes.
+#: Keepalive. The control plane's own uvicorn pings at 30s with a 120s
+#: deadline; the node pings faster so IT notices a dead link first and
+#: reconnects, rather than waiting to be evicted.
+PING_INTERVAL_SECONDS = 20.0
+PING_TIMEOUT_SECONDS = 20.0
+
 _FAST_INBOUND_MESSAGE_TYPES = frozenset(
     {
         "healthcheck",
@@ -297,9 +303,20 @@ class ControlPlaneClient:
                     self.control_plane_url,
                     additional_headers=headers,
                     ssl=ssl_context,
-                    # Transform-heavy requests can block the event loop in the handler path long enough
-                    # to miss pong deadlines; disable pong timeout-driven disconnects.
-                    ping_timeout=None,
+                    # A real pong deadline, restored once the client got its own
+                    # thread and loop. It was disabled because handlers ran here
+                    # and could block long enough to miss pongs — that reason is
+                    # gone: handlers now marshal to the app loop, so this loop is
+                    # always free to answer and to notice silence.
+                    #
+                    # Disabling it turned every silent connection death into a
+                    # permanent wedge: `async for raw in ws` blocked forever, no
+                    # exception fired, no reconnect was scheduled, and the node
+                    # reported "connected" while the control plane had no socket
+                    # at all. Observed live 2026-08-08 — 25 minutes wedged, with
+                    # the web app correctly showing the Topos offline.
+                    ping_interval=PING_INTERVAL_SECONDS,
+                    ping_timeout=PING_TIMEOUT_SECONDS,
                 ) as ws:
                     self._ws = ws
                     self._set_state("connected")

{topos_node-1.3.7 → topos_node-1.3.8}/topos/core/handlers/ingest.py

@@ -215,20 +215,30 @@ async def handle_app_ingest(message: Dict[str, Any]) -> Optional[Dict[str, Any]]
                 len(errors),
                 errors[0].get("error"),
             )
-        db_conn = hub.get_db_connection()
-        if db_conn and user_id:
+        if user_id:
             resource_id = (payload.get("resource_id") or "").strip() or f"dataset:{user_id}:{dataset_id or 'default'}"
-            hub.record_uma_request(
-                db_conn,
-                owner_user_id=user_id,
-                resource_id=resource_id,
-                request_type="write",
-                endpoint="app_ingest",
-                requesting_user_id=(payload.get("requesting_user_id") or None),
-                app_id=payload.get("app_id"),
-                requesting_user_email=(payload.get("requesting_user_email") or "").strip() or None,
-                access_channel=(payload.get("access_channel") or "internal").strip() or "internal",
-            )
+
+            def _record_app_ingest_uma() -> None:
+                # record_uma_request takes the write gate (and on first use runs
+                # the uma_access_requests ensure/migrate DDL) — keep it off the
+                # event-loop thread. Own connection: get_db_connection is
+                # thread-local.
+                own = hub.get_db_connection()
+                if own is None:
+                    return
+                hub.record_uma_request(
+                    own,
+                    owner_user_id=user_id,
+                    resource_id=resource_id,
+                    request_type="write",
+                    endpoint="app_ingest",
+                    requesting_user_id=(payload.get("requesting_user_id") or None),
+                    app_id=payload.get("app_id"),
+                    requesting_user_email=(payload.get("requesting_user_email") or "").strip() or None,
+                    access_channel=(payload.get("access_channel") or "internal").strip() or "internal",
+                )
+
+            await asyncio.to_thread(_record_app_ingest_uma)
         response_payload = {
             "records_processed": processed,
             "records_total": records_total,

{topos_node-1.3.7 → topos_node-1.3.8}/topos/core/state.py

@@ -183,7 +183,9 @@ from ..storage.db.write_gate import (  # noqa: E402
     batched_writes,
     commit_connection,
     db_write_lock,
+    register_connection,
     sqlite_retry_busy,
+    unregister_connection,
     with_db_write,
 )
 
@@ -285,6 +287,7 @@ def _get_thread_db_connection(resolved_path: str) -> Optional[sqlite3.Connection
             _ensure_row_factory(cached)
             return cached
         except (sqlite3.ProgrammingError, sqlite3.OperationalError):
+            unregister_connection(cached)
             try:
                 cached.close()
             except Exception:  # noqa: BLE001
@@ -293,6 +296,7 @@ def _get_thread_db_connection(resolved_path: str) -> Optional[sqlite3.Connection
             _thread_state.path = None
     elif cached is not None:
         # Path changed under us (tests re-point DATABASE_PATH).
+        unregister_connection(cached)
         try:
             cached.close()
         except Exception:  # noqa: BLE001
@@ -314,6 +318,7 @@ def _get_thread_db_connection(resolved_path: str) -> Optional[sqlite3.Connection
     except Exception as exc:  # noqa: BLE001 — tuning is an optimization, not a gate
         logger.debug("Per-thread connection tuning skipped: %s", exc)
 
+    register_connection(conn)
     _thread_state.conn = conn
     _thread_state.path = resolved_path
     logger.debug(
@@ -329,6 +334,7 @@ def close_thread_db_connection() -> None:
     conn = getattr(_thread_state, "conn", None)
     if conn is None:
         return
+    unregister_connection(conn)
     try:
         conn.close()
     except Exception:  # noqa: BLE001
@@ -371,6 +377,7 @@ def _get_owner_db_connection() -> Optional[sqlite3.Connection]:
             try:
                 db_conn.execute("SELECT 1")
             except (sqlite3.ProgrammingError, sqlite3.OperationalError):
+                unregister_connection(db_conn)
                 db_conn = None
                 _db_conn_path = None
             else:
@@ -398,7 +405,10 @@ def _get_owner_db_connection() -> Optional[sqlite3.Connection]:
             # it across queries) — closing under them is the use-after-close
             # that SIGBUSed on 2026-08-08. Dropping the reference lets the last
             # user finish; the handle closes (rolling back any open
-            # transaction) when its refcount reaches zero.
+            # transaction) when its refcount reaches zero. The watchdog is told
+            # here for the same reason it holds no strong reference: it must
+            # not be what keeps this handle (or its stale record) around.
+            unregister_connection(db_conn)
             db_conn = None
             _db_conn_path = None
 
@@ -410,6 +420,7 @@ def _get_owner_db_connection() -> Optional[sqlite3.Connection]:
                     db_conn.row_factory = sqlite3.Row
                 return db_conn
             except (sqlite3.ProgrammingError, sqlite3.OperationalError):
+                unregister_connection(db_conn)
                 db_conn = None
                 _db_conn_path = None
 
@@ -425,11 +436,13 @@ def _get_owner_db_connection() -> Optional[sqlite3.Connection]:
             try:
                 db_conn.execute("SELECT 1")
             except Exception:
+                unregister_connection(db_conn)
                 try:
                     db_conn.close()
                 except Exception:  # noqa: BLE001
                     pass
             else:
+                unregister_connection(new_conn)
                 try:
                     new_conn.close()
                 except Exception:  # noqa: BLE001
@@ -467,6 +480,11 @@ def _open_owner_db_connection(db_path: Path) -> Optional[sqlite3.Connection]:
             )
         except Exception as tuning_exc:  # noqa: BLE001
             logger.warning("Connection tuning skipped: %s", tuning_exc)
+        # Registered before migrations run, not after: a migration that returns
+        # without committing wedges every writer behind it exactly like any
+        # other ungated write, and startup is when the database is least
+        # observable.
+        register_connection(conn)
         try:
             from ..storage.db.migrations import (
                 DowngradeGuardError,
@@ -478,6 +496,7 @@ def _open_owner_db_connection(db_path: Path) -> Optional[sqlite3.Connection]:
         except (MigrationError, DowngradeGuardError) as migration_exc:
             # Shape migrations must fail loud — serving a half-migrated DB corrupts data.
             logger.error("Schema migration failed; refusing to open database: %s", migration_exc)
+            unregister_connection(conn)
             try:
                 conn.close()
             except Exception:  # noqa: BLE001
@@ -490,6 +509,7 @@ def _open_owner_db_connection(db_path: Path) -> Optional[sqlite3.Connection]:
                 "Unexpected schema migration failure; refusing to open database: %s",
                 migration_exc,
             )
+            unregister_connection(conn)
             try:
                 conn.close()
             except Exception:  # noqa: BLE001
@@ -511,6 +531,7 @@ def _open_owner_db_connection(db_path: Path) -> Optional[sqlite3.Connection]:
             raise
         logger.warning("Failed to create database connection: %s", e)
         if conn is not None:
+            unregister_connection(conn)
             try:
                 conn.close()
             except Exception:  # noqa: BLE001

{topos_node-1.3.7 → topos_node-1.3.8}/topos/enrichment/jobs/canonical/attention_triage_job.py

@@ -7,6 +7,7 @@ unchanged, so re-running a day is safe and cheap.
 
 from __future__ import annotations
 
+import asyncio
 import logging
 from typing import Any, Callable, Dict, List, Optional
 
@@ -34,8 +35,7 @@ class AttentionTriageJob(BaseEnrichmentJob):
         canonical_messages: List[Dict[str, Any]],
         progress_callback: Optional[Callable[[int, int], None]] = None,
     ) -> List[Dict[str, Any]]:
-        conn = get_db_connection()
-        if conn is None:
+        if get_db_connection() is None:
             return [{"_deferred": True, "error": "database_unavailable"}]
         days = set()
         for row in canonical_messages:
@@ -46,17 +46,37 @@ class AttentionTriageJob(BaseEnrichmentJob):
                     break
         done = 0
         for day_iso in sorted(days):
+            # A day's re-triage holds the write gate — a blocking OS lock — for
+            # its verdict upserts and signal objects. Held on the event loop it
+            # stalls every coroutine, including the control-plane keepalive, so
+            # each day runs on a worker thread against that thread's own
+            # connection. One day per hop also keeps progress incremental.
+            def _triage(_day: str = day_iso) -> Optional[Dict[str, Any]]:
+                conn = get_db_connection()
+                if conn is None:
+                    return None
+                return run_daily_triage(conn, _day)
+
             try:
-                summary = run_daily_triage(conn, day_iso)
-                logger.info("attention_triage %s: %s", day_iso, summary.get("quadrants"))
+                summary = await asyncio.to_thread(_triage)
+                if summary is not None:
+                    logger.info("attention_triage %s: %s", day_iso, summary.get("quadrants"))
             except Exception:  # one bad day must not sink the batch
                 logger.exception("attention_triage failed for %s", day_iso)
             done += 1
             if progress_callback:
                 progress_callback(done, len(days))
-        try:
+
+        def _award() -> Optional[List[Any]]:
+            conn = get_db_connection()
+            if conn is None:
+                return None
             from ....features.triage.badges import award_badges
-            fresh = award_badges(conn)
+
+            return award_badges(conn)
+
+        try:
+            fresh = await asyncio.to_thread(_award)
             if fresh:
                 logger.info("badges awarded: %s", fresh)
         except Exception:

{topos_node-1.3.7 → topos_node-1.3.8}/topos/enrichment/jobs/canonical/dimension_summary_job.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import logging
 from typing import Any, Callable, Dict, List, Optional
 
@@ -120,26 +121,37 @@ class DimensionSummaryJob(BaseEnrichmentJob):
 
         structured_result: Dict[str, Any] = {}
         if structured_signal_enabled():
-            structured_result = enrich_structured_batch(
-                prepared,
-                source_id=str(source_id or "") or None,
-                only_dimension=only_dimension,
-            )
-            # Piggyback (badge-pass pattern): auto-tag new conversations as
-            # work/personal with the configured local model. Best-effort;
-            # owner-set tags are never touched.
-            try:
-                from ....features.signal.conversation_context import (
-                    classify_untagged_conversations,
-                )
 
-                structured_result["conversation_context"] = (
-                    classify_untagged_conversations(conn)
+            def _structured() -> Dict[str, Any]:
+                # Artifact routing, the gate aggregates and the scope
+                # materializer each take the write gate — a blocking OS lock
+                # that on the event loop stalls every coroutine, including the
+                # control-plane keepalive. enrich_structured_batch resolves its
+                # own connection, so on a worker thread it binds that thread's.
+                out = enrich_structured_batch(
+                    prepared,
+                    source_id=str(source_id or "") or None,
+                    only_dimension=only_dimension,
                 )
-            except Exception as exc:  # noqa: BLE001 — never blocks enrichment
-                logger.debug("conversation-context pass failed: %s", exc)
+                # Piggyback (badge-pass pattern): auto-tag new conversations as
+                # work/personal with the configured local model. Best-effort;
+                # owner-set tags are never touched.
+                try:
+                    from ....features.signal.conversation_context import (
+                        classify_untagged_conversations,
+                    )
+
+                    worker_conn = get_db_connection()
+                    if worker_conn is not None:
+                        out["conversation_context"] = classify_untagged_conversations(
+                            worker_conn
+                        )
+                except Exception as exc:  # noqa: BLE001 — never blocks enrichment
+                    logger.debug("conversation-context pass failed: %s", exc)
+                return out
+
+            structured_result = await asyncio.to_thread(_structured)
 
-        store = DimensionBriefStore(conn)
         updated_dims: List[str] = []
 
         for idx, dimension in enumerate(dimensions):
@@ -199,13 +211,34 @@ class DimensionSummaryJob(BaseEnrichmentJob):
                 continue
             if not any(str(v or "").strip() for v in section_updates.values()):
                 continue
-            store.merge_system_update(
-                dimension,
-                section_updates,
-                source_id=source_id,
-                model=result.output.get("model") if result.status == "completed" and result.output else None,
-                provider=provider,
-            )
+
+            def _merge(
+                _dimension: str = dimension,
+                _updates: Dict[str, Optional[str]] = section_updates,
+                _model: Optional[str] = (
+                    result.output.get("model")
+                    if result.status == "completed" and result.output
+                    else None
+                ),
+                _provider: str = provider,
+            ) -> None:
+                # merge_system_update ensures the brief head and appends a
+                # revision, both under the write gate — a blocking OS lock that
+                # on the event loop stalls every coroutine, including the
+                # control-plane keepalive. The store binds whichever connection
+                # it is built with, so build it on the worker thread.
+                worker_conn = get_db_connection()
+                if worker_conn is None:
+                    return
+                DimensionBriefStore(worker_conn).merge_system_update(
+                    _dimension,
+                    _updates,
+                    source_id=source_id,
+                    model=_model,
+                    provider=_provider,
+                )
+
+            await asyncio.to_thread(_merge)
             updated_dims.append(dimension)
             if progress_callback:
                 progress_callback(idx + 1, len(dimensions))

{topos_node-1.3.7 → topos_node-1.3.8}/topos/enrichment/jobs/canonical/entities_job.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import logging
 import os
 from typing import Any, Callable, Dict, List, Optional
@@ -169,7 +170,14 @@ class EntitiesJob(BaseEnrichmentJob):
 
         if entity_spine_enabled() and results:
             try:
-                self._resolve_into_spine(results, canonical_messages)
+                # Spine resolution upserts entities, mentions, edges and
+                # dossiers under the write gate — a blocking OS lock that on
+                # the event loop stalls every coroutine, including the
+                # control-plane keepalive. It resolves its own connection, so
+                # on a worker thread it binds that thread's handle.
+                await asyncio.to_thread(
+                    self._resolve_into_spine, results, canonical_messages
+                )
             except Exception as exc:
                 logger.warning("entity spine resolution failed: %s", exc)
 

{topos_node-1.3.7 → topos_node-1.3.8}/topos/enrichment/jobs/canonical/statistics_job.py

@@ -10,6 +10,7 @@ Gated by TOPOS_STATS (default on).
 
 from __future__ import annotations
 
+import asyncio
 import logging
 import os
 from typing import Any, Callable, Dict, List, Optional
@@ -44,24 +45,37 @@ class StatisticsJob(BaseEnrichmentJob):
         canonical_messages: List[Dict[str, Any]],
         progress_callback: Optional[Callable[[int, int], None]] = None,
     ) -> List[Dict[str, Any]]:
-        conn = get_db_connection()
-        if conn is None:
+        def _fold_and_promote() -> Optional[Dict[str, Any]]:
+            # Every step here takes the write gate — a blocking OS lock:
+            # StatsEngine's constructor seeds stat definitions, fold_batch
+            # holds it for the batch, and promotion runs migrations through
+            # AdapterFactory. On the event loop that stalls every coroutine,
+            # including the control-plane keepalive, so the whole stretch runs
+            # on a worker thread against that thread's own connection.
+            conn = get_db_connection()
+            if conn is None:
+                return None
+
+            from ....features.stats.engine import StatsEngine
+
+            engine = StatsEngine(conn)
+            folded = dict(engine.fold_batch(canonical_messages))
+            folded["promoted"] = 0
+            if self._should_promote(conn, folded["rows_folded"]):
+                try:
+                    from ....storage.adapters.factory import AdapterFactory
+
+                    bundle = AdapterFactory.create("local_database", conn=conn)
+                    folded["promoted"] = engine.promote_insights(bundle)
+                    self._record_promotion(conn)
+                except Exception as exc:
+                    logger.warning("stat insight promotion failed: %s", exc)
+            return folded
+
+        result = await asyncio.to_thread(_fold_and_promote)
+        if result is None:
             return [{"_deferred": True, "error": "database_unavailable"}]
-
-        from ....features.stats.engine import StatsEngine
-
-        engine = StatsEngine(conn)
-        result = engine.fold_batch(canonical_messages)
-        promoted = 0
-        if self._should_promote(conn, result["rows_folded"]):
-            try:
-                from ....storage.adapters.factory import AdapterFactory
-
-                bundle = AdapterFactory.create("local_database", conn=conn)
-                promoted = engine.promote_insights(bundle)
-                self._record_promotion(conn)
-            except Exception as exc:
-                logger.warning("stat insight promotion failed: %s", exc)
+        promoted = result["promoted"]
 
         if progress_callback:
             progress_callback(len(canonical_messages), len(canonical_messages))
@@ -90,10 +104,18 @@ class StatisticsJob(BaseEnrichmentJob):
         except (json.JSONDecodeError, TypeError, ValueError):
             pending = 0
         pending += rows_folded
-        conn.execute(
-            "UPDATE stat_state SET state_json=? WHERE stat_id=? AND group_key='' AND bucket_date=''",
-            (json.dumps({"pending": pending}), _META_STAT_ID),
-        )
+        # Gated AND committed. Ungated this counter update was still a write: it
+        # took SQLite's write lock at execute time on the event loop's
+        # connection and, with no commit anywhere after it, held that lock for
+        # the rest of the pipeline. Every other thread's first write then waited
+        # out the full 30s busy_timeout and failed "database is locked" — which
+        # is how this job lost its own fold on repeat ingests.
+        with with_db_write():
+            conn.execute(
+                "UPDATE stat_state SET state_json=? WHERE stat_id=? AND group_key='' AND bucket_date=''",
+                (json.dumps({"pending": pending}), _META_STAT_ID),
+            )
+            commit_connection(conn)
         if pending >= _PROMOTE_EVERY_ROWS:
             return True
         stale = conn.execute(

{topos_node-1.3.7 → topos_node-1.3.8}/topos/enrichment/jobs/canonical/timeline_job.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import logging
 from typing import Any, Callable, Dict, List, Optional
 
@@ -27,10 +28,18 @@ class TimelineJob(BaseEnrichmentJob):
         canonical_messages: List[Dict[str, Any]],
         progress_callback: Optional[Callable[[int, int], None]] = None,
     ) -> List[Dict[str, Any]]:
-        conn = get_db_connection()
-        if conn is None:
+        def _project():
+            # project_timeline_rows holds the write gate for the whole batch —
+            # a blocking OS lock — so it runs on a worker thread with that
+            # thread's own connection, never on the event loop.
+            conn = get_db_connection()
+            if conn is None:
+                return None
+            return project_timeline_rows(conn, canonical_messages)
+
+        result = await asyncio.to_thread(_project)
+        if result is None:
             return [{"_deferred": True, "error": "database_unavailable"}]
-        result = project_timeline_rows(conn, canonical_messages)
         if progress_callback:
             progress_callback(len(canonical_messages), len(canonical_messages))
         logger.debug(