topos-node 1.3.37__tar.gz → 1.3.38__tar.gz

{topos_node-1.3.37/topos_node.egg-info → topos_node-1.3.38}/PKG-INFO

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

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

{topos_node-1.3.37 → topos_node-1.3.38}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.3.37"
-__version_info__ = (1, 3, 37)
+__version__ = "1.3.38"
+__version_info__ = (1, 3, 38)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-1.3.37 → topos_node-1.3.38}/topos/api/signal.py

@@ -682,28 +682,37 @@ async def blackhole_entity(
     """
     import asyncio
 
+    from ..core.state import close_thread_db_connection
     from ..features.lifecycle.blackhole import BlackholeStore
     from ..features.lifecycle.blackhole_rebuild import rebuild_for_blackhole
 
-    conn = _entities_conn()
+    _entities_conn()  # fail fast with 503 before spawning the worker
+    processing_tier = body.processing_tier
+    note = body.note
+
+    def _blackhole():
+        try:
+            conn = _entities_conn()
+            result = BlackholeStore(conn).blackhole_entity(
+                entity_ref=entity_id,
+                processing_tier=processing_tier,
+                note=note,
+            )
+            # D4: the notification above was raised first, so the owner already
+            # knows the hide is incomplete; now do the rebuild that makes it
+            # true. Same worker / same connection — do not hop back to the loop
+            # with a write-gate hold still possible.
+            if not result.get("already_blackholed"):
+                result["rebuild"] = rebuild_for_blackhole(conn, entity_id).as_dict()
+            return result
+        finally:
+            close_thread_db_connection()
+
     try:
-        result = BlackholeStore(conn).blackhole_entity(
-            entity_ref=entity_id,
-            processing_tier=body.processing_tier,
-            note=body.note,
-        )
+        return await asyncio.to_thread(_blackhole)
     except ValueError as exc:
         raise HTTPException(status_code=400, detail=str(exc))
 
-    # D4: the notification above was raised first, so the owner already knows the
-    # hide is incomplete; now do the rebuild that makes it true. Non-owners are
-    # withheld the prose artifacts for the duration, so this running late is safe
-    # while it running silently would not be.
-    if not result.get("already_blackholed"):
-        result["rebuild"] = await asyncio.to_thread(rebuild_for_blackhole, conn, entity_id)
-        result["rebuild"] = result["rebuild"].as_dict()
-    return result
-
 
 @router.delete("/entities/{entity_id}/blackhole")
 async def unblackhole_entity(
@@ -711,9 +720,20 @@ async def unblackhole_entity(
     _api_key: str = Depends(require_api_key),
 ):
     """Lift a black hole. Existing grants are not restored — normal permissions resume."""
+    import asyncio
+
+    from ..core.state import close_thread_db_connection
     from ..features.lifecycle.blackhole import BlackholeStore
 
-    return BlackholeStore(_entities_conn()).unblackhole_entity(entity_ref=entity_id)
+    _entities_conn()  # fail fast with 503 before spawning the worker
+
+    def _unblackhole():
+        try:
+            return BlackholeStore(_entities_conn()).unblackhole_entity(entity_ref=entity_id)
+        finally:
+            close_thread_db_connection()
+
+    return await asyncio.to_thread(_unblackhole)
 
 
 @router.get("/blackholes")

{topos_node-1.3.37 → topos_node-1.3.38}/topos/cli/tray.py

@@ -2,8 +2,9 @@
 
 Port of the original open-source topos-cli ``menu_bar_app`` (pystray + PIL):
 the Topos glyph with a status dot composited in the corner — yellow while
-starting, green while the node answers ``/healthcheck``, red while it does
-not, orange when a newer topos-node is published on PyPI. The menu offers
+starting, green while the node answers ``/healthcheck``, red only after
+repeated misses (a single late probe is a busy node, not a dead one),
+orange when a newer topos-node is published on PyPI. The menu offers
 API docs, the hosted Topos app, a one-click update when one is available,
 and Quit.
 
@@ -33,10 +34,36 @@ STATUS_COLORS = {
 }
 
 HEALTH_POLL_SECONDS = 5.0
+#: Must sit above ``probe_db_health``'s 2s budget. A 3s client deadline raced
+#: the probe under ingest load and painted the tray red for a live node.
+HEALTH_TIMEOUT_SECONDS = 10.0
+#: One missed probe is a stalled event loop, not a down node. Two in a row
+#: is enough to go red; a single success clears the count (same shape as
+#: the web app's ``HEALTH_FAILURE_THRESHOLD``).
+HEALTH_FAILURE_THRESHOLD = 2
 TOPOS_APP_URL = "https://topos.dialogues.ai"
 TOPOS_DOCS_URL = "https://topos.dialogues.ai/docs/welcome"
 
 
+def resolve_tray_health_status(
+    *,
+    probe_ok: bool,
+    consecutive_failures: int,
+    current_status: str,
+    failure_threshold: int = HEALTH_FAILURE_THRESHOLD,
+) -> tuple[str, int]:
+    """Map one ``/healthcheck`` result to (next_status, next_failure_count).
+
+    A single timeout must not flip a green (or still-starting) icon to red.
+    """
+    if probe_ok:
+        return "healthy", 0
+    failures = consecutive_failures + 1
+    if failures >= failure_threshold:
+        return "down", failures
+    return current_status, failures
+
+
 def tray_available() -> bool:
     try:
         import pystray  # noqa: F401
@@ -214,16 +241,24 @@ class ToposTray:
     def _poll_health(self) -> None:
         import httpx
 
+        consecutive_failures = 0
         while self._icon is not None and self._icon.visible:
             try:
                 # 401/403 = health auth enabled; the node answered, so it's up.
-                healthy = httpx.get(self.health_url, timeout=3.0).status_code in (200, 401, 403)
+                healthy = httpx.get(
+                    self.health_url, timeout=HEALTH_TIMEOUT_SECONDS
+                ).status_code in (200, 401, 403)
             except Exception:
                 healthy = False
             if healthy:
                 self._fetch_shell_status()
                 self._maybe_fetch_topos_name()
-            self._set_status("healthy" if healthy else "down")
+            next_status, consecutive_failures = resolve_tray_health_status(
+                probe_ok=healthy,
+                consecutive_failures=consecutive_failures,
+                current_status=self.status,
+            )
+            self._set_status(next_status)
             time.sleep(HEALTH_POLL_SECONDS)
 
     def _fetch_shell_status(self) -> None:

{topos_node-1.3.37 → topos_node-1.3.38}/topos/core/handlers/signal_features.py

@@ -1031,7 +1031,10 @@ async def handle_signal_unblackhole_entity(message: Dict[str, Any]) -> Optional[
     try:
         from ...features.lifecycle.blackhole import BlackholeStore
 
-        result = BlackholeStore(hub.get_db_connection()).unblackhole_entity(entity_ref=entity_id)
+        def _unblackhole(conn):
+            return BlackholeStore(conn).unblackhole_entity(entity_ref=entity_id)
+
+        result = await run_db_write(_unblackhole)
         return {"id": req_id, "status": "ok", "payload": result}
     except Exception as exc:  # noqa: BLE001
         return {"id": req_id, "status": "error", "error": str(exc)}

{topos_node-1.3.37 → topos_node-1.3.38}/topos/features/entities/reads.py

@@ -106,6 +106,123 @@ def list_entities(
     }
 
 
+def entity_card_aggregates(
+    conn: sqlite3.Connection,
+    entity_id: str,
+    *,
+    guard: BlackholeGuard,
+) -> Dict[str, Any]:
+    """Full-population counts a type-specific entity card reads.
+
+    Separate from ``recent_mentions`` because they answer a different question.
+    ``recent_mentions`` is a SAMPLE — twenty rows, newest first — and a card that
+    derived "83% of this came from browsing" by counting a sample would be
+    stating a measurement it had not made. Every count here is over the whole
+    mention set.
+
+    Two aggregates, because the card designs turn on two distinctions the spine
+    already records and nothing has ever read:
+
+    ``mention_sources``
+        Mentions grouped by canonical table, with the owner-authored share. This
+        is what separates an organization the owner *writes about* from one whose
+        name appeared in a page title, a place they have *been* (``location_events``)
+        from one they only ever talked about, and a project they *work on*
+        (``activity_events``) from one they have only planned. The whole judgement
+        line of six of the ten cards rests on it.
+
+    ``neighbor_counts``
+        Edges grouped by ``(edge_type, direction, neighbour type)``. The card needs
+        "6 people around this" and "14 goals point at it", and ``connections`` is
+        capped at twelve rows ordered by weight — a cap is the right answer for a
+        list and the wrong one for a count.
+
+    Direction is kept because it is load-bearing for at least one type: a
+    conversation's ``participates_in`` (inbound, someone was there) and its
+    ``mentions`` (outbound, someone was named) are different claims about a
+    person, and a card that merged them would say a person who was discussed was
+    in the room.
+    """
+    eid = str(entity_id)
+
+    # A record that names a protected entity is withheld whole, so its mentions
+    # of THIS entity cannot be counted either — otherwise the total silently
+    # disagrees with the records the reader is allowed to open, and the size of
+    # the disagreement is a signal about what was hidden. Inert for the owner UI,
+    # where `sees_everything` short-circuits `blocked_record_ids` to an empty set.
+    blocked_records = guard.blocked_record_ids()
+
+    mention_rows = conn.execute(
+        """
+        SELECT record_id, COALESCE(canonical_table, ''), COALESCE(authored_by_owner, 0)
+        FROM entity_mentions WHERE entity_id = ?
+        """,
+        (eid,),
+    ).fetchall()
+
+    by_table: Dict[str, Dict[str, int]] = {}
+    for record_id, table, authored in mention_rows:
+        if blocked_records and str(record_id) in blocked_records:
+            continue
+        # An unattributed mention is its own fact — bucketed under "" rather than
+        # dropped, so the card's percentages are over the same denominator as its
+        # total and cannot quietly exceed 100%.
+        slot = by_table.setdefault(str(table), {"count": 0, "owner_authored": 0})
+        slot["count"] += 1
+        if int(authored or 0) == 1:
+            slot["owner_authored"] += 1
+
+    mention_sources = sorted(
+        (
+            {"table": table, "count": v["count"], "owner_authored": v["owner_authored"]}
+            for table, v in by_table.items()
+        ),
+        key=lambda r: (-int(r["count"]), str(r["table"])),
+    )
+
+    # Counted in Python rather than pushed into a GROUP BY so the guard applies
+    # per neighbour: a protected entity must not be counted, and a SQL count
+    # would include it while the neighbour LIST beside it does not.
+    edge_rows = conn.execute(
+        """
+        SELECT e.src_entity_id, e.dst_entity_id, e.edge_type,
+               COALESCE(s.entity_type, ''), COALESCE(t.entity_type, ''),
+               s.canonical_name, t.canonical_name
+        FROM entity_edges e
+        LEFT JOIN entities s ON s.entity_id = e.src_entity_id
+        LEFT JOIN entities t ON t.entity_id = e.dst_entity_id
+        WHERE (e.src_entity_id = ? OR e.dst_entity_id = ?) AND e.valid_to IS NULL
+        """,
+        (eid, eid),
+    ).fetchall()
+
+    tally: Dict[tuple, int] = {}
+    for src, dst, edge_type, src_type, dst_type, src_name, dst_name in edge_rows:
+        outbound = str(src) == eid
+        other_id = dst if outbound else src
+        other_type = dst_type if outbound else src_type
+        other_name = dst_name if outbound else src_name
+        if guard.blocks_entity_id(other_id) or guard.blocks_name(other_name):
+            continue
+        key = (str(edge_type), "out" if outbound else "in", str(other_type))
+        tally[key] = tally.get(key, 0) + 1
+
+    neighbor_counts = sorted(
+        (
+            {
+                "edge_type": edge_type,
+                "direction": direction,
+                "entity_type": other_type,
+                "count": count,
+            }
+            for (edge_type, direction, other_type), count in tally.items()
+        ),
+        key=lambda r: (-int(r["count"]), str(r["edge_type"]), str(r["entity_type"])),
+    )
+
+    return {"mention_sources": mention_sources, "neighbor_counts": neighbor_counts}
+
+
 def get_entity_detail(
     conn: sqlite3.Connection,
     entity_id: str,
@@ -175,6 +292,12 @@ def get_entity_detail(
     entity["affinity_connections"] = guard.filter_rows(
         affinity, id_keys=id_keys, name_keys=name_keys
     )
+    # Full-population counts for the type-specific cards. Attached to every
+    # entity rather than branching on type here: the card layer decides what a
+    # place does with `location_events` and what an org does with the
+    # owner-authored share, and a read that guessed for it would have to be
+    # changed every time a card learns a new question.
+    entity.update(entity_card_aggregates(conn, str(entity_id), guard=guard))
     dossier = load_dossier_for_entity(conn, str(entity_id))
     if isinstance(dossier, dict) and not guard.sees_everything:
         dossier = dict(dossier)

{topos_node-1.3.37 → topos_node-1.3.38}/topos/storage/db/migrations/pipeline_jobs_v1.py

@@ -6,14 +6,47 @@ import sqlite3
 
 MIGRATION_ID = "pipeline_jobs_v1"
 
+_SCHEMA_TABLES = (
+    "pipeline_jobs",
+    "pipeline_derivation_completion",
+    "graph_materialization_state",
+)
+
+
+def _pipeline_jobs_schema_present(conn: sqlite3.Connection) -> bool:
+    """True when the tables this migration owns already exist.
+
+    The step is ``always_run``: a missing table must still CREATE. The skip is
+    only to avoid taking the write gate for INSERT OR IGNORE on every
+    enqueue/claim when the schema is already there — that stall painted the
+    tray red on a live node.
+    """
+    try:
+        rows = conn.execute(
+            """
+            SELECT name FROM sqlite_master
+            WHERE type='table' AND name IN (?, ?, ?)
+            """,
+            _SCHEMA_TABLES,
+        ).fetchall()
+    except sqlite3.OperationalError:
+        return False
+    return {row[0] for row in rows} >= set(_SCHEMA_TABLES)
+
 
 def apply_pipeline_jobs_v1_up(conn: sqlite3.Connection) -> None:
     # Callers invoke this ahead of their own gated sections; the INSERT OR
     # IGNORE below takes SQLite's write lock every call, so gate it here with
-    # its commit (write_gate lock-order inversion).
+    # its commit (write_gate lock-order inversion). Skip the gate entirely
+    # when the tables already exist — a read does not need it, and taking it
+    # on the event-loop thread blocks /healthcheck.
+    if _pipeline_jobs_schema_present(conn):
+        return
     from ..write_gate import commit_connection, with_db_write
 
     with with_db_write():
+        if _pipeline_jobs_schema_present(conn):
+            return
         _apply_pipeline_jobs_v1_up_locked(conn)
         commit_connection(conn)
 

{topos_node-1.3.37 → topos_node-1.3.38}/topos/upgrades/manifests.json

@@ -711,6 +711,15 @@
         "iMessage spam skip is a reader filter ([E:ingestion]). Already-ingested marketing SMS stay on disk; no automatic re-sync -- that needs Full Disk Access and a full-history window."
       ]
     },
+    {
+      "version": "1.3.38",
+      "summary": "Entity cards carry full-population source and neighbour counts; one late healthcheck must not paint a live node red.",
+      "steps": [],
+      "notes": [
+        "Entity-card counts are a read-path aggregate ([E:entities]): mention_sources and neighbor_counts are computed over the whole set, not the twenty-row sample. Nothing already on disk is rewritten.",
+        "Tray flicker is code-only ([O]): hysteresis on the menu-bar probe, skip the write gate when the pipeline_jobs tables already exist, and move blackhole/unblackhole off the event loop. No derived rebuild."
+      ]
+    },
     {
       "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.37 → topos_node-1.3.38/topos_node.egg-info}/PKG-INFO

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