feat: rehydrate widget activity tab from stored timeline (#5069)

## Summary

Builds on PR #5057 (DB tables + timeline endpoint) to wire the widget to
rehydrate its Activity tab on re-mount.

- **MCP routes**: First call (no cursor) now returns the stored
aggregate timeline alongside live data, for both running and terminal
tasks
- **Widget**: On mount, does a live status check (Claude.ai caches the
original tool result so `structuredContent.status` is stale), backfills
`aggHistory` from the stored timeline, then either starts polling
(running) or fetches results (completed)
- **Bug fix**: `pollUrl` was only set in the running-task branch, so
`backfillSummaries` silently returned for completed tasks

### Re-mount scenarios

| Scenario | Before | After |
|---|---|---|
| Task completed, return to conversation | Results only, empty Activity
tab | Full activity timeline + results |
| Leave mid-execution, return | Polling resumes with no history | Stored
timeline replayed, then polling continues |

## Test plan

- [x] Tested in Claude.ai via CF tunnel against local engine + prod
Supabase
- [x] Task completed, leave, return → Activity tab shows stored
aggregates
- [x] Leave mid-execution, return → Activity tab shows prior history +
new updates
- [x] No duplicate entries in Activity tab
- [x] MCP routes lint clean

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Sourced from commit ef235840b023775a5363f71c61f7790681556586

Author: RafaelPo

futuresearch-mcp/src/futuresearch_mcp/routes.py

@@ -111,6 +111,35 @@ async def _fetch_summaries_rest(
     return None, cursor
 
 
+async def _fetch_timeline_rest(
+    client: AuthenticatedClient, task_id: str
+) -> list[dict] | None:
+    """Fetch stored aggregate timeline from the Engine API.
+
+    Returns a list of timeline entries (each with aggregate + micro_summaries),
+    or None if the endpoint is unavailable or returns no data.
+    """
+    try:
+        httpx_client = client.get_async_httpx_client()
+        resp = await httpx_client.request(
+            method="get",
+            url=f"/tasks/{task_id}/summaries/timeline",
+        )
+        if resp.status_code == 200:
+            data = resp.json()
+            timeline = data.get("timeline")
+            if timeline:
+                # Dedupe micro-summaries within each entry
+                for entry in timeline:
+                    micros = entry.get("micro_summaries")
+                    if micros:
+                        entry["micro_summaries"] = dedupe_summaries(micros)
+                return timeline
+    except Exception:
+        logger.debug("Failed to fetch timeline for task %s via REST", task_id)
+    return None
+
+
 async def _fetch_aggregate_rest(
     client: AuthenticatedClient, task_id: str, cursor: str | None
 ) -> tuple[str | None, list[dict] | None, str | None]:
@@ -147,6 +176,48 @@ async def _fetch_aggregate_rest(
     return None, summaries, new_cursor
 
 
+async def _backfill_timeline(
+    client: AuthenticatedClient, task_id: str, payload: dict
+) -> None:
+    """Populate payload with stored timeline + tail aggregate for re-mount.
+
+    Fetches the stored aggregate timeline (no LLM call), then fills any gap
+    with one aggregate call for micro-summaries that arrived after the last
+    stored aggregate.
+    """
+    timeline = await _fetch_timeline_rest(client, task_id)
+    if timeline:
+        payload["timeline"] = timeline
+        # Find the latest micro-summary timestamp to fill the gap
+        last_cursor = max(
+            (
+                ms.get("updated_at", "")
+                for entry in timeline
+                for ms in entry.get("micro_summaries", [])
+            ),
+            default=None,
+        )
+        if last_cursor:
+            aggregate, summaries, new_cursor = await _fetch_aggregate_rest(
+                client, task_id, last_cursor
+            )
+            if aggregate:
+                payload["aggregate_summary"] = aggregate
+                payload["summaries"] = summaries
+                payload["cursor"] = new_cursor
+    else:
+        # No stored timeline — fall back to generating one aggregate
+        aggregate, summaries, new_cursor = await _fetch_aggregate_rest(
+            client, task_id, None
+        )
+        if aggregate:
+            payload["aggregate_summary"] = aggregate
+        if summaries:
+            payload["summaries"] = summaries
+        if new_cursor:
+            payload["cursor"] = new_cursor
+
+
 async def api_progress(request: Request) -> Response:
     """REST endpoint for the session widget to poll task progress."""
     cors = _cors_headers()
@@ -193,13 +264,21 @@ async def api_progress(request: Request) -> Response:
 
         payload = ts.model_dump(mode="json", exclude=_UI_EXCLUDE)
 
-        # Fetch aggregate + micro-summaries for non-terminal tasks,
-        # or for terminal tasks without cursor (re-mount backfill).
-        backfill = ts.is_terminal and not request.query_params.get("cursor")
-        if not ts.is_terminal or backfill:
-            cursor = request.query_params.get("cursor")
+        cursor = request.query_params.get("cursor")
+        # First call (no cursor) = widget just mounted — include stored
+        # timeline so the activity tab can replay prior history, regardless
+        # of whether the task is still running or already terminal.
+        if not cursor:
+            await _backfill_timeline(client, task_id, payload)
+
+        # Fetch live aggregate + micro-summaries for:
+        # - incremental polling (has cursor)
+        # - non-terminal first-call (alongside timeline)
+        # Skip for terminal first-call — _backfill_timeline already
+        # fetched the tail aggregate covering any gap.
+        if not ts.is_terminal:
             aggregate, summaries, new_cursor = await _fetch_aggregate_rest(
-                client, task_id, cursor
+                client, task_id, cursor or payload.get("cursor")
             )
             if aggregate:
                 payload["aggregate_summary"] = aggregate

futuresearch-mcp/src/futuresearch_mcp/templates.py

@@ -1002,30 +1002,65 @@
 }
 
 /* ── fetch last aggregate summary (for re-mount when task already done) ── */
-async function backfillSummaries(){
-  if(!pollUrl||!pollToken)return;
-  try{
-    const opts=pollToken?{headers:{"Authorization":"Bearer "+pollToken}}:{};
-    const r=await fetch(pollUrl,opts);
-    if(!r.ok)return;
-    const d=await r.json();
-    if(d.aggregate_summary||d.summaries)renderProgress(d);
-  }catch{}
+async function backfillSummaries(prefetched){
+
+  let d=prefetched;
+  if(!d){
+    if(!pollUrl||!pollToken)return;
+    try{
+      const opts=pollToken?{headers:{"Authorization":"Bearer "+pollToken}}:{};
+      const r=await fetch(pollUrl,opts);
+      if(!r.ok)return;
+      d=await r.json();
+    }catch{return;}
+  }
+  /* Timeline rehydration: stored aggregates with their micro-summaries */
+  if(d.timeline&&d.timeline.length){
+    for(const entry of d.timeline){
+      const ts=new Date(entry.created_at).toLocaleTimeString([],{hour:"2-digit",minute:"2-digit",second:"2-digit"});
+      const micros=(entry.micro_summaries||[]).map(s=>({text:s.summary||String(s),row_indices:s.row_indices||null,row_index:s.row_index}));
+      aggHistory.push({aggregate:entry.summary,micros,ts});
+    }
+    if(d.cursor)pollCursor=d.cursor;
+    if(aggHistory.length>30)aggHistory.splice(0,aggHistory.length-30);
+
+  }
+  /* Render current state (progress bar + activity list) */
+  renderProgress(d);
 }
 
 /* ── ontoolresult: unified entry point ── */
 app.ontoolresult=({content,structuredContent})=>{
+
   /* Entry 1: structuredContent from futuresearch_status (widget data) */
   if(structuredContent&&structuredContent.progress_url){
     enterProgressMode(structuredContent);
-    /* If task already completed on re-mount, backfill summaries then fetch results */
-    const done=["completed","failed","revoked"].includes(structuredContent.status);
-    if(done){
-      wasDone=true;
-      backfillSummaries().then(()=>{if(!resultsFetched)autoFetchResults();});
-    } else if(!pollTimer){
-      pollUrl=structuredContent.progress_url;startPoll();
-    }
+    pollUrl=structuredContent.progress_url;
+    /* Claude.ai caches the original tool result — structuredContent.status
+       may be stale (e.g. "running" even though the task completed).
+       Always do a one-off fetch to get current status before deciding path. */
+    (async()=>{
+      try{
+        const opts=structuredContent.poll_token?{headers:{"Authorization":"Bearer "+structuredContent.poll_token}}:{};
+        const r=await fetch(pollUrl,opts);
+        if(!r.ok){if(!pollTimer)startPoll();return;}
+        const d=await r.json();
+        const currentStatus=d.status||structuredContent.status;
+        const done=["completed","failed","revoked"].includes(currentStatus);
+
+        /* Always backfill stored timeline on mount (covers mid-execution re-mount too) */
+        await backfillSummaries(d);
+        if(done){
+          wasDone=true;
+          if(!resultsFetched)autoFetchResults();
+        } else if(!pollTimer){
+          startPoll();
+        }
+      }catch(e){
+
+        if(!pollTimer)startPoll();
+      }
+    })();
     return;
   }
 
@@ -1037,13 +1072,27 @@
         const d=JSON.parse(t.text);
         if(d.progress_url){
           enterProgressMode(d);
-          const done=["completed","failed","revoked"].includes(d.status);
-          if(done){
-            wasDone=true;
-            backfillSummaries().then(()=>{if(!resultsFetched)autoFetchResults();});
-          } else if(!pollTimer){
-            pollUrl=d.progress_url;startPoll();
-          }
+          pollUrl=d.progress_url;
+          /* Same live-check as Entry 1 — cached status may be stale */
+          (async()=>{
+            try{
+              const opts=d.poll_token?{headers:{"Authorization":"Bearer "+d.poll_token}}:{};
+              const r2=await fetch(pollUrl,opts);
+              if(!r2.ok){if(!pollTimer)startPoll();return;}
+              const d2=await r2.json();
+              const currentStatus=d2.status||d.status;
+              const done2=["completed","failed","revoked"].includes(currentStatus);
+              await backfillSummaries(d2);
+              if(done2){
+                wasDone=true;
+                if(!resultsFetched)autoFetchResults();
+              } else if(!pollTimer){
+                startPoll();
+              }
+            }catch(e2){
+              if(!pollTimer)startPoll();
+            }
+          })();
           return;
         }
       }catch{}