topos-node 1.5.6__tar.gz → 1.5.8__tar.gz

{topos_node-1.5.6/topos_node.egg-info → topos_node-1.5.8}/PKG-INFO

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

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

{topos_node-1.5.6 → topos_node-1.5.8}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.5.6"
-__version_info__ = (1, 5, 6)
+__version__ = "1.5.8"
+__version_info__ = (1, 5, 8)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-1.5.6 → topos_node-1.5.8}/topos/api/home_chat.py

@@ -98,3 +98,19 @@ async def delete_home_chat_session(
     deleted = home_chat_store.delete_session(conn, user_id=user_id.strip(), session_id=session_id.strip())
     if not deleted:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Session not found")
+
+
+@router.post("/v1/home-chat/memory", dependencies=[Depends(require_api_key)])
+async def home_chat_memory(
+    user_id: str = Query(..., min_length=1),
+    engine_id: str = Query(..., min_length=1),
+    body: Dict[str, Any] = Body(default_factory=dict),
+) -> Dict[str, Any]:
+    from ..home_chat.memory import memory_action
+    try:
+        return memory_action(_get_conn(), user_id=user_id.strip(), engine_id=engine_id.strip(),
+                             action=body.get("action"), payload=body)
+    except ValueError as exc:
+        code = str(exc)
+        raise HTTPException(status_code=409 if code == "STALE_REVISION" else 404 if code == "MEMORY_NOT_FOUND" else 400,
+                            detail={"code": code}) from exc

{topos_node-1.5.6 → topos_node-1.5.8}/topos/api/source_install.py

@@ -153,7 +153,8 @@ async def _list_sources_core(payload: Dict[str, Any]) -> Dict[str, Any]:
             continue
         active_by_source[sid] = with_source_capabilities(source_def)
     sources = list(active_by_source.values())
-    return {"status": "ok", "sources": sources, "scope_supply": _scope_supply(list(active_by_source))}
+    return {"status": "ok", "sources": sources,
+            "scope_supply": await asyncio.to_thread(_scope_supply, list(active_by_source))}
 
 
 def _scope_supply(installed_source_ids: list[str]) -> Dict[str, str]:
@@ -168,7 +169,9 @@ def _scope_supply(installed_source_ids: list[str]) -> Dict[str, str]:
     try:
         from ..query.retrieval import routing_supply_states
 
-        return routing_supply_states(installed_source_ids)
+        from ..core.state import get_db_connection
+
+        return routing_supply_states(installed_source_ids, conn=get_db_connection())
     except Exception as exc:  # noqa: BLE001
         logger.debug("[SOURCE_INSTALL] scope supply projection skipped: %s", exc)
         return {}

{topos_node-1.5.6 → topos_node-1.5.8}/topos/core/handlers/home_chat.py

@@ -109,3 +109,20 @@ async def handle_delete_home_chat_session(message: Dict[str, Any]) -> Optional[D
     if not deleted:
         return {"id": req_id, "status": "error", "error": "Session not found"}
     return {"id": req_id, "status": "ok", "payload": {"deleted": True}}
+
+
+@handles("home_chat_memory")
+async def handle_home_chat_memory(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    from ...home_chat.memory import memory_action
+    pl = message.get("payload") or {}
+    conn = hub.get_db_connection()
+    if not conn:
+        return {"id": message.get("id"), "status": "error", "error": "Database not available"}
+    uid, eid = str(pl.get("user_id") or "").strip(), str(pl.get("engine_id") or "").strip()
+    if not uid or not eid:
+        return {"id": message.get("id"), "status": "error", "error": "user_id and engine_id required"}
+    try:
+        result = memory_action(conn, user_id=uid, engine_id=eid, action=pl.get("action"), payload=pl.get("body") or {})
+        return {"id": message.get("id"), "status": "ok", "payload": result}
+    except ValueError as exc:
+        return {"id": message.get("id"), "status": "error", "error": str(exc), "error_code": str(exc)}

{topos_node-1.5.6 → topos_node-1.5.8}/topos/core/handlers/permissions_v2.py

@@ -517,7 +517,7 @@ async def handle_permissions_v2_message_review(message):
         return {"id":req_id,"status":"ok","payload":result.model_dump()}
     except PolicyError as exc:
         code = (403 if exc.code in {"owner_authority_required", "evidence_target_binding"} else
-                409 if exc.code in {"review_stale", "review_conflict", "review_id_conflict"} else
+                409 if exc.code in {"review_stale", "review_conflict", "review_id_conflict", "message_review_busy"} else
                 400 if exc.code in {"schema_invalid", "message_review_window_invalid", "message_review_operation_invalid"} else 503)
         return {"id":req_id,"status":"error","code":code,"error":exc.code}
     except Exception:

{topos_node-1.5.6 → topos_node-1.5.8}/topos/enrichment/jobs/canonical/embeddings_job.py

@@ -23,7 +23,15 @@ def _content_hash(content: str) -> str:
 
 
 def _event_at(msg: Dict[str, Any]) -> Optional[str]:
-    for field in ("event_at", "ts", "entry_at", "occurred_at", "starts_at", "created_at"):
+    # Generic event_at/ts can be a connector's submission clock. Canonical
+    # event fields must win, especially for a journal entered after the event.
+    record_type = _record_type(msg)
+    source_fields = {
+        "journal_entry": ("starts_at", "entry_at"),
+        "calendar_event": ("starts_at",),
+        "activity_event": ("occurred_at",),
+    }.get(record_type, ())
+    for field in (*source_fields, "event_at", "ts", "entry_at", "occurred_at", "starts_at", "created_at"):
         value = msg.get(field)
         if value:
             return str(value)

{topos_node-1.5.6 → topos_node-1.5.8}/topos/features/lifecycle/blackhole_rebuild.py

@@ -658,6 +658,9 @@ def _withdraw_home_chat_sessions(conn: sqlite3.Connection, terms: Set[str], *, d
                 "UPDATE home_chat_sessions SET title=?, history_json=? WHERE id=?",
                 ("conversation" if title_hit else title, history, session_id),
             )
+            if _table_exists(conn, "home_chat_memories"):
+                from ...home_chat.memory import withdraw_changed_sources
+                withdraw_changed_sources(conn, session_id, json.loads(history))
         cleaned += 1
     return cleaned
 

topos_node-1.5.8/topos/home_chat/memory.py

@@ -0,0 +1,118 @@
+"""Explicit, source-backed home-chat memories. Never learns from assistant output.
+
+Functional node storage for milestone one. No query-session/embedding cache: every
+read revalidates its source, so an edit, branch change or deletion withdraws it.
+"""
+from __future__ import annotations
+
+import json
+import re
+from uuid import UUID
+from .schema import ensure_home_chat_schema
+from .store import _now_iso
+from ..storage.db.write_gate import with_db_write, commit_connection
+
+
+def source_message(history, message_id):
+    """Only completed owner messages on the active branch are evidence."""
+    if not isinstance(history, dict) or not isinstance(history.get("messages"), dict):
+        return None
+    messages = history["messages"]
+    current = history.get("currentId")
+    seen, evidence = set(), None
+    while isinstance(current, str) and current not in seen:
+        seen.add(current)
+        message = messages.get(current)
+        if not isinstance(message, dict):
+            return None
+        # A grant's release must not become a new unrestricted memory source.
+        if message.get("sharedGrantAnswer"):
+            return None
+        if current == message_id:
+            if message.get("role") == "user" and message.get("done") and not message.get("streaming"):
+                evidence = str(message.get("content") or "")
+        current = message.get("parentId")
+    return evidence if current is None else None
+
+
+def withdraw_changed_sources(conn, session_id, history):
+    rows = conn.execute("SELECT id, source_message_id, source_content FROM home_chat_memories WHERE source_session_id=? AND deleted=0", (session_id,)).fetchall()
+    for row in rows:
+        if source_message(history, row["source_message_id"]) != row["source_content"]:
+            conn.execute("UPDATE home_chat_memories SET deleted=1, text='', source_content='', revision=revision+1 WHERE id=?", (row["id"],))
+
+
+def _visible(conn, user_id, engine_id):
+    rows = conn.execute("""SELECT m.*, s.title, s.history_json FROM home_chat_memories m
+        JOIN home_chat_sessions s ON s.id=m.source_session_id
+        WHERE m.user_id=? AND m.engine_id=? AND m.deleted=0
+          AND s.user_id=m.user_id AND s.engine_id=m.engine_id
+        ORDER BY m.updated_at DESC, m.id""", (user_id, engine_id)).fetchall()
+    result = []
+    for r in rows:
+        if source_message(json.loads(r["history_json"]), r["source_message_id"]) != r["source_content"]:
+            continue
+        result.append({"id": r["id"], "text": r["text"], "revision": r["revision"],
+            "sourceSessionId": r["source_session_id"], "sourceMessageId": r["source_message_id"],
+            "sourceTitle": r["title"], "updatedAt": r["updated_at"]})
+    return result
+
+
+def memory_action(conn, *, user_id, engine_id, action, payload):
+    ensure_home_chat_schema(conn)
+    if action == "search":
+        rows = _visible(conn, user_id, engine_id)
+        terms = set(re.findall(r"\w+", str(payload.get("query") or "").lower()))
+        if terms:
+            rows = [r for r in rows if any(t in r["text"].lower() for t in terms)]
+            rows.sort(key=lambda r: sum(t in r["text"].lower() for t in terms), reverse=True)
+        return {"memories": rows[:50], "truncated": len(rows) > 50}
+    if action not in {"remember", "correct", "forget"}:
+        raise ValueError("INVALID_ACTION")
+    mid = str(payload.get("id") or "")
+    try:
+        UUID(mid)
+    except ValueError as exc:
+        raise ValueError("INVALID_MEMORY_ID") from exc
+    with with_db_write():
+        try:
+            conn.execute("BEGIN IMMEDIATE")
+            existing = conn.execute("SELECT * FROM home_chat_memories WHERE id=?", (mid,)).fetchone()
+            if existing and (existing["user_id"] != user_id or existing["engine_id"] != engine_id):
+                raise ValueError("MEMORY_NOT_FOUND")
+            if action != "remember":
+                if not existing or existing["deleted"]:
+                    raise ValueError("MEMORY_NOT_FOUND")
+                if existing["revision"] != payload.get("revision"):
+                    raise ValueError("STALE_REVISION")
+            elif existing:
+                # Idempotency: never resurrect a forgotten record on a retry.
+                if existing["deleted"]:
+                    raise ValueError("MEMORY_NOT_FOUND")
+                if existing["text"] != str(payload.get("text") or "").strip():
+                    raise ValueError("STALE_REVISION")
+                visible = next((r for r in _visible(conn, user_id, engine_id) if r["id"] == mid), None)
+                if visible is None:
+                    raise ValueError("MEMORY_NOT_FOUND")
+                commit_connection(conn)
+                return {"memory": visible}
+            if action == "forget":
+                conn.execute("UPDATE home_chat_memories SET deleted=1, text='', source_content='', revision=revision+1 WHERE id=?", (mid,))
+                commit_connection(conn)
+                return {"forgotten": True, "id": mid}
+            sid = str(payload.get("sourceSessionId") or "")
+            message_id = str(payload.get("sourceMessageId") or "")
+            row = conn.execute("SELECT history_json FROM home_chat_sessions WHERE id=? AND user_id=? AND engine_id=?", (sid, user_id, engine_id)).fetchone()
+            content = source_message(json.loads(row[0]), message_id) if row else None
+            text = str(payload.get("text") or "").strip()
+            if not text or len(text) > 1000 or content is None or text not in content:
+                raise ValueError("INVALID_MEMORY_SOURCE")
+            if action == "remember":
+                conn.execute("INSERT INTO home_chat_memories(id,user_id,engine_id,origin_session_id,source_session_id,source_message_id,source_content,text,updated_at) VALUES(?,?,?,?,?,?,?,?,?)", (mid,user_id,engine_id,sid,sid,message_id,content,text,_now_iso()))
+            else:
+                conn.execute("UPDATE home_chat_memories SET source_session_id=?,source_message_id=?,source_content=?,text=?,revision=revision+1,updated_at=? WHERE id=?", (sid,message_id,content,text,_now_iso(),mid))
+            commit_connection(conn)
+            return {"memory": next(r for r in _visible(conn, user_id, engine_id) if r["id"] == mid)}
+        except Exception:
+            conn.rollback()
+            raise

{topos_node-1.5.6 → topos_node-1.5.8}/topos/home_chat/schema.py

@@ -40,6 +40,22 @@ def ensure_home_chat_schema(conn: sqlite3.Connection) -> None:
                 ON home_chat_sessions (user_id, engine_id, updated_at_ms DESC)
                 """
             )
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS home_chat_memories (
+                    id TEXT PRIMARY KEY,
+                    user_id TEXT NOT NULL,
+                    engine_id TEXT NOT NULL,
+                    origin_session_id TEXT NOT NULL REFERENCES home_chat_sessions(id) ON DELETE CASCADE,
+                    source_session_id TEXT NOT NULL REFERENCES home_chat_sessions(id) ON DELETE CASCADE,
+                    source_message_id TEXT NOT NULL,
+                    source_content TEXT NOT NULL,
+                    text TEXT NOT NULL,
+                    revision INTEGER NOT NULL DEFAULT 1,
+                    deleted INTEGER NOT NULL DEFAULT 0,
+                    updated_at TEXT NOT NULL
+                )
+            """)
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_home_chat_memories_owner ON home_chat_memories(user_id, engine_id, deleted)")
             _ensure_participants_column(conn)
             commit_connection(conn)
     except Exception as exc:  # noqa: BLE001

{topos_node-1.5.6 → topos_node-1.5.8}/topos/home_chat/store.py

@@ -270,6 +270,8 @@ def upsert_session(conn: sqlite3.Connection, *, user_id: str, payload: Dict[str,
                 now,
             ),
         )
+        from .memory import withdraw_changed_sources
+        withdraw_changed_sources(conn, sid, history)
         commit_connection(conn)
     row = conn.execute("SELECT * FROM home_chat_sessions WHERE id = ?", (sid,)).fetchone()
     if not row:

{topos_node-1.5.6 → topos_node-1.5.8}/topos/permissions_v2/automatic_review_worker.py

@@ -70,6 +70,10 @@ class AutomaticReviewWorker:
             raise PolicyError("message_review_window_invalid")
         with self._lock:
             if self._thread and self._thread.is_alive():
+                # An owner request names a specific window. Returning another
+                # pass's status would acknowledge work we never scheduled.
+                if refresh:
+                    raise PolicyError("message_review_busy")
                 return self._status.model_copy(deep=True)
             self._stop.clear()
             self._status = AutomaticReviewStatus(state="running")

{topos_node-1.5.6 → topos_node-1.5.8}/topos/protocol/handled_message_types.json

@@ -90,6 +90,7 @@
   "graph_cypher_query",
   "graph_summary",
   "healthcheck",
+  "home_chat_memory",
   "import_apple_contacts",
   "import_contacts_apple_global",
   "import_google_contacts_token",

{topos_node-1.5.6 → topos_node-1.5.8}/topos/query/disclosure.py

@@ -37,6 +37,7 @@ _GRANTEE_TEXT_KEYS = (
     "entity_text",
     "tag",
     "title",
+    "conversation_title",
     "description",
     "search_text",
     "centroid_preview",

{topos_node-1.5.6 → topos_node-1.5.8}/topos/query/game_layer.py

@@ -310,6 +310,11 @@ class DefaultGameLayer:
             payload["answer_type"] = "raw"
             payload["rows"] = context_packet.get("rows") or []
 
+        # Retrieval publishes this only when it enforced the evidence window.
+        # Keep it in inference too, so a dated empty isn't an all-time denial.
+        if context_packet.get("time_window"):
+            payload["time_window"] = context_packet["time_window"]
+
         # Enforced exclusion (retrieval plane). Carried on EVERY mode because the
         # claim it makes is about the whole turn: what the owner asked to be left
         # out, whether it actually was, and how much it removed. The block is closed

{topos_node-1.5.6 → topos_node-1.5.8}/topos/query/inference.py

@@ -70,7 +70,7 @@ def build_inference_context_packet(filtered_context: Dict[str, Any], *, max_char
             compact[key] = ctx[key]
     # Honesty metadata first — see docstring. These keys exist to prevent the model
     # reading an absence as a fact about the world; they must survive any cut.
-    for key in ("truncated", "empty_cause", "exclusion"):
+    for key in ("truncated", "empty_cause", "exclusion", "time_window"):
         if key in ctx and ctx[key] is not None:
             compact[key] = ctx[key]
     # Packet resolution (F2.6 / owner decision 2026-08-25): at 'facts'/'facts_all' the

{topos_node-1.5.6 → topos_node-1.5.8}/topos/query/pipeline.py

@@ -698,7 +698,10 @@ class QueryPipelineOrchestrator:
         availability_final = access_mode == "inference" and is_availability_scope(scope_id)
         if (access_mode == "inference"
                 and not availability_final
-                and public.payload.get("answer_type") != "band"):
+                and public.payload.get("answer_type") != "band"
+                # These direct views describe durable/all-time relationships.
+                # They cannot override a packet with an enforced activity window.
+                and not final_packet.get("time_window")):
             # C7 facts-direct (W3.1): a known-item ask with live facts gets its
             # exact values, validity dates and evidence counts with ZERO LLM —
             # same contract as `band`: deterministic answer_types are final.

{topos_node-1.5.6 → topos_node-1.5.8}/topos/query/planner.py

@@ -217,7 +217,7 @@ _EARLIEST_INSTANT = "1970-01-01T00:00:00+00:00"
 
 def _relative_match(query_text: str) -> Optional["re.Match[str]"]:
     """The phrase `_relative_time_range` resolved, found in the same precedence order."""
-    match = re.search(r"\blast (\d{1,3}) days\b", query_text, re.I)
+    match = re.search(r"\b(?:last|past) (\d{1,3}) days\b", query_text, re.I)
     if match:
         return match
     for pattern, resolver in _RELATIVE_RANGES:
@@ -284,12 +284,14 @@ def _explicit_time_range(query_text: str) -> Optional[Tuple[str, str]]:
 
 
 def _relative_time_range(query_text: str, now: datetime) -> Optional[Tuple[str, str]]:
-    match = re.search(r"\blast (\d{1,3}) days\b", query_text, re.I)
+    match = re.search(r"\b(?:last|past) (\d{1,3}) days\b", query_text, re.I)
     if match:
         start = now - timedelta(days=int(match.group(1)))
+        if match.group(0).lower().startswith("past"):
+            return ((now.astimezone(timezone.utc) - timedelta(days=int(match.group(1)))).astimezone(now.tzinfo).isoformat(), now.isoformat())
         return (
-            start.strftime("%Y-%m-%dT00:00:00+00:00"),
-            now.strftime("%Y-%m-%dT23:59:59+00:00"),
+            start.replace(hour=0, minute=0, second=0, microsecond=0).isoformat(),
+            now.replace(hour=23, minute=59, second=59, microsecond=0).isoformat(),
         )
     for pattern, resolver in _RELATIVE_RANGES:
         if resolver is None:
@@ -297,8 +299,8 @@ def _relative_time_range(query_text: str, now: datetime) -> Optional[Tuple[str,
         if pattern.search(query_text):
             start, end = resolver(now)
             return (
-                start.strftime("%Y-%m-%dT00:00:00+00:00"),
-                end.strftime("%Y-%m-%dT23:59:59+00:00"),
+                start.replace(hour=0, minute=0, second=0, microsecond=0).isoformat(),
+                end.replace(hour=23, minute=59, second=59, microsecond=0).isoformat(),
             )
     return None
 
@@ -331,12 +333,15 @@ def _all_relative_ranges(query_text: str, now: datetime) -> List[Tuple[str, str]
     single-window ask and is exactly why a differenced ask lost its other half.
     """
     found: List[Tuple[str, str]] = []
-    for match in re.finditer(r"\blast (\d{1,3}) days\b", query_text, re.I):
+    for match in re.finditer(r"\b(?:last|past) (\d{1,3}) days\b", query_text, re.I):
         start = now - timedelta(days=int(match.group(1)))
+        if match.group(0).lower().startswith("past"):
+            found.append(((now.astimezone(timezone.utc) - timedelta(days=int(match.group(1)))).astimezone(now.tzinfo).isoformat(), now.isoformat()))
+            continue
         found.append(
             (
-                start.strftime("%Y-%m-%dT00:00:00+00:00"),
-                now.strftime("%Y-%m-%dT23:59:59+00:00"),
+                start.replace(hour=0, minute=0, second=0, microsecond=0).isoformat(),
+                now.replace(hour=23, minute=59, second=59, microsecond=0).isoformat(),
             )
         )
     for pattern, resolver in _RELATIVE_RANGES:
@@ -346,8 +351,8 @@ def _all_relative_ranges(query_text: str, now: datetime) -> List[Tuple[str, str]
             start, end = resolver(now)
             found.append(
                 (
-                    start.strftime("%Y-%m-%dT00:00:00+00:00"),
-                    end.strftime("%Y-%m-%dT23:59:59+00:00"),
+                    start.replace(hour=0, minute=0, second=0, microsecond=0).isoformat(),
+                    end.replace(hour=23, minute=59, second=59, microsecond=0).isoformat(),
                 )
             )
     # Distinct windows only, ordered earliest-first so `baseline` is genuinely the
@@ -407,7 +412,7 @@ def _residual(query_text: str, entities: List[Dict[str, Any]]) -> str:
             if len(first) > 2:
                 residual = re.sub(rf"\b{re.escape(first)}\b", " ", residual, flags=re.I)
     residual = re.sub(
-        r"\b(today|yesterday|this week|last week|this month|last month|last \d+ days)\b",
+        r"\b(today|yesterday|this week|last week|this month|last month|(?:last|past) \d+ days)\b",
         " ",
         residual,
         flags=re.I,
@@ -464,3 +469,8 @@ def build_query_plan(
     plan.dimensions = _dimensions_for(q)
     plan.semantic_residual = _residual(q, plan.entities)
     return plan
+
+
+def is_dated_activity_query(query: str) -> bool:
+    """Event recall, rather than identity, aggregate statistics or goal browsing."""
+    return bool(re.search(r"\b(?:been up to|been working|worked on|working on|did I work on|the work I did|did I do|my activity|code changes)\b", query, re.I))