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

{topos_node-1.3.39/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.39
+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.39 → topos_node-1.3.41}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "topos-node"
-version = "1.3.39"
+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.39 → topos_node-1.3.41}/topos/__version__.py

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

topos_node-1.3.41/topos/api/ingestion_api.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, Body, Depends, HTTPException, Request
+
+from ..auth import require_api_key
+from ..ingestion.reprocess import reprocess_source
+from .ingestion_sources import ingest_source
+
+router = APIRouter()
+
+
+@router.post("/ingestion/start")
+async def start_ingestion() -> dict:
+    return {"status": "stub"}
+
+
+@router.post("/ingestion/progress")
+async def report_progress() -> dict:
+    return {"status": "stub"}
+
+
+@router.post("/ingestion/reprocess", dependencies=[Depends(require_api_key)])
+async def ingestion_reprocess(payload: dict = Body(default_factory=dict)) -> dict:
+    """Re-run raw→canonical for a source (optional newest-N via ``limit``).
+
+    Body:
+      - source_id (required)
+      - dataset_id (required)
+      - from_stage: ``raw`` (default) | ``canonical``
+      - limit: optional int — newest N raw rows only
+      - run_enrichment: optional bool (default true)
+      - force / sync_batch_id: optional
+    """
+    try:
+        limit_raw = payload.get("limit")
+        limit = int(limit_raw) if limit_raw is not None and str(limit_raw).strip() != "" else None
+        return await reprocess_source(
+            source_id=str(payload["source_id"]),
+            dataset_id=str(payload["dataset_id"]),
+            from_stage=payload.get("from_stage") or "raw",
+            sync_batch_id=payload.get("sync_batch_id"),
+            force=bool(payload.get("force", False)),
+            limit=limit,
+            run_enrichment=bool(payload.get("run_enrichment", True)),
+        )
+    except KeyError as exc:
+        raise HTTPException(status_code=400, detail=f"Missing field: {exc}") from exc
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+
+@router.get("/ingestion/audit", dependencies=[Depends(require_api_key)])
+async def get_ingestion_audit(sync_batch_id: str) -> dict:
+    from ..core.state import get_db_connection
+    from ..pipeline.audit import SQLiteIngestAuditStore
+
+    conn = get_db_connection()
+    if not conn:
+        raise HTTPException(status_code=503, detail="Database unavailable")
+    store = SQLiteIngestAuditStore(conn)
+    return {"sync_batch_id": sync_batch_id, "stages": store.query_by_batch(sync_batch_id)}
+
+
+@router.post("/ingestion/upload", dependencies=[Depends(require_api_key)])
+async def upload_ingestion_file(request: Request) -> dict:
+    return await ingest_source("chatgpt_file_ingestion", request)
+
+
+@router.get("/ingestion/local-exports", dependencies=[Depends(require_api_key)])
+async def list_local_exports() -> dict:
+    """Exports sitting on this machine, for the import screen to offer.
+
+    The node is the only party that can answer this: a browser cannot read a
+    filesystem, and cannot produce an absolute path even for a file the user
+    picks. So the node looks, and hands back opaque handles plus labels a person
+    can recognise -- never the paths themselves.
+
+    Bounded and stateless by construction (see ``local_exports``): a few known
+    folders, shallow, symlinks skipped, time-boxed, nothing written down.
+    """
+    import asyncio
+
+    from ..ingestion.local_exports import find_exports
+
+    result = await asyncio.to_thread(find_exports)
+    return result.as_payload()
+
+
+@router.get("/ingestion/local-exports/{handle}/describe", dependencies=[Depends(require_api_key)])
+async def describe_local_export(handle: str) -> dict:
+    """What is inside one discovered export: conversation count and date range.
+
+    Separate from discovery on purpose. Listing candidates reads only an
+    archive's central directory and stays in the low hundreds of milliseconds;
+    this opens the conversations file and parses it, which is about a second on
+    a 52 MB export. Paying that for every row of a scan to inform a choice about
+    one of them would be the wrong trade.
+
+    It exists because a window is measured against today while an export is
+    fixed in the past, and nothing in the UI could see the gap: a six-month
+    window against a fourteen-month-old export drops every conversation and
+    completes successfully with nothing imported.
+    """
+    import asyncio
+
+    from ..ingestion.local_exports import describe_export, resolve
+
+    path = await asyncio.to_thread(resolve, handle)
+    if path is None:
+        raise HTTPException(
+            status_code=404,
+            detail="That export is no longer where we found it. Scan again and pick it.",
+        )
+    try:
+        return await asyncio.to_thread(describe_export, path)
+    except Exception as exc:  # noqa: BLE001 — a describe failure must not block the import
+        raise HTTPException(status_code=422, detail=f"Could not read that export: {exc}") from exc
+
+
+@router.post("/ingestion/upload-local-path", dependencies=[Depends(require_api_key)])
+async def upload_ingestion_local_path(
+    request: Request, payload: dict = Body(default_factory=dict)
+) -> dict:
+    """Ingest a file that is already on this machine. No bytes cross a network.
+
+    Accepts either a ``handle`` from ``/ingestion/local-exports`` -- the path
+    never leaves the node -- or an explicit ``file_path``, which is still how
+    someone points at an export outside the searched folders.
+    """
+    from ..ingestion.local_exports import resolve
+
+    dataset_id = payload.get("dataset_id")
+    file_path = payload.get("file_path")
+    handle = str(payload.get("handle") or "").strip()
+
+    if handle and not file_path:
+        resolved = resolve(handle)
+        if resolved is None:
+            # Handles are re-found rather than remembered, so a stale one means
+            # the file moved or went away -- not that the user did anything odd.
+            raise HTTPException(
+                status_code=404,
+                detail="That export is no longer where we found it. Scan again and pick it.",
+            )
+        file_path = str(resolved)
+
+    if not file_path:
+        raise HTTPException(status_code=400, detail="Provide a handle or a file_path.")
+
+    return await ingest_source(
+        "chatgpt_file_ingestion",
+        request,
+        dataset_id=dataset_id,
+        file_path=file_path,
+    )

