[codex] Remove async_trait from first-party code (#27475)

## Why

First-party async traits should expose their `Send` contracts explicitly
without requiring `async_trait`. This completes the migration pattern
established in #27303 and #27304.

## What changed

- Replaced the remaining first-party `async_trait` traits with native
return-position `impl Future + Send` where statically dispatched and
explicit boxed `Send` futures where object safety is required.
- Kept implementations behavior-preserving, outlining existing async
bodies into inherent methods where that keeps the diff reviewable.
- Removed all direct first-party `async-trait` dependencies and the
workspace dependency declaration.
- Added a cargo-deny policy that permits `async-trait` only through the
remaining transitive wrapper crates.
- Updated `rand` from 0.8.5 to 0.8.6 to resolve RUSTSEC-2026-0097 and
keep the full cargo-deny check passing.

## Validation

- `just test -p codex-exec-server`: 216 passed, 2 skipped.
- `just test -p codex-model-provider`: 39 passed.
- `just test -p codex-core` and `just test`: changed tests passed;
remaining failures are environment-sensitive suites unrelated to this
migration.
- `cargo deny check`
- `just fix`
- `just fmt`
- `cargo shear`
- `just bazel-lock-check`

codex-rs/thread-store/src/store.rs

@@ -1,6 +1,7 @@
-use async_trait::async_trait;
 use codex_protocol::ThreadId;
 use std::any::Any;
+use std::future::Future;
+use std::pin::Pin;
 
 use crate::AppendThreadItemsParams;
 use crate::ArchiveThreadParams;
@@ -24,81 +25,89 @@ use crate::ThreadStoreResult;
 use crate::TurnPage;
 use crate::UpdateThreadMetadataParams;
 
+/// Future returned by [`ThreadStore`] operations.
+pub type ThreadStoreFuture<'a, T> = Pin<Box<dyn Future<Output = ThreadStoreResult<T>> + Send + 'a>>;
+
 /// Storage-neutral thread persistence boundary.
-#[async_trait]
 pub trait ThreadStore: Any + Send + Sync {
     /// Return this store as [`Any`] for implementation-owned escape hatches.
     fn as_any(&self) -> &dyn Any;
 
     /// Creates a new live thread.
-    async fn create_thread(&self, params: CreateThreadParams) -> ThreadStoreResult<()>;
+    fn create_thread(&self, params: CreateThreadParams) -> ThreadStoreFuture<'_, ()>;
 
     /// Reopens an existing thread for live appends.
-    async fn resume_thread(&self, params: ResumeThreadParams) -> ThreadStoreResult<()>;
+    fn resume_thread(&self, params: ResumeThreadParams) -> ThreadStoreFuture<'_, ()>;
 
     /// Appends raw rollout items to a live thread.
     ///
     /// Implementations should apply the shared rollout persistence policy before writing durable
     /// replay history and before updating any implementation-owned projections.
-    async fn append_items(&self, params: AppendThreadItemsParams) -> ThreadStoreResult<()>;
+    fn append_items(&self, params: AppendThreadItemsParams) -> ThreadStoreFuture<'_, ()>;
 
     /// Materializes the thread if persistence is lazy, then persists all queued items.
-    async fn persist_thread(&self, thread_id: ThreadId) -> ThreadStoreResult<()>;
+    fn persist_thread(&self, thread_id: ThreadId) -> ThreadStoreFuture<'_, ()>;
 
     /// Flushes all queued items and returns once they are durable/readable.
-    async fn flush_thread(&self, thread_id: ThreadId) -> ThreadStoreResult<()>;
+    fn flush_thread(&self, thread_id: ThreadId) -> ThreadStoreFuture<'_, ()>;
 
     /// Flushes pending items and closes the live thread writer.
-    async fn shutdown_thread(&self, thread_id: ThreadId) -> ThreadStoreResult<()>;
+    fn shutdown_thread(&self, thread_id: ThreadId) -> ThreadStoreFuture<'_, ()>;
 
     /// Discards the live thread writer without forcing pending in-memory items to become durable.
     ///
     /// Core calls this when session initialization fails after a live writer has been created.
     /// Implementations should release any live writer resources for the thread while preserving
     /// already-durable thread data.
-    async fn discard_thread(&self, thread_id: ThreadId) -> ThreadStoreResult<()>;
+    fn discard_thread(&self, thread_id: ThreadId) -> ThreadStoreFuture<'_, ()>;
 
     /// Loads persisted history for resume, fork, rollback, and memory jobs.
-    async fn load_history(
+    fn load_history(
         &self,
         params: LoadThreadHistoryParams,
-    ) -> ThreadStoreResult<StoredThreadHistory>;
+    ) -> ThreadStoreFuture<'_, StoredThreadHistory>;
 
     /// Reads a thread summary and optionally its persisted history.
-    async fn read_thread(&self, params: ReadThreadParams) -> ThreadStoreResult<StoredThread>;
+    fn read_thread(&self, params: ReadThreadParams) -> ThreadStoreFuture<'_, StoredThread>;
 
     /// Reads a rollout-backed thread by path when the store supports path-addressed lookups.
     ///
     /// Deprecated: new callers should use [`ThreadStore::read_thread`] instead.
-    async fn read_thread_by_rollout_path(
+    fn read_thread_by_rollout_path(
         &self,
         params: ReadThreadByRolloutPathParams,
-    ) -> ThreadStoreResult<StoredThread>;
+    ) -> ThreadStoreFuture<'_, StoredThread>;
 
     /// Lists stored threads matching the supplied filters.
-    async fn list_threads(&self, params: ListThreadsParams) -> ThreadStoreResult<ThreadPage>;
+    fn list_threads(&self, params: ListThreadsParams) -> ThreadStoreFuture<'_, ThreadPage>;
 
     /// Searches stored threads and returns search-only preview metadata.
-    async fn search_threads(
+    fn search_threads(
         &self,
         _params: SearchThreadsParams,
-    ) -> ThreadStoreResult<ThreadSearchPage> {
-        Err(ThreadStoreError::Unsupported {
-            operation: "thread/search",
+    ) -> ThreadStoreFuture<'_, ThreadSearchPage> {
+        Box::pin(async {
+            Err(ThreadStoreError::Unsupported {
+                operation: "thread/search",
+            })
         })
     }
 
     /// Lists turns within a stored thread.
-    async fn list_turns(&self, _params: ListTurnsParams) -> ThreadStoreResult<TurnPage> {
-        Err(ThreadStoreError::Unsupported {
-            operation: "list_turns",
+    fn list_turns(&self, _params: ListTurnsParams) -> ThreadStoreFuture<'_, TurnPage> {
+        Box::pin(async {
+            Err(ThreadStoreError::Unsupported {
+                operation: "list_turns",
+            })
         })
     }
 
     /// Lists persisted items within a stored turn.
-    async fn list_items(&self, _params: ListItemsParams) -> ThreadStoreResult<ItemPage> {
-        Err(ThreadStoreError::Unsupported {
-            operation: "list_items",
+    fn list_items(&self, _params: ListItemsParams) -> ThreadStoreFuture<'_, ItemPage> {
+        Box::pin(async {
+            Err(ThreadStoreError::Unsupported {
+                operation: "list_items",
+            })
         })
     }
 
@@ -106,20 +115,17 @@ pub trait ThreadStore: Any + Send + Sync {
     ///
     /// Implementations should apply the supplied fields directly. Policy such as deciding whether
     /// an append-derived preview should be emitted belongs above the store.
-    async fn update_thread_metadata(
+    fn update_thread_metadata(
         &self,
         params: UpdateThreadMetadataParams,
-    ) -> ThreadStoreResult<StoredThread>;
+    ) -> ThreadStoreFuture<'_, StoredThread>;
 
     /// Archives a thread.
-    async fn archive_thread(&self, params: ArchiveThreadParams) -> ThreadStoreResult<()>;
+    fn archive_thread(&self, params: ArchiveThreadParams) -> ThreadStoreFuture<'_, ()>;
 
     /// Unarchives a thread and returns its updated metadata.
-    async fn unarchive_thread(
-        &self,
-        params: ArchiveThreadParams,
-    ) -> ThreadStoreResult<StoredThread>;
+    fn unarchive_thread(&self, params: ArchiveThreadParams) -> ThreadStoreFuture<'_, StoredThread>;
 
     /// Deletes a thread's persisted rollout data and associated metadata.
-    async fn delete_thread(&self, params: DeleteThreadParams) -> ThreadStoreResult<()>;
+    fn delete_thread(&self, params: DeleteThreadParams) -> ThreadStoreFuture<'_, ()>;
 }