test: prove shell chooser values survive relaunch bootstrap

The shell chooser looked broken from the UI because coverage stopped short of proving that a saved chooser value like "fish" survives persistence and reaches the next-launch bootstrap path. This adds focused UI-side chooser tests, runtime bootstrap tests for direct overrides and invalid fallback, and an end-to-endish settings -> persisted config -> relaunch bootstrap test for the chooser value itself. The settings copy now also makes the full-relaunch requirement explicit.

Constraint: The chosen shell only affects new Taskers launches because existing panes already own live PTYs
Rejected: Rely on runtime bootstrap unit tests alone | they did not prove that the chooser value itself survived persistence
Rejected: Add only wording | the reported problem needed executable coverage around the relaunch path
Confidence: high
Scope-risk: narrow
Reversibility: clean
Directive: Keep one test that starts from the chooser-style value "fish" and proves it reaches relaunch bootstrap, not just absolute shell paths
Tested: cargo test -p taskers-shell --lib configured_shell
Tested: cargo test -p taskers runtime_bootstrap_tests --bin taskers-gtk
Tested: cargo test -p taskers-shell-core configured_shell_setting_normalizes_blank_values --lib
Tested: cargo test -p taskers startup_tests --bin taskers-gtk
Tested: cargo install --path crates/taskers-app --force
Not-tested: Manual relaunch with the settings UI set to Fish

Author: OneNoted

crates/taskers-app/src/main.rs

@@ -1121,6 +1121,140 @@ mod config_tests {
     }
 }
 