{topos_node-1.3.39 → topos_node-1.3.41}/topos/core/handlers/__init__.py

@@ -170,6 +170,7 @@ from . import (  # noqa: F401  (imported for handler registration side effects)
     complexity,
     timeline_daily,
     graph_query,
+    graph_summary,
 )
 
 

topos_node-1.3.41/topos/core/handlers/graph_summary.py

@@ -0,0 +1,76 @@
+"""How much is in the graph — the smallest possible answer.
+
+Why this exists rather than a count taken from ``/v1/signal/graph``: that
+endpoint returns node and edge LISTS, capped at 200 and 500, and no totals. To
+learn "how many" from it you would fetch rows you throw away, and still not
+know the answer once the graph passed the cap.
+
+Why not carry the number on the ingestion job instead: the progress channel is
+a fixed set of columns on the control plane's ``ingestion_jobs`` table, with no
+JSON field, and ``stage_event`` is filtered down to four keys. Adding it there
+means a schema migration on the production database — a real cost to pay for a
+reassurance line, and a change that is hard to take back.
+
+So: three COUNT(*) queries, read on demand, owned by nothing.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Dict, Optional
+
+from .registry import handles
+
+
+def _counts() -> Dict[str, Any]:
+    from ...core.state import get_db_connection
+
+    conn = get_db_connection()
+    if conn is None:
+        return {"available": False}
+
+    out: Dict[str, Any] = {"available": True}
+    # Each table is counted independently and a failure on one is not a failure
+    # of the reply: a missing table on an older node should cost that number,
+    # not the whole answer.
+    for key, table in (
+        ("nodes", "graph_nodes"),
+        ("edges", "graph_edges"),
+        ("entities", "entities"),
+    ):
+        try:
+            row = conn.execute(f"SELECT COUNT(*) FROM {table}").fetchone()  # noqa: S608 — fixed names
+            out[key] = int(row[0]) if row else 0
+        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(last_run_at) FROM graph_materialization_state"
+        ).fetchone()
+        out["materialized_at"] = row[0] if row else None
+    except Exception:  # noqa: BLE001
+        out["materialized_at"] = None
+    return out
+
+
+@handles("graph_summary")
+async def handle_graph_summary(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Node, edge and entity counts, for a screen that wants to show growth.
+
+    The reason it is worth showing during an import: entity data lands at the
+    third of twenty stages and the graph is materialised twice, so these numbers
+    move long before the import finishes. Watching them move is the difference
+    between a long wait and a long wait you can see the point of.
+    """
+    req_id = message.get("id")
+    if not req_id:
+        return None
+    try:
+        payload = await asyncio.to_thread(_counts)
+        return {"id": req_id, "status": "ok", "payload": payload}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}

