Register agent identities behind use_agent_identity (#17386)

## Summary

Stack PR 2 of 4 for feature-gated agent identity support.

This PR adds agent identity registration behind
`features.use_agent_identity`. It keeps the app-server protocol
unchanged and starts registration after ChatGPT auth exists rather than
requiring a client restart.

## Stack

- PR1: https://github.com/openai/codex/pull/17385 - add
`features.use_agent_identity`
- PR2: https://github.com/openai/codex/pull/17386 - this PR
- PR3: https://github.com/openai/codex/pull/17387 - register agent tasks
when enabled
- PR4: https://github.com/openai/codex/pull/17388 - use `AgentAssertion`
downstream when enabled

## Validation

Covered as part of the local stack validation pass:

- `just fmt`
- `cargo test -p codex-core --lib agent_identity`
- `cargo test -p codex-core --lib agent_assertion`
- `cargo test -p codex-core --lib websocket_agent_task`
- `cargo test -p codex-api api_bridge`
- `cargo build -p codex-cli --bin codex`

## Notes

The full local app-server E2E path is still being debugged after PR
creation. The current branch stack is directionally ready for review
while that follow-up continues.

codex-rs/login/src/auth/auth_tests.rs

@@ -16,6 +16,8 @@ use serde_json::json;
 use std::sync::Arc;
 use tempfile::TempDir;
 use tempfile::tempdir;
+use tokio::time::Duration;
+use tokio::time::timeout;
 
 #[tokio::test]
 async fn refresh_without_id_token() {
@@ -135,6 +137,7 @@ async fn pro_account_with_no_api_key_uses_chatgpt_auth() {
                 account_id: None,
             }),
             last_refresh: Some(last_refresh),
+            agent_identity: None,
         },
         auth_dot_json
     );
@@ -172,6 +175,7 @@ fn logout_removes_auth_file() -> Result<(), std::io::Error> {
         openai_api_key: Some("sk-test-key".to_string()),
         tokens: None,
         last_refresh: None,
+        agent_identity: None,
     };
     super::save_auth(dir.path(), &auth_dot_json, AuthCredentialsStoreMode::File)?;
     let auth_file = get_auth_file(dir.path());
@@ -181,6 +185,49 @@ fn logout_removes_auth_file() -> Result<(), std::io::Error> {
     Ok(())
 }
 
+#[test]
+fn chatgpt_auth_persists_agent_identity_for_workspace() {
+    let codex_home = tempdir().unwrap();
+    write_auth_file(
+        AuthFileParams {
+            openai_api_key: None,
+            chatgpt_plan_type: Some("pro".to_string()),
+            chatgpt_account_id: Some("account-123".to_string()),
+        },
+        codex_home.path(),
+    )
+    .expect("failed to write auth file");
+    let auth = super::load_auth(
+        codex_home.path(),
+        /*enable_codex_api_key_env*/ false,
+        AuthCredentialsStoreMode::File,
+    )
+    .expect("load auth")
+    .expect("auth available");
+    let record = AgentIdentityAuthRecord {
+        workspace_id: "account-123".to_string(),
+        chatgpt_user_id: Some("user-123".to_string()),
+        agent_runtime_id: "agent_123".to_string(),
+        agent_private_key: "pkcs8-base64".to_string(),
+        registered_at: "2026-04-13T12:00:00Z".to_string(),
+    };
+
+    auth.set_agent_identity(record.clone())
+        .expect("set agent identity");
+
+    assert_eq!(auth.get_agent_identity("account-123"), Some(record.clone()));
+    assert_eq!(auth.get_agent_identity("other-account"), None);
+    let storage = FileAuthStorage::new(codex_home.path().to_path_buf());
+    let persisted = storage
+        .load()
+        .expect("load auth")
+        .expect("auth should exist");
+    assert_eq!(persisted.agent_identity, Some(record));
+
+    assert!(auth.remove_agent_identity().expect("remove agent identity"));
+    assert_eq!(auth.get_agent_identity("account-123"), None);
+}
+
 #[test]
 fn unauthorized_recovery_reports_mode_and_step_names() {
     let dir = tempdir().unwrap();
@@ -474,6 +521,67 @@ exit 1
     }
 }
 
+#[tokio::test]
+async fn auth_manager_notifies_when_auth_state_changes() {
+    let dir = tempdir().unwrap();
+    let manager = AuthManager::shared(
+        dir.path().to_path_buf(),
+        /*enable_codex_api_key_env*/ false,
+        AuthCredentialsStoreMode::File,
+    );
+    let mut auth_state_rx = manager.subscribe_auth_state();
+
+    save_auth(
+        dir.path(),
+        &AuthDotJson {
+            auth_mode: Some(ApiAuthMode::ApiKey),
+            openai_api_key: Some("sk-test-key".to_string()),
+            tokens: None,
+            last_refresh: None,
+            agent_identity: None,
+        },
+        AuthCredentialsStoreMode::File,
+    )
+    .expect("save auth");
+
+    assert!(
+        manager.reload(),
+        "reload should report a changed auth state"
+    );
+    timeout(Duration::from_secs(1), auth_state_rx.changed())
+        .await
+        .expect("auth change notification should arrive")
+        .expect("auth state watch should remain open");
+
+    save_auth(
+        dir.path(),
+        &AuthDotJson {
+            auth_mode: Some(ApiAuthMode::ApiKey),
+            openai_api_key: Some("sk-updated-key".to_string()),
+            tokens: None,
+            last_refresh: None,
+            agent_identity: None,
+        },
+        AuthCredentialsStoreMode::File,
+    )
+    .expect("save updated auth");
+
+    assert!(
+        !manager.reload(),
+        "reload remains mode-stable even when the underlying credentials change"
+    );
+    timeout(Duration::from_secs(1), auth_state_rx.changed())
+        .await
+        .expect("auth reload notification should still arrive")
+        .expect("auth state watch should remain open");
+
+    manager.set_forced_chatgpt_workspace_id(Some("workspace-123".to_string()));
+    timeout(Duration::from_secs(1), auth_state_rx.changed())
+        .await
+        .expect("workspace change notification should arrive")
+        .expect("auth state watch should remain open");
+}
+
 struct AuthFileParams {
     openai_api_key: Option<String>,
     chatgpt_plan_type: Option<String>,