Add thread metadata update endpoint to app server (#13280)

## Summary
- add the v2 `thread/metadata/update` API, including
protocol/schema/TypeScript exports and app-server docs
- patch stored thread `gitInfo` in sqlite without resuming the thread,
with validation plus support for explicit `null` clears
- repair missing sqlite thread rows from rollout data before patching,
and make those repairs safe by inserting only when absent and updating
only git columns so newer metadata is not clobbered
- keep sqlite authoritative for mutable thread git metadata by
preserving existing sqlite git fields during reconcile/backfill and only
using rollout `SessionMeta` git fields to fill gaps
- add regression coverage for the endpoint, repair paths, concurrent
sqlite writes, clearing git fields, and rollout/backfill reconciliation
- fix the login server shutdown race so cancelling before the waiter
starts still terminates `block_until_done()` correctly

## Testing
- `cargo test -p codex-state
apply_rollout_items_preserves_existing_git_branch_and_fills_missing_git_fields`
- `cargo test -p codex-state
update_thread_git_info_preserves_newer_non_git_metadata`
- `cargo test -p codex-core
backfill_sessions_preserves_existing_git_branch_and_fills_missing_git_fields`
- `cargo test -p codex-app-server thread_metadata_update`
- `cargo test`
- currently fails in existing `codex-core` grep-files tests with
`unsupported call: grep_files`:
    - `suite::grep_files::grep_files_tool_collects_matches`
    - `suite::grep_files::grep_files_tool_reports_empty_results`

codex-rs/core/src/rollout/metadata.rs

@@ -282,6 +282,9 @@ pub(crate) async fn backfill_sessions(
                     let mut metadata = outcome.metadata;
                     metadata.cwd = normalize_cwd_for_state_db(&metadata.cwd);
                     let memory_mode = outcome.memory_mode.unwrap_or_else(|| "enabled".to_string());
+                    if let Ok(Some(existing_metadata)) = runtime.get_thread(metadata.id).await {
+                        metadata.prefer_existing_git_info(&existing_metadata);
+                    }
                     if rollout.archived && metadata.archived_at.is_none() {
                         let fallback_archived_at = metadata.updated_at;
                         metadata.archived_at = file_modified_time_utc(&rollout.path)
@@ -503,6 +506,7 @@ mod tests {
     use chrono::Utc;
     use codex_protocol::ThreadId;
     use codex_protocol::protocol::CompactedItem;
+    use codex_protocol::protocol::GitInfo;
     use codex_protocol::protocol::RolloutItem;
     use codex_protocol::protocol::RolloutLine;
     use codex_protocol::protocol::SessionMeta;
@@ -669,12 +673,14 @@ mod tests {
             "2026-01-27T12-34-56",
             "2026-01-27T12:34:56Z",
             first_uuid,
+            None,
         );
         let second_path = write_rollout_in_sessions(
             codex_home.as_path(),
             "2026-01-27T12-35-56",
             "2026-01-27T12:35:56Z",
             second_uuid,
+            None,
         );
 
         let runtime =
@@ -730,6 +736,58 @@ mod tests {
         assert!(state.last_success_at.is_some());
     }
 
+    #[tokio::test]
+    async fn backfill_sessions_preserves_existing_git_branch_and_fills_missing_git_fields() {
+        let dir = tempdir().expect("tempdir");
+        let codex_home = dir.path().to_path_buf();
+        let thread_uuid = Uuid::new_v4();
+        let rollout_path = write_rollout_in_sessions(
+            codex_home.as_path(),
+            "2026-01-27T12-34-56",
+            "2026-01-27T12:34:56Z",
+            thread_uuid,
+            Some(GitInfo {
+                commit_hash: Some("rollout-sha".to_string()),
+                branch: Some("rollout-branch".to_string()),
+                repository_url: Some("git@example.com:openai/codex.git".to_string()),
+            }),
+        );
+
+        let runtime =
+            codex_state::StateRuntime::init(codex_home.clone(), "test-provider".to_string(), None)
+                .await
+                .expect("initialize runtime");
+        let thread_id = ThreadId::from_string(&thread_uuid.to_string()).expect("thread id");
+        let mut existing = extract_metadata_from_rollout(&rollout_path, "test-provider", None)
+            .await
+            .expect("extract")
+            .metadata;
+        existing.git_sha = None;
+        existing.git_branch = Some("sqlite-branch".to_string());
+        existing.git_origin_url = None;
+        runtime
+            .upsert_thread(&existing)
+            .await
+            .expect("existing metadata upsert");
+
+        let mut config = crate::config::test_config();
+        config.codex_home = codex_home.clone();
+        config.model_provider_id = "test-provider".to_string();
+        backfill_sessions(runtime.as_ref(), &config, None).await;
+
+        let persisted = runtime
+            .get_thread(thread_id)
+            .await
+            .expect("get thread")
+            .expect("thread exists");
+        assert_eq!(persisted.git_sha.as_deref(), Some("rollout-sha"));
+        assert_eq!(persisted.git_branch.as_deref(), Some("sqlite-branch"));
+        assert_eq!(
+            persisted.git_origin_url.as_deref(),
+            Some("git@example.com:openai/codex.git")
+        );
+    }
+
     #[tokio::test]
     async fn backfill_sessions_normalizes_cwd_before_upsert() {
         let dir = tempdir().expect("tempdir");
@@ -742,6 +800,7 @@ mod tests {
             "2026-01-27T12:34:56Z",
             thread_uuid,
             session_cwd.clone(),
+            None,
         );
 
         let runtime =
@@ -770,6 +829,7 @@ mod tests {
         filename_ts: &str,
         event_ts: &str,
         thread_uuid: Uuid,
+        git: Option<GitInfo>,
     ) -> PathBuf {
         write_rollout_in_sessions_with_cwd(
             codex_home,
@@ -777,6 +837,7 @@ mod tests {
             event_ts,
             thread_uuid,
             codex_home.to_path_buf(),
+            git,
         )
     }
 
@@ -786,6 +847,7 @@ mod tests {
         event_ts: &str,
         thread_uuid: Uuid,
         cwd: PathBuf,
+        git: Option<GitInfo>,
     ) -> PathBuf {
         let id = ThreadId::from_string(&thread_uuid.to_string()).expect("thread id");
         let sessions_dir = codex_home.join("sessions");
@@ -808,7 +870,7 @@ mod tests {
         };
         let session_meta_line = SessionMetaLine {
             meta: session_meta,
-            git: None,
+            git,
         };
         let rollout_line = RolloutLine {
             timestamp: event_ts.to_string(),

codex-rs/core/src/state_db.rs

@@ -390,6 +390,9 @@ pub async fn reconcile_rollout(
     let mut metadata = outcome.metadata;
     let memory_mode = outcome.memory_mode.unwrap_or_else(|| "enabled".to_string());
     metadata.cwd = normalize_cwd_for_state_db(&metadata.cwd);
+    if let Ok(Some(existing_metadata)) = ctx.get_thread(metadata.id).await {
+        metadata.prefer_existing_git_info(&existing_metadata);
+    }
     match archived_only {
         Some(true) if metadata.archived_at.is_none() => {
             metadata.archived_at = Some(metadata.updated_at);