{topos_node-1.3.39 → topos_node-1.3.41}/topos/core/handlers/ingest.py

@@ -365,6 +365,22 @@ async def handle_start_ingestion(message: Dict[str, Any]) -> Optional[Dict[str,
     file_url = payload.get("file_url")
     file_base64 = payload.get("file_base64")
     file_path = payload.get("file_path")
+    local_handle = str(payload.get("local_export_handle") or "").strip()
+    if local_handle and not file_path:
+        # A handle from `list_local_exports`. The path was never sent to the
+        # browser, so it is resolved here — and only ever to something still
+        # inside a searched folder, which is what makes a handle safe to accept
+        # back over the relay.
+        from ...ingestion.local_exports import resolve as _resolve_local_export
+
+        resolved = _resolve_local_export(local_handle)
+        if resolved is None:
+            return {
+                "id": req_id,
+                "status": "error",
+                "error": "That export is no longer where we found it. Scan again and pick it.",
+            }
+        file_path = str(resolved)
     job_id = payload.get("job_id")
     source_id = payload.get("source_id")  # Optional source_id from control plane
     source_definition = payload.get("source_definition")
@@ -481,6 +497,62 @@ async def handle_ingestion_reprocess(message: Dict[str, Any]) -> Optional[Dict[s
     except Exception as exc:  # noqa: BLE001
         return {"id": req_id, "status": "error", "error": str(exc)}
 
+@handles("list_local_exports")
+async def handle_list_local_exports(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Exports sitting on this machine, for the import screen to offer.
+
+    Only the node can answer this. A browser cannot read a filesystem, and
+    cannot produce an absolute path even for a file the user picks — so without
+    this the only way to reach the free import path was to type one out by hand.
+
+    What comes back is opaque handles and labels a person can recognise, never
+    paths: the reply travels to the browser over the relay, and a home-directory
+    path carries the account name and whatever else lives beside it.
+    """
+    req_id = message.get("id")
+    if not req_id:
+        return None
+    try:
+        import asyncio
+
+        from ...ingestion.local_exports import find_exports
+
+        result = await asyncio.to_thread(find_exports)
+        return {"id": req_id, "status": "ok", "payload": result.as_payload()}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}
+
+
+@handles("describe_local_export")
+async def handle_describe_local_export(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Conversation count and date range for one discovered export.
+
+    The window a person picks is measured from today; the export is fixed in
+    the past. Nothing in the UI could see that gap, so a six-month window
+    against a fourteen-month-old file imported nothing and said it succeeded.
+    This is the number that closes it, read where the dates are.
+    """
+    req_id = message.get("id")
+    if not req_id:
+        return None
+    payload = message.get("payload") or {}
+    handle = str(payload.get("handle") or "").strip()
+    if not handle:
+        return {"id": req_id, "status": "error", "error": "handle required"}
+    try:
+        import asyncio
+
+        from ...ingestion.local_exports import describe_export, resolve
+
+        path = await asyncio.to_thread(resolve, handle)
+        if path is None:
+            return {"id": req_id, "status": "error", "error": "export no longer found"}
+        described = await asyncio.to_thread(describe_export, path)
+        return {"id": req_id, "status": "ok", "payload": described}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}
+
+
 @handles("get_ingestion_audit")
 async def handle_get_ingestion_audit(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     req_id = message.get("id")

{topos_node-1.3.39 → topos_node-1.3.41}/topos/disclosure/privacy_layer.py

@@ -169,13 +169,36 @@ class PrivacyLayerClient:
         return {"status": "failed", "error": str(last_exc), "items": []}
 
 
+# Names for the two model passes below. They are reported to the caller's
+# progress callback and surface verbatim in the UI, so they are written for a
+# person watching an import rather than for a log grep.
+#
+# "Filtering private information" rather than "checking for private details":
+# this pass does not merely look. It detects PII spans and REDACTS them into
+# the disclosure copy, which is the whole point of the layer — the node is
+# preparing what it can safely show. A name that says "checking" describes an
+# inspection and undersells the thing the product actually does for you.
+PRIVACY_STAGE_REDACT = "filtering private information"
+PRIVACY_STAGE_NSFW = "checking for sensitive content"
+
+# How many records to send per call. NOT a throughput choice: both engine
+# backends (redact_privacy_batch, classify_nsfw_batch) loop over `items` one at
+# a time, so grouping 32 records buys no batched inference -- it is purely
+# transport. The only thing the group size decides is how often progress can
+# move. Measured on a live import: ~3.75s per record on CPU, so a group of 32
+# meant the bar stepped once every two minutes and read as frozen; at 4 it
+# moves about every fifteen seconds. The per-call overhead is a dict and a
+# thread hop against ~15s of model work.
+PRIVACY_PROGRESS_CHUNK = 4
+
+
 async def run_privacy_disclosure_layer(
     conn,
     canonical_messages: List[Dict[str, Any]],
     *,
     source_group: Optional[str] = None,
     client: Optional[PrivacyLayerClient] = None,
-    progress_callback: Optional[Callable[[int, int], None]] = None,
+    progress_callback: Optional[Callable[[int, int, str], None]] = None,
     nsfw_only: bool = False,
 ) -> Dict[str, Any]:
     """Mandatory post-canonical Platform Privacy Layer: PII disclosure + NSFW tags.
@@ -242,7 +265,7 @@ async def run_privacy_disclosure_layer(
             table = canonical_table_for_message(msg, source_group=source_group)
             if not table:
                 if progress_callback:
-                    progress_callback(idx + 1, total)
+                    progress_callback(idx + 1, total, PRIVACY_STAGE_REDACT)
                 continue
             record_id = (
                 msg.get("message_id")
@@ -252,7 +275,7 @@ async def run_privacy_disclosure_layer(
             )
             if not record_id:
                 if progress_callback:
-                    progress_callback(idx + 1, total)
+                    progress_callback(idx + 1, total, PRIVACY_STAGE_REDACT)
                 continue
             record_id = str(record_id)
             for field in fields_for_table(table):
@@ -284,10 +307,24 @@ async def run_privacy_disclosure_layer(
 
         from ..sanitization.privacy_filter import PRIVACY_DISCLOSE_MAX_BATCH
 
-        for i in range(0, len(flat_pending), PRIVACY_DISCLOSE_MAX_BATCH):
-            batch = flat_pending[i : i + PRIVACY_DISCLOSE_MAX_BATCH]
+        # Report against the batched work, not the message list: this loop is
+        # where the model time goes, and the old callback fired only on the
+        # branches that SKIP a message -- so a run with nothing to skip
+        # reported nothing at all, for its entire duration.
+        _redact_total = len(flat_pending)
+        _redact_done = 0
+        _redact_chunk = min(PRIVACY_DISCLOSE_MAX_BATCH, PRIVACY_PROGRESS_CHUNK)
+        for i in range(0, len(flat_pending), _redact_chunk):
+            batch = flat_pending[i : i + _redact_chunk]
             items = [{"id": e["batch_key"], "text": e["raw"]} for e in batch]
+            if progress_callback:
+                progress_callback(_redact_done, _redact_total, PRIVACY_STAGE_REDACT)
             result = await privacy_client.redact_batch(items)
+            _redact_done += len(batch)
+            # Also after: without this the final group never reports, and the
+            # stage appears to stop one group short of its own total.
+            if progress_callback:
+                progress_callback(_redact_done, _redact_total, PRIVACY_STAGE_REDACT)
             if result.get("status") in ("unavailable", "failed"):
                 failed_batches += 1
                 logger.warning(
@@ -349,10 +386,18 @@ async def run_privacy_disclosure_layer(
         from ..sanitization.nsfw_classifier import NSFW_CLASSIFY_MAX_BATCH
 
         nsfw_items = list(nsfw_pending.items())
-        for i in range(0, len(nsfw_items), NSFW_CLASSIFY_MAX_BATCH):
-            batch = nsfw_items[i : i + NSFW_CLASSIFY_MAX_BATCH]
+        _nsfw_total = len(nsfw_items)
+        _nsfw_done = 0
+        _nsfw_chunk = min(NSFW_CLASSIFY_MAX_BATCH, PRIVACY_PROGRESS_CHUNK)
+        for i in range(0, len(nsfw_items), _nsfw_chunk):
+            batch = nsfw_items[i : i + _nsfw_chunk]
             items = [{"id": key, "text": entry["text"]} for key, entry in batch]
+            if progress_callback:
+                progress_callback(_nsfw_done, _nsfw_total, PRIVACY_STAGE_NSFW)
             nsfw_result = await privacy_client.classify_nsfw_batch(items)
+            _nsfw_done += len(batch)
+            if progress_callback:
+                progress_callback(_nsfw_done, _nsfw_total, PRIVACY_STAGE_NSFW)
             if nsfw_result.get("status") in ("failed",):
                 nsfw_failed_batches += 1
                 continue

{topos_node-1.3.39 → topos_node-1.3.41}/topos/enrichment/jobs/canonical/entities_job.py

@@ -317,7 +317,20 @@ class EntitiesJob(BaseEnrichmentJob):
             from ....features.entities.edges import record_cooccurrence_pairs
 
             for record_id, ids in entities_by_record.items():
-                event_at = (msg_by_id.get(record_id) or {}).get("event_at")
+                # Tolerant lookup, like every other read of a record's time in
+                # this file. `msg_by_id` holds RAW canonical messages, and the
+                # canonical groups disagree on the column (see
+                # _EVENT_AT_FIELDS) — reading only "event_at" left every
+                # co-occurrence edge undated for any group that names it
+                # otherwise. Measured on a real import: 9,242 of 9,242
+                # co-occurrence edges had no time, while the declared lane
+                # beside them, which already used this lookup, was fully dated.
+                # Undated edges cannot be placed in a temporal view at all.
+                msg_for_event = msg_by_id.get(record_id) or {}
+                event_at = next(
+                    (msg_for_event.get(f) for f in _EVENT_AT_FIELDS if msg_for_event.get(f)),
+                    None,
+                )
                 for src, dst in record_cooccurrence_pairs(ids):
                     update_edge(
                         conn,

{topos_node-1.3.39 → topos_node-1.3.41}/topos/enrichment/orchestrator.py

@@ -181,7 +181,11 @@ class EnrichmentOrchestrator(BaseObject):
                         jobs_percent = ((job_idx - 1) / total_jobs * 100) if total_jobs > 0 else 0
                         # Call orchestrator progress callback with job-level info
                         progress_callback(
-                            processed_count=0,  # Not used for job-level tracking
+                            # The real within-job position. This was pinned to 0
+                            # with a note that it was unused -- true when the only
+                            # consumer was a percentage, but a caller showing
+                            # "N of M" then reads zero for a whole job.
+                            processed_count=current_count,
                             total_count=total_count,
                             job_name=job_name,
                             job_percent=jobs_percent,
@@ -279,7 +283,11 @@ class EnrichmentOrchestrator(BaseObject):
                     job_progress_percent = (job_idx / total_jobs * 100) if total_jobs > 0 else 100
                     # Update with messages processed so far (cumulative across jobs)
                     # Job is 100% complete
-                    progress_callback(messages_processed_so_far, total_messages, job_name, job_progress_percent, 100.0)
+                    # Within-job counts, matching the mid-job callback above.
+                    # This passed a CUMULATIVE total against a per-job
+                    # denominator, so the fourth job of ten reported
+                    # "2,904 of 726" to anyone rendering the pair.
+                    progress_callback(total_messages, total_messages, job_name, job_progress_percent, 100.0)
                 
                 results["jobs_run"] += 1
             except Exception as exc:
@@ -297,7 +305,10 @@ class EnrichmentOrchestrator(BaseObject):
                 if progress_callback:
                     job_progress_percent = (job_idx / total_jobs * 100) if total_jobs > 0 else 100
                     # Mark job as 100% complete (even if failed, we've moved past it)
-                    progress_callback(messages_processed_so_far, total_messages, job.get_job_name(), job_progress_percent, 100.0)
+                    # Within-job counts, as above: a failed job has still
+                    # been moved past, but it did not process more messages
+                    # than it was given.
+                    progress_callback(total_messages, total_messages, job.get_job_name(), job_progress_percent, 100.0)
         
         logger.debug(
             "[PIPELINE:ENRICHMENT] %s: Enrichment complete: %d jobs run, %d total records created",
@@ -498,7 +509,25 @@ class SignalDerivationOrchestrator(EnrichmentOrchestrator):
                 continue
             job_name = job.get_job_name()
             try:
-                records = await job.enrich(canonical_messages)
+                # Report like the canonical lane: a start post, a per-record
+                # callback, and a completion post. This lane used to make ONE
+                # call per job, after the job, with processed=0 and progress=100
+                # -- so every signal stage read "0 of 726" for its whole
+                # duration and the bar jumped to the end of the stage the moment
+                # it began. Observed live: "deriving emo 27, 0/726" on screen for
+                # 34 minutes while TopicsJob logged 264/726 underneath it.
+                _total_msgs = len(canonical_messages)
+                _jobs_pct_before = ((job_idx - 1) / total_jobs * 100) if total_jobs > 0 else 0.0
+
+                def _signal_job_progress(current_count: int, total_count: int, *, _name: str = job_name, _before: float = _jobs_pct_before) -> None:
+                    if not progress_callback:
+                        return
+                    pct = (current_count / total_count * 100) if total_count > 0 else 0.0
+                    progress_callback(current_count, total_count, _name, _before, pct)
+
+                if progress_callback:
+                    progress_callback(0, _total_msgs, job_name, _jobs_pct_before, 0.0)
+                records = await job.enrich(canonical_messages, progress_callback=_signal_job_progress)
                 if records and records[0].get("_deferred"):
                     deferral_error = str(records[0].get("error"))
                     results["deferred_jobs"].append(job_name)
@@ -572,7 +601,8 @@ class SignalDerivationOrchestrator(EnrichmentOrchestrator):
 
                 await _offload_write(_settle_debt)
                 if progress_callback:
-                    progress_callback(0, len(canonical_messages), job_name, (job_idx / total_jobs) * 100, 100.0)
+                    # Within-job counts at completion, matching the canonical lane.
+                    progress_callback(_total_msgs, _total_msgs, job_name, (job_idx / total_jobs) * 100, 100.0)
             except Exception as exc:
                 logger.error("[PIPELINE:SIGNAL_DERIVE] job %s failed: %s", job_name, exc)
                 results["errors"].append({"job": job_name, "error": str(exc)})

{topos_node-1.3.39 → 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.39 → 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 = (