topos-node 1.3.32__tar.gz → 1.3.33__tar.gz

{topos_node-1.3.32/topos_node.egg-info → topos_node-1.3.33}/PKG-INFO

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

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

{topos_node-1.3.32 → topos_node-1.3.33}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.3.32"
-__version_info__ = (1, 3, 32)
+__version__ = "1.3.33"
+__version_info__ = (1, 3, 33)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-1.3.32 → topos_node-1.3.33}/topos/analytics/messenger_communities.py

@@ -4,13 +4,18 @@ from __future__ import annotations
 
 import json
 from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional, Sequence
+from typing import Any, Dict, List, Optional, Sequence, Set
+
+import logging
 
 import networkx as nx
 
+from .messenger_directed import create_directed_tables
 from .messenger_graph import extract_messenger_graph
 from ..storage.db.write_gate import batched_writes, commit_connection, with_db_write
 
+logger = logging.getLogger(__name__)
+
 MESSENGER_SOCIAL_EDGES_TABLE = "messenger_social_edges"
 MESSENGER_PARTICIPANT_IMPORTANCE_TABLE = "messenger_participant_importance"
 MESSENGER_COMMUNITIES_TABLE = "messenger_communities"
@@ -36,6 +41,13 @@ def ensure_messenger_analytics_tables(conn: Any) -> None:
         commit_connection(conn)
 
 
+def _add_column_if_missing(conn: Any, table: str, column: str, col_type: str) -> None:
+    """Idempotent additive column. Safe to call on every ensure."""
+    cols = {row[1] for row in conn.execute(f"PRAGMA table_info({table})").fetchall()}
+    if column not in cols:
+        conn.execute(f"ALTER TABLE {table} ADD COLUMN {column} {col_type}")
+
+
 def _create_messenger_analytics_tables(conn: Any) -> None:
     conn.execute(
         f"""
@@ -60,6 +72,16 @@ def _create_messenger_analytics_tables(conn: Any) -> None:
         ON {MESSENGER_SOCIAL_EDGES_TABLE}(dataset_id, period_key, source_scope)
         """
     )
