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

{topos_node-1.5.7/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.7
+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.7 → topos_node-1.5.8}/pyproject.toml

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

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

{topos_node-1.5.7 → 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.7 → 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.7 → 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.7 → 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.7 → 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.7 → 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.7 → 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.7 → topos_node-1.5.8}/topos/query/retrieval.py

@@ -5301,6 +5301,124 @@ def _load_recent_summary_items(
     return items
 
 
+def _annotate_owner_chat_urls(items, conn, *, now=None):
+    """Attach an observed original URL to eligible owner ChatGPT evidence only.
+
+    Prefer the message's captured thread identity (branches can share messages).
+    Never construct a URL or interpret URLs mentioned inside message content.
+    """
+    from urllib.parse import urlsplit, urlunsplit
+    from ..principal import current_principal
+    if conn is None or str(getattr(current_principal(), "cls", "")) not in {"owner_app", "owner_automation"}:
+        return items
+    ids = list({str(i.get("record_id") or "") for i in items if i.get("record_id")})
+    threads = {}
+    try:
+        for offset in range(0, len(ids), 400):
+            batch = ids[offset:offset + 400]
+            rows = conn.execute(
+                "SELECT message_id, conversation_id, metadata_json FROM ai_chat_messages "
+                "WHERE source_id IN ('chatgpt_ui_conversation','chatgpt_file_ingestion') AND "
+                f"message_id IN ({','.join('?' for _ in batch)})", batch).fetchall()
+            for rid, cid, metadata in rows:
+                try:
+                    meta = json.loads(metadata or "{}")
+                except (ValueError, TypeError):
+                    meta = {}
+                tid = meta.get("thread_id") if isinstance(meta, dict) else None
+                tid = tid or (str(cid)[8:] if str(cid).startswith("chatgpt:") else "")
+                if re.fullmatch(r"[0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}", str(tid)):
+                    threads[str(rid)] = str(tid)
+        urls = {}
+        tids = sorted(set(threads.values()))
+        for offset in range(0, len(tids), 100):
+            batch = tids[offset:offset + 100]
+            rows = conn.execute(
+                "SELECT url FROM browser_visits WHERE (" + " OR ".join("url LIKE ?" for _ in batch) + ") "
+                "AND julianday(visited_at) <= julianday(?) ORDER BY julianday(visited_at) DESC",
+                [f"%/c/{tid}%" for tid in batch] + [(now or datetime.now(timezone.utc)).isoformat()]).fetchall()
+            for (url,) in rows:
+                try:
+                    parsed = urlsplit(url)
+                    tid = parsed.path.rstrip("/").split("/")[-1]
+                    if (parsed.scheme != "https" or parsed.hostname not in {"chatgpt.com", "chat.openai.com"}
+                            or parsed.username or parsed.password or parsed.port not in (None, 443)
+                            or not parsed.path.rstrip("/").endswith("/c/" + tid) or tid not in batch):
+                        continue
+                    # Query strings/fragments are unnecessary to identify the conversation.
+                    urls.setdefault(tid, urlunsplit((parsed.scheme, parsed.netloc, parsed.path, "", "")))
+                except (ValueError, TypeError):
+                    continue
+        for item in items:
+            url = urls.get(threads.get(str(item.get("record_id") or "")))
+            if url:
+                item["source_url"] = url
+                item["source_url_basis"] = "observed_browser_url_exact_thread"
+    except Exception:
+        # Old databases without URL storage still return their normal evidence.
+        pass
+    return items
+
+
+def _annotate_owner_ai_threads(items: List[Dict[str, Any]], conn, *, now=None) -> List[Dict[str, Any]]:
+    """Give an owner's chat snippets their conversation context, from existing records.
+
+    The join annotates only already eligible message IDs; it never retrieves
+    additional message bodies or participates in a grantee's disclosure.
+    """
+    from ..principal import current_principal
+    if conn is None or str(getattr(current_principal(), "cls", "")) not in {"owner_app", "owner_automation"}:
+        return items
+    ids = list({str(i.get("record_id") or "") for i in items if i.get("record_id")})
+    context = {}
+    headings = {}
+    heading_levels = {}
+    try:
+        for offset in range(0, len(ids), 400):
+            batch = ids[offset:offset + 400]
+            rows = conn.execute(
+                "SELECT m.message_id, m.conversation_id, c.title FROM ai_chat_messages m "
+                "LEFT JOIN ai_chat_conversations c ON c.conversation_id = m.conversation_id "
+                f"WHERE m.message_id IN ({','.join('?' for _ in batch)})", batch).fetchall()
+            context.update({str(r[0]): (str(r[1]), str(r[2] or "")) for r in rows})
+        # Some UI captures omit the conversation title. An explicit, unnumbered
+        # document heading is useful source context; keep its provenance and do
+        # not manufacture a project name from an untitled snippet.
+        missing = list({cid for cid, title in context.values() if not title})
+        for offset in range(0, len(missing), 400):
+            batch = missing[offset:offset + 400]
+            reference = (now or datetime.now(timezone.utc)).isoformat()
+            rows = conn.execute(
+                "SELECT conversation_id, message_id, event_at, substr(content,1,200) "
+                "FROM ai_chat_messages WHERE "
+                f"conversation_id IN ({','.join('?' for _ in batch)}) "
+                "AND (content LIKE '# %' OR content LIKE '## %') "
+                "AND julianday(event_at) <= julianday(?) ORDER BY julianday(event_at) DESC", batch + [reference]).fetchall()
+            for cid, rid, event_at, prefix in rows:
+                heading = re.match(r"^#{1,2}\s+([^\n]{8,160})(?:\n|$)", str(prefix or ""))
+                if heading and not re.match(r"\d|(?:section|part)\s+\d", heading[1], re.I):
+                    level = len(str(prefix).split(" ", 1)[0])
+                    if str(cid) not in headings or level < heading_levels[str(cid)]:
+                        headings[str(cid)] = (heading[1].strip(), str(rid), str(event_at))
+                        heading_levels[str(cid)] = level
+    except Exception:
+        return items
+    for item in items:
+        value = context.get(str(item.get("record_id") or ""))
+        if value:
+            item["conversation_id"] = value[0]
+            if value[1]:
+                item["conversation_title"] = value[1]
+                item["conversation_title_source"] = "conversation_record"
+            elif value[0] in headings:
+                heading, rid, event_at = headings[value[0]]
+                item["conversation_title"] = heading
+                item["conversation_title_source"] = "message_heading"
+                item["conversation_title_record_id"] = rid
+                item["conversation_title_event_at"] = event_at
+    return _annotate_owner_chat_urls(items, conn, now=now)
+
+
 def _fusion_item_key(item: Dict[str, Any]) -> str:
     record_id = str(item.get("record_id") or "")
     retrieval = str(item.get("retrieval_source") or "")
@@ -5566,18 +5684,40 @@ def _rrf_fuse_summary_lists(
         ranked.sort(key=lambda pair: _parse_instant(best_item[pair[0]].get("event_at") or best_item[pair[0]].get("occurred_at") or best_item[pair[0]].get("ts")), reverse=True)
         min_per_source = None
     if activity_time_range:
-        # Reserve one latest record per observed day, then fill with the newest.
-        # A dense last day must not erase the rest of a requested week.
-        day_keys = {}
+        # Share the fixed budget across days, then distinct conversations within
+        # each day. One token record per earlier day cannot represent its work.
+        day_keys: Dict[Any, List[str]] = {}
         for key, _ in ranked:
             ts = _parse_instant(best_item[key].get("event_at") or best_item[key].get("occurred_at") or best_item[key].get("ts"))
             day = ts.astimezone((now or datetime.now(timezone.utc)).tzinfo).date()
-            day_keys.setdefault(day, key)
-        chosen = set(list(day_keys.values())[:cap])
-        for key, _ in ranked:
-            if len(chosen) >= cap:
-                break
-            chosen.add(key)
+            day_keys.setdefault(day, []).append(key)
+        def is_goal(key):
+            return str(best_item[key].get("retrieval_source") or "").lower() in {"user_goal", "derived:goal", "derived:user_goals"}
+        for day, keys in day_keys.items():
+            heads, tails, threads = [], [], set()
+            # Prefer an actual source to its extracted goals at equal time.
+            for key in sorted(keys, key=is_goal):
+                thread = str(best_item[key].get("conversation_id") or key)
+                if thread in threads:
+                    tails.append(key)
+                else:
+                    threads.add(thread)
+                    heads.append(key)
+            day_keys[day] = heads + tails
+        chosen = set()
+        goal_count = 0
+        goal_limit = max(0, goal_cap) if goal_cap is not None else cap
+        while len(chosen) < cap and any(day_keys.values()):
+            for keys in day_keys.values():
+                while keys:
+                    key = keys.pop(0)
+                    if is_goal(key) and goal_count >= goal_limit:
+                        continue
+                    chosen.add(key)
+                    goal_count += int(is_goal(key))
+                    break
+                if len(chosen) >= cap:
+                    break
         selected = [key for key, _ in ranked if key in chosen]
     else:
         selection_ranked = ranked
@@ -6850,6 +6990,8 @@ def _build_summary_items_unfiltered(
         # on the generic half of a query ("compiler rewrite") cannot evidence a
         # name the corpus does not contain ("Threnody-7"). The N-lane found
         # exactly this leak when a strong-vector waiver existed here.
+        if disclosure_tier == "owner_raw":
+            _annotate_owner_ai_threads(canonical_items + entity_thread_items + recent_items + vector_items + goal_items, bundle_conn, now=now)
         fused = _rrf_fuse_summary_lists(
             [
                 ("stat_insights", 2.0, stat_items),
@@ -6900,7 +7042,7 @@ def _build_summary_items_unfiltered(
             now=now,
             min_per_source=min_per,
             source_head_guarantees={"canonical": 2} if canonical_items else None,
-            goal_cap=_WORK_GOAL_FUSION_CAP if work_scope and goal_intent else None,
+            goal_cap=_WORK_GOAL_FUSION_CAP if activity_window or (work_scope and goal_intent) else None,
             activity_time_range=activity_window,
             ledger=ledger,
         )

topos_node-1.5.8/topos/storage/db/migrations/home_chat_memories_v1.py

@@ -0,0 +1,25 @@
+"""Add explicit owner memory storage under the backed-up migration ledger."""
+import sqlite3
+
+MIGRATION_ID = "home_chat_memories_v1"
+
+
+def apply_home_chat_memories_v1_up(conn: sqlite3.Connection) -> None:
+    # SQLite permits the references before functional home_chat_sessions is created.
+    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)")
+    conn.execute("INSERT OR IGNORE INTO wiki_schema_migrations (migration_id) VALUES (?)", (MIGRATION_ID,))
+    conn.commit()

{topos_node-1.5.7 → topos_node-1.5.8}/topos/storage/db/migrations/registry.py

@@ -12,6 +12,7 @@ from typing import Callable, List, Optional
 
 import sqlite3
 
+from .home_chat_memories_v1 import MIGRATION_ID as HOME_CHAT_MEMORIES_V1_ID, apply_home_chat_memories_v1_up
 from .wiki_mvp_phase0 import MIGRATION_ID as PHASE0_ID, apply_wiki_mvp_phase0_up
 from .owner_only_records_v1 import MIGRATION_ID as OWNER_ONLY_RECORDS_V1_ID, apply_owner_only_records_v1_up
 from .temporal_fields_v1 import MIGRATION_ID as TEMPORAL_FIELDS_V1_ID, apply_temporal_fields_v1_up
@@ -453,6 +454,7 @@ MIGRATIONS: List[MigrationSpec] = [
     # build reads such an entry as an ordinary one and a clean-up there deletes). One nullable column on the
     # Off-limits table, PRAGMA-guarded; no row is read or changed.
     _spec(81, OFF_LIMITS_CARRIED_WAITING_V1_ID, apply_off_limits_carried_waiting_v1_up, always_run=True),
+    _spec(82, HOME_CHAT_MEMORIES_V1_ID, apply_home_chat_memories_v1_up),
 ]
 
 

{topos_node-1.5.7 → topos_node-1.5.8}/topos/storage/db/migrations/registry_checksums.json

@@ -24,6 +24,7 @@
     "explicit_signal_ia_extraction_artifacts_v1": "e089b4c0565341220a02c62e70ff75c8989c3af31833acd311e12c02fe277f72",
     "explicit_signal_ia_signal_objects_v1": "265e84f58cdb3d329d9c71338d93e261cb84a8f233d5186a45a92676e800d5ab",
     "fact_dimension_by_entity_type_v1": "debc0b1961f20a47d203d611ab05295e3c26c7fb38e59b8e719f4e51586bda58",
+    "home_chat_memories_v1": "249038c4f629ee36ec2300e3421cdf167bc29d0477a61fa8781a294cedec0b11",
     "journal_origin_dimension_v1": "732e59c3fba86fa9057b6c4783385d993d12f514d529cae4e4c2201c04130ab3",
     "mention_table_stamp_backfill_v1": "df56305a0c806ff09f0c57fecdffc386274e360fc641e0cd5e12747585b55cca",
     "message_emotions_role_backfill_v1": "d0db5a58d484844872e37395a730f6e7311a7515b1cba16c97e59e960493524c",

{topos_node-1.5.7 → topos_node-1.5.8}/topos/upgrades/manifests.json

@@ -1031,6 +1031,16 @@
         "Code-only recovery; no schema migration or bulk reprocessing. Existing journal index timestamps are corrected from canonical rows during retrieval before filtering and ordering. Embedding text, model and vectors are unchanged."
       ]
     },
+    {
+      "version": "1.5.8",
+      "summary": "Owner activity coverage, source provenance URLs, and explicit source-backed chat memory.",
+      "steps": [],
+      "notes": [
+        "Additive home_chat_memories_v1 migration, order 82, creates private functional memory storage with source-deletion cascades. Migration ledger enables pre-upgrade backup and downgrade protection.",
+        "No derived invalidation, re-embedding, automatic extraction or bulk reprocessing. Owner URL matching does not widen grants.",
+        "Companion control-plane and web changes enable the memory UI; older clients continue using existing chat APIs."
+      ]
+    },
     {
       "version": "unreleased",
       "summary": "Staging entry for in-flight PRs. cut_release.py stamps this with the next version at release cut. Never executed by steps_between.",

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.5.7
+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.7 → topos_node-1.5.8}/topos_node.egg-info/SOURCES.txt

@@ -507,6 +507,7 @@ topos/filter_lab/service.py
 topos/filter_lab/store.py
 topos/filter_lab/worker.py
 topos/home_chat/__init__.py
+topos/home_chat/memory.py
 topos/home_chat/schema.py
 topos/home_chat/store.py
 topos/ingestion/__init__.py
@@ -830,6 +831,7 @@ topos/storage/db/migrations/entity_review_provenance_v1.py
 topos/storage/db/migrations/episodes_v1.py
 topos/storage/db/migrations/extraction_artifacts.py
 topos/storage/db/migrations/fact_dimension_by_entity_type_v1.py
+topos/storage/db/migrations/home_chat_memories_v1.py
 topos/storage/db/migrations/journal_entries_duration_v1.py
 topos/storage/db/migrations/journal_entries_ends_at_v1.py
 topos/storage/db/migrations/journal_entries_people_v1.py