chore: merge name and title (#17116)

Merge title and name concept to leverage the sqlite title column and
have more efficient queries

---------

Co-authored-by: Codex <noreply@openai.com>

codex-rs/state/src/extract.rs

@@ -33,7 +33,9 @@ pub fn apply_rollout_item(
 pub fn rollout_item_affects_thread_metadata(item: &RolloutItem) -> bool {
     match item {
         RolloutItem::SessionMeta(_) | RolloutItem::TurnContext(_) => true,
-        RolloutItem::EventMsg(EventMsg::TokenCount(_) | EventMsg::UserMessage(_)) => true,
+        RolloutItem::EventMsg(
+            EventMsg::TokenCount(_) | EventMsg::UserMessage(_) | EventMsg::ThreadNameUpdated(_),
+        ) => true,
         RolloutItem::EventMsg(_) | RolloutItem::ResponseItem(_) | RolloutItem::Compacted(_) => {
             false
         }
@@ -95,13 +97,18 @@ fn apply_event_msg(metadata: &mut ThreadMetadata, event: &EventMsg) {
                 }
             }
         }
+        EventMsg::ThreadNameUpdated(updated) => {
+            if let Some(title) = updated.thread_name.as_deref()
+                && !title.trim().is_empty()
+            {
+                metadata.title = title.trim().to_string();
+            }
+        }
         _ => {}
     }
 }
 
-fn apply_response_item(_metadata: &mut ThreadMetadata, _item: &ResponseItem) {
-    // Title and first_user_message are derived from EventMsg::UserMessage only.
-}
+fn apply_response_item(_metadata: &mut ThreadMetadata, _item: &ResponseItem) {}
 
 fn strip_user_message_prefix(text: &str) -> &str {
     match text.find(USER_MESSAGE_BEGIN) {
@@ -152,6 +159,7 @@ mod tests {
     use codex_protocol::protocol::SessionMeta;
     use codex_protocol::protocol::SessionMetaLine;
     use codex_protocol::protocol::SessionSource;
+    use codex_protocol::protocol::ThreadNameUpdatedEvent;
     use codex_protocol::protocol::TurnContextItem;
     use codex_protocol::protocol::USER_MESSAGE_BEGIN;
     use codex_protocol::protocol::UserMessageEvent;
@@ -198,6 +206,25 @@ mod tests {
         assert_eq!(metadata.title, "actual user request");
     }
 
+    #[test]
+    fn thread_name_update_replaces_title_without_changing_first_user_message() {
+        let mut metadata = metadata_for_test();
+        metadata.title = "actual user request".to_string();
+        metadata.first_user_message = Some("actual user request".to_string());
+        let item = RolloutItem::EventMsg(EventMsg::ThreadNameUpdated(ThreadNameUpdatedEvent {
+            thread_id: metadata.id,
+            thread_name: Some("saved-session".to_string()),
+        }));
+
+        apply_rollout_item(&mut metadata, &item, "test-provider");
+
+        assert_eq!(
+            metadata.first_user_message.as_deref(),
+            Some("actual user request")
+        );
+        assert_eq!(metadata.title, "saved-session");
+    }
+
     #[test]
     fn event_msg_image_only_user_message_sets_image_placeholder_preview() {
         let mut metadata = metadata_for_test();

codex-rs/state/src/runtime/threads.rs

@@ -326,6 +326,66 @@ ON CONFLICT(child_thread_id) DO NOTHING
             .map(PathBuf::from))
     }
 
+    /// Find the newest thread whose user-facing title exactly matches `title`.
+    #[allow(clippy::too_many_arguments)]
+    pub async fn find_thread_by_exact_title(
+        &self,
+        title: &str,
+        allowed_sources: &[String],
+        model_providers: Option<&[String]>,
+        archived_only: bool,
+        cwd: Option<&Path>,
+    ) -> anyhow::Result<Option<crate::ThreadMetadata>> {
+        let mut builder = QueryBuilder::<Sqlite>::new(
+            r#"
+SELECT
+    id,
+    rollout_path,
+    created_at,
+    updated_at,
+    source,
+    agent_nickname,
+    agent_role,
+    agent_path,
+    model_provider,
+    model,
+    reasoning_effort,
+    cwd,
+    cli_version,
+    title,
+    sandbox_policy,
+    approval_mode,
+    tokens_used,
+    first_user_message,
+    archived_at,
+    git_sha,
+    git_branch,
+    git_origin_url
+FROM threads
+            "#,
+        );
+        push_thread_filters(
+            &mut builder,
+            archived_only,
+            allowed_sources,
+            model_providers,
+            /*anchor*/ None,
+            crate::SortKey::UpdatedAt,
+            /*search_term*/ None,
+        );
+        builder.push(" AND title = ");
+        builder.push_bind(title);
+        if let Some(cwd) = cwd {
+            builder.push(" AND cwd = ");
+            builder.push_bind(cwd.display().to_string());
+        }
+        push_thread_order_and_limit(&mut builder, crate::SortKey::UpdatedAt, /*limit*/ 1);
+
+        let row = builder.build().fetch_optional(self.pool.as_ref()).await?;
+        row.map(|row| ThreadRow::try_from_row(&row).and_then(crate::ThreadMetadata::try_from))
+            .transpose()
+    }
+
     /// List threads using the underlying database.
     #[allow(clippy::too_many_arguments)]
     pub async fn list_threads(
@@ -521,6 +581,19 @@ ON CONFLICT(id) DO NOTHING
         Ok(result.rows_affected() > 0)
     }
 
+    pub async fn update_thread_title(
+        &self,
+        thread_id: ThreadId,
+        title: &str,
+    ) -> anyhow::Result<bool> {
+        let result = sqlx::query("UPDATE threads SET title = ? WHERE id = ?")
+            .bind(title)
+            .bind(thread_id.to_string())
+            .execute(self.pool.as_ref())
+            .await?;
+        Ok(result.rows_affected() > 0)
+    }
+
     pub async fn touch_thread_updated_at(
         &self,
         thread_id: ThreadId,