Simplify Rust core runtime, settings and CLI (lane E)

rust/src/agent_sessions/parsers.rs

@@ -52,13 +52,6 @@ impl AgentPSOutputParser {
         record.source
     }
 
-    pub fn has_codex_app_server(records: &[AgentProcessRecord]) -> bool {
-        records.iter().any(|record| {
-            record.kind == AgentProcessKind::AppServer
-                && record.provider == Some(AgentSessionProvider::Codex)
-        })
-    }
-
     fn parse_line(line: &str, seen_pids: &mut HashSet<u32>) -> Option<AgentProcessRecord> {
         let mut fields = line.split_whitespace();
         let pid = fields.next()?.parse::<u32>().ok()?;
@@ -447,10 +440,6 @@ impl ClaudeSessionProjectMapper {
         });
         transcripts
     }
-
-    pub fn newest_transcript(cwd: &str, home_directory: &Path) -> Option<ClaudeTranscript> {
-        Self::transcripts(cwd, home_directory).into_iter().next()
-    }
 }
 
 impl ClaudeTranscriptMetadataParser {

rust/src/agent_sessions/pi_family/roots.rs

@@ -161,14 +161,6 @@ impl DirectoryScanBudget {
         retained
     }
 
-    pub fn visit_entry(&mut self) -> bool {
-        if !self.has_time_remaining() || self.entries_seen >= self.max_entry_count {
-            return false;
-        }
-        self.entries_seen += 1;
-        true
-    }
-
     /// Resolve a path only while the shared scan deadline is live.
     ///
     /// The operation is gated before it starts. If it finishes after expiry,

rust/src/agent_sessions/remote.rs

@@ -338,10 +338,6 @@ impl RemoteSessionFetcher {
         })?;
         Ok(result)
     }
-
-    pub fn failed_result(host: &str, err: impl std::fmt::Display) -> AgentSessionHostResult {
-        AgentSessionHostResult::failed(host.to_string(), err)
-    }
 }
 
 impl Default for RemoteSessionFetcher {

rust/src/browser/cookie_cache.rs

@@ -5,13 +5,6 @@
 //! are session secrets, so they are written through `secure_file` (DPAPI on
 //! Windows, staged and published atomically) rather than as plaintext.
 
-// The cache API is currently unused by the crate (reserved for provider
-// cookie reuse), so every public item would trip dead_code.
-#![allow(
-    dead_code,
-    reason = "module reserved: CookieHeaderCache has no callers yet"
-)]
-
 use crate::core::ProviderId;
 use crate::secure_file;
 use chrono::{DateTime, Utc};
@@ -154,14 +147,6 @@ impl CookieHeaderCache {
             .collect::<Vec<_>>()
             .join("; ")
     }
-
-    /// Check if a cached entry exists and is fresh
-    pub fn has_fresh_cache(provider: ProviderId, max_age_secs: i64) -> bool {
-        match Self::load(provider) {
-            Some(entry) => !entry.is_stale(max_age_secs),
-            None => false,
-        }
-    }
 }
 
 /// Cookie header cache errors

rust/src/browser/cookies.rs

@@ -3,11 +3,6 @@
 //! Chromium browsers store cookies in an SQLite database encrypted with DPAPI.
 //! Firefox stores cookies in an unencrypted SQLite database.
 
-#![allow(
-    dead_code,
-    reason = "the cookie API surface is shared across providers and cfg-split Windows/WSLS code paths, so individual helpers are reached only from their own browser/provider callers"
-)]
-
 use std::path::Path;
 
 use aes_gcm::{
@@ -813,18 +808,6 @@ pub fn get_cookie_header_for_domains(domains: &[&str]) -> Result<String, CookieE
     }
 }
 
