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

{topos_node-1.2.5/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.5
+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.5 → topos_node-1.2.7}/pyproject.toml

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

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

{topos_node-1.2.5 → topos_node-1.2.7}/topos/api/tool_index.py

@@ -40,6 +40,10 @@ class RetrieveToolsRequest(BaseModel):
     query: str
     connector_scope: Optional[str] = None
     k: int = 8
+    # Per-connector identity-tool override (PLAN_HELP_NUDGE A2): bare names to
+    # ride along beyond IDENTITY_TOOL_NAMES, for connectors whose identity tool
+    # has a nonstandard name (e.g. GraphQL ``viewer``).
+    identity_tools: Optional[List[str]] = None
 
 
 def _require_conn():
@@ -74,6 +78,7 @@ def tools_retrieve(body: RetrieveToolsRequest):
         body.query,
         connector_scope=body.connector_scope,
         k=body.k,
+        extra_identity_names=body.identity_tools or (),
     )
 
 

{topos_node-1.2.5 → 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.5 → topos_node-1.2.7}/topos/core/handlers/tool_index.py

@@ -66,6 +66,13 @@ async def handle_tools_retrieve(message: Dict[str, Any]) -> Optional[Dict[str, A
     query = str(payload.get("query") or "").strip()
     if not query:
         return {"id": req_id, "status": "error", "error": "query is required"}
+    # Per-connector identity-tool override (PLAN_HELP_NUDGE A2).
+    raw_identity = payload.get("identity_tools")
+    identity_tools = (
+        [str(n) for n in raw_identity if str(n or "").strip()]
+        if isinstance(raw_identity, list)
+        else []
+    )
     try:
         from ...features.signal.tool_index import retrieve_tools
 
@@ -75,6 +82,7 @@ async def handle_tools_retrieve(message: Dict[str, Any]) -> Optional[Dict[str, A
             query,
             connector_scope=payload.get("connector_scope"),
             k=int(payload.get("k") or 8),
+            extra_identity_names=identity_tools,
         )
         return {"id": req_id, "status": "ok", "payload": result}
     except Exception as exc:  # noqa: BLE001

{topos_node-1.2.5 → topos_node-1.2.7}/topos/features/signal/tool_index.py

@@ -47,6 +47,16 @@ _TABLE = "tool_index"
 # with a workable move.
 CORE_TOOL_NAMES: tuple[str, ...] = ("query_scope", "describe_connector", "list_connectors")
 
+# Identity-shaped bare tool names that ride along in scoped retrievals
+# (PLAN_HELP_NUDGE A2). Identity tools never rank for task-verb queries ("what
+# were my commits" embeds nothing profile-shaped — get_me sat 24/27 by cosine
+# on the live GitHub index) yet they are the prerequisite for any first-person
+# question: without the login the model fills in a placeholder username and
+# confidently reports empty results.
+IDENTITY_TOOL_NAMES: frozenset[str] = frozenset(
+    {"get_me", "whoami", "me", "get_current_user", "get_authenticated_user", "about_me"}
+)
+
 # Wire-name shape for remote connector tools: remote__{connector}__{tool}.
 _REMOTE_WIRE_RE = re.compile(r"^remote__(?P<connector>[^_].*?)__(?P<tool>.+)$")
 
@@ -263,11 +273,22 @@ def retrieve_tools(
     connector_scope: Optional[str] = None,
     k: int = 8,
     embed_fn: Optional[EmbedFn] = None,
+    extra_identity_names: Sequence[str] = (),
 ) -> Dict[str, Any]:
     """Rank indexed tools for a query; always carries CORE_TOOL_NAMES.
 
     Returns {"tools": [{name, connector_id, description, similarity}], "core",
-    "backend": "cosine" | "keyword_fallback", "model", "indexed_count", "k"}.
+    "identity", "backend": "cosine" | "keyword_fallback", "model",
+    "indexed_count", "k"}.
+
+    When ``connector_scope`` is set, the scoped connector's identity-shaped
+    tools (IDENTITY_TOOL_NAMES, plus ``extra_identity_names`` for connectors
+    whose identity tool has a nonstandard bare name, e.g. GraphQL ``viewer``)
+    always ride along regardless of similarity. Matched names are echoed in the
+    ``identity`` field (empty when unscoped or nothing matched). Ride-alongs
+    outside the top-k carry ``injected: True`` (``similarity: None`` when no
+    score was computable, e.g. a dims-stale row) — so ``tools`` may exceed
+    ``k`` and isn't strictly similarity-sorted at the tail.
     """
     ensure_table(conn)
     k = max(1, min(int(k or 8), 50))
@@ -308,9 +329,44 @@ def retrieve_tools(
 
     scored.sort(key=lambda pair: pair[0], reverse=True)
     top = [{**meta, "similarity": round(score, 6)} for score, meta in scored[:k]]
+
+    # Identity ride-along (PLAN_HELP_NUDGE A2): rows is already scope-filtered
+    # (WHERE connector_id = ?), so matching here can never pull in another
+    # connector's identity tool.
+    identity: List[str] = []
+    if scope:
+        wanted = IDENTITY_TOOL_NAMES | {
+            str(n).strip() for n in extra_identity_names if str(n).strip()
+        }
+        top_names = {t["name"] for t in top}
+        scored_by_name = {meta["name"]: score for score, meta in scored}
+        for name, connector, description, _model, _blob in rows:
+            name = str(name)
+            if _bare_name(name) not in wanted or name in identity:
+                continue
+            identity.append(name)
+            if name in top_names:
+                continue  # already ranked into the top-k on its own; no flag
+            entry: Dict[str, Any] = {
+                "name": name,
+                "connector_id": str(connector),
+                "description": str(description),
+                # Keep the computed (low) score when the scan produced one; a
+                # dims-stale/decode-skipped row gets None — don't invent one.
+                "similarity": round(scored_by_name[name], 6) if name in scored_by_name else None,
+                "injected": True,
+            }
+            top.append(entry)
+        if not identity:
+            logger.debug(
+                "tool_index scoped retrieval found no identity tool to inject (scope=%s)",
+                scope,
+            )
+
     return {
         "tools": top,
         "core": list(CORE_TOOL_NAMES),
+        "identity": identity,
         "backend": backend,
         "model": active_model_label() if embed_fn is None else "injected",
         "indexed_count": len(rows),

{topos_node-1.2.5 → 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.5 → 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.5 → 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.5 → 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.5
+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