diff --git a/src-tauri/src/bin/codex_monitor_daemon.rs b/src-tauri/src/bin/codex_monitor_daemon.rs
index a659483ba..bcb148ac3 100644
--- a/src-tauri/src/bin/codex_monitor_daemon.rs
+++ b/src-tauri/src/bin/codex_monitor_daemon.rs
@@ -23,6 +23,7 @@ mod utils;
 #[path = "../types.rs"]
 mod types;
 
+use base64::Engine;
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Map, Value};
 use std::collections::HashMap;
@@ -31,17 +32,23 @@ use std::fs::File;
 use std::io::Read;
 use std::net::SocketAddr;
 use std::path::PathBuf;
+use std::process::Stdio;
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::time::Duration;
 
 use ignore::WalkBuilder;
-use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
 use tokio::net::{TcpListener, TcpStream};
 use tokio::process::Command;
-use tokio::sync::{broadcast, mpsc, Mutex};
+use tokio::sync::{broadcast, mpsc, oneshot, Mutex};
+use tokio::time::timeout;
 use uuid::Uuid;
 use utils::{git_env_path, resolve_git_binary};
 
-use backend::app_server::{spawn_workspace_session, WorkspaceSession};
+use backend::app_server::{
+    build_codex_command_with_bin, spawn_workspace_session, WorkspaceSession,
+};
 use backend::events::{AppServerEvent, EventSink, TerminalOutput};
 use storage::{read_settings, read_workspaces, write_settings, write_workspaces};
 use types::{
@@ -103,6 +110,7 @@ struct DaemonState {
     settings_path: PathBuf,
     app_settings: Mutex<AppSettings>,
     event_sink: DaemonEventSink,
+    codex_login_cancels: Mutex<HashMap<String, oneshot::Sender<()>>>,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -125,6 +133,7 @@ impl DaemonState {
             settings_path,
             app_settings: Mutex::new(app_settings),
             event_sink,
+            codex_login_cancels: Mutex::new(HashMap::new()),
         }
     }
 
@@ -1302,6 +1311,173 @@ impl DaemonState {
             .await
     }
 
+    async fn account_read(&self, workspace_id: String) -> Result<Value, String> {
+        let response = match self.get_session(&workspace_id).await {
+            Ok(session) => session.send_request("account/read", Value::Null).await.ok(),
+            Err(_) => None,
+        };
+        let codex_home = self.resolve_codex_home_for_workspace(&workspace_id).await.ok();
+        let fallback = read_auth_account(codex_home);
+        Ok(build_account_response(response, fallback))
+    }
+
+    async fn codex_login(&self, workspace_id: String) -> Result<Value, String> {
+        let (entry, parent_entry, settings) = {
+            let workspaces = self.workspaces.lock().await;
+            let entry = workspaces
+                .get(&workspace_id)
+                .ok_or("workspace not found")?
+                .clone();
+            let parent_entry = entry
+                .parent_id
+                .as_ref()
+                .and_then(|parent_id| workspaces.get(parent_id))
+                .cloned();
+            let settings = self.app_settings.lock().await.clone();
+            (entry, parent_entry, settings)
+        };
+
+        let codex_bin = entry
+            .codex_bin
+            .clone()
+            .filter(|value| !value.trim().is_empty())
+            .or(settings.codex_bin.clone());
+        let codex_args =
+            codex_args::resolve_workspace_codex_args(&entry, parent_entry.as_ref(), Some(&settings));
+        let codex_home = codex_home::resolve_workspace_codex_home(&entry, parent_entry.as_ref())
+            .or_else(codex_home::resolve_default_codex_home);
+
+        let mut command = build_codex_command_with_bin(codex_bin);
+        if let Some(ref codex_home) = codex_home {
+            command.env("CODEX_HOME", codex_home);
+        }
+        codex_args::apply_codex_args(&mut command, codex_args.as_deref())?;
+        command.arg("login");
+        command.stdout(Stdio::piped());
+        command.stderr(Stdio::piped());
+
+        let mut child = command.spawn().map_err(|error| error.to_string())?;
+        let (cancel_tx, cancel_rx) = oneshot::channel::<()>();
+        {
+            let mut cancels = self.codex_login_cancels.lock().await;
+            if let Some(existing) = cancels.remove(&workspace_id) {
+                let _ = existing.send(());
+            }
+            cancels.insert(workspace_id.clone(), cancel_tx);
+        }
+        let pid = child.id();
+        let canceled = Arc::new(AtomicBool::new(false));
+        let canceled_for_task = Arc::clone(&canceled);
+        let cancel_task = tokio::spawn(async move {
+            if cancel_rx.await.is_ok() {
+                canceled_for_task.store(true, Ordering::Relaxed);
+                if let Some(pid) = pid {
+                    #[cfg(not(target_os = "windows"))]
+                    unsafe {
+                        libc::kill(pid as i32, libc::SIGKILL);
+                    }
+                    #[cfg(target_os = "windows")]
+                    {
+                        let _ = Command::new("taskkill")
+                            .args(["/PID", &pid.to_string(), "/T", "/F"])
+                            .status()
+                            .await;
+                    }
+                }
+            }
+        });
+        let stdout_pipe = child.stdout.take();
+        let stderr_pipe = child.stderr.take();
+
+        let stdout_task = tokio::spawn(async move {
+            let mut buffer = Vec::new();
+            if let Some(mut stdout) = stdout_pipe {
+                let _ = stdout.read_to_end(&mut buffer).await;
+            }
+            buffer
+        });
+        let stderr_task = tokio::spawn(async move {
+            let mut buffer = Vec::new();
+            if let Some(mut stderr) = stderr_pipe {
+                let _ = stderr.read_to_end(&mut buffer).await;
+            }
+            buffer
+        });
+
+        let status = match timeout(Duration::from_secs(120), child.wait()).await {
+            Ok(result) => result.map_err(|error| error.to_string())?,
+            Err(_) => {
+                let _ = child.kill().await;
+                let _ = child.wait().await;
+                cancel_task.abort();
+                {
+                    let mut cancels = self.codex_login_cancels.lock().await;
+                    cancels.remove(&workspace_id);
+                }
+                return Err("Codex login timed out.".to_string());
+            }
+        };
+
+        cancel_task.abort();
+        {
+            let mut cancels = self.codex_login_cancels.lock().await;
+            cancels.remove(&workspace_id);
+        }
+
+        if canceled.load(Ordering::Relaxed) {
+            return Err("Codex login canceled.".to_string());
+        }
+
+        let stdout_bytes = match stdout_task.await {
+            Ok(bytes) => bytes,
+            Err(_) => Vec::new(),
+        };
+        let stderr_bytes = match stderr_task.await {
+            Ok(bytes) => bytes,
+            Err(_) => Vec::new(),
+        };
+
+        let stdout = String::from_utf8_lossy(&stdout_bytes);
+        let stderr = String::from_utf8_lossy(&stderr_bytes);
+        let detail = if stderr.trim().is_empty() {
+            stdout.trim()
+        } else {
+            stderr.trim()
+        };
+        let combined = if stdout.trim().is_empty() {
+            stderr.trim().to_string()
+        } else if stderr.trim().is_empty() {
+            stdout.trim().to_string()
+        } else {
+            format!("{}\n{}", stdout.trim(), stderr.trim())
+        };
+        let limited = combined.chars().take(4000).collect::<String>();
+
+        if !status.success() {
+            return Err(if detail.is_empty() {
+                "Codex login failed.".to_string()
+            } else {
+                format!("Codex login failed: {detail}")
+            });
+        }
+
+        Ok(json!({ "output": limited }))
+    }
+
+    async fn codex_login_cancel(&self, workspace_id: String) -> Result<Value, String> {
+        let cancel_tx = {
+            let mut cancels = self.codex_login_cancels.lock().await;
+            cancels.remove(&workspace_id)
+        };
+        let canceled = if let Some(tx) = cancel_tx {
+            let _ = tx.send(());
+            true
+        } else {
+            false
+        };
+        Ok(json!({ "canceled": canceled }))
+    }
+
     async fn skills_list(&self, workspace_id: String) -> Result<Value, String> {
         let session = self.get_session(&workspace_id).await?;
         let params = json!({
@@ -1394,6 +1570,213 @@ fn normalize_git_path(path: &str) -> String {
     path.replace('\\', "/")
 }
 
+struct AuthAccount {
+    email: Option<String>,
+    plan_type: Option<String>,
+}
+
+fn build_account_response(response: Option<Value>, fallback: Option<AuthAccount>) -> Value {
+    let mut account = response
+        .as_ref()
+        .and_then(extract_account_map)
+        .unwrap_or_default();
+    if let Some(fallback) = fallback {
+        let account_type = account
+            .get("type")
+            .and_then(|value| value.as_str())
+            .map(|value| value.to_ascii_lowercase());
+        let allow_fallback = account.is_empty()
+            || matches!(account_type.as_deref(), None | Some("chatgpt") | Some("unknown"));
+        if allow_fallback {
+            if !account.contains_key("email") {
+                if let Some(email) = fallback.email {
+                    account.insert("email".to_string(), Value::String(email));
+                }
+            }
+            if !account.contains_key("planType") {
+                if let Some(plan) = fallback.plan_type {
+                    account.insert("planType".to_string(), Value::String(plan));
+                }
+            }
+            if !account.contains_key("type") {
+                account.insert("type".to_string(), Value::String("chatgpt".to_string()));
+            }
+        }
+    }
+
+    let account_value = if account.is_empty() {
+        Value::Null
+    } else {
+        Value::Object(account)
+    };
+    let mut result = Map::new();
+    result.insert("account".to_string(), account_value);
+    if let Some(requires_openai_auth) = response
+        .as_ref()
+        .and_then(extract_requires_openai_auth)
+    {
+        result.insert(
+            "requiresOpenaiAuth".to_string(),
+            Value::Bool(requires_openai_auth),
+        );
+    }
+    Value::Object(result)
+}
+
+fn extract_account_map(value: &Value) -> Option<Map<String, Value>> {
+    let account = value
+        .get("account")
+        .or_else(|| value.get("result").and_then(|result| result.get("account")))
+        .and_then(|value| value.as_object().cloned());
+    if account.is_some() {
+        return account;
+    }
+    let root = value.as_object()?;
+    if root.contains_key("email") || root.contains_key("planType") || root.contains_key("type") {
+        return Some(root.clone());
+    }
+    None
+}
+
+fn extract_requires_openai_auth(value: &Value) -> Option<bool> {
+    value
+        .get("requiresOpenaiAuth")
+        .or_else(|| value.get("requires_openai_auth"))
+        .or_else(|| {
+            value
+                .get("result")
+                .and_then(|result| result.get("requiresOpenaiAuth"))
+        })
+        .or_else(|| {
+            value
+                .get("result")
+                .and_then(|result| result.get("requires_openai_auth"))
+        })
+        .and_then(|value| value.as_bool())
+}
+
+fn read_auth_account(codex_home: Option<PathBuf>) -> Option<AuthAccount> {
+    let codex_home = codex_home?;
+    let auth_path = codex_home.join("auth.json");
+    let data = std::fs::read(auth_path).ok()?;
+    let auth_value: Value = serde_json::from_slice(&data).ok()?;
+    let tokens = auth_value.get("tokens")?;
+    let id_token = tokens
+        .get("idToken")
+        .or_else(|| tokens.get("id_token"))
+        .and_then(|value| value.as_str())?;
+    let payload = decode_jwt_payload(id_token)?;
+
+    let auth_dict = payload
+        .get("https://api.openai.com/auth")
+        .and_then(|value| value.as_object());
+    let profile_dict = payload
+        .get("https://api.openai.com/profile")
+        .and_then(|value| value.as_object());
+    let plan = normalize_string(
+        auth_dict
+            .and_then(|dict| dict.get("chatgpt_plan_type"))
+            .or_else(|| payload.get("chatgpt_plan_type")),
+    );
+    let email = normalize_string(
+        payload
+            .get("email")
+            .or_else(|| profile_dict.and_then(|dict| dict.get("email"))),
+    );
+
+    if email.is_none() && plan.is_none() {
+        return None;
+    }
+
+    Some(AuthAccount {
+        email,
+        plan_type: plan,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    fn fallback_account() -> AuthAccount {
+        AuthAccount {
+            email: Some("chatgpt@example.com".to_string()),
+            plan_type: Some("plus".to_string()),
+        }
+    }
+
+    fn result_account_map(value: &Value) -> Map<String, Value> {
+        value
+            .get("account")
+            .and_then(Value::as_object)
+            .cloned()
+            .unwrap_or_default()
+    }
+
+    #[test]
+    fn build_account_response_does_not_fallback_for_apikey() {
+        let response = Some(json!({
+            "account": {
+                "type": "apikey"
+            }
+        }));
+        let result = build_account_response(response, Some(fallback_account()));
+        let account = result_account_map(&result);
+
+        assert_eq!(account.get("type").and_then(Value::as_str), Some("apikey"));
+        assert!(!account.contains_key("email"));
+        assert!(!account.contains_key("planType"));
+    }
+
+    #[test]
+    fn build_account_response_falls_back_when_account_missing() {
+        let result = build_account_response(None, Some(fallback_account()));
+        let account = result_account_map(&result);
+
+        assert_eq!(
+            account.get("email").and_then(Value::as_str),
+            Some("chatgpt@example.com"),
+        );
+        assert_eq!(account.get("planType").and_then(Value::as_str), Some("plus"));
+        assert_eq!(account.get("type").and_then(Value::as_str), Some("chatgpt"));
+    }
+
+    #[test]
+    fn build_account_response_allows_fallback_for_chatgpt_type() {
+        let response = Some(json!({
+            "account": {
+                "type": "chatgpt"
+            }
+        }));
+        let result = build_account_response(response, Some(fallback_account()));
+        let account = result_account_map(&result);
+
+        assert_eq!(account.get("type").and_then(Value::as_str), Some("chatgpt"));
+        assert_eq!(
+            account.get("email").and_then(Value::as_str),
+            Some("chatgpt@example.com"),
+        );
+        assert_eq!(account.get("planType").and_then(Value::as_str), Some("plus"));
+    }
+}
+
+fn decode_jwt_payload(token: &str) -> Option<Value> {
+    let payload = token.split('.').nth(1)?;
+    let decoded = base64::engine::general_purpose::URL_SAFE_NO_PAD
+        .decode(payload.as_bytes())
+        .or_else(|_| base64::engine::general_purpose::URL_SAFE.decode(payload.as_bytes()))
+        .ok()?;
+    serde_json::from_slice(&decoded).ok()
+}
+
+fn normalize_string(value: Option<&Value>) -> Option<String> {
+    value
+        .and_then(|value| value.as_str())
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+}
+
 fn list_workspace_files_inner(root: &PathBuf, max_files: usize) -> Vec<String> {
     let mut results = Vec::new();
     let walker = WalkBuilder::new(root)
@@ -2158,6 +2541,18 @@ async fn handle_rpc_request(
             let workspace_id = parse_string(&params, "workspaceId")?;
             state.account_rate_limits(workspace_id).await
         }
+        "account_read" => {
+            let workspace_id = parse_string(&params, "workspaceId")?;
+            state.account_read(workspace_id).await
+        }
+        "codex_login" => {
+            let workspace_id = parse_string(&params, "workspaceId")?;
+            state.codex_login(workspace_id).await
+        }
+        "codex_login_cancel" => {
+            let workspace_id = parse_string(&params, "workspaceId")?;
+            state.codex_login_cancel(workspace_id).await
+        }
         "skills_list" => {
             let workspace_id = parse_string(&params, "workspaceId")?;
             state.skills_list(workspace_id).await
diff --git a/src-tauri/src/codex.rs b/src-tauri/src/codex.rs
index 6faebd0ca..d7c8614e6 100644
--- a/src-tauri/src/codex.rs
+++ b/src-tauri/src/codex.rs
@@ -1,12 +1,17 @@
+use base64::Engine;
 use serde_json::{json, Map, Value};
+use std::fs;
 use std::io::ErrorKind;
 use std::path::PathBuf;
+use std::process::Stdio;
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::Duration;
 
 use tauri::{AppHandle, State};
+use tokio::io::AsyncReadExt;
 use tokio::process::Command;
-use tokio::sync::mpsc;
+use tokio::sync::{mpsc, oneshot};
 use tokio::time::timeout;
 
 pub(crate) use crate::backend::app_server::WorkspaceSession;
@@ -14,7 +19,7 @@ use crate::backend::app_server::{
     build_codex_command_with_bin, build_codex_path_env, check_codex_installation,
     spawn_workspace_session as spawn_workspace_session_inner,
 };
-use crate::codex_args::apply_codex_args;
+use crate::codex_args::{apply_codex_args, resolve_workspace_codex_args};
 use crate::codex_config;
 use crate::codex_home::{resolve_default_codex_home, resolve_workspace_codex_home};
 use crate::event_sink::TauriEventSink;
@@ -503,6 +508,238 @@ pub(crate) async fn account_rate_limits(
         .await
 }
 
+#[tauri::command]
+pub(crate) async fn account_read(
+    workspace_id: String,
+    state: State<'_, AppState>,
+    app: AppHandle,
+) -> Result<Value, String> {
+    if remote_backend::is_remote_mode(&*state).await {
+        return remote_backend::call_remote(
+            &*state,
+            app,
+            "account_read",
+            json!({ "workspaceId": workspace_id }),
+        )
+        .await;
+    }
+
+    let session = {
+        let sessions = state.sessions.lock().await;
+        sessions.get(&workspace_id).cloned()
+    };
+    let response = if let Some(session) = session {
+        session.send_request("account/read", Value::Null).await.ok()
+    } else {
+        None
+    };
+
+    let (entry, parent_entry) = {
+        let workspaces = state.workspaces.lock().await;
+        let entry = workspaces
+            .get(&workspace_id)
+            .ok_or("workspace not found")?
+            .clone();
+        let parent_entry = entry
+            .parent_id
+            .as_ref()
+            .and_then(|parent_id| workspaces.get(parent_id))
+            .cloned();
+        (entry, parent_entry)
+    };
+    let codex_home = resolve_workspace_codex_home(&entry, parent_entry.as_ref())
+        .or_else(resolve_default_codex_home);
+    let fallback = read_auth_account(codex_home);
+
+    Ok(build_account_response(response, fallback))
+}
+
+#[tauri::command]
+pub(crate) async fn codex_login(
+    workspace_id: String,
+    state: State<'_, AppState>,
+    app: AppHandle,
+) -> Result<Value, String> {
+    if remote_backend::is_remote_mode(&*state).await {
+        return remote_backend::call_remote(
+            &*state,
+            app,
+            "codex_login",
+            json!({ "workspaceId": workspace_id }),
+        )
+        .await;
+    }
+
+    let (entry, parent_entry, settings) = {
+        let workspaces = state.workspaces.lock().await;
+        let entry = workspaces
+            .get(&workspace_id)
+            .ok_or("workspace not found")?
+            .clone();
+        let parent_entry = entry
+            .parent_id
+            .as_ref()
+            .and_then(|parent_id| workspaces.get(parent_id))
+            .cloned();
+        let settings = state.app_settings.lock().await.clone();
+        (entry, parent_entry, settings)
+    };
+
+    let codex_bin = entry
+        .codex_bin
+        .clone()
+        .filter(|value| !value.trim().is_empty())
+        .or(settings.codex_bin.clone());
+    let codex_args = resolve_workspace_codex_args(&entry, parent_entry.as_ref(), Some(&settings));
+    let codex_home = resolve_workspace_codex_home(&entry, parent_entry.as_ref())
+        .or_else(resolve_default_codex_home);
+
+    let mut command = build_codex_command_with_bin(codex_bin);
+    if let Some(ref codex_home) = codex_home {
+        command.env("CODEX_HOME", codex_home);
+    }
+    apply_codex_args(&mut command, codex_args.as_deref())?;
+    command.arg("login");
+    command.stdout(Stdio::piped());
+    command.stderr(Stdio::piped());
+
+    let mut child = command.spawn().map_err(|error| error.to_string())?;
+    let (cancel_tx, cancel_rx) = oneshot::channel::<()>();
+    {
+        let mut cancels = state.codex_login_cancels.lock().await;
+        if let Some(existing) = cancels.remove(&workspace_id) {
+            let _ = existing.send(());
+        }
+        cancels.insert(workspace_id.clone(), cancel_tx);
+    }
+    let pid = child.id();
+    let canceled = Arc::new(AtomicBool::new(false));
+    let canceled_for_task = Arc::clone(&canceled);
+    let cancel_task = tokio::spawn(async move {
+        if cancel_rx.await.is_ok() {
+            canceled_for_task.store(true, Ordering::Relaxed);
+            if let Some(pid) = pid {
+                #[cfg(not(target_os = "windows"))]
+                unsafe {
+                    libc::kill(pid as i32, libc::SIGKILL);
+                }
+                #[cfg(target_os = "windows")]
+                {
+                    let _ = Command::new("taskkill")
+                        .args(["/PID", &pid.to_string(), "/T", "/F"])
+                        .status()
+                        .await;
+                }
+            }
+        }
+    });
+    let stdout_pipe = child.stdout.take();
+    let stderr_pipe = child.stderr.take();
+
+    let stdout_task = tokio::spawn(async move {
+        let mut buffer = Vec::new();
+        if let Some(mut stdout) = stdout_pipe {
+            let _ = stdout.read_to_end(&mut buffer).await;
+        }
+        buffer
+    });
+    let stderr_task = tokio::spawn(async move {
+        let mut buffer = Vec::new();
+        if let Some(mut stderr) = stderr_pipe {
+            let _ = stderr.read_to_end(&mut buffer).await;
+        }
+        buffer
+    });
+
+    let status = match timeout(Duration::from_secs(120), child.wait()).await {
+        Ok(result) => result.map_err(|error| error.to_string())?,
+        Err(_) => {
+            let _ = child.kill().await;
+            let _ = child.wait().await;
+            cancel_task.abort();
+            {
+                let mut cancels = state.codex_login_cancels.lock().await;
+                cancels.remove(&workspace_id);
+            }
+            return Err("Codex login timed out.".to_string());
+        }
+    };
+
+    cancel_task.abort();
+    {
+        let mut cancels = state.codex_login_cancels.lock().await;
+        cancels.remove(&workspace_id);
+    }
+
+    if canceled.load(Ordering::Relaxed) {
+        return Err("Codex login canceled.".to_string());
+    }
+
+    let stdout_bytes = match stdout_task.await {
+        Ok(bytes) => bytes,
+        Err(_) => Vec::new(),
+    };
+    let stderr_bytes = match stderr_task.await {
+        Ok(bytes) => bytes,
+        Err(_) => Vec::new(),
+    };
+
+    let stdout = String::from_utf8_lossy(&stdout_bytes);
+    let stderr = String::from_utf8_lossy(&stderr_bytes);
+    let detail = if stderr.trim().is_empty() {
+        stdout.trim()
+    } else {
+        stderr.trim()
+    };
+    let combined = if stdout.trim().is_empty() {
+        stderr.trim().to_string()
+    } else if stderr.trim().is_empty() {
+        stdout.trim().to_string()
+    } else {
+        format!("{}\n{}", stdout.trim(), stderr.trim())
+    };
+    let limited = combined.chars().take(4000).collect::<String>();
+
+    if !status.success() {
+        return Err(if detail.is_empty() {
+            "Codex login failed.".to_string()
+        } else {
+            format!("Codex login failed: {detail}")
+        });
+    }
+
+    Ok(json!({ "output": limited }))
+}
+
+#[tauri::command]
+pub(crate) async fn codex_login_cancel(
+    workspace_id: String,
+    state: State<'_, AppState>,
+    app: AppHandle,
+) -> Result<Value, String> {
+    if remote_backend::is_remote_mode(&*state).await {
+        return remote_backend::call_remote(
+            &*state,
+            app,
+            "codex_login_cancel",
+            json!({ "workspaceId": workspace_id }),
+        )
+        .await;
+    }
+
+    let cancel_tx = {
+        let mut cancels = state.codex_login_cancels.lock().await;
+        cancels.remove(&workspace_id)
+    };
+    let canceled = if let Some(tx) = cancel_tx {
+        let _ = tx.send(());
+        true
+    } else {
+        false
+    };
+    Ok(json!({ "canceled": canceled }))
+}
+
 #[tauri::command]
 pub(crate) async fn skills_list(
     workspace_id: String,
@@ -1048,3 +1285,210 @@ fn sanitize_run_worktree_name(value: &str) -> String {
     }
     format!("feat/{}", cleaned.trim_start_matches('/'))
 }
+
+struct AuthAccount {
+    email: Option<String>,
+    plan_type: Option<String>,
+}
+
+fn build_account_response(response: Option<Value>, fallback: Option<AuthAccount>) -> Value {
+    let mut account = response
+        .as_ref()
+        .and_then(extract_account_map)
+        .unwrap_or_default();
+    if let Some(fallback) = fallback {
+        let account_type = account
+            .get("type")
+            .and_then(|value| value.as_str())
+            .map(|value| value.to_ascii_lowercase());
+        let allow_fallback = account.is_empty()
+            || matches!(account_type.as_deref(), None | Some("chatgpt") | Some("unknown"));
+        if allow_fallback {
+            if !account.contains_key("email") {
+                if let Some(email) = fallback.email {
+                    account.insert("email".to_string(), Value::String(email));
+                }
+            }
+            if !account.contains_key("planType") {
+                if let Some(plan) = fallback.plan_type {
+                    account.insert("planType".to_string(), Value::String(plan));
+                }
+            }
+            if !account.contains_key("type") {
+                account.insert("type".to_string(), Value::String("chatgpt".to_string()));
+            }
+        }
+    }
+
+    let account_value = if account.is_empty() {
+        Value::Null
+    } else {
+        Value::Object(account)
+    };
+    let mut result = Map::new();
+    result.insert("account".to_string(), account_value);
+    if let Some(requires_openai_auth) = response
+        .as_ref()
+        .and_then(extract_requires_openai_auth)
+    {
+        result.insert(
+            "requiresOpenaiAuth".to_string(),
+            Value::Bool(requires_openai_auth),
+        );
+    }
+    Value::Object(result)
+}
+
+fn extract_account_map(value: &Value) -> Option<Map<String, Value>> {
+    let account = value
+        .get("account")
+        .or_else(|| value.get("result").and_then(|result| result.get("account")))
+        .and_then(|value| value.as_object().cloned());
+    if account.is_some() {
+        return account;
+    }
+    let root = value.as_object()?;
+    if root.contains_key("email") || root.contains_key("planType") || root.contains_key("type") {
+        return Some(root.clone());
+    }
+    None
+}
+
+fn extract_requires_openai_auth(value: &Value) -> Option<bool> {
+    value
+        .get("requiresOpenaiAuth")
+        .or_else(|| value.get("requires_openai_auth"))
+        .or_else(|| {
+            value
+                .get("result")
+                .and_then(|result| result.get("requiresOpenaiAuth"))
+        })
+        .or_else(|| {
+            value
+                .get("result")
+                .and_then(|result| result.get("requires_openai_auth"))
+        })
+        .and_then(|value| value.as_bool())
+}
+
+fn read_auth_account(codex_home: Option<PathBuf>) -> Option<AuthAccount> {
+    let codex_home = codex_home?;
+    let auth_path = codex_home.join("auth.json");
+    let data = fs::read(auth_path).ok()?;
+    let auth_value: Value = serde_json::from_slice(&data).ok()?;
+    let tokens = auth_value.get("tokens")?;
+    let id_token = tokens
+        .get("idToken")
+        .or_else(|| tokens.get("id_token"))
+        .and_then(|value| value.as_str())?;
+    let payload = decode_jwt_payload(id_token)?;
+
+    let auth_dict = payload
+        .get("https://api.openai.com/auth")
+        .and_then(|value| value.as_object());
+    let profile_dict = payload
+        .get("https://api.openai.com/profile")
+        .and_then(|value| value.as_object());
+    let plan = normalize_string(
+        auth_dict
+            .and_then(|dict| dict.get("chatgpt_plan_type"))
+            .or_else(|| payload.get("chatgpt_plan_type")),
+    );
+    let email = normalize_string(
+        payload
+            .get("email")
+            .or_else(|| profile_dict.and_then(|dict| dict.get("email"))),
+    );
+
+    if email.is_none() && plan.is_none() {
+        return None;
+    }
+
+    Some(AuthAccount {
+        email,
+        plan_type: plan,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    fn fallback_account() -> AuthAccount {
+        AuthAccount {
+            email: Some("chatgpt@example.com".to_string()),
+            plan_type: Some("plus".to_string()),
+        }
+    }
+
+    fn result_account_map(value: &Value) -> Map<String, Value> {
+        value
+            .get("account")
+            .and_then(Value::as_object)
+            .cloned()
+            .unwrap_or_default()
+    }
+
+    #[test]
+    fn build_account_response_does_not_fallback_for_apikey() {
+        let response = Some(json!({
+            "account": {
+                "type": "apikey"
+            }
+        }));
+        let result = build_account_response(response, Some(fallback_account()));
+        let account = result_account_map(&result);
+
+        assert_eq!(account.get("type").and_then(Value::as_str), Some("apikey"));
+        assert!(!account.contains_key("email"));
+        assert!(!account.contains_key("planType"));
+    }
+
+    #[test]
+    fn build_account_response_falls_back_when_account_missing() {
+        let result = build_account_response(None, Some(fallback_account()));
+        let account = result_account_map(&result);
+
+        assert_eq!(
+            account.get("email").and_then(Value::as_str),
+            Some("chatgpt@example.com"),
+        );
+        assert_eq!(account.get("planType").and_then(Value::as_str), Some("plus"));
+        assert_eq!(account.get("type").and_then(Value::as_str), Some("chatgpt"));
+    }
+
+    #[test]
+    fn build_account_response_allows_fallback_for_chatgpt_type() {
+        let response = Some(json!({
+            "account": {
+                "type": "chatgpt"
+            }
+        }));
+        let result = build_account_response(response, Some(fallback_account()));
+        let account = result_account_map(&result);
+
+        assert_eq!(account.get("type").and_then(Value::as_str), Some("chatgpt"));
+        assert_eq!(
+            account.get("email").and_then(Value::as_str),
+            Some("chatgpt@example.com"),
+        );
+        assert_eq!(account.get("planType").and_then(Value::as_str), Some("plus"));
+    }
+}
+
+fn decode_jwt_payload(token: &str) -> Option<Value> {
+    let payload = token.split('.').nth(1)?;
+    let decoded = base64::engine::general_purpose::URL_SAFE_NO_PAD
+        .decode(payload.as_bytes())
+        .or_else(|_| base64::engine::general_purpose::URL_SAFE.decode(payload.as_bytes()))
+        .ok()?;
+    serde_json::from_slice(&decoded).ok()
+}
+
+fn normalize_string(value: Option<&Value>) -> Option<String> {
+    value
+        .and_then(|value| value.as_str())
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+}
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index f7df80679..6c3dd1606 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -143,6 +143,9 @@ pub fn run() {
             git::create_git_branch,
             codex::model_list,
             codex::account_rate_limits,
+            codex::account_read,
+            codex::codex_login,
+            codex::codex_login_cancel,
             codex::skills_list,
             prompts::prompts_list,
             prompts::prompts_create,
diff --git a/src-tauri/src/state.rs b/src-tauri/src/state.rs
index ffad46019..86e481023 100644
--- a/src-tauri/src/state.rs
+++ b/src-tauri/src/state.rs
@@ -3,6 +3,7 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use tauri::{AppHandle, Manager};
 use tokio::sync::Mutex;
+use tokio::sync::oneshot;
 
 use crate::dictation::DictationState;
 use crate::storage::{read_settings, read_workspaces};
@@ -18,6 +19,7 @@ pub(crate) struct AppState {
     pub(crate) settings_path: PathBuf,
     pub(crate) app_settings: Mutex<AppSettings>,
     pub(crate) dictation: Mutex<DictationState>,
+    pub(crate) codex_login_cancels: Mutex<HashMap<String, oneshot::Sender<()>>>,
 }
 
 impl AppState {
@@ -39,6 +41,7 @@ impl AppState {
             settings_path,
             app_settings: Mutex::new(app_settings),
             dictation: Mutex::new(DictationState::default()),
+            codex_login_cancels: Mutex::new(HashMap::new()),
         }
     }
 }
diff --git a/src/App.tsx b/src/App.tsx
index 3ff7510b7..2ff6d50e2 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -104,6 +104,7 @@ import type {
 import { OPEN_APP_STORAGE_KEY } from "./features/app/constants";
 import { useOpenAppIcons } from "./features/app/hooks/useOpenAppIcons";
 import { useCodeCssVars } from "./features/app/hooks/useCodeCssVars";
+import { useAccountSwitching } from "./features/app/hooks/useAccountSwitching";
 
 const AboutView = lazy(() =>
   import("./features/about/components/AboutView").then((module) => ({
@@ -596,6 +597,7 @@ function MainApp() {
     threadListCursorByWorkspace,
     tokenUsageByThread,
     rateLimitsByWorkspace,
+    accountByWorkspace,
     planByThread,
     lastAgentMessageByThread,
     interruptTurn,
@@ -616,6 +618,8 @@ function MainApp() {
     handleApprovalDecision,
     handleApprovalRemember,
     handleUserInputSubmit,
+    refreshAccountInfo,
+    refreshAccountRateLimits,
   } = useThreads({
     activeWorkspace,
     onWorkspaceConnected: markWorkspaceConnected,
@@ -628,6 +632,18 @@ function MainApp() {
     customPrompts: prompts,
     onMessageActivity: queueGitStatusRefresh
   });
+  const {
+    activeAccount,
+    accountSwitching,
+    handleSwitchAccount,
+    handleCancelSwitchAccount,
+  } = useAccountSwitching({
+    activeWorkspaceId,
+    accountByWorkspace,
+    refreshAccountInfo,
+    refreshAccountRateLimits,
+    alertError,
+  });
   const activeThreadIdRef = useRef<string | null>(activeThreadId ?? null);
   const { getThreadRows } = useThreadRows(threadParentById);
   useEffect(() => {
@@ -1532,6 +1548,10 @@ function MainApp() {
     activeItems,
     activeRateLimits,
     usageShowRemaining: appSettings.usageShowRemaining,
+    accountInfo: activeAccount,
+    onSwitchAccount: handleSwitchAccount,
+    onCancelSwitchAccount: handleCancelSwitchAccount,
+    accountSwitching,
     codeBlockCopyUseModifier: appSettings.composerCodeBlockCopyUseModifier,
     openAppTargets: appSettings.openAppTargets,
     openAppIconById,
diff --git a/src/features/app/components/Sidebar.test.tsx b/src/features/app/components/Sidebar.test.tsx
index 11ad59f46..08d9658c5 100644
--- a/src/features/app/components/Sidebar.test.tsx
+++ b/src/features/app/components/Sidebar.test.tsx
@@ -20,6 +20,10 @@ const baseProps = {
   activeThreadId: null,
   accountRateLimits: null,
   usageShowRemaining: false,
+  accountInfo: null,
+  onSwitchAccount: vi.fn(),
+  onCancelSwitchAccount: vi.fn(),
+  accountSwitching: false,
   onOpenSettings: vi.fn(),
   onOpenDebug: vi.fn(),
   showDebugButton: false,
diff --git a/src/features/app/components/Sidebar.tsx b/src/features/app/components/Sidebar.tsx
index 69eda490e..a0901847d 100644
--- a/src/features/app/components/Sidebar.tsx
+++ b/src/features/app/components/Sidebar.tsx
@@ -1,4 +1,9 @@
-import type { RateLimitSnapshot, ThreadSummary, WorkspaceInfo } from "../../../types";
+import type {
+  AccountSnapshot,
+  RateLimitSnapshot,
+  ThreadSummary,
+  WorkspaceInfo,
+} from "../../../types";
 import { createPortal } from "react-dom";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import type { RefObject } from "react";
@@ -48,6 +53,10 @@ type SidebarProps = {
   activeThreadId: string | null;
   accountRateLimits: RateLimitSnapshot | null;
   usageShowRemaining: boolean;
+  accountInfo: AccountSnapshot | null;
+  onSwitchAccount: () => void;
+  onCancelSwitchAccount: () => void;
+  accountSwitching: boolean;
   onOpenSettings: () => void;
   onOpenDebug: () => void;
   showDebugButton: boolean;
@@ -95,6 +104,10 @@ export function Sidebar({
   activeThreadId,
   accountRateLimits,
   usageShowRemaining,
+  accountInfo,
+  onSwitchAccount,
+  onCancelSwitchAccount,
+  accountSwitching,
   onOpenSettings,
   onOpenDebug,
   showDebugButton,
@@ -207,6 +220,17 @@ export function Sidebar({
     [normalizedQuery],
   );
 
+  const accountEmail = accountInfo?.email?.trim() ?? "";
+  const accountButtonLabel = accountEmail
+    ? accountEmail
+    : accountInfo?.type === "apikey"
+      ? "API key"
+      : "Sign in to Codex";
+  const accountActionLabel = accountEmail ? "Switch account" : "Sign in";
+  const showAccountSwitcher = Boolean(activeWorkspaceId);
+  const accountSwitchDisabled = accountSwitching || !activeWorkspaceId;
+  const accountCancelDisabled = !accountSwitching || !activeWorkspaceId;
+
   const pinnedThreadRows = (() => {
     type ThreadRow = { thread: ThreadSummary; depth: number };
     const groups: Array<{
@@ -614,6 +638,14 @@ export function Sidebar({
         onOpenSettings={onOpenSettings}
         onOpenDebug={onOpenDebug}
         showDebugButton={showDebugButton}
+        showAccountSwitcher={showAccountSwitcher}
+        accountLabel={accountButtonLabel}
+        accountActionLabel={accountActionLabel}
+        accountDisabled={accountSwitchDisabled}
+        accountSwitching={accountSwitching}
+        accountCancelDisabled={accountCancelDisabled}
+        onSwitchAccount={onSwitchAccount}
+        onCancelSwitchAccount={onCancelSwitchAccount}
       />
     </aside>
   );
diff --git a/src/features/app/components/SidebarCornerActions.tsx b/src/features/app/components/SidebarCornerActions.tsx
index 9680604ba..f670c71d0 100644
--- a/src/features/app/components/SidebarCornerActions.tsx
+++ b/src/features/app/components/SidebarCornerActions.tsx
@@ -1,19 +1,111 @@
 import ScrollText from "lucide-react/dist/esm/icons/scroll-text";
 import Settings from "lucide-react/dist/esm/icons/settings";
+import User from "lucide-react/dist/esm/icons/user";
+import X from "lucide-react/dist/esm/icons/x";
+import { useEffect, useRef, useState } from "react";
 
 type SidebarCornerActionsProps = {
   onOpenSettings: () => void;
   onOpenDebug: () => void;
   showDebugButton: boolean;
+  showAccountSwitcher: boolean;
+  accountLabel: string;
+  accountActionLabel: string;
+  accountDisabled: boolean;
+  accountSwitching: boolean;
+  accountCancelDisabled: boolean;
+  onSwitchAccount: () => void;
+  onCancelSwitchAccount: () => void;
 };
 
 export function SidebarCornerActions({
   onOpenSettings,
   onOpenDebug,
   showDebugButton,
+  showAccountSwitcher,
+  accountLabel,
+  accountActionLabel,
+  accountDisabled,
+  accountSwitching,
+  accountCancelDisabled,
+  onSwitchAccount,
+  onCancelSwitchAccount,
 }: SidebarCornerActionsProps) {
+  const [accountMenuOpen, setAccountMenuOpen] = useState(false);
+  const accountMenuRef = useRef<HTMLDivElement | null>(null);
+
+  useEffect(() => {
+    if (!accountMenuOpen) {
+      return;
+    }
+    const handleClick = (event: MouseEvent) => {
+      const target = event.target as Node;
+      if (accountMenuRef.current?.contains(target)) {
+        return;
+      }
+      setAccountMenuOpen(false);
+    };
+    window.addEventListener("mousedown", handleClick);
+    return () => {
+      window.removeEventListener("mousedown", handleClick);
+    };
+  }, [accountMenuOpen]);
+
+  useEffect(() => {
+    if (!showAccountSwitcher) {
+      setAccountMenuOpen(false);
+    }
+  }, [showAccountSwitcher]);
+
   return (
     <div className="sidebar-corner-actions">
+      {showAccountSwitcher && (
+        <div className="sidebar-account-menu" ref={accountMenuRef}>
+          <button
+            className="ghost sidebar-corner-button"
+            type="button"
+            onClick={() => setAccountMenuOpen((open) => !open)}
+            aria-label="Account"
+            title="Account"
+          >
+            <User size={14} aria-hidden />
+          </button>
+          {accountMenuOpen && (
+            <div className="sidebar-account-popover popover-surface" role="dialog">
+              <div className="sidebar-account-title">Account</div>
+              <div className="sidebar-account-value">{accountLabel}</div>
+              <div className="sidebar-account-actions-row">
+                <button
+                  type="button"
+                  className="primary sidebar-account-action"
+                  onClick={onSwitchAccount}
+                  disabled={accountDisabled}
+                  aria-busy={accountSwitching}
+                >
+                  <span className="sidebar-account-action-content">
+                    {accountSwitching && (
+                      <span className="sidebar-account-spinner" aria-hidden />
+                    )}
+                    <span>{accountActionLabel}</span>
+                  </span>
+                </button>
+                {accountSwitching && (
+                  <button
+                    type="button"
+                    className="secondary sidebar-account-cancel"
+                    onClick={onCancelSwitchAccount}
+                    disabled={accountCancelDisabled}
+                    aria-label="Cancel account switch"
+                    title="Cancel"
+                  >
+                    <X size={12} aria-hidden />
+                  </button>
+                )}
+              </div>
+            </div>
+          )}
+        </div>
+      )}
       <button
         className="ghost sidebar-corner-button"
         type="button"
diff --git a/src/features/app/hooks/useAccountSwitching.ts b/src/features/app/hooks/useAccountSwitching.ts
new file mode 100644
index 000000000..c701f0a96
--- /dev/null
+++ b/src/features/app/hooks/useAccountSwitching.ts
@@ -0,0 +1,99 @@
+import { useCallback, useMemo, useRef, useState } from "react";
+import { cancelCodexLogin, runCodexLogin } from "../../../services/tauri";
+import type { AccountSnapshot } from "../../../types";
+
+type UseAccountSwitchingArgs = {
+  activeWorkspaceId: string | null;
+  accountByWorkspace: Record<string, AccountSnapshot | null | undefined>;
+  refreshAccountInfo: (workspaceId: string) => Promise<void> | void;
+  refreshAccountRateLimits: (workspaceId: string) => Promise<void> | void;
+  alertError: (error: unknown) => void;
+};
+
+type UseAccountSwitchingResult = {
+  activeAccount: AccountSnapshot | null;
+  accountSwitching: boolean;
+  handleSwitchAccount: () => Promise<void>;
+  handleCancelSwitchAccount: () => Promise<void>;
+};
+
+export function useAccountSwitching({
+  activeWorkspaceId,
+  accountByWorkspace,
+  refreshAccountInfo,
+  refreshAccountRateLimits,
+  alertError,
+}: UseAccountSwitchingArgs): UseAccountSwitchingResult {
+  const [accountSwitching, setAccountSwitching] = useState(false);
+  const accountSwitchCanceledRef = useRef(false);
+
+  const activeAccount = useMemo(() => {
+    if (!activeWorkspaceId) {
+      return null;
+    }
+    return accountByWorkspace[activeWorkspaceId] ?? null;
+  }, [activeWorkspaceId, accountByWorkspace]);
+
+  const isCodexLoginCanceled = useCallback((error: unknown) => {
+    const message =
+      typeof error === "string" ? error : error instanceof Error ? error.message : "";
+    const normalized = message.toLowerCase();
+    return (
+      normalized.includes("codex login canceled") ||
+      normalized.includes("codex login cancelled") ||
+      normalized.includes("request canceled")
+    );
+  }, []);
+
+  const handleSwitchAccount = useCallback(async () => {
+    if (!activeWorkspaceId || accountSwitching) {
+      return;
+    }
+    accountSwitchCanceledRef.current = false;
+    setAccountSwitching(true);
+    try {
+      await runCodexLogin(activeWorkspaceId);
+      if (accountSwitchCanceledRef.current) {
+        return;
+      }
+      await refreshAccountInfo(activeWorkspaceId);
+      await refreshAccountRateLimits(activeWorkspaceId);
+    } catch (error) {
+      if (accountSwitchCanceledRef.current || isCodexLoginCanceled(error)) {
+        return;
+      }
+      alertError(error);
+    } finally {
+      setAccountSwitching(false);
+      accountSwitchCanceledRef.current = false;
+    }
+  }, [
+    activeWorkspaceId,
+    accountSwitching,
+    refreshAccountInfo,
+    refreshAccountRateLimits,
+    alertError,
+    isCodexLoginCanceled,
+  ]);
+
+  const handleCancelSwitchAccount = useCallback(async () => {
+    if (!activeWorkspaceId || !accountSwitching) {
+      return;
+    }
+    accountSwitchCanceledRef.current = true;
+    try {
+      await cancelCodexLogin(activeWorkspaceId);
+    } catch (error) {
+      alertError(error);
+    } finally {
+      setAccountSwitching(false);
+    }
+  }, [activeWorkspaceId, accountSwitching, alertError]);
+
+  return {
+    activeAccount,
+    accountSwitching,
+    handleSwitchAccount,
+    handleCancelSwitchAccount,
+  };
+}
diff --git a/src/features/layout/hooks/useLayoutNodes.tsx b/src/features/layout/hooks/useLayoutNodes.tsx
index 24a8139dd..8737f8bbb 100644
--- a/src/features/layout/hooks/useLayoutNodes.tsx
+++ b/src/features/layout/hooks/useLayoutNodes.tsx
@@ -26,6 +26,7 @@ import type {
   ConversationItem,
   ComposerEditorSettings,
   CustomPromptOption,
+  AccountSnapshot,
   DebugEntry,
   DictationSessionState,
   DictationTranscript,
@@ -110,6 +111,10 @@ type LayoutNodesOptions = {
   activeItems: ConversationItem[];
   activeRateLimits: RateLimitSnapshot | null;
   usageShowRemaining: boolean;
+  accountInfo: AccountSnapshot | null;
+  onSwitchAccount: () => void;
+  onCancelSwitchAccount: () => void;
+  accountSwitching: boolean;
   codeBlockCopyUseModifier: boolean;
   openAppTargets: OpenAppTarget[];
   openAppIconById: Record<string, string>;
@@ -437,6 +442,10 @@ export function useLayoutNodes(options: LayoutNodesOptions): LayoutNodesResult {
       activeThreadId={options.activeThreadId}
       accountRateLimits={options.activeRateLimits}
       usageShowRemaining={options.usageShowRemaining}
+      accountInfo={options.accountInfo}
+      onSwitchAccount={options.onSwitchAccount}
+      onCancelSwitchAccount={options.onCancelSwitchAccount}
+      accountSwitching={options.accountSwitching}
       onOpenSettings={options.onOpenSettings}
       onOpenDebug={options.onOpenDebug}
       showDebugButton={options.showDebugButton}
diff --git a/src/features/threads/hooks/useThreadAccountInfo.test.tsx b/src/features/threads/hooks/useThreadAccountInfo.test.tsx
new file mode 100644
index 000000000..353dda9af
--- /dev/null
+++ b/src/features/threads/hooks/useThreadAccountInfo.test.tsx
@@ -0,0 +1,45 @@
+// @vitest-environment jsdom
+import { renderHook, waitFor } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { getAccountInfo } from "../../../services/tauri";
+import { useThreadAccountInfo } from "./useThreadAccountInfo";
+
+vi.mock("../../../services/tauri", () => ({
+  getAccountInfo: vi.fn(),
+}));
+
+describe("useThreadAccountInfo", () => {
+  it("refreshes account info on connect and dispatches snapshot", async () => {
+    vi.mocked(getAccountInfo).mockResolvedValue({
+      result: {
+        account: { type: "chatgpt", email: "user@example.com", planType: "pro" },
+        requiresOpenaiAuth: false,
+      },
+    });
+
+    const dispatch = vi.fn();
+
+    renderHook(() =>
+      useThreadAccountInfo({
+        activeWorkspaceId: "ws-1",
+        activeWorkspaceConnected: true,
+        dispatch,
+      }),
+    );
+
+    await waitFor(() => {
+      expect(getAccountInfo).toHaveBeenCalledWith("ws-1");
+    });
+
+    expect(dispatch).toHaveBeenCalledWith({
+      type: "setAccountInfo",
+      workspaceId: "ws-1",
+      account: {
+        type: "chatgpt",
+        email: "user@example.com",
+        planType: "pro",
+        requiresOpenaiAuth: false,
+      },
+    });
+  });
+});
diff --git a/src/features/threads/hooks/useThreadAccountInfo.ts b/src/features/threads/hooks/useThreadAccountInfo.ts
new file mode 100644
index 000000000..02dc08772
--- /dev/null
+++ b/src/features/threads/hooks/useThreadAccountInfo.ts
@@ -0,0 +1,108 @@
+import { useCallback, useEffect } from "react";
+import type { AccountSnapshot, DebugEntry } from "../../../types";
+import { getAccountInfo } from "../../../services/tauri";
+import type { ThreadAction } from "./useThreadsReducer";
+
+type UseThreadAccountInfoOptions = {
+  activeWorkspaceId: string | null;
+  activeWorkspaceConnected?: boolean;
+  dispatch: React.Dispatch<ThreadAction>;
+  onDebug?: (entry: DebugEntry) => void;
+};
+
+function normalizeAccountSnapshot(
+  response: Record<string, unknown> | null,
+): AccountSnapshot {
+  const accountValue =
+    (response?.result as Record<string, unknown> | undefined)?.account ??
+    response?.account;
+  const account =
+    accountValue && typeof accountValue === "object"
+      ? (accountValue as Record<string, unknown>)
+      : null;
+  const requiresOpenaiAuthRaw =
+    (response?.result as Record<string, unknown> | undefined)?.requiresOpenaiAuth ??
+    (response?.result as Record<string, unknown> | undefined)?.requires_openai_auth ??
+    response?.requiresOpenaiAuth ??
+    response?.requires_openai_auth;
+  const requiresOpenaiAuth =
+    typeof requiresOpenaiAuthRaw === "boolean" ? requiresOpenaiAuthRaw : null;
+
+  if (!account) {
+    return {
+      type: "unknown",
+      email: null,
+      planType: null,
+      requiresOpenaiAuth,
+    };
+  }
+
+  const typeRaw =
+    typeof account.type === "string" ? account.type.toLowerCase() : "unknown";
+  const type = typeRaw === "chatgpt" || typeRaw === "apikey" ? typeRaw : "unknown";
+  const emailRaw = typeof account.email === "string" ? account.email.trim() : "";
+  const planRaw =
+    typeof account.planType === "string" ? account.planType.trim() : "";
+
+  return {
+    type,
+    email: emailRaw ? emailRaw : null,
+    planType: planRaw ? planRaw : null,
+    requiresOpenaiAuth,
+  };
+}
+
+export function useThreadAccountInfo({
+  activeWorkspaceId,
+  activeWorkspaceConnected,
+  dispatch,
+  onDebug,
+}: UseThreadAccountInfoOptions) {
+  const refreshAccountInfo = useCallback(
+    async (workspaceId?: string) => {
+      const targetId = workspaceId ?? activeWorkspaceId;
+      if (!targetId) {
+        return;
+      }
+      onDebug?.({
+        id: `${Date.now()}-client-account-read`,
+        timestamp: Date.now(),
+        source: "client",
+        label: "account/read",
+        payload: { workspaceId: targetId },
+      });
+      try {
+        const response = await getAccountInfo(targetId);
+        onDebug?.({
+          id: `${Date.now()}-server-account-read`,
+          timestamp: Date.now(),
+          source: "server",
+          label: "account/read response",
+          payload: response,
+        });
+        dispatch({
+          type: "setAccountInfo",
+          workspaceId: targetId,
+          account: normalizeAccountSnapshot(response),
+        });
+      } catch (error) {
+        onDebug?.({
+          id: `${Date.now()}-client-account-read-error`,
+          timestamp: Date.now(),
+          source: "error",
+          label: "account/read error",
+          payload: error instanceof Error ? error.message : String(error),
+        });
+      }
+    },
+    [activeWorkspaceId, dispatch, onDebug],
+  );
+
+  useEffect(() => {
+    if (activeWorkspaceConnected && activeWorkspaceId) {
+      void refreshAccountInfo(activeWorkspaceId);
+    }
+  }, [activeWorkspaceConnected, activeWorkspaceId, refreshAccountInfo]);
+
+  return { refreshAccountInfo };
+}
diff --git a/src/features/threads/hooks/useThreads.integration.test.tsx b/src/features/threads/hooks/useThreads.integration.test.tsx
index 00883a1ba..c03e15543 100644
--- a/src/features/threads/hooks/useThreads.integration.test.tsx
+++ b/src/features/threads/hooks/useThreads.integration.test.tsx
@@ -32,6 +32,7 @@ vi.mock("../../../services/tauri", () => ({
   resumeThread: vi.fn(),
   archiveThread: vi.fn(),
   getAccountRateLimits: vi.fn(),
+  getAccountInfo: vi.fn(),
   interruptTurn: vi.fn(),
 }));
 
diff --git a/src/features/threads/hooks/useThreads.ts b/src/features/threads/hooks/useThreads.ts
index baa897e89..e1a7b80fb 100644
--- a/src/features/threads/hooks/useThreads.ts
+++ b/src/features/threads/hooks/useThreads.ts
@@ -9,6 +9,7 @@ import { useThreadEventHandlers } from "./useThreadEventHandlers";
 import { useThreadActions } from "./useThreadActions";
 import { useThreadMessaging } from "./useThreadMessaging";
 import { useThreadApprovals } from "./useThreadApprovals";
+import { useThreadAccountInfo } from "./useThreadAccountInfo";
 import { useThreadRateLimits } from "./useThreadRateLimits";
 import { useThreadSelectors } from "./useThreadSelectors";
 import { useThreadStatus } from "./useThreadStatus";
@@ -73,6 +74,12 @@ export function useThreads({
     dispatch,
     onDebug,
   });
+  const { refreshAccountInfo } = useThreadAccountInfo({
+    activeWorkspaceId,
+    activeWorkspaceConnected: activeWorkspace?.connected,
+    dispatch,
+    onDebug,
+  });
 
   const { markProcessing, markReviewing, setActiveTurnId } = useThreadStatus({
     dispatch,
@@ -109,8 +116,9 @@ export function useThreads({
     (workspaceId: string) => {
       onWorkspaceConnected(workspaceId);
       void refreshAccountRateLimits(workspaceId);
+      void refreshAccountInfo(workspaceId);
     },
-    [onWorkspaceConnected, refreshAccountRateLimits],
+    [onWorkspaceConnected, refreshAccountRateLimits, refreshAccountInfo],
   );
 
   const handlers = useThreadEventHandlers({
@@ -265,9 +273,11 @@ export function useThreads({
     activeTurnIdByThread: state.activeTurnIdByThread,
     tokenUsageByThread: state.tokenUsageByThread,
     rateLimitsByWorkspace: state.rateLimitsByWorkspace,
+    accountByWorkspace: state.accountByWorkspace,
     planByThread: state.planByThread,
     lastAgentMessageByThread: state.lastAgentMessageByThread,
     refreshAccountRateLimits,
+    refreshAccountInfo,
     interruptTurn,
     removeThread,
     pinThread,
diff --git a/src/features/threads/hooks/useThreadsReducer.ts b/src/features/threads/hooks/useThreadsReducer.ts
index 8272de701..44880d726 100644
--- a/src/features/threads/hooks/useThreadsReducer.ts
+++ b/src/features/threads/hooks/useThreadsReducer.ts
@@ -1,4 +1,5 @@
 import type {
+  AccountSnapshot,
   ApprovalRequest,
   ConversationItem,
   RateLimitSnapshot,
@@ -129,6 +130,7 @@ export type ThreadState = {
   userInputRequests: RequestUserInputRequest[];
   tokenUsageByThread: Record<string, ThreadTokenUsage>;
   rateLimitsByWorkspace: Record<string, RateLimitSnapshot | null>;
+  accountByWorkspace: Record<string, AccountSnapshot | null>;
   planByThread: Record<string, TurnPlan | null>;
   lastAgentMessageByThread: Record<string, { text: string; timestamp: number }>;
 };
@@ -226,6 +228,11 @@ export type ThreadAction =
       workspaceId: string;
       rateLimits: RateLimitSnapshot | null;
     }
+  | {
+      type: "setAccountInfo";
+      workspaceId: string;
+      account: AccountSnapshot | null;
+    }
   | { type: "setActiveTurnId"; threadId: string; turnId: string | null }
   | { type: "setThreadPlan"; threadId: string; plan: TurnPlan | null }
   | { type: "clearThreadPlan"; threadId: string }
@@ -252,6 +259,7 @@ export const initialState: ThreadState = {
   userInputRequests: [],
   tokenUsageByThread: {},
   rateLimitsByWorkspace: {},
+  accountByWorkspace: {},
   planByThread: {},
   lastAgentMessageByThread: {},
 };
@@ -977,6 +985,14 @@ export function threadReducer(state: ThreadState, action: ThreadAction): ThreadS
           [action.workspaceId]: action.rateLimits,
         },
       };
+    case "setAccountInfo":
+      return {
+        ...state,
+        accountByWorkspace: {
+          ...state.accountByWorkspace,
+          [action.workspaceId]: action.account,
+        },
+      };
     case "setThreadPlan":
       return {
         ...state,
diff --git a/src/services/tauri.ts b/src/services/tauri.ts
index fcfda2c04..b6494aa59 100644
--- a/src/services/tauri.ts
+++ b/src/services/tauri.ts
@@ -465,6 +465,18 @@ export async function getAccountRateLimits(workspaceId: string) {
   return invoke<any>("account_rate_limits", { workspaceId });
 }
 
+export async function getAccountInfo(workspaceId: string) {
+  return invoke<any>("account_read", { workspaceId });
+}
+
+export async function runCodexLogin(workspaceId: string) {
+  return invoke<{ output: string }>("codex_login", { workspaceId });
+}
+
+export async function cancelCodexLogin(workspaceId: string) {
+  return invoke<{ canceled: boolean }>("codex_login_cancel", { workspaceId });
+}
+
 export async function getSkillsList(workspaceId: string) {
   return invoke<any>("skills_list", { workspaceId });
 }
diff --git a/src/styles/sidebar.css b/src/styles/sidebar.css
index 4f583c416..56212d83e 100644
--- a/src/styles/sidebar.css
+++ b/src/styles/sidebar.css
@@ -1072,6 +1072,89 @@
   color: var(--text-subtle);
 }
 
+.sidebar-account-menu {
+  position: relative;
+}
+
+.sidebar-account-popover {
+  position: absolute;
+  left: 0;
+  bottom: 42px;
+  min-width: 220px;
+  padding: 10px 12px;
+  display: grid;
+  gap: 8px;
+  z-index: 10;
+}
+
+.sidebar-account-title {
+  color: var(--text-subtle);
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+}
+
+.sidebar-account-value {
+  color: var(--text-stronger);
+  font-weight: 600;
+  font-size: 12px;
+  max-width: 220px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.sidebar-account-actions-row {
+  display: flex;
+  align-items: stretch;
+  gap: 6px;
+}
+
+.sidebar-account-action {
+  width: 100%;
+  justify-content: center;
+  font-size: 11px;
+}
+
+.sidebar-account-action[aria-busy="true"]:disabled {
+  opacity: 0.85;
+}
+
+.sidebar-account-action-content {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 6px;
+}
+
+.sidebar-account-spinner {
+  width: 12px;
+  height: 12px;
+  border-radius: 999px;
+  border: 2px solid rgba(11, 15, 26, 0.22);
+  border-top-color: rgba(11, 15, 26, 0.8);
+  animation: sidebar-account-spin 0.8s linear infinite;
+}
+
+@keyframes sidebar-account-spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+.sidebar-account-cancel {
+  width: 34px;
+  padding: 0;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.sidebar-account-cancel svg {
+  width: 12px;
+  height: 12px;
+}
+
 .sidebar-corner-actions {
   position: absolute;
   left: var(--sidebar-padding);
diff --git a/src/types.ts b/src/types.ts
index d812aa296..d69d04ea0 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -394,6 +394,13 @@ export type RateLimitSnapshot = {
   planType: string | null;
 };
 
+export type AccountSnapshot = {
+  type: "chatgpt" | "apikey" | "unknown";
+  email: string | null;
+  planType: string | null;
+  requiresOpenaiAuth: boolean | null;
+};
+
 export type QueuedMessage = {
   id: string;
   text: string;