feat: add thread lifecycle contributor hooks (#22476)

## Why

Extensions that need thread-scoped state currently only get a start-time
callback. That is enough for seeding stores, but it leaves the host
without a shared extension seam for later thread rehydrate and flush
work as thread ownership evolves. This PR turns that start-only seam
into a host-owned thread lifecycle contributor contract so
extension-private state can stay behind the extension API instead of
leaking extra orchestration through core.

## What changed

- Replaced `ThreadStartContributor` with `ThreadLifecycleContributor`
and added typed lifecycle inputs for thread start, resume, and stop. The
contract lives in
[`contributors/thread_lifecycle.rs`](https://github.com/openai/codex/blob/d0e9211f70e58d6b07ef07e84f359d1b9aa25955/codex-rs/ext/extension-api/src/contributors/thread_lifecycle.rs#L1-L64).
- Kept the existing start-time behavior intact by routing session
construction through `on_thread_start`.
- Invoked `on_thread_stop` during session shutdown before thread-scoped
extension state is dropped, while isolating contributor failures behind
warning logs.
- Migrated `git-attribution` and `guardian` onto the lifecycle
registration path.
- Renamed the extension registry plumbing from start-specific
contributors to lifecycle-specific contributors.

## Notes

`on_thread_resume` is introduced at the API boundary here so extensions
can target the final lifecycle shape; host resume dispatch can be wired
where that runtime path is finalized.

codex-rs/core/src/codex_thread.rs

@@ -140,6 +140,22 @@ impl CodexThread {
         self.codex.session_loop_termination.clone().await;
     }
 
+    pub(crate) fn emit_thread_resume_lifecycle(&self) {
+        for contributor in self
+            .codex
+            .session
+            .services
+            .extensions
+            .thread_lifecycle_contributors()
+        {
+            contributor.on_thread_resume(codex_extension_api::ThreadResumeInput {
+                thread_id: self.codex.session.conversation_id,
+                session_store: &self.codex.session.services.session_extension_data,
+                thread_store: &self.codex.session.services.thread_extension_data,
+            });
+        }
+    }
+
     pub async fn apply_goal_resume_runtime_effects(&self) -> anyhow::Result<()> {
         self.codex
             .session

codex-rs/core/src/session/handlers.rs

@@ -643,6 +643,14 @@ pub async fn shutdown(sess: &Arc<Session>, sub_id: String) -> bool {
         &[],
     );
 
+    for contributor in sess.services.extensions.thread_lifecycle_contributors() {
+        contributor.on_thread_stop(codex_extension_api::ThreadStopInput {
+            thread_id: sess.conversation_id,
+            session_store: &sess.services.session_extension_data,
+            thread_store: &sess.services.thread_extension_data,
+        });
+    }
+
     // Gracefully flush and shutdown thread persistence on session end so tests
     // that inspect durable state do not race with the background writer.
     if let Some(live_thread) = sess.live_thread()

codex-rs/core/src/session/session.rs

@@ -813,13 +813,13 @@ impl Session {
             let agent_control = agent_control.with_session_id(session_id);
             let session_extension_data = codex_extension_api::ExtensionData::new();
             let thread_extension_data = codex_extension_api::ExtensionData::new();
-            for contributor in extensions.thread_start_contributors() {
-                contributor.contribute(
+            for contributor in extensions.thread_lifecycle_contributors() {
+                contributor.on_thread_start(codex_extension_api::ThreadStartInput {
                     thread_id,
-                    config.as_ref(),
-                    &session_extension_data,
-                    &thread_extension_data,
-                );
+                    config: config.as_ref(),
+                    session_store: &session_extension_data,
+                    thread_store: &thread_extension_data,
+                });
             }
 
             let services = SessionServices {

codex-rs/core/src/thread_manager.rs

@@ -1227,10 +1227,11 @@ impl ThreadManagerState {
         let new_thread = self
             .finalize_thread_spawn(codex, thread_id, tracked_session_source)
             .await?;
-        if is_resumed_thread
-            && let Err(err) = new_thread.thread.apply_goal_resume_runtime_effects().await
-        {
-            warn!("failed to apply goal resume runtime effects: {err}");
+        if is_resumed_thread {
+            new_thread.thread.emit_thread_resume_lifecycle();
+            if let Err(err) = new_thread.thread.apply_goal_resume_runtime_effects().await {
+                warn!("failed to apply goal resume runtime effects: {err}");
+            }
         }
         Ok(new_thread)
     }