-/// Get a cookie header string for a domain from a specific browser
-pub fn get_cookie_header_from_browser(
-    domain: &str,
-    browser: &super::detection::DetectedBrowser,
-) -> Result<String, CookieError> {
-    let cookies = CookieExtractor::extract_for_domain(browser, domain)?;
-    if cookies.is_empty() {
-        return Err(CookieError::NotFound(domain.to_string()));
-    }
-    Ok(CookieExtractor::build_cookie_header(&cookies))
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

rust/src/browser/detection.rs

@@ -3,11 +3,6 @@
 //! On native Windows, uses standard AppData paths.
 //! On WSL, resolves browser paths via /mnt/c/ to access Windows browser data.
 
-#![allow(
-    dead_code,
-    reason = "browser detection types reserved for future cookie-based session management"
-)]
-
 use std::path::{Path, PathBuf};
 
 use crate::wsl;

rust/src/browser/watchdog.rs

@@ -3,11 +3,6 @@
 //! Monitors and manages child web probe processes to prevent orphaned processes.
 //! Ensures that browser automation or scraping processes are properly cleaned up.
 
-#![allow(
-    dead_code,
-    reason = "watchdog types reserved for future browser-session monitoring integration"
-)]
-
 use std::collections::HashMap;
 use std::process::Child;
 use std::sync::Arc;

rust/src/cli/account.rs

@@ -111,17 +111,7 @@ async fn list_accounts(provider_name: &str) -> anyhow::Result<()> {
 
 /// Add a new account
 async fn add_account(provider_name: &str, label: &str, token: &str) -> anyhow::Result<()> {
-    let provider = parse_provider(provider_name)?;
-
-    if !TokenAccountSupport::is_supported(provider) {
-        anyhow::bail!(
-            "{} does not support token accounts.",
-            provider.display_name()
-        );
-    }
-
-    let store = TokenAccountStore::new();
-    let mut data = store.load_provider(provider)?;
+    let (provider, store, mut data) = load_supported_accounts(provider_name)?;
 
     // Check for duplicate label
     if data
@@ -142,17 +132,7 @@ async fn add_account(provider_name: &str, label: &str, token: &str) -> anyhow::R
 
 /// Remove an account
 async fn remove_account(provider_name: &str, account_ref: &str) -> anyhow::Result<()> {
-    let provider = parse_provider(provider_name)?;
-
-    if !TokenAccountSupport::is_supported(provider) {
-        anyhow::bail!(
-            "{} does not support token accounts.",
-            provider.display_name()
-        );
-    }
-
-    let store = TokenAccountStore::new();
-    let mut data = store.load_provider(provider)?;
+    let (provider, store, mut data) = load_supported_accounts(provider_name)?;
 
     let account = find_account(&data, account_ref)?;
     let label = account.label.clone();
@@ -171,17 +151,7 @@ async fn remove_account(provider_name: &str, account_ref: &str) -> anyhow::Resul
 
 /// Switch active account
 async fn switch_account(provider_name: &str, account_ref: &str) -> anyhow::Result<()> {
-    let provider = parse_provider(provider_name)?;
-
-    if !TokenAccountSupport::is_supported(provider) {
-        anyhow::bail!(
-            "{} does not support token accounts.",
-            provider.display_name()
-        );
-    }
-
-    let store = TokenAccountStore::new();
-    let mut data = store.load_provider(provider)?;
+    let (provider, store, mut data) = load_supported_accounts(provider_name)?;
 
     let account = find_account(&data, account_ref)?;
     let label = account.label.clone();
@@ -198,6 +168,22 @@ async fn switch_account(provider_name: &str, account_ref: &str) -> anyhow::Resul
     Ok(())
 }
 
+/// Resolve a provider that supports token accounts and load its stored accounts.
+fn load_supported_accounts(
+    provider_name: &str,
+) -> anyhow::Result<(ProviderId, TokenAccountStore, ProviderAccountData)> {
+    let provider = parse_provider(provider_name)?;
+    if !TokenAccountSupport::is_supported(provider) {
+        anyhow::bail!(
+            "{} does not support token accounts.",
+            provider.display_name()
+        );
+    }
+    let store = TokenAccountStore::new();
+    let data = store.load_provider(provider)?;
+    Ok((provider, store, data))
+}
+
 /// Parse provider name to ProviderId
 fn parse_provider(name: &str) -> anyhow::Result<ProviderId> {
     ProviderId::from_cli_name(name)