topos-node 1.2.6__tar.gz → 1.2.7__tar.gz

{topos_node-1.2.6/topos_node.egg-info → topos_node-1.2.7}/PKG-INFO

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

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

{topos_node-1.2.6 → topos_node-1.2.7}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.2.6"
-__version_info__ = (1, 2, 6)
+__version__ = "1.2.7"
+__version_info__ = (1, 2, 7)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-1.2.6 → topos_node-1.2.7}/topos/core/handlers/query.py

@@ -50,11 +50,24 @@ async def handle_query(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
                     "session_id": payload.get("query_session_id") or payload.get("session_id"),
                 },
             }
+        # Client-supplied reference instant (offset-aware ISO): "yesterday"
+        # resolves against the USER's calendar day, not this server's UTC day.
+        # Unparseable/absent → None → planner wall clock.
+        query_now = None
+        raw_now = str(payload.get("now") or "").strip()
+        if raw_now:
+            try:
+                from datetime import datetime
+
+                query_now = datetime.fromisoformat(raw_now.replace("Z", "+00:00"))
+            except ValueError:
+                logger.debug("unparseable query now=%r ignored", raw_now)
         result = await get_query_orchestrator(conn=hub.get_db_connection()).execute(
             query_text=intent,
             scope_id=scope_id,
             access_mode=str(payload.get("access_mode") or "summary"),
             manifest=manifest,
+            now=query_now,
             query_session_id=payload.get("query_session_id") or payload.get("session_id"),
             filter_manifest=filter_manifest,
             field_transforms=payload.get("field_transforms"),

{topos_node-1.2.6 → topos_node-1.2.7}/topos/query/game_layer.py

@@ -165,6 +165,10 @@ class DefaultGameLayer:
         elif access_mode == "summary":
             payload["answer_type"] = "summary"
             payload["summaries"] = context_packet.get("summaries") or []
+            # Planner-parsed date window (present only when retrieval honored
+            # one) — lets synthesis state the searched range explicitly.
+            if context_packet.get("time_window"):
+                payload["time_window"] = context_packet["time_window"]
         else:
             payload["answer_type"] = "raw"
             payload["rows"] = context_packet.get("rows") or []

{topos_node-1.2.6 → topos_node-1.2.7}/topos/query/retrieval.py

@@ -587,21 +587,57 @@ def _resolve_source_ids(
     return resolve_retrieval_source_ids(manifest, installed_source_ids)
 
 
+def _parse_instant(raw: Any) -> Optional[datetime]:
+    if not raw:
+        return None
+    try:
+        ts = datetime.fromisoformat(str(raw).replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    return ts if ts.tzinfo else ts.replace(tzinfo=timezone.utc)
+
+
 def _parse_row_timestamp(row: Dict[str, Any]) -> Optional[datetime]:
     for field in ("event_at", "ts", "occurred_at", "created_at"):
-        raw = row.get(field)
-        if not raw:
-            continue
-        try:
-            ts = datetime.fromisoformat(str(raw).replace("Z", "+00:00"))
-            if ts.tzinfo is None:
-                ts = ts.replace(tzinfo=timezone.utc)
+        ts = _parse_instant(row.get(field))
+        if ts is not None:
             return ts
-        except ValueError:
-            continue
     return None
 
 
+def _prefer_time_window(
+    items: List[Dict[str, Any]],
+    time_range: Optional[Tuple[str, str]],
+) -> List[Dict[str, Any]]:
+    """Keep the items inside the plan's time window when any exist.
+
+    Soft fallback, mirroring the vector lane's unscoped retry: a time-scoped
+    ask over a lane with nothing in-window degrades to dated-but-out-of-window
+    evidence rather than an empty lane — but every returned item is annotated
+    with `in_time_window` so synthesis can say "nothing from yesterday; most
+    recent instead" rather than passing off stale items as in-range. Undated
+    items count as out-of-window: they cannot evidence a date-scoped claim.
+    """
+    if not time_range or not items:
+        return items
+    start = _parse_instant(time_range[0])
+    end = _parse_instant(time_range[1])
+    if start is None or end is None:
+        return items
+    in_window: List[Dict[str, Any]] = []
+    for item in items:
+        ts = _parse_row_timestamp(item)
+        if ts is not None and start <= ts <= end:
+            in_window.append(item)
+    if in_window:
+        for item in in_window:
+            item["in_time_window"] = True
+        return in_window
+    for item in items:
+        item["in_time_window"] = False
+    return items
+
+
 def _apply_filter_manifest_rows(
     rows: List[Dict[str, Any]],
     filter_manifest: Optional[Dict[str, Any]],
@@ -641,6 +677,7 @@ def _load_user_goal_summaries(
     source_ids: Optional[List[str]] = None,
     limit: int = _SUMMARY_ITEM_CAP,
     conn: Optional[Any] = None,
+    time_range: Optional[Tuple[str, str]] = None,
 ) -> List[Dict[str, Any]]:
     try:
         # Prefer the query's own connection (multi-db verification, seeded evals);
@@ -652,20 +689,40 @@ def _load_user_goal_summaries(
         if conn is None:
             return []
         params: List[Any] = []
-        query = "SELECT goal_id, record_id, source_id, goal_text FROM user_goals"
+        # event_at is the source message's time from the unified timeline
+        # (user_goals.record_id = message_id); created_at is only ingest time.
+        # Without a date field goals can never answer "yesterday's goals" and
+        # dodge recency decay entirely.
+        select = (
+            "SELECT g.goal_id, g.record_id, g.source_id, g.goal_text, g.created_at,"
+            " (SELECT MAX(t.event_at) FROM timeline t WHERE t.record_id = g.record_id)"
+            " FROM user_goals g"
+        )
+        where = ""
         if source_ids:
             placeholders = ",".join("?" for _ in source_ids)
-            query += f" WHERE source_id IN ({placeholders})"
+            where = f" WHERE g.source_id IN ({placeholders})"
             params.extend(source_ids)
-        query += " ORDER BY created_at DESC LIMIT ?"
+        tail = " ORDER BY g.created_at DESC LIMIT ?"
         params.append(max(limit * 3, 50))
-        rows = conn.execute(query, tuple(params)).fetchall()
+        try:
+            rows = conn.execute(select + where + tail, tuple(params)).fetchall()
+        except Exception:
+            # Databases predating the timeline projection: dated by ingest only.
+            rows = [
+                (*row, None)
+                for row in conn.execute(
+                    "SELECT goal_id, record_id, source_id, goal_text, created_at"
+                    " FROM user_goals" + where.replace("g.", "") + tail.replace("g.", ""),
+                    tuple(params),
+                ).fetchall()
+            ]
         items: List[Dict[str, Any]] = []
         tokens = _query_tokens(query_text)
         query_lower = (query_text or "").lower()
         goal_intent = any(term in query_lower for term in _EXTRA_SURFACE_TERMS)
         seen_texts: set = set()
-        for goal_id, record_id, source_id, goal_text in rows:
+        for goal_id, record_id, source_id, goal_text, created_at, event_at in rows:
             text = str(goal_text or "").strip()
             if not text:
                 continue
@@ -686,10 +743,13 @@ def _load_user_goal_summaries(
                     "record_id": record_id,
                     "source_id": source_id,
                     "dimension": "work",
+                    "event_at": event_at or created_at,
+                    "created_at": created_at,
                     "relevance_score": round(_goal_relevance(text, query_text), 4),
                     "retrieval_source": "user_goal",
                 }
             )
+        items = _prefer_time_window(items, time_range)
         items.sort(key=lambda item: float(item.get("relevance_score") or 0.0), reverse=True)
         return items[:limit]
     except Exception as exc:
@@ -1035,6 +1095,14 @@ def _load_canonical_summary_items(
                 "relevance_score": round(_canonical_relevance(text, query_text), 4),
                 "retrieval_source": f"canonical:{table}",
             }
+            # Per-table event-time column (same keys the recency sort in
+            # _list_canonical_rows uses); without it canonical rows can neither
+            # decay in fusion nor answer a date-scoped ask.
+            for ts_key in ("event_at", "starts_at", "occurred_at", "entry_at"):
+                ts_val = clean.get(ts_key) or row.get(ts_key)
+                if ts_val:
+                    item["event_at"] = ts_val
+                    break
             if owner is not None:
                 item["owner_authored"] = owner
             items.append(item)
@@ -1440,6 +1508,9 @@ def _semantic_hits(
                     "similarity": item.get("similarity"),
                     "source_id": item.get("source_id"),
                     "signal_dimension": item.get("signal_dimension"),
+                    # Without the event time, vector items are exempt from
+                    # recency decay by accident and undated at synthesis.
+                    "event_at": item.get("event_at"),
                 }
             )
         return hits, result.get("error")
@@ -2059,7 +2130,10 @@ def _build_summary_items(
             str(s).strip() for s in (manifest.default_source_ids or []) if str(s).strip()
         ] or (source_ids or None)
         goal_items = _load_user_goal_summaries(
-            query_text, source_ids=goal_source_ids or None, conn=bundle_conn
+            query_text,
+            source_ids=goal_source_ids or None,
+            conn=bundle_conn,
+            time_range=getattr(plan, "time_range", None) if plan else None,
         )
 
     canonical_items = _load_canonical_summary_items(
@@ -2073,6 +2147,9 @@ def _build_summary_items(
         conn=bundle_conn,
         exposure_visible=exposure_visible,
     )
+    canonical_items = _prefer_time_window(
+        canonical_items, getattr(plan, "time_range", None) if plan else None
+    )
 
     # Interaction browse ("who do I talk to"): the contact registry is the
     # ground truth of interaction partners — mention-only names (someone the
@@ -2162,6 +2239,7 @@ def _build_summary_items(
             "record_id": hit.get("record_id"),
             "source_id": hit.get("source_id"),
             "signal_dimension": hit.get("signal_dimension"),
+            "event_at": hit.get("event_at"),
             "relevance_score": round(similarity, 4),
             "retrieval_source": "vector",
         }
@@ -2236,6 +2314,12 @@ def _build_summary_items(
                     "retrieval_source": "signal_fact",
                 }
             )
+    # Same time-window preference as the goal lane: dimension facts now carry
+    # created_at (and sometimes event_at) — a "yesterday" ask keeps in-window
+    # facts when any exist, annotated fallback otherwise.
+    fact_items = _prefer_time_window(
+        fact_items, getattr(plan, "time_range", None) if plan else None
+    )
     fact_items.sort(key=lambda item: float(item.get("relevance_score") or 0.0), reverse=True)
     if first_person:
         # The dimension-dump lane carries raw stat payloads too — the same
@@ -2608,6 +2692,18 @@ class DefaultSignalRetrievalAdapter:
                 )
                 if summaries:
                     touched.append("signal")
+                # Surface the planner's parsed window so synthesis can state
+                # which dates were searched ("nothing from 2026-07-16") instead
+                # of inferring it from per-item timestamps. Summary mode only:
+                # its lanes honor the window; raw/inference do not yet
+                # (PLAN_TEMPORAL_COHERENCE.md M5/M6) and must not claim to.
+                if plan is not None and (plan.time_range or plan.as_of):
+                    window: Dict[str, Any] = {"source": "query_planner"}
+                    if plan.time_range:
+                        window["from"], window["to"] = plan.time_range
+                    if plan.as_of:
+                        window["as_of"] = plan.as_of
+                    packet["time_window"] = window
             else:
                 summaries = []
                 for dim in manifest.primary_dimensions:

{topos_node-1.2.6 → topos_node-1.2.7}/topos/storage/adapters/sqlite/stores.py

@@ -609,7 +609,7 @@ class SQLiteSignalFeatureStore:
         return summary_id
 
     def _list_rows(self, table: str, *, dimension: Optional[str], limit: int, offset: int) -> ListPage:
-        query = f"SELECT payload_json FROM {table}"
+        query = f"SELECT payload_json, created_at FROM {table}"
         params: List[Any] = []
         if dimension is not None:
             query += " WHERE dimension=?"
@@ -618,7 +618,14 @@ class SQLiteSignalFeatureStore:
         total = int(count[0]) if count else 0
         query += " ORDER BY rowid LIMIT ? OFFSET ?"
         params.extend([limit, offset])
-        items = [json.loads(r[0]) for r in self._conn.execute(query, params).fetchall()]
+        items: List[Dict[str, Any]] = []
+        for payload_json, created_at in self._conn.execute(query, params).fetchall():
+            item = json.loads(payload_json)
+            # The row timestamp lives in the column, not the payload; without it
+            # facts are undated downstream (no recency decay, no time filtering).
+            if created_at:
+                item.setdefault("created_at", created_at)
+            items.append(item)
         return ListPage(items=items, total=total, offset=offset, limit=limit)
 
     def get_by_dimension(self, dimension: str, *, limit: int = 100, offset: int = 0) -> ListPage:

{topos_node-1.2.6 → topos_node-1.2.7/topos_node.egg-info}/PKG-INFO

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