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

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

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

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

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

{topos_node-1.3.7 → topos_node-1.3.9}/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.9}/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.9}/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.9}/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.9}/topos/enrichment/derivation_recovery.py

@@ -240,6 +240,70 @@ def list_pending_derivation_retries(
     return out
 
 
+async def retry_single_derivation(
+    conn: sqlite3.Connection,
+    *,
+    source_id: str,
+    sync_batch_id: str,
+    job_name: str,
+    record_ids: Optional[Sequence[str]] = None,
+) -> Dict[str, Any]:
+    """Re-run exactly one recorded derivation debt.
+
+    Reloads the debt's canonical records and re-runs ONLY the job that failed,
+    so a retry cannot disturb jobs that already succeeded. Jobs are idempotent
+    per (batch, job) at the ledger level; a retry that fails again simply leaves
+    the debt in place for the next attempt.
+
+    Returns ``{"outcome": "recovered" | "still_failing" | "skipped", ...}``.
+    "skipped" means the debt cannot be re-run mechanically (unknown source, no
+    surviving records) — the caller decides whether that discharges it.
+    """
+    if not job_name or not source_id:
+        return {"outcome": "skipped", "reason": "incomplete record"}
+    try:
+        from ..ingestion.canonical_pipeline import load_canonical_records_for_signal
+        # Reuses reprocess's resolver so a runtime-installed source rehydrates
+        # the same way it does for a manual reprocess.
+        from ..ingestion.reprocess import _resolve_source_def
+
+        try:
+            source_def = _resolve_source_def(source_id)
+        except ValueError:
+            return {"outcome": "skipped", "reason": "unknown source"}
+        records = load_canonical_records_for_signal(conn, source_def)
+        wanted = {str(r) for r in (record_ids or []) if r}
+        if wanted:
+            scoped = [
+                r
+                for r in records
+                if str(r.get("message_id") or r.get("record_id") or "") in wanted
+            ]
+            records = scoped or records
+        if not records:
+            return {"outcome": "skipped", "reason": "no records"}
+
+        from .orchestrator import SignalDerivationOrchestrator
+
+        result = await SignalDerivationOrchestrator().run_signal_derivation(
+            records, source_id, job_names=[job_name], sync_batch_id=sync_batch_id
+        )
+        if result.get("errors"):
+            return {
+                "outcome": "still_failing",
+                "error": result["errors"][0].get("error"),
+            }
+        # run_signal_derivation clears the debt itself on success.
+        return {
+            "outcome": "recovered",
+            "records": len(records),
+            "created": result.get("records_created", {}).get(job_name, 0),
+        }
+    except Exception as exc:  # noqa: BLE001 — one bad debt must not stop the rest
+        logger.warning("[DERIVE:RETRY] retry failed job=%s source=%s: %s", job_name, source_id, exc)
+        return {"outcome": "still_failing", "error": str(exc)}
+
+
 async def retry_pending_derivations(
     conn: Optional[sqlite3.Connection] = None,
     *,
@@ -249,11 +313,6 @@ async def retry_pending_derivations(
 ) -> Dict[str, Any]:
     """Re-run derivation jobs that previously failed, clearing settled debts.
 
-    Reloads each debt's canonical records and re-runs ONLY the job that failed,
-    so a retry cannot disturb jobs that already succeeded. Jobs are idempotent
-    per (batch, job) at the ledger level; a retry that fails again simply leaves
-    the debt in place for the next attempt.
-
     ``dry_run`` reports what would run without touching anything.
     """
     from ..core.state import get_db_connection
@@ -278,61 +337,27 @@ async def retry_pending_derivations(
         ]
         return outcome
 
-    from ..ingestion.canonical_pipeline import load_canonical_records_for_signal
-    # Reuses reprocess's resolver so a runtime-installed source rehydrates the
-    # same way it does for a manual reprocess.
-    from ..ingestion.reprocess import _resolve_source_def
-
     for debt in pending:
         job_name = debt["job_name"]
         src = debt["source_id"]
         batch = debt["sync_batch_id"]
-        if not job_name or not src:
-            outcome["skipped"].append({**debt, "reason": "incomplete record"})
-            continue
-        try:
-            try:
-                source_def = _resolve_source_def(src)
-            except ValueError:
-                outcome["skipped"].append({"job_name": job_name, "source_id": src, "reason": "unknown source"})
-                continue
-            records = load_canonical_records_for_signal(conn, source_def)
-            wanted = set(debt.get("record_ids") or [])
-            if wanted:
-                scoped = [
-                    r
-                    for r in records
-                    if str(r.get("message_id") or r.get("record_id") or "") in wanted
-                ]
-                records = scoped or records
-            if not records:
-                outcome["skipped"].append({"job_name": job_name, "source_id": src, "reason": "no records"})
-                continue
-
-            from .orchestrator import SignalDerivationOrchestrator
-
+        result = await retry_single_derivation(
+            conn,
+            source_id=src,
+            sync_batch_id=batch,
+            job_name=job_name,
+            record_ids=debt.get("record_ids") or [],
+        )
+        kind = result.pop("outcome")
+        entry = {"job_name": job_name, "source_id": src, **result}
+        if kind == "recovered":
             outcome["attempted"] += 1
-            result = await SignalDerivationOrchestrator().run_signal_derivation(
-                records, src, job_names=[job_name], sync_batch_id=batch
-            )
-            if result.get("errors"):
-                outcome["still_failing"].append(
-                    {"job_name": job_name, "source_id": src, "error": result["errors"][0].get("error")}
-                )
-            else:
-                # run_signal_derivation clears the debt itself on success.
-                outcome["recovered"].append(
-                    {
-                        "job_name": job_name,
-                        "source_id": src,
-                        "batch": batch,
-                        "records": len(records),
-                        "created": result.get("records_created", {}).get(job_name, 0),
-                    }
-                )
-        except Exception as exc:  # noqa: BLE001 — one bad debt must not stop the rest
-            logger.warning("[DERIVE:RETRY] retry failed job=%s source=%s: %s", job_name, src, exc)
-            outcome["still_failing"].append({"job_name": job_name, "source_id": src, "error": str(exc)})
+            outcome["recovered"].append({**entry, "batch": batch})
+        elif kind == "still_failing":
+            outcome["attempted"] += 1
+            outcome["still_failing"].append(entry)
+        else:
+            outcome["skipped"].append(entry)
 
     outcome["pending_after"] = len(list_pending_derivation_retries(conn, source_id=source_id, limit=1000))
     logger.info(
@@ -344,6 +369,67 @@ async def retry_pending_derivations(
     return outcome
 
 
+#: How long a worker-claimed retry waits for an active derivation batch to end
+#: before handing the job back to the queue. Debts are recorded MID-batch, and
+#: the worker claims within its poll interval — re-running immediately would
+#: re-contend for the same write gate that produced the original "database is
+#: locked". The wait doubles as the requeue backoff: while a long batch runs,
+#: the worker cycles claim → wait → requeue at this period instead of spinning.
+_IN_FLIGHT_WAIT_SECONDS = 30.0
+_IN_FLIGHT_POLL_SECONDS = 0.5
+
+
+async def run_derivation_retry_job(payload: Dict[str, Any]) -> Dict[str, Any]:
+    """Worker executor for ``SIGNAL_DERIVE_RETRY_KIND`` pipeline jobs.
+
+    This is the "by the worker" half of the module contract: the debt record IS
+    the queue row, so the worker claims it and re-runs the one derivation it
+    describes. Success marks the row done (the orchestrator clears the debt,
+    then the worker completes the job). A retry that fails again returns an
+    error status, parking the row 'failed' — still visible in every debt
+    listing, re-queued by the next organic failure of the same (batch, job), and
+    re-runnable via ``POST /signal/derivation-debt/retry``. One claim is one
+    attempt; nothing here loops.
+    """
+    import asyncio
+
+    from .pipeline_activity import is_derivation_in_flight
+
+    waited = 0.0
+    while is_derivation_in_flight():
+        if waited >= _IN_FLIGHT_WAIT_SECONDS:
+            return {"status": "requeue", "reason": "derivation in flight"}
+        await asyncio.sleep(_IN_FLIGHT_POLL_SECONDS)
+        waited += _IN_FLIGHT_POLL_SECONDS
+
+    from ..core.state import get_db_connection
+
+    conn = get_db_connection()
+    if conn is None:
+        return {"status": "error", "error": "no database connection"}
+
+    job_name = str(payload.get("job_name") or "")
+    result = await retry_single_derivation(
+        conn,
+        source_id=str(payload.get("source_id") or ""),
+        sync_batch_id=str(payload.get("sync_batch_id") or "unknown"),
+        job_name=job_name,
+        record_ids=payload.get("record_ids") or [],
+    )
+    outcome = result.pop("outcome")
+    if outcome == "recovered":
+        return {
+            "status": "ok",
+            "records_created": {job_name: result.get("created", 0)},
+            **result,
+        }
+    if outcome == "skipped":
+        # A debt that cannot be re-run is still recorded data loss. Failing the
+        # job keeps it visible for a human instead of silently discharging it.
+        return {"status": "error", "error": f"cannot retry: {result.get('reason')}"}
+    return {"status": "error", "error": str(result.get("error") or "retry failed")}
+
+
 def pending_derivation_summary(conn: Optional[sqlite3.Connection]) -> Dict[str, Any]:
     """What derived data this node KNOWS it is missing, and since when it knew.
 

{topos_node-1.3.7 → topos_node-1.3.9}/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.9}/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.9}/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)