+    # Per-edge connector provenance. Deliberately an additive ALTER here rather
+    # than a registry migration: these three tables are created by this function
+    # and appear nowhere in storage/db/migrations/registry.py, so they are already
+    # feature-owned. Routing this through the registry would bump user_version
+    # past what an installed engine understands and fence the node out of every
+    # write — which is exactly what happened on 2026-08-25.
+    _add_column_if_missing(conn, MESSENGER_SOCIAL_EDGES_TABLE, "source_counts_json", "TEXT")
+
+    # L1 — the directed half. Same site, same gate, same reasoning about migrations.
+    create_directed_tables(conn)
 
     conn.execute(
         f"""
@@ -105,12 +127,36 @@ def _create_messenger_analytics_tables(conn: Any) -> None:
     )
 
 
-def build_networkx_graph(period_payload: Dict[str, Any]) -> nx.Graph:
-    """Build an undirected weighted graph from Sprint 01 period payload."""
+def build_networkx_graph(
+    period_payload: Dict[str, Any],
+    exclude: Optional[Set[str]] = None,
+) -> nx.Graph:
+    """Build an undirected weighted graph from Sprint 01 period payload.
+
+    `exclude` drops nodes and every edge touching them — used to remove the OWNER
+    before centrality and community detection. The owner sits inside every
+    conversation they are part of, so co-participation makes them adjacent to
+    nearly everyone: they are the most central node in every period measured
+    (degree 0.375-0.582), and the partition collapses around them.
+
+    Measured on the live corpus 2026-08-26, removing that single node:
+
+        period    communities        largest community
+        2026-04   34 ->  53          35% -> 15%
+        2026-05   40 ->  63          34% ->  6%
+        2026-06   34 ->  54          37% -> 17%
+        2026-07   31 ->  48          34% -> 18%
+        2026-08   12 ->  37          58% -> 20%
+
+    August's "community" of 58% of all participants was the owner's star, not a
+    group of people who know each other. Every brokerage, bridge and circle number
+    computed with the ego present describes the owner's own reach.
+    """
+    exclude = exclude or set()
     graph = nx.Graph()
     for node in period_payload.get("nodes", []):
         node_id = str(node.get("id") or "").strip()
-        if not node_id:
+        if not node_id or node_id in exclude:
             continue
         graph.add_node(node_id, **node)
 
@@ -119,14 +165,26 @@ def build_networkx_graph(period_payload: Dict[str, Any]) -> nx.Graph:
         target_id = str(edge.get("target") or "").strip()
         if not source_id or not target_id or source_id == target_id:
             continue
+        if source_id in exclude or target_id in exclude:
+            continue
         weight = float(edge.get("weight") or 0.0)
         graph.add_edge(source_id, target_id, weight=max(weight, 0.0))
     return graph
 
 
-def compute_importance_and_communities(period_payload: Dict[str, Any]) -> Dict[str, Any]:
-    """Compute centrality metrics and Louvain communities for one period."""
-    graph = build_networkx_graph(period_payload)
+def compute_importance_and_communities(
+    period_payload: Dict[str, Any],
+    exclude: Optional[Set[str]] = None,
+) -> Dict[str, Any]:
+    """Compute centrality metrics and Louvain communities for one period.
+
+    `exclude` (the owner) is removed from the GRAPH but never from the stored
+    EDGES: the edges are a factual record of who talked to whom and the owner's
+    are the most important ones there, while centrality and communities are an
+    interpretation of structure BETWEEN other people. Those are different
+    questions and only the second one needs the ego gone.
+    """
+    graph = build_networkx_graph(period_payload, exclude=exclude)
     node_ids = list(graph.nodes())
     if not node_ids:
         return {"importance": {}, "communities": {}, "graph": graph}
@@ -162,6 +220,25 @@ def compute_importance_and_communities(period_payload: Dict[str, Any]) -> Dict[s
     }
 
 
+def _owner_participant_ids(conn: Any) -> Set[str]:
+    """Every contact id that IS the owner.
+
+    Plural on purpose: the owner can hold more than one contact row. Live on this
+    machine there are two — the canonical id and a `test-dataset:`-prefixed
+    duplicate left by the phone-only matching in the dataset unification — and
+    excluding only one of them would leave the ego in the graph under its other
+    identity, which looks exactly like the fix working while it has not.
+    """
+    try:
+        return {
+            str(r[0])
+            for r in conn.execute("SELECT contact_id FROM contacts WHERE is_self=1").fetchall()
+            if r and r[0]
+        }
+    except Exception:  # noqa: BLE001 — a missing or older contacts table must not break analytics
+        return set()
+
+
 def _persist_period_results(
     conn: Any,
     *,
@@ -189,6 +266,7 @@ def _persist_period_results(
                 float(edge.get("weight") or 0.0),
                 str(edge.get("edge_type") or ""),
                 json.dumps(edge.get("edge_type_counts") or {}, ensure_ascii=False),
+                json.dumps(edge.get("source_counts") or {}, ensure_ascii=False),
                 now,
                 now,
             )
@@ -252,9 +330,10 @@ def _persist_period_results(
                 INSERT INTO {MESSENGER_SOCIAL_EDGES_TABLE}
                 (
                     dataset_id, period_key, source_scope, source_id, target_id,
-                    weight, edge_type, edge_type_counts_json, created_at, updated_at
+                    weight, edge_type, edge_type_counts_json, source_counts_json,
+                    created_at, updated_at
                 )
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                 """,
                 edge_rows,
             )
@@ -321,6 +400,7 @@ def compute_and_persist_messenger_analytics(
     )
 
     scope = _source_scope(source_ids)
+    ego = _owner_participant_ids(db)
     periods_out: List[Dict[str, Any]] = []
     totals = {"edges_written": 0, "importance_written": 0, "communities_written": 0}
 
