Cloud follow-up finished before a new session became availab

Error message

Cloud follow-up finished before a new session became available

What it means

Informational terminal error for follow-up polling: the run ended in a terminal, non-failure-like state with no status_message, and no new session ever became joinable (SessionJoinInfo::from_task never matched while InProgress). The stream ends with this message rather than a session event.

Source

Thrown at app/src/ai/ambient_agents/spawn.rs:294

                                    status_message: task.status_message.clone(),
                                });
                            }

                            if task.state.is_terminal() {
                                if matches!(&mode, RunPollMode::Followup { .. }) {
                                    let exhausted_stale_skips = !seen_working_state
                                        && skipped_stale_polls >= MAX_STALE_POLLS_BEFORE_FAILURE;
                                    let message = if exhausted_stale_skips {
                                        "Cloud follow-up did not start in time".to_string()
                                    } else {
                                        task.status_message
                                            .as_ref()
                                            .map(|msg| msg.message.clone())
                                            .unwrap_or_else(|| {
                                                if task.state.is_failure_like() {
                                                    "Cloud agent failed".to_string()
                                                } else {
                                                    "Cloud follow-up finished before a new session became available".to_string()
                                                }
                                            })
                                    };
                                    yield Err(anyhow!(message));
                                }
                                return;
                            }

                            if task.state == AmbientAgentTaskState::InProgress
                                && let Some(session_join_info) = SessionJoinInfo::from_task(&task) {
                                    let has_new_session = match &mode {
                                        RunPollMode::InitialRun
                                        | RunPollMode::Followup {
                                            previous_session_id: None,
                                        } => true,
                                        RunPollMode::Followup {
                                            previous_session_id: Some(previous_session_id),
                                        } => session_join_info

View on GitHub (pinned to e72fd7aacb)

Solutions

Refresh the agent/task list to pick up any session created near the end of the run
Treat as benign completion and resync local ambient-agent state instead of surfacing a hard error
Re-trigger the follow-up if a new session was expected
If sessions routinely appear after this error, shorten the poll interval so InProgress + join info is observed

Defensive patterns

Strategy: fallback

Try / catch

match event {
    Err(e) if e.to_string().contains("before a new session became available") => {
        refresh_agent_sessions().await; // benign terminal case; resync instead of erroring
    }
    other => handle(other),
}

Prevention

Poll fast enough that short InProgress windows with joinable session info are observed
Treat non-failure-like terminal follow-ups as completions, not hard errors, in UX copy
Resync the local session list whenever a follow-up stream ends

When it happens

Trigger: Follow-up task reaches a terminal non-failure state (e.g. completed) with task.status_message == None, after never yielding session join info - either it finished before a poll observed InProgress with joinable session data, or it completed without creating a session (spawn.rs:290-295, 303-304).

Common situations: Very short follow-up that completes between two polls; follow-up that ends without spawning a session (e.g. nothing to do); polling interval too coarse for fast runs.

Related errors

AI-assisted analysis of warpdotdev/warp@e72fd7aacb (2026-08-16). Data as JSON: /api/errors/3b841529ef1158b3. Report an issue: GitHub.