feat: Claude Code-style team orchestration for Codex

codex-rs/Cargo.toml

@@ -51,6 +51,14 @@ members = [
     "codex-api",
     "state",
     "codex-experimental-api-macros",
+    "console-team",
+    "console-tui",
+    "console-provider",
+    "console-runtime",
+    "console-persist",
+    "console-plugin",
+    "console-security",
+    "console-cli",
 ]
 resolver = "2"
 
@@ -97,6 +105,14 @@ codex-ollama = { path = "ollama" }
 codex-otel = { path = "otel" }
 codex-process-hardening = { path = "process-hardening" }
 codex-protocol = { path = "protocol" }
+console-provider = { path = "console-provider" }
+console-runtime = { path = "console-runtime" }
+console-team = { path = "console-team" }
+console-persist = { path = "console-persist" }
+console-plugin = { path = "console-plugin" }
+console-security = { path = "console-security" }
+console-cli = { path = "console-cli" }
+console-tui = { path = "console-tui" }
 codex-responses-api-proxy = { path = "responses-api-proxy" }
 codex-rmcp-client = { path = "rmcp-client" }
 codex-state = { path = "state" }
@@ -298,7 +314,7 @@ unwrap_used = "deny"
 # cargo-shear cannot see the platform-specific openssl-sys usage, so we
 # silence the false positive here instead of deleting a real dependency.
 [workspace.metadata.cargo-shear]
-ignored = ["icu_provider", "openssl-sys", "codex-utils-readiness", "codex-secrets"]
+ignored = ["icu_provider", "openssl-sys", "codex-utils-readiness", "codex-secrets", "console-cli"]
 
 [profile.release]
 lto = "fat"

codex-rs/cli/src/main.rs

@@ -912,6 +912,12 @@ async fn run_interactive_tui(
         }
     }
 
+    // Propagate --teammate-mode to the team handler via environment variable.
+    // SAFETY: called before any threads are spawned; single-threaded at this point.
+    if let Some(ref mode) = interactive.teammate_mode {
+        unsafe { std::env::set_var("CONSOLE_TEAMMATE_MODE", mode) };
+    }
+
     codex_tui::run_main(interactive, codex_linux_sandbox_exe).await
 }
 
@@ -1013,6 +1019,9 @@ fn merge_interactive_cli_flags(interactive: &mut TuiCli, subcommand_cli: TuiCli)
     if !subcommand_cli.add_dir.is_empty() {
         interactive.add_dir.extend(subcommand_cli.add_dir);
     }
+    if subcommand_cli.teammate_mode.is_some() {
+        interactive.teammate_mode = subcommand_cli.teammate_mode;
+    }
     if let Some(prompt) = subcommand_cli.prompt {
         // Normalize CRLF/CR to LF so CLI-provided text can't leak `\r` into TUI state.
         interactive.prompt = Some(prompt.replace("\r\n", "\n").replace('\r', "\n"));

codex-rs/console-cli/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "console-cli"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }

codex-rs/console-cli/src/cli_args.rs

