fix(otto): reuse known thread ids progressively

Known conversation reuse should stay on the preview-first path instead of hydrating the full thread, and stale history errors should stop leaking into newer TUI generations.

Iteration: iter-03
Agent: software-engineer/a
Made-with: Cursor

Author: seanknapp

crates/ascend-tools-cli/src/conversation.rs

@@ -301,7 +301,13 @@ pub(crate) fn resolve_conversation_flag(
     if resume {
         Ok(Some(client.latest_conversation_id()?))
     } else if let Some(conv) = conversation {
-        Ok(Some(resolve_conversation_id_interactive(client, &conv)?))
+        match client.resolve_otto_thread(Some(&conv), None) {
+            Ok(thread_id) => Ok(thread_id),
+            Err(Error::AmbiguousTitle { matches, .. }) => {
+                pick_from_matches(&conv, &matches).map(Some)
+            }
+            Err(e) => Err(e.into()),
+        }
     } else {
         Ok(thread)
     }

crates/ascend-tools-cli/tests/cli_integration.rs

@@ -303,6 +303,79 @@ fn otto_run_jsonl_rejects_json_output_mode() {
     ));
 }
 
+#[test]
+fn otto_run_with_known_conversation_id_avoids_full_thread_get() {
+    let mut server = Server::new();
+    mock_auth(&mut server);
+
+    let preview_body = serde_json::json!({
+        "id": "thread-cli-cont",
+        "title": "Continuation thread",
+        "messages": {
+            "msg-1": {
+                "id": "msg-1",
+                "role": "user",
+                "content": "hello",
+                "created_at": "2026-01-01T00:00:00Z"
+            }
+        },
+        "updated_at": "2026-01-01T00:00:00Z",
+        "is_processing": false,
+        "context_window_stats": null,
+        "total_message_count": 1,
+        "has_more": false,
+        "oldest_message_id": "msg-1",
+        "latest_message_id": "msg-1"
+    })
+    .to_string();
+    let updates_body = format!(
+        "event: thread.preview\ndata: {preview_body}\n\n\
+         event: response.output_text.delta\ndata: {{\"delta\":\"continued\",\"item_id\":\"item-1\",\"content_index\":0,\"output_index\":0,\"type\":\"response.output_text.delta\"}}\n\n\
+         event: thread.done\ndata: {{\"latest_message_id\":\"msg-2\"}}\n\n"
+    );
+
+    let full_get = server
+        .mock("GET", "/api/v1/otto/threads/thread-cli-cont")
+        .expect(0)
+        .create();
+    let updates = server
+        .mock("GET", "/api/v1/otto/threads/thread-cli-cont/updates")
+        .match_header("accept", "text/event-stream")
+        .with_status(200)
+        .with_body(updates_body)
+        .expect(2)
+        .create();
+    let send = server
+        .mock("POST", "/api/v1/otto/threads/thread-cli-cont/messages")
+        .match_header("authorization", "Bearer cli-token")
+        .with_status(200)
+        .with_header("content-type", "application/json")
+        .with_body(r#"{"thread_id":"thread-cli-cont"}"#)
+        .expect(1)
+        .create();
+
+    let mut cmd = command_with_auth(&server);
+    cmd.args([
+        "-o",
+        "json",
+        "otto",
+        "run",
+        "continue",
+        "--conversation",
+        "thread-cli-cont",
+    ]);
+    cmd.assert()
+        .success()
+        .stdout(predicate::str::contains("\"message\": \"continued\""))
+        .stdout(predicate::str::contains(
+            "\"thread_id\": \"thread-cli-cont\"",
+        ));
+
+    updates.assert();
+    send.assert();
+    full_get.assert();
+}
+
 #[test]
 fn otto_conversation_open_emits_progressive_preview_json() {
     let mut server = Server::new();

crates/ascend-tools-core/src/client.rs

@@ -559,20 +559,23 @@ impl AscendClient {
             Err(e) => return Err(e),
         }
 
-        // Not a valid ID — use server-side title filter.
+        self.resolve_conversation_title(title_or_id)
+    }
+
+    fn resolve_conversation_title(&self, title: &str) -> Result<String> {
         let list = self.list_conversations(ConversationFilters {
-            title: Some(title_or_id.to_string()),
+            title: Some(title.to_string()),
             ..Default::default()
         })?;
         match list.threads.len() {
             0 => Err(Error::NotFound {
                 kind: "conversation".to_string(),
-                title: title_or_id.to_string(),
+                title: title.to_string(),
             }),
             1 => Ok(list.threads.into_iter().next().unwrap().id),
             _ => Err(Error::AmbiguousTitle {
                 kind: "conversation".to_string(),
-                title: title_or_id.to_string(),
+                title: title.to_string(),
                 matches: list
                     .threads
                     .iter()
@@ -600,16 +603,23 @@ impl AscendClient {
 
     /// Resolve a `conversation` or `thread_id` parameter to an optional thread ID.
     ///
-    /// If `conversation` is `Some`, resolves it via `resolve_conversation_id`.
-    /// Otherwise passes through `thread_id` as-is. Used by SDK bindings to
-    /// avoid duplicating the resolution logic.
+    /// If `conversation` is `Some`, accepts a known thread ID via the
+    /// progressive preview path and falls back to title resolution when that
+    /// preview probe returns 404. Otherwise passes through `thread_id` as-is.
+    /// Used by SDK bindings to avoid duplicating the continuation logic.
     pub fn resolve_otto_thread(
         &self,
         conversation: Option<&str>,
         thread_id: Option<String>,
     ) -> Result<Option<String>> {
         if let Some(conv) = conversation {
-            Ok(Some(self.resolve_conversation_id(conv)?))
+            match self.get_conversation_preview(conv) {
+                Ok(_) => Ok(Some(conv.to_string())),
+                Err(ref e) if e.http_status() == Some(404) => {
+                    Ok(Some(self.resolve_conversation_title(conv)?))
+                }
+                Err(e) => Err(e),
+            }
         } else {
             Ok(thread_id)
         }

crates/ascend-tools-core/tests/client_http.rs

@@ -343,6 +343,97 @@ fn get_conversation_messages_before_requests_before_limit() {
     assert_eq!(ordered, vec!["msg-18", "msg-19"]);
 }
 
+#[test]
+fn resolve_otto_thread_reuses_known_id_via_progressive_preview() {
+    let mut server = Server::new();
+    let now = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_secs();
+    mock_auth(&mut server, "token-resolve-thread-id", now + 3600, 1);
+
+    let preview_body = serde_json::json!({
+        "id": "thread-known",
+        "title": "Known thread",
+        "messages": {},
+        "updated_at": "2026-01-01T00:01:00Z",
+        "is_processing": false,
+        "context_window_stats": null,
+        "total_message_count": 0,
+        "has_more": false,
+        "oldest_message_id": null,
+        "latest_message_id": null
+    })
+    .to_string();
+
+    let full_get = server
+        .mock("GET", "/api/v1/otto/threads/thread-known")
+        .expect(0)
+        .create();
+    let updates = server
+        .mock("GET", "/api/v1/otto/threads/thread-known/updates")
+        .match_header("accept", "text/event-stream")
+        .with_status(200)
+        .with_body(format!("event: thread.preview\ndata: {preview_body}\n\n"))
+        .expect(1)
+        .create();
+
+    let client = test_client(&server);
+    let resolved = client
+        .resolve_otto_thread(Some("thread-known"), None)
+        .unwrap();
+
+    assert_eq!(resolved.as_deref(), Some("thread-known"));
+    updates.assert();
+    full_get.assert();
+}
+
+#[test]
+fn resolve_otto_thread_falls_back_to_title_search_after_preview_404() {
+    let mut server = Server::new();
+    let now = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_secs();
+    mock_auth(&mut server, "token-resolve-thread-title", now + 3600, 1);
+
+    let updates = server
+        .mock("GET", "/api/v1/otto/threads/Named%20thread/updates")
+        .match_header("accept", "text/event-stream")
+        .with_status(404)
+        .with_header("content-type", "application/json")
+        .with_body(r#"{"detail":"thread not found"}"#)
+        .expect(1)
+        .create();
+    let list = server
+        .mock("GET", "/api/v1/otto/threads")
+        .match_query(Matcher::UrlEncoded("title".into(), "Named thread".into()))
+        .with_status(200)
+        .with_header("content-type", "application/json")
+        .with_body(
+            serde_json::json!({
+                "threads": [{
+                    "id": "thread-from-title",
+                    "title": "Named thread",
+                    "updated_at": "2026-01-01T00:00:00Z"
+                }],
+                "total": 1
+            })
+            .to_string(),
+        )
+        .expect(1)
+        .create();
+
+    let client = test_client(&server);
+    let resolved = client
+        .resolve_otto_thread(Some("Named thread"), None)
+        .unwrap();
+
+    assert_eq!(resolved.as_deref(), Some("thread-from-title"));
+    updates.assert();
+    list.assert();
+}
+
 #[test]
 fn otto_streaming_events_exposes_raw_updates() {
     let mut server = Server::new();

crates/ascend-tools-tui/src/lib.rs

@@ -142,7 +142,10 @@ enum StreamMsg {
         generation: u64,
         messages: Vec<Message>,
     },
-    ConversationHistoryError(String),
+    ConversationHistoryError {
+        generation: u64,
+        error: String,
+    },
     StopFinished {
         error: Option<String>,
     },
@@ -943,11 +946,13 @@ impl App {
                     }
                 }
             }
-            StreamMsg::ConversationHistoryError(error) => {
-                if self.messages.is_empty() {
-                    self.push_system(format!("Could not load recent history: {error}"));
-                } else {
-                    self.push_system(format!("Could not load older history: {error}"));
+            StreamMsg::ConversationHistoryError { generation, error } => {
+                if generation == self.stream_generation {
+                    if self.messages.is_empty() {
+                        self.push_system(format!("Could not load recent history: {error}"));
+                    } else {
+                        self.push_system(format!("Could not load older history: {error}"));
+                    }
                 }
             }
             StreamMsg::StopFinished { error } => {
@@ -2542,7 +2547,10 @@ pub fn run_tui(
                     });
                 });
                 if let Err(err) = result {
-                    let _ = history_tx.send(StreamMsg::ConversationHistoryError(err.to_string()));
+                    let _ = history_tx.send(StreamMsg::ConversationHistoryError {
+                        generation: history_gen,
+                        error: err.to_string(),
+                    });
                 }
             });
         }
@@ -2842,13 +2850,33 @@ mod tests {
     fn conversation_history_error_surfaces_when_history_is_empty() {
         let mut app = test_app();
 
-        app.handle_stream_msg(StreamMsg::ConversationHistoryError("preview failed".into()));
+        app.handle_stream_msg(StreamMsg::ConversationHistoryError {
+            generation: 0,
+            error: "preview failed".into(),
+        });
 
         assert!(app.messages.iter().any(|m| {
             m.role == Role::System && m.content.contains("Could not load recent history")
         }));
     }
 
+    #[test]
+    fn stale_conversation_history_error_is_discarded_after_generation_advances() {
+        let mut app = test_app();
+        app.stream_generation = 2;
+
+        app.handle_stream_msg(StreamMsg::ConversationHistoryError {
+            generation: 1,
+            error: "stale failure".into(),
+        });
+
+        assert!(
+            !app.messages
+                .iter()
+                .any(|m| m.role == Role::System && m.content.contains("stale failure"))
+        );
+    }
+
     #[test]
     fn stream_conversation_history_fetches_preview_then_older_pages() {
         let preview = test_preview(