story-kit: accept 96_story_reset_agent_lozenge_to_idle_state_when_returning_to_roster

server/src/http/mcp.rs

@@ -1016,28 +1016,101 @@ async fn tool_get_agent_output_poll(args: &Value, ctx: &AppContext) -> Result<St
         .and_then(|v| v.as_str())
         .ok_or("Missing required argument: agent_name")?;
 
-    // Drain all accumulated events since the last poll.
-    let drained = ctx.agents.drain_events(story_id, agent_name)?;
+    // Try draining in-memory events first.
+    match ctx.agents.drain_events(story_id, agent_name) {
+        Ok(drained) => {
+            let done = drained.iter().any(|e| {
+                matches!(
+                    e,
+                    crate::agents::AgentEvent::Done { .. }
+                        | crate::agents::AgentEvent::Error { .. }
+                )
+            });
 
-    let done = drained.iter().any(|e| {
-        matches!(
-            e,
-            crate::agents::AgentEvent::Done { .. } | crate::agents::AgentEvent::Error { .. }
-        )
-    });
+            let events: Vec<serde_json::Value> = drained
+                .into_iter()
+                .filter_map(|e| serde_json::to_value(&e).ok())
+                .collect();
 
-    let events: Vec<serde_json::Value> = drained
-        .into_iter()
-        .filter_map(|e| serde_json::to_value(&e).ok())
-        .collect();
+            serde_json::to_string_pretty(&json!({
+                "events": events,
+                "done": done,
+                "event_count": events.len(),
+                "message": if done { "Agent stream ended." } else if events.is_empty() { "No new events. Call again to continue." } else { "Events returned. Call again to continue." }
+            }))
+            .map_err(|e| format!("Serialization error: {e}"))
+        }
+        Err(_) => {
+            // Agent not in memory — fall back to persistent log file.
+            get_agent_output_from_log(story_id, agent_name, ctx)
+        }
+    }
+}
 
-    serde_json::to_string_pretty(&json!({
-        "events": events,
-        "done": done,
-        "event_count": events.len(),
-        "message": if done { "Agent stream ended." } else if events.is_empty() { "No new events. Call again to continue." } else { "Events returned. Call again to continue." }
-    }))
-    .map_err(|e| format!("Serialization error: {e}"))
+/// Fall back to reading agent output from the persistent log file on disk.
+///
+/// Tries to find the log file via the agent's stored log_session_id first,
+/// then falls back to `find_latest_log` scanning the log directory.
+fn get_agent_output_from_log(
+    story_id: &str,
+    agent_name: &str,
+    ctx: &AppContext,
+) -> Result<String, String> {
+    use crate::agent_log;
+
+    let project_root = ctx.agents.get_project_root(&ctx.state)?;
+
+    // Try to find the log file: first from in-memory agent info, then by scanning.
+    let log_path = ctx
+        .agents
+        .get_log_info(story_id, agent_name)
+        .map(|(session_id, root)| agent_log::log_file_path(&root, story_id, agent_name, &session_id))
+        .filter(|p| p.exists())
+        .or_else(|| agent_log::find_latest_log(&project_root, story_id, agent_name));
+
+    let log_path = match log_path {
+        Some(p) => p,
+        None => {
+            return serde_json::to_string_pretty(&json!({
+                "events": [],
+                "done": true,
+                "event_count": 0,
+                "message": format!("No agent '{agent_name}' for story '{story_id}' and no log file found."),
+                "source": "none",
+            }))
+            .map_err(|e| format!("Serialization error: {e}"));
+        }
+    };
+
+    match agent_log::read_log(&log_path) {
+        Ok(entries) => {
+            let events: Vec<serde_json::Value> = entries
+                .into_iter()
+                .map(|e| {
+                    let mut val = e.event;
+                    if let serde_json::Value::Object(ref mut map) = val {
+                        map.insert(
+                            "timestamp".to_string(),
+                            serde_json::Value::String(e.timestamp),
+                        );
+                    }
+                    val
+                })
+                .collect();
+
+            let count = events.len();
+            serde_json::to_string_pretty(&json!({
+                "events": events,
+                "done": true,
+                "event_count": count,
+                "message": "Events loaded from persistent log file.",
+                "source": "log_file",
+                "log_file": log_path.to_string_lossy(),
+            }))
+            .map_err(|e| format!("Serialization error: {e}"))
+        }
+        Err(e) => Err(format!("Failed to read log file: {e}")),
+    }
 }
 
 fn tool_get_agent_config(ctx: &AppContext) -> Result<String, String> {