@@ -0,0 +1,179 @@
+use serde::Deserialize;
+use serde::Serialize;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ConsoleCliArgs {
+    pub provider: Option<String>,
+    pub model: Option<String>,
+    pub permission_mode: Option<String>,
+    pub enable_teams: bool,
+    pub enable_plugins: bool,
+    pub onboarding: bool,
+    pub export_session: Option<String>,
+    pub import_session: Option<String>,
+    pub verbose: bool,
+    pub config_path: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum ArgsValidationError {
+    InvalidProvider(String),
+    InvalidMode(String),
+    ConflictingFlags(String),
+}
+
+impl std::fmt::Display for ArgsValidationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ArgsValidationError::InvalidProvider(p) => write!(f, "Invalid provider: {p}"),
+            ArgsValidationError::InvalidMode(m) => write!(f, "Invalid mode: {m}"),
+            ArgsValidationError::ConflictingFlags(msg) => write!(f, "Conflicting flags: {msg}"),
+        }
+    }
+}
+
+pub fn default_args() -> ConsoleCliArgs {
+    ConsoleCliArgs {
+        provider: None,
+        model: None,
+        permission_mode: None,
+        enable_teams: true,
+        enable_plugins: false,
+        onboarding: false,
+        export_session: None,
+        import_session: None,
+        verbose: false,
+        config_path: None,
+    }
+}
+
+pub fn known_providers() -> Vec<&'static str> {
+    vec!["anthropic", "openai", "openrouter", "ollama"]
+}
+
+pub fn known_modes() -> Vec<&'static str> {
+    vec![
+        "default",
+        "acceptEdits",
+        "plan",
+        "delegate",
+        "dontAsk",
+        "bypassPermissions",
+    ]
+}
+
+pub fn validate(args: &ConsoleCliArgs) -> Result<(), ArgsValidationError> {
+    if let Some(ref provider) = args.provider {
+        if !known_providers().contains(&provider.as_str()) {
+            return Err(ArgsValidationError::InvalidProvider(provider.clone()));
+        }
+    }
+    if let Some(ref mode) = args.permission_mode {
+        if !known_modes().contains(&mode.as_str()) {
+            return Err(ArgsValidationError::InvalidMode(mode.clone()));
+        }
+    }
+    if args.export_session.is_some() && args.import_session.is_some() {
+        return Err(ArgsValidationError::ConflictingFlags(
+            "export_session and import_session cannot both be set".to_string(),
+        ));
+    }
+    Ok(())
+}
+
+pub fn merge_with_env(args: &mut ConsoleCliArgs) {
+    if args.provider.is_none() {
+        if let Ok(val) = std::env::var("CONSOLE_PROVIDER") {
+            args.provider = Some(val);
+        }
+    }
+    if args.model.is_none() {
+        if let Ok(val) = std::env::var("CONSOLE_MODEL") {
+            args.model = Some(val);
+        }
+    }
+    if args.permission_mode.is_none() {
+        if let Ok(val) = std::env::var("CONSOLE_MODE") {
+            args.permission_mode = Some(val);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_default_args() {
+        let args = default_args();
+        assert!(args.provider.is_none());
+        assert!(args.model.is_none());
+        assert!(args.permission_mode.is_none());
+        assert!(args.enable_teams);
+        assert!(!args.enable_plugins);
+        assert!(!args.onboarding);
+        assert!(args.export_session.is_none());
+        assert!(args.import_session.is_none());
+        assert!(!args.verbose);
+        assert!(args.config_path.is_none());
+    }
+
+    #[test]
+    fn test_validate_valid_args() {
+        let args = ConsoleCliArgs {
+            provider: Some("anthropic".to_string()),
+            permission_mode: Some("plan".to_string()),
+            ..default_args()
+        };
+        assert!(validate(&args).is_ok());
+    }
+
+    #[test]
+    fn test_validate_invalid_provider() {
+        let args = ConsoleCliArgs {
+            provider: Some("unknown_provider".to_string()),
+            ..default_args()
+        };
+        assert_eq!(
+            validate(&args),
+            Err(ArgsValidationError::InvalidProvider(
+                "unknown_provider".to_string()
+            ))
+        );
+    }
+
+    #[test]
+    fn test_validate_invalid_mode() {
+        let args = ConsoleCliArgs {
+            permission_mode: Some("yolo".to_string()),
+            ..default_args()
+        };
+        assert_eq!(
+            validate(&args),
+            Err(ArgsValidationError::InvalidMode("yolo".to_string()))
+        );
+    }
+
+    #[test]
+    fn test_validate_conflicting_export_import() {
+        let args = ConsoleCliArgs {
+            export_session: Some("out.json".to_string()),
+            import_session: Some("in.json".to_string()),
+            ..default_args()
+        };
+        assert!(matches!(
+            validate(&args),
+            Err(ArgsValidationError::ConflictingFlags(_))
+        ));
+    }
+
+    #[test]
+    fn test_known_providers_complete() {
+        let providers = known_providers();
+        assert!(providers.contains(&"anthropic"));
+        assert!(providers.contains(&"openai"));
+        assert!(providers.contains(&"openrouter"));
+        assert!(providers.contains(&"ollama"));
+        assert_eq!(providers.len(), 4);
+    }
+}

codex-rs/console-cli/src/lib.rs

@@ -0,0 +1,9 @@
+pub mod cli_args;
+pub mod onboarding;
+
+pub use cli_args::ArgsValidationError;
+pub use cli_args::ConsoleCliArgs;
+pub use onboarding::OnboardingConfig;
+pub use onboarding::OnboardingProgress;
+pub use onboarding::OnboardingState;
+pub use onboarding::OnboardingStep;