diff --git a/src-tauri/src/acp/connection.rs b/src-tauri/src/acp/connection.rs
index 150f2d74c..1864cb6fe 100644
--- a/src-tauri/src/acp/connection.rs
+++ b/src-tauri/src/acp/connection.rs
@@ -36,7 +36,9 @@ use crate::acp::file_system_runtime::{FileSystemRuntime, FileSystemRuntimeError,
 use crate::acp::registry::{self, AgentDistribution};
 use crate::acp::session_state::SessionState;
 use crate::acp::stderr_tail::{summarize_parser_error, StderrTail, TailScope};
-use crate::acp::terminal_runtime::{TerminalRuntime, TerminalRuntimeError};
+use crate::acp::terminal_runtime::{
+    TerminalRuntime, TerminalRuntimeError, TerminalShellRuntimeConfig,
+};
 use crate::acp::types::{
     AcpEvent, AvailableCommandInfo, ConnectionInfo, ConnectionStatus, GrokEffortSpec,
     PermissionOptionInfo, PlanEntryInfo, PromptCapabilitiesInfo, PromptInputBlock,
@@ -1154,6 +1156,7 @@ pub async fn spawn_agent_connection(
     preferred_mode_id: Option<String>,
     preferred_config_values: BTreeMap<String, String>,
     delegation_injection: Option<DelegationInjection>,
+    terminal_shell_config: TerminalShellRuntimeConfig,
 ) -> Result<tokio::sync::oneshot::Receiver<()>, AcpError> {
     // Create the authoritative session state up front. Subsequent emit_with_state
     // calls write through this state and increment its seq counter so the first
@@ -1317,6 +1320,7 @@ pub async fn spawn_agent_connection(
             emitter_clone.clone(),
             Arc::clone(&state_clone),
             terminal_base_env,
+            terminal_shell_config,
             preferred_mode_id,
             preferred_config_values,
             delegation_injection,
@@ -3170,6 +3174,7 @@ async fn run_connection(
     emitter: EventEmitter,
     state: Arc<RwLock<SessionState>>,
     terminal_base_env: BTreeMap<String, String>,
+    terminal_shell_config: TerminalShellRuntimeConfig,
     preferred_mode_id: Option<String>,
     preferred_config_values: BTreeMap<String, String>,
     delegation_injection: Option<DelegationInjection>,
@@ -3188,7 +3193,9 @@ async fn run_connection(
     // `terminal/create` without a `cwd` (e.g. CodeBuddy) runs in the folder the
     // conversation runs in rather than codeg's own process cwd.
     let terminal_runtime = Arc::new(
-        TerminalRuntime::with_base_env(terminal_base_env).with_default_cwd(Some(cwd.clone())),
+        TerminalRuntime::with_base_env(terminal_base_env)
+            .with_default_cwd(Some(cwd.clone()))
+            .with_default_shell_config(terminal_shell_config),
     );
     let cwd_string = cwd.to_string_lossy().to_string();
     tracing::info!("[ACP] fs policy {}", fs_policy.describe());
diff --git a/src-tauri/src/acp/manager.rs b/src-tauri/src/acp/manager.rs
index 59d6549ee..1ed437f1a 100644
--- a/src-tauri/src/acp/manager.rs
+++ b/src-tauri/src/acp/manager.rs
@@ -25,6 +25,7 @@ use crate::acp::question::{
     build_outcome, QuestionAnswer, QuestionOutcome, QuestionSpec, RegisteredQuestion,
     SessionQuestionAccess,
 };
+use crate::acp::terminal_runtime::TerminalShellRuntimeConfig;
 use crate::acp::types::{
     AcpEvent, AgentOptionsSnapshot, ConfigStaleKind, ConnectionInfo, ConnectionStatus,
     ForkResultInfo, PromptCapabilitiesInfo, PromptInputBlock,
@@ -201,6 +202,10 @@ pub struct ConnectionManager {
     /// tests; in production initialized from env via
     /// `spawn_handshake_timeout_from_env`.
     spawn_handshake_timeout: Duration,
+    /// Shared General Settings shell used by ACP terminal fallbacks. Cloned
+    /// into each connection runtime so a setting update applies to existing
+    /// model sessions as well as newly spawned ones.
+    terminal_shell_config: TerminalShellRuntimeConfig,
     /// Delegation broker + token registry + UDS path installed during app
     /// bootstrap (`install_delegation`). When present, `spawn_agent` propagates
     /// the injection to `spawn_agent_connection`, which makes
@@ -262,6 +267,7 @@ impl ConnectionManager {
             connections: Arc::new(Mutex::new(HashMap::new())),
             spawn_locks: Arc::new(Mutex::new(HashMap::new())),
             spawn_handshake_timeout: spawn_handshake_timeout_from_env(),
+            terminal_shell_config: TerminalShellRuntimeConfig::new(),
             delegation_injection: Arc::new(std::sync::OnceLock::new()),
             probe_locks: Arc::new(Mutex::new(HashMap::new())),
             pending_questions: Arc::new(Mutex::new(HashMap::new())),
@@ -275,6 +281,7 @@ impl ConnectionManager {
             connections: self.connections.clone(),
             spawn_locks: self.spawn_locks.clone(),
             spawn_handshake_timeout: self.spawn_handshake_timeout,
+            terminal_shell_config: self.terminal_shell_config.clone(),
             delegation_injection: self.delegation_injection.clone(),
             probe_locks: self.probe_locks.clone(),
             pending_questions: self.pending_questions.clone(),
@@ -293,6 +300,13 @@ impl ConnectionManager {
         self.delegation_injection.get().cloned()
     }
 
+    /// Returns the shared terminal-shell setting consumed by ACP terminal
+    /// runtimes. Keeping the handle shared makes saves apply immediately to
+    /// connections that are already running.
+    pub fn terminal_shell_config(&self) -> TerminalShellRuntimeConfig {
+        self.terminal_shell_config.clone()
+    }
+
     /// Test-only constructor that overrides the spawn-handshake timeout.
     /// Production code should use `new()`.
     #[cfg(test)]
@@ -301,6 +315,7 @@ impl ConnectionManager {
             connections: Arc::new(Mutex::new(HashMap::new())),
             spawn_locks: Arc::new(Mutex::new(HashMap::new())),
             spawn_handshake_timeout: timeout,
+            terminal_shell_config: TerminalShellRuntimeConfig::new(),
             delegation_injection: Arc::new(std::sync::OnceLock::new()),
             probe_locks: Arc::new(Mutex::new(HashMap::new())),
             pending_questions: Arc::new(Mutex::new(HashMap::new())),
@@ -478,6 +493,7 @@ impl ConnectionManager {
             preferred_mode_id,
             preferred_config_values,
             self.delegation_snapshot(),
+            self.terminal_shell_config.clone(),
         )
         .await?;
 
diff --git a/src-tauri/src/acp/terminal_runtime.rs b/src-tauri/src/acp/terminal_runtime.rs
index 70c5b51cc..bfa1097c3 100644
--- a/src-tauri/src/acp/terminal_runtime.rs
+++ b/src-tauri/src/acp/terminal_runtime.rs
@@ -1,5 +1,5 @@
 use std::collections::{BTreeMap, HashMap, HashSet};
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::process::Stdio;
 use std::sync::Arc;
 use std::time::Duration;
@@ -10,9 +10,11 @@ use sacp::schema::{
     TerminalOutputResponse, WaitForTerminalExitRequest, WaitForTerminalExitResponse,
 };
 use tokio::io::{AsyncRead, AsyncReadExt};
-use tokio::sync::{watch, Mutex, Notify};
+use tokio::sync::{watch, Mutex, Notify, RwLock};
 use tokio::task::JoinHandle;
 
+use crate::terminal::manager::resolve_shell;
+
 type TerminalMap = HashMap<String, Arc<TerminalInstance>>;
 const DEFAULT_OUTPUT_BYTE_LIMIT: u64 = 1_000_000;
 /// After the child process exits, wait up to this long for the stdout/stderr
@@ -390,6 +392,31 @@ async fn own_terminal_process(terminal: Arc<TerminalInstance>, mut child: tokio:
         .send_replace(TerminalCompletion::Exited(exit_status));
 }
 
+/// Shared, hot-swappable default shell for ACP terminal requests.
+///
+/// The setting is owned by [`crate::acp::manager::ConnectionManager`] and
+/// cloned into every connection runtime. Reading it when a terminal is created
+/// means a change in General Settings also affects already-running model
+/// sessions.
+#[derive(Clone, Default)]
+pub struct TerminalShellRuntimeConfig {
+    inner: Arc<RwLock<Option<String>>>,
+}
+
+impl TerminalShellRuntimeConfig {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub async fn snapshot(&self) -> Option<String> {
+        self.inner.read().await.clone()
+    }
+
+    pub async fn set(&self, default_shell: Option<String>) {
+        *self.inner.write().await = default_shell;
+    }
+}
+
 pub struct TerminalRuntime {
     terminals: Mutex<TerminalMap>,
     /// Base environment merged into every spawned terminal command before
@@ -407,6 +434,10 @@ pub struct TerminalRuntime {
     /// process cwd (often "/" on desktop, the dev crate dir in development).
     /// `None` leaves the process cwd inherited (legacy behavior).
     default_cwd: Option<PathBuf>,
+    /// The current General Settings default shell. Structured ACP requests
+    /// still direct-exec real programs, while shell command lines and shell
+    /// builtins use this selected shell as their fallback.
+    default_shell: TerminalShellRuntimeConfig,
 }
 
 #[derive(Debug, Clone)]
@@ -428,6 +459,7 @@ impl TerminalRuntime {
             terminals: Mutex::new(HashMap::new()),
             base_env,
             default_cwd: None,
+            default_shell: TerminalShellRuntimeConfig::new(),
         }
     }
 
@@ -438,6 +470,17 @@ impl TerminalRuntime {
         self
     }
 
+    /// Use a shared General Settings shell value for ACP terminal fallbacks.
+    /// The config is read at command creation time so existing connections pick
+    /// up setting changes without being restarted.
+    pub fn with_default_shell_config(
+        mut self,
+        default_shell: TerminalShellRuntimeConfig,
+    ) -> Self {
+        self.default_shell = default_shell;
+        self
+    }
+
     /// Apply stdio, working directory, and environment to a freshly built
     /// terminal command. Shared by the direct-exec and shell-fallback spawn
     /// paths in `create_terminal` so both honor the same cwd precedence and
@@ -514,14 +557,15 @@ impl TerminalRuntime {
         // as unrunnable (`NotFound`, or `InvalidFilename` when the whole line is
         // longer than the OS path limit — grok crams `<shell> -lc "<script>"`
         // into `command`, so a multi-KB heredoc exceeds PATH_MAX and the direct
-        // exec fails with ENAMETOOLONG, not ENOENT) AND the request looks like a
-        // whole shell line crammed into `command` (empty args + embedded
-        // whitespace, the shape CodeBuddy and grok send) do we retry through the
-        // platform shell so its `&&`, pipes, `$VAR`, and globs evaluate. A path
-        // that long can never be a real executable, so rerouting it is always at
-        // least as correct. Deciding off a real failed spawn — rather than a
-        // pre-spawn `which` guess that runs in codeg's own cwd/env — means we
-        // never reroute a command that would otherwise have run.
+        // exec fails with ENAMETOOLONG, not ENOENT) do we retry through a shell.
+        // Whole shell lines (empty args + embedded whitespace, the shape
+        // CodeBuddy and grok send) always qualify. A configured default shell
+        // additionally qualifies a no-argv shell builtin such as PowerShell's
+        // `Get-ChildItem`. A path that long can never be a real executable, so
+        // rerouting it is always at least as correct. Deciding off a real failed
+        // spawn — rather than a pre-spawn `which` guess that runs in codeg's own
+        // cwd/env — means we never reroute a command that would otherwise have
+        // run.
         //
         // A spawn the kernel refuses with `ETXTBSY` is retried in place instead
         // (see `spawn_retrying_exec_busy`): the program *is* runnable, it is
@@ -532,6 +576,13 @@ impl TerminalRuntime {
         direct.args(&request.args);
         self.configure_command(&mut direct, &request);
 
+        let configured_shell = self.default_shell.snapshot().await;
+        // A structured ACP request normally names an executable plus argv, so
+        // preserve direct execution for it. If an explicit shell is selected,
+        // also let no-argv shell builtins (for example PowerShell's
+        // `Get-ChildItem`) fall back through that shell after direct exec fails.
+        let can_retry_through_shell = request.args.is_empty()
+            && (request.command.contains(char::is_whitespace) || configured_shell.is_some());
         let spawned = crate::process::spawn_retrying_exec_busy(|| direct.spawn()).await;
         let mut child = match spawned {
             Ok(child) => child,
@@ -539,10 +590,10 @@ impl TerminalRuntime {
                 if matches!(
                     err.kind(),
                     std::io::ErrorKind::NotFound | std::io::ErrorKind::InvalidFilename
-                ) && request.args.is_empty()
-                    && request.command.contains(char::is_whitespace) =>
+                ) && can_retry_through_shell =>
             {
-                let mut shell = shell_wrapped_command(&request.command);
+                let shell = configured_shell.unwrap_or_else(resolve_shell);
+                let mut shell = shell_wrapped_command(&shell, &request.command);
                 self.configure_command(&mut shell, &request);
                 shell.spawn().map_err(|err| {
                     TerminalRuntimeError::Internal(format!(
@@ -782,23 +833,24 @@ where
     }
 }
 
-/// Wrap a full shell command line so it executes through the platform shell.
-/// Used when an agent passes an entire command line in `command` with empty
-/// `args` (see `create_terminal`); the shell preserves the `&&`, pipes,
-/// `$VAR`, and globs the agent's line relies on. Reuses `tokio_command` so the
-/// shell still inherits codeg's UTF-8 env and Windows program normalization.
-#[cfg(not(windows))]
-fn shell_wrapped_command(line: &str) -> tokio::process::Command {
-    let mut command = crate::process::tokio_command("/bin/sh");
-    command.arg("-c").arg(line);
-    command
-}
-
-#[cfg(windows)]
-fn shell_wrapped_command(line: &str) -> tokio::process::Command {
-    let comspec = std::env::var("COMSPEC").unwrap_or_else(|_| "cmd.exe".to_string());
-    let mut command = crate::process::tokio_command(comspec);
-    command.arg("/C").arg(line);
+/// Wrap a command line through the configured shell. This matches the shell
+/// semantics used by the built-in terminal instead of hard-coding `/bin/sh` or
+/// `cmd.exe` for model tool calls.
+fn shell_wrapped_command(shell: &str, line: &str) -> tokio::process::Command {
+    let shell_name = Path::new(shell)
+        .file_name()
+        .and_then(|value| value.to_str())
+        .unwrap_or(shell)
+        .to_ascii_lowercase();
+    let mut command = crate::process::tokio_command(shell);
+
+    if shell_name.contains("pwsh") || shell_name.contains("powershell") {
+        command.args(["-NoLogo", "-NoProfile", "-Command", line]);
+    } else if shell_name == "cmd" || shell_name == "cmd.exe" {
+        command.args(["/D", "/S", "/C", line]);
+    } else {
+        command.arg("-c").arg(line);
+    }
     command
 }
 
@@ -868,6 +920,41 @@ fn decode_available_utf8(pending: &mut Vec<u8>) -> String {
     output
 }
 
+#[cfg(test)]
+mod shell_config_tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn default_shell_config_hot_swaps() {
+        let config = TerminalShellRuntimeConfig::new();
+        assert_eq!(config.snapshot().await, None);
+
+        config.set(Some("pwsh.exe".to_string())).await;
+        assert_eq!(config.snapshot().await.as_deref(), Some("pwsh.exe"));
+    }
+
+    #[test]
+    fn powershell_fallback_uses_the_selected_executable() {
+        let command = shell_wrapped_command("pwsh.exe", "Get-ChildItem");
+        let std_command = command.as_std();
+        let args: Vec<_> = std_command
+            .get_args()
+            .map(|value| value.to_string_lossy().to_string())
+            .collect();
+
+        assert_eq!(std_command.get_program().to_string_lossy(), "pwsh.exe");
+        assert_eq!(
+            args,
+            vec![
+                "-NoLogo".to_string(),
+                "-NoProfile".to_string(),
+                "-Command".to_string(),
+                "Get-ChildItem".to_string(),
+            ]
+        );
+    }
+}
+
 #[cfg(all(test, unix))]
 mod tests {
     use super::*;
@@ -969,6 +1056,49 @@ mod tests {
         out.output
     }
 
+    /// The shell handle is shared with a live connection, so changing General
+    /// Settings after the agent connects affects its next shell command.
+    #[tokio::test]
+    async fn shell_fallback_uses_the_live_selected_shell() {
+        use std::os::unix::fs::PermissionsExt;
+
+        let dir = tempfile::tempdir().expect("temp dir");
+        let shell = dir.path().join("selected-shell");
+        std::fs::write(
+            &shell,
+            "#!/bin/sh\nprintf '%s\\n' selected-shell\nexec /bin/sh \"$@\"\n",
+        )
+        .expect("write shell");
+        let mut permissions = std::fs::metadata(&shell)
+            .expect("shell metadata")
+            .permissions();
+        permissions.set_mode(0o755);
+        std::fs::set_permissions(&shell, permissions).expect("make shell executable");
+
+        let config = TerminalShellRuntimeConfig::new();
+        let runtime = TerminalRuntime::with_base_env(BTreeMap::new())
+            .with_default_shell_config(config.clone());
+        config
+            .set(Some(shell.to_string_lossy().to_string()))
+            .await;
+
+        let session_id = SessionId::new("selected-shell".to_string());
+        let request = CreateTerminalRequest::new(
+            session_id.clone(),
+            "printf 'command-output\\n'".to_string(),
+        );
+        let output = run_and_capture(&runtime, &session_id, request).await;
+
+        assert!(
+            output.contains("selected-shell"),
+            "configured shell did not run; got:\n{output}"
+        );
+        assert!(
+            output.contains("command-output"),
+            "configured shell did not execute the command; got:\n{output}"
+        );
+    }
+
     /// A `terminal/create` that omits `cwd` defaults to the runtime's
     /// configured working directory rather than codeg's own process cwd.
     #[tokio::test]
diff --git a/src-tauri/src/bin/codeg_server.rs b/src-tauri/src/bin/codeg_server.rs
index 715aacabd..0973e7ca0 100644
--- a/src-tauri/src/bin/codeg_server.rs
+++ b/src-tauri/src/bin/codeg_server.rs
@@ -334,6 +334,14 @@ async fn async_main() -> ExitCode {
         &chat_authoring_config,
     )
     .await;
+    // Keep ACP model terminal fallbacks aligned with the same default-shell
+    // preference used by the built-in terminal before accepting connections.
+    let terminal_shell_config = state.connection_manager.terminal_shell_config();
+    codeg_lib::commands::system_settings::apply_persisted_terminal_shell_config(
+        &state.db.conn,
+        &terminal_shell_config,
+    )
+    .await;
 
     // Spawn the delegation listener so companion processes can round-trip
     // through the broker. Path is PID-scoped, so the listener owns it for
diff --git a/src-tauri/src/commands/system_settings.rs b/src-tauri/src/commands/system_settings.rs
index 1ecf48af1..a1abe829c 100644
--- a/src-tauri/src/commands/system_settings.rs
+++ b/src-tauri/src/commands/system_settings.rs
@@ -2,6 +2,9 @@ use sea_orm::DatabaseConnection;
 #[cfg(feature = "tauri-runtime")]
 use tauri::State;
 
+use crate::acp::terminal_runtime::TerminalShellRuntimeConfig;
+#[cfg(feature = "tauri-runtime")]
+use crate::acp::manager::ConnectionManager;
 use crate::app_error::AppCommandError;
 use crate::db::service::app_metadata_service;
 #[cfg(feature = "tauri-runtime")]
@@ -210,6 +213,52 @@ pub(crate) async fn load_system_terminal_settings(
     Ok(normalize_terminal_settings(parsed))
 }
 
+/// Load the persisted shell selection into the live ACP terminal runtime.
+///
+/// This runs during app startup; a failure leaves the runtime on its system
+/// fallback so a malformed old preference cannot prevent agents from running.
+pub async fn apply_persisted_terminal_shell_config(
+    conn: &DatabaseConnection,
+    config: &TerminalShellRuntimeConfig,
+) {
+    match load_system_terminal_settings(conn).await {
+        Ok(settings) => config.set(settings.default_shell).await,
+        Err(err) => tracing::warn!(
+            "[settings] failed to load default terminal shell for ACP runtime: {err}"
+        ),
+    }
+}
+
+/// Persist, apply, and broadcast the default shell in one path shared by the
+/// desktop command and web handler.
+pub(crate) async fn set_system_terminal_settings_core(
+    conn: &DatabaseConnection,
+    config: &TerminalShellRuntimeConfig,
+    emitter: &crate::web::event_bridge::EventEmitter,
+    settings: SystemTerminalSettings,
+) -> Result<SystemTerminalSettings, AppCommandError> {
+    let normalized = normalize_terminal_settings(settings);
+    let serialized = serde_json::to_string(&normalized).map_err(|e| {
+        AppCommandError::invalid_input("Failed to serialize terminal settings")
+            .with_detail(e.to_string())
+    })?;
+
+    app_metadata_service::upsert_value(conn, SYSTEM_TERMINAL_SETTINGS_KEY, &serialized)
+        .await
+        .map_err(AppCommandError::from)?;
+
+    // Update the shared handle before notifying the frontend, so an already
+    // connected model can issue its next terminal request with the new shell.
+    config.set(normalized.default_shell.clone()).await;
+    crate::web::event_bridge::emit_event(
+        emitter,
+        TERMINAL_SETTINGS_UPDATED_EVENT,
+        normalized.clone(),
+    );
+
+    Ok(normalized)
+}
+
 #[cfg(feature = "tauri-runtime")]
 #[cfg_attr(feature = "tauri-runtime", tauri::command)]
 pub async fn get_system_proxy_settings(
@@ -298,25 +347,11 @@ pub async fn update_system_terminal_settings(
     settings: SystemTerminalSettings,
     db: State<'_, AppDatabase>,
     app: tauri::AppHandle,
+    manager: State<'_, ConnectionManager>,
 ) -> Result<SystemTerminalSettings, AppCommandError> {
-    let normalized = normalize_terminal_settings(settings);
-    let serialized = serde_json::to_string(&normalized).map_err(|e| {
-        AppCommandError::invalid_input("Failed to serialize terminal settings")
-            .with_detail(e.to_string())
-    })?;
-
-    app_metadata_service::upsert_value(&db.conn, SYSTEM_TERMINAL_SETTINGS_KEY, &serialized)
-        .await
-        .map_err(AppCommandError::from)?;
-
+    let config = manager.terminal_shell_config();
     let emitter = crate::web::event_bridge::EventEmitter::Tauri(app);
-    crate::web::event_bridge::emit_event(
-        &emitter,
-        TERMINAL_SETTINGS_UPDATED_EVENT,
-        normalized.clone(),
-    );
-
-    Ok(normalized)
+    set_system_terminal_settings_core(&db.conn, &config, &emitter, settings).await
 }
 
 #[cfg(feature = "tauri-runtime")]
@@ -341,3 +376,37 @@ pub async fn update_system_rendering_settings(
     })?;
     Ok(settings)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::db::test_helpers::fresh_in_memory_db;
+    use crate::web::event_bridge::EventEmitter;
+
+    #[tokio::test]
+    async fn terminal_shell_setting_persists_and_updates_live_runtime() {
+        let db = fresh_in_memory_db().await;
+        let config = TerminalShellRuntimeConfig::new();
+
+        let saved = set_system_terminal_settings_core(
+            &db.conn,
+            &config,
+            &EventEmitter::Noop,
+            SystemTerminalSettings {
+                default_shell: Some("  pwsh.exe  ".to_string()),
+            },
+        )
+        .await
+        .expect("save terminal setting");
+
+        assert_eq!(saved.default_shell.as_deref(), Some("pwsh.exe"));
+        assert_eq!(config.snapshot().await.as_deref(), Some("pwsh.exe"));
+
+        let restarted_config = TerminalShellRuntimeConfig::new();
+        apply_persisted_terminal_shell_config(&db.conn, &restarted_config).await;
+        assert_eq!(
+            restarted_config.snapshot().await.as_deref(),
+            Some("pwsh.exe")
+        );
+    }
+}
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index d4d27b28e..c26116c3f 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -550,6 +550,7 @@ mod tauri_app {
                     let question_for_init = question_config.clone();
                     let session_info_for_init = session_info_config.clone();
                     let chat_authoring_for_init = chat_authoring_config.clone();
+                    let terminal_shell_for_init = cm_state.terminal_shell_config();
                     tauri::async_runtime::block_on(async move {
                         delegation_commands::apply_persisted_config(
                             &db_for_init,
@@ -576,6 +577,11 @@ mod tauri_app {
                             &chat_authoring_for_init,
                         )
                         .await;
+                        crate::commands::system_settings::apply_persisted_terminal_shell_config(
+                            &db_for_init,
+                            &terminal_shell_for_init,
+                        )
+                        .await;
                     });
 
                     let listener_broker = broker.clone();
diff --git a/src-tauri/src/web/handlers/system_settings.rs b/src-tauri/src/web/handlers/system_settings.rs
index 0865e589d..ee82cc52c 100644
--- a/src-tauri/src/web/handlers/system_settings.rs
+++ b/src-tauri/src/web/handlers/system_settings.rs
@@ -8,7 +8,6 @@ use crate::app_state::AppState;
 use crate::commands::system_settings as settings_commands;
 use crate::commands::system_settings::{
     LANGUAGE_SETTINGS_UPDATED_EVENT, SYSTEM_LANGUAGE_SETTINGS_KEY, SYSTEM_PROXY_SETTINGS_KEY,
-    SYSTEM_TERMINAL_SETTINGS_KEY, TERMINAL_SETTINGS_UPDATED_EVENT,
 };
 use crate::db::service::app_metadata_service;
 use crate::models::*;
@@ -134,23 +133,13 @@ pub async fn update_system_terminal_settings(
     Extension(state): Extension<Arc<AppState>>,
     Json(params): Json<UpdateTerminalSettingsParams>,
 ) -> Result<Json<SystemTerminalSettings>, AppCommandError> {
-    let settings = settings_commands::normalize_terminal_settings(params.settings);
-    let db = &state.db;
-
-    let serialized = serde_json::to_string(&settings).map_err(|e| {
-        AppCommandError::invalid_input("Failed to serialize terminal settings")
-            .with_detail(e.to_string())
-    })?;
-
-    app_metadata_service::upsert_value(&db.conn, SYSTEM_TERMINAL_SETTINGS_KEY, &serialized)
-        .await
-        .map_err(AppCommandError::from)?;
-
-    crate::web::event_bridge::emit_event(
+    let config = state.connection_manager.terminal_shell_config();
+    let settings = settings_commands::set_system_terminal_settings_core(
+        &state.db.conn,
+        &config,
         &state.emitter,
-        TERMINAL_SETTINGS_UPDATED_EVENT,
-        settings.clone(),
-    );
-
+        params.settings,
+    )
+    .await?;
     Ok(Json(settings))
 }