+#[cfg(test)]
+mod runtime_bootstrap_tests {
+    use super::{TaskersConfig, resolve_runtime_bootstrap};
+    use std::{env, fs, os::unix::fs::PermissionsExt, sync::Mutex};
+    use taskers_ghostty::EmbeddedTerminalAppearance;
+    use taskers_shell_core::{NotificationPreferencesSnapshot, SettingsSnapshot};
+    use tempfile::TempDir;
+
+    static PATH_MUTEX: Mutex<()> = Mutex::new(());
+
+    struct PathGuard(Option<std::ffi::OsString>);
+
+    impl Drop for PathGuard {
+        fn drop(&mut self) {
+            unsafe {
+                if let Some(path) = self.0.as_ref() {
+                    env::set_var("PATH", path);
+                } else {
+                    env::remove_var("PATH");
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn runtime_bootstrap_uses_configured_shell_override_in_launch_spec() {
+        let _guard = PATH_MUTEX.lock().expect("path mutex");
+        let temp = TempDir::new().expect("tempdir");
+        let shell_path = temp.path().join("fish");
+        fs::write(&shell_path, "#!/bin/sh\nexit 0\n").expect("write shell");
+        let mut permissions = fs::metadata(&shell_path).expect("metadata").permissions();
+        permissions.set_mode(0o755);
+        fs::set_permissions(&shell_path, permissions).expect("chmod");
+
+        let runtime = resolve_runtime_bootstrap(
+            EmbeddedTerminalAppearance::Taskers,
+            Some(shell_path.to_str().expect("shell path utf8")),
+            None,
+        );
+
+        assert_eq!(
+            runtime
+                .shell_launch
+                .env
+                .get("TASKERS_REAL_SHELL")
+                .map(String::as_str),
+            Some(shell_path.to_str().expect("shell path utf8"))
+        );
+        assert!(
+            runtime
+                .shell_launch
+                .args
+                .iter()
+                .any(|arg| arg == "--interactive"),
+            "expected configured fish shell to launch interactively"
+        );
+        assert!(
+            runtime
+                .shell_launch
+                .args
+                .iter()
+                .any(|arg| arg.contains("taskers-hooks.fish")),
+            "expected fish launch spec to source the fish shell hooks"
+        );
+    }
+
+    #[test]
+    fn runtime_bootstrap_invalid_configured_shell_falls_back_with_note() {
+        let _guard = PATH_MUTEX.lock().expect("path mutex");
+        let runtime = resolve_runtime_bootstrap(
+            EmbeddedTerminalAppearance::Taskers,
+            Some("/definitely/missing/taskers-shell"),
+            None,
+        );
+
+        assert!(
+            runtime.startup_notes.iter().any(|note| {
+                note.contains("Configured shell '/definitely/missing/taskers-shell' is unavailable")
+                    && note.contains("falling back to the system default shell")
+            }),
+            "expected fallback startup note when configured shell is invalid"
+        );
+    }
+
+    #[test]
+    fn configured_shell_round_trips_from_settings_into_relaunch_bootstrap() {
+        let _guard = PATH_MUTEX.lock().expect("path mutex");
+        let temp = TempDir::new().expect("tempdir");
+        let shell_path = temp.path().join("fish");
+        fs::write(&shell_path, "#!/bin/sh\nexit 0\n").expect("write shell");
+        let mut permissions = fs::metadata(&shell_path).expect("metadata").permissions();
+        permissions.set_mode(0o755);
+        fs::set_permissions(&shell_path, permissions).expect("chmod");
+        let original_path = env::var_os("PATH");
+        let _restore_path = PathGuard(original_path);
+        unsafe {
+            env::set_var("PATH", temp.path());
+        }
+
+        let settings = SettingsSnapshot {
+            selected_theme_id: "dark".into(),
+            theme_options: Vec::new(),
+            shortcut_presets: Vec::new(),
+            shortcuts: Vec::new(),
+            configured_shell: Some(" fish ".into()),
+            default_shell_label: "/bin/zsh".into(),
+            notification_preferences: NotificationPreferencesSnapshot::default(),
+            render_live_surfaces_in_overview: true,
+        };
+        let next = TaskersConfig::from_settings(&settings, &TaskersConfig::default());
+        let persisted = serde_json::to_string(&next).expect("serialize config");
+        let reloaded: TaskersConfig = serde_json::from_str(&persisted).expect("reload config");
+
+        let runtime = resolve_runtime_bootstrap(
+            reloaded.embedded_terminal_appearance,
+            reloaded.configured_shell.as_deref(),
+            None,
+        );
+
+        assert_eq!(
+            runtime
+                .shell_launch
+                .env
+                .get("TASKERS_REAL_SHELL")
+                .map(String::as_str),
+            Some(shell_path.to_str().expect("shell path utf8")),
+            "reloaded configured_shell={:?} path={:?} startup_notes={:?}",
+            reloaded.configured_shell,
+            env::var_os("PATH"),
+            runtime.startup_notes
+        );
+    }
+}
+
 fn is_modifier_key(key: gdk::Key) -> bool {
     matches!(
         key,

crates/taskers-shell/src/lib.rs

@@ -4196,10 +4196,11 @@ fn render_notification_row(
 #[cfg(test)]
 mod tests {
     use super::{
-        SurfaceDragCandidate, SurfaceKind, attention_ring_class, select_active_surface,
-        show_surface_backdrop, surface_drag_threshold_reached, surface_primary_label,
-        surface_runtime_badge_text, surface_status_text, surface_summary_title,
-        vcs_commit_net_summary, vcs_diff_line_class, vcs_file_dot_class, vcs_ref_input_value,
+        SurfaceDragCandidate, SurfaceKind, attention_ring_class, configured_shell_is_custom,
+        configured_shell_matches_option, select_active_surface, show_surface_backdrop,
+        surface_drag_threshold_reached, surface_primary_label, surface_runtime_badge_text,
+        surface_status_text, surface_summary_title, vcs_commit_net_summary, vcs_diff_line_class,
+        vcs_file_dot_class, vcs_ref_input_value,
     };
     use crate::taskers_core::{
         AttentionRingState, AttentionState, BrowserProfileMode, PaneId, RuntimeIdentitySnapshot,
@@ -4428,6 +4429,26 @@ mod tests {
         assert_eq!(selected.id, first.id);
     }
 
+    #[test]
+    fn configured_shell_option_matching_accepts_names_and_paths() {
+        assert!(configured_shell_matches_option(Some("fish"), "fish"));
+        assert!(configured_shell_matches_option(
+            Some("/usr/bin/fish"),
+            "fish"
+        ));
+        assert!(!configured_shell_matches_option(
+            Some("/usr/bin/zsh"),
+            "fish"
+        ));
+    }
+
+    #[test]
+    fn configured_shell_custom_detection_excludes_common_shells() {
+        assert!(!configured_shell_is_custom(Some("fish")));
+        assert!(!configured_shell_is_custom(Some("/usr/bin/zsh")));
+        assert!(configured_shell_is_custom(Some("/opt/homebrew/bin/nu")));
+    }
+
     #[test]
     fn vcs_file_dot_class_tracks_each_file_status_group() {
         assert_eq!(
@@ -4652,7 +4673,7 @@ fn render_terminal_tab(settings: &SettingsSnapshot, core: SharedCore) -> Element
         section { class: "settings-section",
             div { class: "settings-section-heading", "Terminal" }
             div { class: "settings-section-helper",
-                "Configure how new Taskers terminal panes launch. Shell changes apply to new Taskers launches."
+                "Configure how new Taskers terminal panes launch. Fully quit and relaunch Taskers to apply shell changes to new panes."
             }
             div { class: "settings-row",
                 div { class: "settings-row-copy",