@@ -328,7 +408,7 @@ def compute_and_persist_messenger_analytics(
         period_key = str(period_payload.get("period_key") or "")
         if not period_key:
             continue
-        computed = compute_importance_and_communities(period_payload)
+        computed = compute_importance_and_communities(period_payload, exclude=ego)
         writes = _persist_period_results(
             db,
             dataset_id=dataset_id,
@@ -349,6 +429,25 @@ def compute_and_persist_messenger_analytics(
             }
         )
 
+    # L1 — the directed lane, computed inside the pass that already runs.
+    #
+    # Deliberately NOT a new trigger and NOT a second rebuild lifecycle. Two of the three
+    # existing messenger triggers call this function synchronously, and prod CP is a single
+    # uvicorn worker where added synchronous work starves every tenant. Converging the
+    # messenger lane onto graph_materialization_state's debounce + flock + subprocess is real
+    # work with its own failure modes; doing it as a side effect of L1 would put an
+    # unreviewed refactor on the critical path of a single-worker service.
+    #
+    # A failure here must not lose the undirected results already computed above — the
+    # directed lane is additive, and a partial answer beats no answer.
+    directed_totals = {"directed_edges_written": 0, "dyads_written": 0}
+    try:
+        directed_totals = _compute_directed_lane(db, dataset_id, source_ids)
+    except Exception as exc:  # noqa: BLE001 — additive lane, never fails the pass
+        logger.warning("directed lane failed for %s: %s", dataset_id, exc)
+        directed_totals["error"] = str(exc)[:200]
+    totals.update(directed_totals)
+
     return {
         "dataset_id": dataset_id,
         "period_granularity": period_granularity,
@@ -356,3 +455,58 @@ def compute_and_persist_messenger_analytics(
         "periods": periods_out,
         "totals": totals,
     }
+
+
+def _compute_directed_lane(db: Any, dataset_id: str, source_ids: Optional[Sequence[str]]) -> Dict[str, int]:
+    """Extract, persist and roll up L1's directed edges for one dataset."""
+    from .messenger_directed import (DEFAULT_SESSION_GAP_SECONDS, build_dyad_stats,
+                                     extract_directed_dyadic_edges, persist_directed_edges,
+                                     persist_dyad_stats, rows_for_persist)
+
+    # Safe standalone: the orchestrator ensures tables before calling, but this function is
+    # also the unit under test and a future caller should not have to know the order.
+    with with_db_write():
+        create_directed_tables(db)
+        commit_connection(db)
+
+    # A single connector filter narrows the pass; several would need one pass each, and the
+    # rollup is lifetime-wide either way, so the filter only applies to the edge lane.
+    only = str(source_ids[0]) if source_ids and len(source_ids) == 1 else None
+    acc = extract_directed_dyadic_edges(db, dataset_id, connector=only)
+    from .messenger_directed import attach_affect, attach_topics
+    rows = rows_for_persist(acc, dataset_id, DEFAULT_SESSION_GAP_SECONDS,
+                            affect=attach_affect(db, dataset_id, acc),
+                            topics=attach_topics(db, dataset_id, acc))
+    # BOTH computations complete BEFORE either persist. The first version persisted edges,
+    # then computed and persisted dyads: a failure in the rollup left the two tables
+    # describing different corpora while totals reported neither — a split brain the
+    # adversarial pass demonstrated. Compute everything, then write; a failure now leaves
+    # the previous consistent state intact.
+    dyad_rows = build_dyad_stats(db, dataset_id)
+    periods = sorted({r[1] for r in rows})
+    edges = persist_directed_edges(db, dataset_id, rows, periods=periods)
+    dyads = persist_dyad_stats(db, dataset_id, dyad_rows)
+    # L1-8: fill the nullable person-id columns where identity is unambiguous. Runs after
+    # persistence because it reads the tables it fills; abstains on ambiguity.
+    from .messenger_directed import backfill_person_ids
+    ident = backfill_person_ids(db, dataset_id)
+    # G3: the calibrated warmth band is the authoritative label and is stored with the
+    # dyad, so every reader — including ones that never import the kernel — gets ONE
+    # answer to "what state is this relationship".
+    banded = 0
+    try:
+        from ..features.derivation.social_kernels import _dyad_rows, compute_warmth
+        from ..storage.db.write_gate import batched_writes
+
+        bands = compute_warmth(_dyad_rows(db, dataset_id))
+        with batched_writes(db):
+            for b in bands:
+                cur = db.execute(
+                    "UPDATE messenger_dyad_stats SET warmth_band=? WHERE dataset_id=?"
+                    " AND (a_key=? OR b_key=?) AND involves_self=1",
+                    (b["warmth_band"], dataset_id, b["peer_key"], b["peer_key"]))
+                banded += cur.rowcount
+    except Exception as exc:  # noqa: BLE001 — labelling must not fail the lane
+        logger.warning("warmth banding failed for %s: %s", dataset_id, exc)
+    return {"directed_edges_written": edges, "dyads_written": dyads,
+            "person_ids_resolved": ident.get("resolved", 0), "warmth_banded": banded}