nexo-brain 3.1.6 → 3.1.8

package/src/db/_learnings.py

@@ -1,9 +1,17 @@
 from __future__ import annotations
 """NEXO DB — Learnings module."""
+import importlib
 import re, time
-from db._core import get_db, now_epoch
+import sys
 from db._fts import fts_upsert, fts_search
 
+
+def _core():
+    module = sys.modules.get("db._core")
+    if module is None:
+        module = importlib.import_module("db._core")
+    return module
+
 # ── Learnings ──────────────────────────────────────────────────────
 
 def create_learning(
@@ -19,8 +27,8 @@ def create_learning(
     last_reviewed_at: float | None = None,
 ) -> dict:
     """Create a new learning entry with optional reasoning."""
-    conn = get_db()
-    now = now_epoch()
+    conn = _core().get_db()
+    now = _core().now_epoch()
     cursor = conn.execute(
         "INSERT INTO learnings "
         "(category, title, content, reasoning, prevention, applies_to, supersedes_id, status, review_due_at, last_reviewed_at, created_at, updated_at) "
@@ -39,7 +47,7 @@ def create_learning(
 
 def update_learning(id: int, **kwargs) -> dict:
     """Update any fields of a learning: category, title, content, reasoning."""
-    conn = get_db()
+    conn = _core().get_db()
     row = conn.execute("SELECT * FROM learnings WHERE id = ?", (id,)).fetchone()
     if not row:
             return {"error": f"Learning {id} not found"}
@@ -50,7 +58,7 @@ def update_learning(id: int, **kwargs) -> dict:
     updates = {k: v for k, v in kwargs.items() if k in allowed}
     if not updates:
             return dict(row)
-    updates["updated_at"] = now_epoch()
+    updates["updated_at"] = _core().now_epoch()
     set_clause = ", ".join(f"{k} = ?" for k in updates)
     values = list(updates.values()) + [id]
     conn.execute(f"UPDATE learnings SET {set_clause} WHERE id = ?", values)
@@ -63,7 +71,7 @@ def update_learning(id: int, **kwargs) -> dict:
 
 def supersede_learning(old_id: int, new_id: int, note: str = '') -> dict:
     """Mark an older learning as superseded by a newer canonical learning."""
-    conn = get_db()
+    conn = _core().get_db()
     old_row = conn.execute("SELECT * FROM learnings WHERE id = ?", (old_id,)).fetchone()
     new_row = conn.execute("SELECT * FROM learnings WHERE id = ?", (new_id,)).fetchone()
     if not old_row:
@@ -74,7 +82,7 @@ def supersede_learning(old_id: int, new_id: int, note: str = '') -> dict:
     old_reasoning = str(old_row["reasoning"] or "")
     suffix = note.strip() if note.strip() else f"Superseded by learning #{new_id}."
     combined_reasoning = f"{old_reasoning}\n{suffix}".strip() if old_reasoning else suffix
-    updated_at = now_epoch()
+    updated_at = _core().now_epoch()
     conn.execute(
         "UPDATE learnings SET status = 'superseded', updated_at = ?, reasoning = ? WHERE id = ?",
         (updated_at, combined_reasoning, old_id),
@@ -90,7 +98,7 @@ def supersede_learning(old_id: int, new_id: int, note: str = '') -> dict:
 
 def delete_learning(id: int) -> bool:
     """Delete a learning entry."""
-    conn = get_db()
+    conn = _core().get_db()
     result = conn.execute("DELETE FROM learnings WHERE id = ?", (id,))
     conn.execute("DELETE FROM unified_search WHERE source = 'learning' AND source_id = ?", (str(id),))
     conn.commit()
@@ -103,7 +111,7 @@ def search_learnings(query: str, category: str = None) -> list[dict]:
     # Try FTS5 first
     fts_results = fts_search(query, source_filter="learning", limit=30)
     if fts_results:
-        conn = get_db()
+        conn = _core().get_db()
         ids = [int(r['source_id']) for r in fts_results]
         placeholders = ','.join('?' * len(ids))
         rows = conn.execute(
@@ -116,7 +124,7 @@ def search_learnings(query: str, category: str = None) -> list[dict]:
         return filtered
 
     # Fallback to LIKE
-    conn = get_db()
+    conn = _core().get_db()
     words = query.strip().split()
     if not words:
         return []
@@ -139,7 +147,7 @@ def search_learnings(query: str, category: str = None) -> list[dict]:
 
 def list_learnings(category: str = None) -> list[dict]:
     """List all learnings, optionally filtered by category."""
-    conn = get_db()
+    conn = _core().get_db()
     if category:
         rows = conn.execute(
             "SELECT * FROM learnings WHERE category = ? ORDER BY updated_at DESC",
@@ -176,7 +184,7 @@ def find_similar_learnings(new_id: int, title: str, content: str, category: str)
     keywords_new = set(extract_keywords(f"{title} {content}"))
     if not keywords_new:
         return []
-    conn = get_db()
+    conn = _core().get_db()
     rows = conn.execute(
         "SELECT id, title, content FROM learnings WHERE category = ? AND id != ?",
         (category, new_id)
@@ -193,4 +201,3 @@ def find_similar_learnings(new_id: int, title: str, content: str, category: str)
             results.append((row['id'], round(similarity, 2)))
     results.sort(key=lambda x: x[1], reverse=True)
     return results[:5]
-

package/src/db/_reminders.py

@@ -9,6 +9,7 @@ from typing import Any
 
 from db._core import get_db, now_epoch
 from db._fts import fts_upsert
+from db._hot_context import capture_context_event
 
 ACTIVE_EXCLUDED_STATUSES = {"DELETED", "archived", "blocked", "waiting"}
 READ_TOKEN_TTL_SECONDS = 30 * 60
@@ -190,6 +191,19 @@ def _active_status_where(column_name: str = "status") -> str:
     )
 
 
+def _context_state_from_status(status: str | None) -> str:
+    normalized = str(status or "PENDING").strip().upper()
+    if normalized.startswith("COMPLETED"):
+        return "resolved"
+    if normalized == "DELETED":
+        return "abandoned"
+    if normalized == "WAITING":
+        return "waiting_user"
+    if normalized == "BLOCKED":
+        return "blocked"
+    return "active"
+
+
 # ── Reminders ──────────────────────────────────────────────────────
 
 
@@ -221,6 +235,23 @@ def create_reminder(
         note=f"Reminder created. Category={category}. Date={date or '—'}.",
         actor="db",
     )
+    capture_context_event(
+        event_type="reminder_created",
+        title=description[:160],
+        summary=description[:600],
+        body=f"Category={category}. Date={date or '—'}.",
+        context_key=f"reminder:{id}",
+        context_title=description[:160],
+        context_summary=description[:600],
+        context_type="reminder",
+        state=_context_state_from_status(status),
+        owner="user",
+        actor="db",
+        source_type="reminder",
+        source_id=id,
+        metadata={"category": category, "status": status, "date": date or ""},
+        ttl_hours=24,
+    )
     return dict(row)
 
 
@@ -251,9 +282,27 @@ def update_reminder(
     conn.commit()
 
     new_row = conn.execute("SELECT * FROM reminders WHERE id = ?", (id,)).fetchone()
+    current = dict(new_row) if new_row else dict(row)
     if log_history:
         note = history_note or _format_changes(row, new_row, ["description", "date", "status", "category"])
         add_item_history("reminder", id, history_event, note=note or "Reminder updated.", actor=history_actor)
+    capture_context_event(
+        event_type=f"reminder_{history_event}",
+        title=(new_row["description"] if new_row else row["description"])[:160],
+        summary=((note if log_history else history_note) or "Reminder updated.")[:600],
+        body=((new_row["description"] if new_row else row["description"]) or "")[:1600],
+        context_key=f"reminder:{id}",
+        context_title=(new_row["description"] if new_row else row["description"])[:160],
+        context_summary=((new_row["description"] if new_row else row["description"]) or "")[:600],
+        context_type="reminder",
+        state=_context_state_from_status(current.get("status")),
+        owner="user",
+        actor=history_actor,
+        source_type="reminder",
+        source_id=id,
+        metadata={"status": current.get("status", ""), "date": current.get("date", "")},
+        ttl_hours=24,
+    )
     return dict(new_row)
 
 
@@ -267,6 +316,23 @@ def complete_reminder(id: str) -> dict:
     if "error" in result:
         return result
     add_item_history("reminder", id, "completed", note="Reminder marked COMPLETED.", actor="db")
+    capture_context_event(
+        event_type="reminder_completed",
+        title=(result.get("description") or id)[:160],
+        summary="Reminder marked COMPLETED.",
+        body=(result.get("description") or "")[:1600],
+        context_key=f"reminder:{id}",
+        context_title=(result.get("description") or id)[:160],
+        context_summary=(result.get("description") or "")[:600],
+        context_type="reminder",
+        state="resolved",
+        owner="user",
+        actor="db",
+        source_type="reminder",
+        source_id=id,
+        metadata={"status": "COMPLETED"},
+        ttl_hours=24,
+    )
     return result
 
 
@@ -280,6 +346,23 @@ def delete_reminder(id: str) -> bool:
     if "error" in result:
         return False
     add_item_history("reminder", id, "deleted", note="Reminder soft-deleted (status=DELETED).", actor="db")
+    capture_context_event(
+        event_type="reminder_deleted",
+        title=(result.get("description") or id)[:160],
+        summary="Reminder soft-deleted (status=DELETED).",
+        body=(result.get("description") or "")[:1600],
+        context_key=f"reminder:{id}",
+        context_title=(result.get("description") or id)[:160],
+        context_summary=(result.get("description") or "")[:600],
+        context_type="reminder",
+        state="abandoned",
+        owner="user",
+        actor="db",
+        source_type="reminder",
+        source_id=id,
+        metadata={"status": "DELETED"},
+        ttl_hours=24,
+    )
     return True
 
 
@@ -297,6 +380,23 @@ def restore_reminder(id: str) -> dict:
         return result
     previous = row.get("status") or "unknown"
     add_item_history("reminder", id, "restored", note=f"Reminder restored from {previous} to PENDING.", actor="db")
+    capture_context_event(
+        event_type="reminder_restored",
+        title=(result.get("description") or id)[:160],
+        summary=f"Reminder restored from {previous} to PENDING.",
+        body=(result.get("description") or "")[:1600],
+        context_key=f"reminder:{id}",
+        context_title=(result.get("description") or id)[:160],
+        context_summary=(result.get("description") or "")[:600],
+        context_type="reminder",
+        state="active",
+        owner="user",
+        actor="db",
+        source_type="reminder",
+        source_id=id,
+        metadata={"previous_status": previous, "status": "PENDING"},
+        ttl_hours=24,
+    )
     return result
 
 
@@ -305,7 +405,25 @@ def add_reminder_note(id: str, note: str, actor: str = "nexo") -> dict:
     row = get_reminder(id)
     if not row:
         return {"error": f"Reminder {id} not found"}
-    return add_item_history("reminder", id, "note", note=note, actor=actor)
+    history = add_item_history("reminder", id, "note", note=note, actor=actor)
+    capture_context_event(
+        event_type="reminder_note",
+        title=(row.get("description") or id)[:160],
+        summary=note[:600],
+        body=note[:1600],
+        context_key=f"reminder:{id}",
+        context_title=(row.get("description") or id)[:160],
+        context_summary=(row.get("description") or "")[:600],
+        context_type="reminder",
+        state=_context_state_from_status(row.get("status")),
+        owner="user",
+        actor=actor,
+        source_type="reminder",
+        source_id=id,
+        metadata={"status": row.get("status", "")},
+        ttl_hours=24,
+    )
+    return history
 
 
 def get_reminders(filter_type: str = "all") -> list[dict]:
@@ -450,6 +568,23 @@ def create_followup(
         note=f"Followup created. Date={date or '—'}. Recurrence={recurrence or '—'}.",
         actor="db",
     )
+    capture_context_event(
+        event_type="followup_created",
+        title=description[:160],
+        summary=description[:600],
+        body=f"Verification={verification[:240]}. Reasoning={reasoning[:240]}.",
+        context_key=f"followup:{id}",
+        context_title=description[:160],
+        context_summary=description[:600],
+        context_type="followup",
+        state=_context_state_from_status(status),
+        owner="nexo",
+        actor="db",
+        source_type="followup",
+        source_id=id,
+        metadata={"status": status, "date": date or "", "priority": priority or "medium"},
+        ttl_hours=24,
+    )
     result = dict(row)
     if warning:
         result["warning"] = warning
@@ -483,6 +618,7 @@ def update_followup(
     conn.commit()
 
     new_row = conn.execute("SELECT * FROM followups WHERE id = ?", (id,)).fetchone()
+    current = dict(new_row) if new_row else dict(row)
     if new_row and _table_exists(conn, "unified_search"):
         new_row_dict = dict(new_row)
         fts_upsert(
@@ -500,6 +636,27 @@ def update_followup(
             ["description", "date", "verification", "status", "reasoning", "recurrence", "priority"],
         )
         add_item_history("followup", id, history_event, note=note or "Followup updated.", actor=history_actor)
+    capture_context_event(
+        event_type=f"followup_{history_event}",
+        title=(new_row["description"] if new_row else row["description"])[:160],
+        summary=((note if log_history else history_note) or "Followup updated.")[:600],
+        body=((new_row["description"] if new_row else row["description"]) or "")[:1600],
+        context_key=f"followup:{id}",
+        context_title=(new_row["description"] if new_row else row["description"])[:160],
+        context_summary=((new_row["description"] if new_row else row["description"]) or "")[:600],
+        context_type="followup",
+        state=_context_state_from_status(current.get("status")),
+        owner="nexo",
+        actor=history_actor,
+        source_type="followup",
+        source_id=id,
+        metadata={
+            "status": current.get("status", ""),
+            "date": current.get("date", ""),
+            "priority": current.get("priority", ""),
+        },
+        ttl_hours=24,
+    )
     return dict(new_row)
 
 
@@ -572,6 +729,23 @@ def complete_followup(id: str, result: str = "") -> dict:
         note=result or "Followup marked COMPLETED.",
         actor="db",
     )
+    capture_context_event(
+        event_type="followup_completed",
+        title=(update_result.get("description") or id)[:160],
+        summary=(result or "Followup marked COMPLETED.")[:600],
+        body=(update_result.get("description") or "")[:1600],
+        context_key=f"followup:{id}",
+        context_title=(update_result.get("description") or id)[:160],
+        context_summary=(update_result.get("description") or "")[:600],
+        context_type="followup",
+        state="resolved",
+        owner="nexo",
+        actor="db",
+        source_type="followup",
+        source_id=id,
+        metadata={"status": "COMPLETED"},
+        ttl_hours=24,
+    )
 
     recurrence = row["recurrence"]
     if recurrence:
@@ -619,6 +793,23 @@ def complete_followup(id: str, result: str = "") -> dict:
                 actor="db",
                 metadata={"source_followup_id": archived_id},
             )
+            capture_context_event(
+                event_type="followup_recurrence_archived",
+                title=(archived_row["description"] or archived_id)[:160],
+                summary=f"Recurring followup archived as {archived_id}. Next occurrence spawned as {id} for {next_date}.",
+                body=(archived_row["description"] or "")[:1600],
+                context_key=f"followup:{archived_id}",
+                context_title=(archived_row["description"] or archived_id)[:160],
+                context_summary=(archived_row["description"] or "")[:600],
+                context_type="followup",
+                state="resolved",
+                owner="nexo",
+                actor="db",
+                source_type="followup",
+                source_id=archived_id,
+                metadata={"next_id": id, "next_date": next_date},
+                ttl_hours=24,
+            )
             return {
                 "id": archived_id,
                 "status": "COMPLETED",
@@ -636,6 +827,23 @@ def delete_followup(id: str) -> bool:
     if "error" in result:
         return False
     add_item_history("followup", id, "deleted", note="Followup soft-deleted (status=DELETED).", actor="db")
+    capture_context_event(
+        event_type="followup_deleted",
+        title=(result.get("description") or id)[:160],
+        summary="Followup soft-deleted (status=DELETED).",
+        body=(result.get("description") or "")[:1600],
+        context_key=f"followup:{id}",
+        context_title=(result.get("description") or id)[:160],
+        context_summary=(result.get("description") or "")[:600],
+        context_type="followup",
+        state="abandoned",
+        owner="nexo",
+        actor="db",
+        source_type="followup",
+        source_id=id,
+        metadata={"status": "DELETED"},
+        ttl_hours=24,
+    )
     return True
 
 
@@ -649,6 +857,23 @@ def restore_followup(id: str) -> dict:
         return result
     previous = row.get("status") or "unknown"
     add_item_history("followup", id, "restored", note=f"Followup restored from {previous} to PENDING.", actor="db")
+    capture_context_event(
+        event_type="followup_restored",
+        title=(result.get("description") or id)[:160],
+        summary=f"Followup restored from {previous} to PENDING.",
+        body=(result.get("description") or "")[:1600],
+        context_key=f"followup:{id}",
+        context_title=(result.get("description") or id)[:160],
+        context_summary=(result.get("description") or "")[:600],
+        context_type="followup",
+        state="active",
+        owner="nexo",
+        actor="db",
+        source_type="followup",
+        source_id=id,
+        metadata={"previous_status": previous, "status": "PENDING"},
+        ttl_hours=24,
+    )
     return result
 
 
@@ -657,7 +882,25 @@ def add_followup_note(id: str, note: str, actor: str = "nexo") -> dict:
     row = get_followup(id)
     if not row:
         return {"error": f"Followup {id} not found"}
-    return add_item_history("followup", id, "note", note=note, actor=actor)
+    history = add_item_history("followup", id, "note", note=note, actor=actor)
+    capture_context_event(
+        event_type="followup_note",
+        title=(row.get("description") or id)[:160],
+        summary=note[:600],
+        body=note[:1600],
+        context_key=f"followup:{id}",
+        context_title=(row.get("description") or id)[:160],
+        context_summary=(row.get("description") or "")[:600],
+        context_type="followup",
+        state=_context_state_from_status(row.get("status")),
+        owner="nexo",
+        actor=actor,
+        source_type="followup",
+        source_id=id,
+        metadata={"status": row.get("status", "")},
+        ttl_hours=24,
+    )
+    return history
 
 
 def get_followups(filter_type: str = "all") -> list[dict]:

package/src/db/_schema.py

@@ -703,6 +703,55 @@ def _m29_item_history_and_soft_delete(conn):
     _migrate_add_index(conn, "idx_item_read_tokens_lookup", "item_read_tokens", "item_type, item_id, expires_at")
 
 
+def _m30_hot_context_memory(conn):
+    """Persist recent events + hot context for 24h operational continuity."""
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS hot_context (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            context_key TEXT NOT NULL UNIQUE,
+            title TEXT NOT NULL,
+            summary TEXT DEFAULT '',
+            context_type TEXT DEFAULT 'topic',
+            state TEXT DEFAULT 'active',
+            owner TEXT DEFAULT '',
+            source_type TEXT DEFAULT '',
+            source_id TEXT DEFAULT '',
+            session_id TEXT DEFAULT '',
+            metadata TEXT DEFAULT '{}',
+            first_seen_at REAL NOT NULL,
+            last_event_at REAL NOT NULL,
+            expires_at REAL NOT NULL,
+            created_at REAL NOT NULL,
+            updated_at REAL NOT NULL
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS recent_events (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            context_key TEXT DEFAULT '',
+            event_type TEXT NOT NULL,
+            title TEXT DEFAULT '',
+            summary TEXT DEFAULT '',
+            body TEXT DEFAULT '',
+            actor TEXT DEFAULT '',
+            source_type TEXT DEFAULT '',
+            source_id TEXT DEFAULT '',
+            session_id TEXT DEFAULT '',
+            metadata TEXT DEFAULT '{}',
+            created_at REAL NOT NULL,
+            expires_at REAL NOT NULL
+        )
+    """)
+    _migrate_add_index(conn, "idx_hot_context_last_event", "hot_context", "last_event_at")
+    _migrate_add_index(conn, "idx_hot_context_state", "hot_context", "state")
+    _migrate_add_index(conn, "idx_hot_context_source", "hot_context", "source_type, source_id")
+    _migrate_add_index(conn, "idx_hot_context_session", "hot_context", "session_id, last_event_at")
+    _migrate_add_index(conn, "idx_recent_events_created", "recent_events", "created_at")
+    _migrate_add_index(conn, "idx_recent_events_context", "recent_events", "context_key, created_at")
+    _migrate_add_index(conn, "idx_recent_events_source", "recent_events", "source_type, source_id, created_at")
+    _migrate_add_index(conn, "idx_recent_events_session", "recent_events", "session_id, created_at")
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -733,6 +782,7 @@ MIGRATIONS = [
     (27, "state_watchers", _m27_state_watchers),
     (28, "automation_runs", _m28_automation_runs),
     (29, "item_history_and_soft_delete", _m29_item_history_and_soft_delete),
+    (30, "hot_context_memory", _m30_hot_context_memory),
 ]
 
 

package/src/plugins/protocol.py

@@ -13,6 +13,9 @@ from db import (
     create_followup,
     create_protocol_debt,
     create_protocol_task,
+    build_pre_action_context,
+    capture_context_event,
+    format_pre_action_context_bundle,
     get_db,
     get_protocol_task,
     list_workflow_goals,
@@ -484,6 +487,12 @@ def handle_task_open(
         verification_step=state["verification_step"],
         stakes=stakes,
     )
+    recent_bundle = build_pre_action_context(
+        query=" | ".join(part for part in [clean_goal, context_hint.strip()] if part),
+        session_id=sid.strip(),
+        hours=24,
+        limit=4,
+    )
     heartbeat_result = handle_heartbeat(sid, clean_goal[:120], context_hint=context_hint[:500])
     attention = _attention_snapshot(sid.strip())
     anticipatory_warnings = _preview_prospective_triggers(clean_goal, context_hint.strip(), files_list)
@@ -540,6 +549,29 @@ def handle_task_open(
         response_reasons=response_contract["reasons"],
         response_high_stakes=response_contract["high_stakes"],
     )
+    protocol_context_key = f"protocol_task:{task['task_id']}"
+    capture_context_event(
+        event_type="protocol_task_opened",
+        title=clean_goal[:160],
+        summary=(context_hint or clean_goal)[:600],
+        body="\n".join(state["plan"][:5])[:1600] if state["plan"] else "",
+        context_key=protocol_context_key,
+        context_title=clean_goal[:160],
+        context_summary=(context_hint or clean_goal)[:600],
+        context_type="protocol_task",
+        state="active",
+        owner="nexo",
+        actor=sid,
+        source_type="protocol_task",
+        source_id=task["task_id"],
+        session_id=sid,
+        metadata={
+            "task_type": clean_type,
+            "area": area.strip(),
+            "files": files_list[:8],
+        },
+        ttl_hours=24,
+    )
     blocking_rule_ids = _extract_guard_blocking_ids(guard_summary) if guard_has_blocking else []
     if guard_has_blocking:
         _record_debt(
@@ -605,6 +637,10 @@ def handle_task_open(
             ),
         },
         "response_contract": response_contract,
+        "recent_context": {
+            "has_matches": bool(recent_bundle.get("has_matches")),
+            "excerpt": format_pre_action_context_bundle(recent_bundle, compact=True) if recent_bundle.get("has_matches") else "",
+        },
         "contract": {
             "must_verify": must_verify,
             "must_change_log": must_change_log,
@@ -835,6 +871,29 @@ def handle_task_close(
         followup_id=created_followup_id,
         outcome_notes=outcome_notes,
     )
+    capture_context_event(
+        event_type=f"protocol_task_{clean_outcome}",
+        title=(task.get("goal") or task_id)[:160],
+        summary=(outcome_notes or clean_evidence or clean_outcome)[:600],
+        body=(change_summary or change_why or "")[:1600],
+        context_key=f"protocol_task:{task_id}",
+        context_title=(task.get("goal") or task_id)[:160],
+        context_summary=(task.get("context_hint") or task.get("goal") or "")[:600],
+        context_type="protocol_task",
+        state="resolved" if clean_outcome in {"done", "cancelled"} else ("abandoned" if clean_outcome == "failed" else "blocked"),
+        owner="nexo",
+        actor=sid or task.get("session_id") or "nexo",
+        source_type="protocol_task",
+        source_id=task_id,
+        session_id=task.get("session_id") or sid,
+        metadata={
+            "outcome": clean_outcome,
+            "change_log_id": change_log_id,
+            "learning_id": learning_id,
+            "followup_id": created_followup_id,
+        },
+        ttl_hours=24,
+    )
     open_debts = list_protocol_debts(status="open", task_id=task_id, limit=20)
 
     response = {