@@ -667,39 +667,11 @@ pub fn show(
             crate::video_tools::TOOL_PROBE_TIMEOUT,
         )
     }
-    fn tool_version(binary: &std::path::Path, version_arg: &str) -> Option<String> {
-        let first = tool_first_line(binary, version_arg)?;
-        // ffmpeg prints a whole sentence ("ffmpeg version n9.0.1 ..."):
-        // keep the version token so the row stays readable.
-        if binary
-            .file_name()
-            .is_some_and(|n| n.to_string_lossy() == "ffmpeg")
-            && let Some(token) = first.split_whitespace().nth(2)
-        {
-            return Some(format!("ffmpeg {token}"));
-        }
-        Some(first)
-    }
-    /// Probe installed tool versions: `(yt-dlp, ffmpeg, quickjs?)` plus
-    /// gallery-dl; `None` when the core tools are missing, falling back to
-    /// the binary path if `--version` fails. quickjs is `None` when no
-    /// `qjs` is on hand — it is only provisioned for YouTube. Only tool
-    /// presence matters for the row ("Ready" vs "Not installed"); the
-    /// versions themselves are not shown.
-    fn installed_tool_versions() -> Option<(String, String, Option<String>, Option<String>)> {
-        crate::video::resolve_libraries().ok().map(|libs| {
-            let yt = tool_version(&libs.youtube, "--version")
-                .map(|v| format!("yt-dlp {v}"))
-                .unwrap_or_else(|| libs.youtube.display().to_string());
-            let ff = tool_version(&libs.ffmpeg, "-version")
-                .unwrap_or_else(|| libs.ffmpeg.display().to_string());
-            let qjs = crate::video_tools::find_quickjs()
-                .and_then(|p| tool_version(&p, "--version").map(|v| format!("quickjs {v}")));
-            let gdl = crate::gallery_tools::resolve_gallerydl()
-                .ok()
-                .and_then(|p| tool_version(&p, "--version").map(|v| format!("gallery-dl {v}")));
-            (yt, ff, qjs, gdl)
-        })
+    /// The row only needs to know whether both required video tools are present.
+    /// Check filesystem paths only: do not launch subprocesses or contact upstream
+    /// services just to choose between Install and Check for Updates.
+    fn core_tools_installed() -> bool {
+        crate::video::resolve_libraries().is_ok()
     }
     /// What the tools-row button does: Install when tools are missing, Check to
     /// probe each tool's upstream for a newer release, Update once one is
@@ -715,21 +687,18 @@ pub fn show(
         row: &adw::ActionRow,
         btn: &gtk4::Button,
         action: &std::rc::Rc<std::cell::Cell<ToolAction>>,
-        probed: Option<(String, String, Option<String>, Option<String>)>,
+        installed: bool,
     ) {
-        match probed {
-            // Tool names live in the group description; the row carries
-            // state only: no versions, no ffmpeg/quickjs noise.
-            Some(_) => {
-                row.set_subtitle(&gettext("Ready"));
-                btn.set_label(&gettext("Check for Updates"));
-                action.set(ToolAction::Check);
-            }
-            None => {
-                row.set_subtitle(&gettext("Not installed"));
-                btn.set_label(&gettext("Install"));
-                action.set(ToolAction::Install);
-            }
+        // Tool names live in the group description; the row carries state
+        // only, with no version strings or optional-tool noise.
+        if installed {
+            row.set_subtitle(&gettext("Ready"));
+            btn.set_label(&gettext("Check for Updates"));
+            action.set(ToolAction::Check);
+        } else {
+            row.set_subtitle(&gettext("Not installed"));
+            btn.set_label(&gettext("Install"));
+            action.set(ToolAction::Install);
         }
     }
     fn refresh_video_tools(
@@ -739,14 +708,15 @@ pub fn show(
         action: &std::rc::Rc<std::cell::Cell<ToolAction>>,
     ) {
         spin.set_visible(false);
-        // Probe off the GTK thread (three subprocesses), then paint.
+        btn.set_sensitive(false);
+        // Presence-only probe off the GTK thread; no network calls or subprocesses.
         let (row, btn, action) = (row.clone(), btn.clone(), action.clone());
         gtk4::glib::spawn_future_local(async move {
-            let probed = gio::spawn_blocking(installed_tool_versions)
+            let installed = gio::spawn_blocking(core_tools_installed)
                 .await
-                .ok()
-                .flatten();
-            paint_tools_state(&row, &btn, &action, probed);
+                .unwrap_or(false);
+            paint_tools_state(&row, &btn, &action, installed);
+            btn.set_sensitive(true);
         });
     }
     let video_page = adw::PreferencesPage::builder()
@@ -999,13 +969,15 @@ pub fn show(
     video_tools_group.add(&video_tools_row);
     // Nothing is probed on open: versions and updates are checked only when
     // the user presses Check for Updates.
-    let tool_action = std::rc::Rc::new(std::cell::Cell::new(ToolAction::Check));
+    let tool_action = std::rc::Rc::new(std::cell::Cell::new(ToolAction::Install));
     // Tools needing update (from the check); passed to install_progress::run
     // so the popup only shows what's actually downloading.
     let pending_updates: std::rc::Rc<std::cell::RefCell<Vec<String>>> =
         std::rc::Rc::new(std::cell::RefCell::new(Vec::new()));
-    video_tools_btn.set_label(&gettext("Check for Updates"));
-    video_tools_row.set_subtitle(&gettext("Press Check for Updates to see versions"));
+    // Start in the safe fresh-install state; the local presence probe below
+    // switches to Check for Updates only when yt-dlp and ffmpeg are present.
+    video_tools_btn.set_label(&gettext("Install"));
+    video_tools_row.set_subtitle(&gettext("Not installed"));
     {
         let (row, btn, spin) = (
             video_tools_row.clone(),
@@ -1067,24 +1039,23 @@ pub fn show(
                     // upstream for its latest release tag: yt-dlp/yt-dlp,
                     // BtbN/FFmpeg-Builds, quickjs-ng/quickjs, gdl-org/builds.
                     let installed = gio::spawn_blocking(|| {
-                        crate::video::resolve_libraries().ok().map(|libs| {
-                            let yt = tool_first_line(&libs.youtube, "--version");
-                            let ff = tool_first_line(&libs.ffmpeg, "-version");
-                            let qjs = crate::video_tools::find_quickjs()
-                                .and_then(|p| tool_first_line(&p, "--version"));
-                            let gdl = crate::gallery_tools::resolve_gallerydl()
-                                .ok()
-                                .and_then(|p| tool_first_line(&p, "--version"));
-                            let ffprobe_available = crate::video_tools::toolchain_dir_in(
-                                &crate::video_tools::tool_search_dirs(),
-                            )
-                            .is_some();
-                            (yt, ff, qjs, gdl, ffprobe_available)
-                        })
+                        let dirs = crate::video_tools::tool_search_dirs();
+                        let inspect = |name: &str, version_arg: &str| {
+                            crate::video_tools::find_in_dirs(name, &dirs).map(|path| {
+                                let version = tool_first_line(&path, version_arg);
+                                (path, version)
+                            })
+                        };
+                        let yt = inspect("yt-dlp", "--version");
+                        let ff = inspect("ffmpeg", "-version");
+                        let qjs = inspect("qjs", "--version");
+                        let gdl = inspect("gallery-dl", "--version");
+                        let ffprobe_available =
+                            crate::video_tools::toolchain_dir_in(&dirs).is_some();
+                        (yt, ff, qjs, gdl, ffprobe_available)
                     })
                     .await
-                    .ok()
-                    .flatten();
+                    .ok();
                     // Upstream tags come from the update cache: a click reuses a
                     // check from the last 15 minutes. The lookups run on Grab's
                     // Tokio runtime inside update_cache, never on this GLib task.
@@ -1113,8 +1084,11 @@ pub fn show(
                     let mut current: Vec<String> = Vec::new();
                     let mut indeterminate = installed.is_none();
                     if let Some((yt, ff, qjs, gdl, ffprobe_available)) = installed {
-                        match (yt.as_deref(), yt_tag.as_deref()) {
-                            (Some(installed), Some(tag))
+                        // Presence is independent for each binary. In particular,
+                        // resolve_libraries() must not hide all missing tools just
+                        // because a fresh profile has no yt-dlp yet.
+                        match (yt.as_ref(), yt_tag.as_deref()) {
+                            (Some((_, Some(installed))), Some(tag))
                                 if crate::video_tools::tool_update_available(installed, tag) =>
                             {
                                 updates.push(format!(
@@ -1123,48 +1097,46 @@ pub fn show(
                                     tag.trim()
                                 ));
                             }
-                            (Some(installed), Some(_)) => {
+                            (Some((_, Some(installed))), Some(_)) => {
                                 current.push(format!("yt-dlp {}", installed.trim()));
                             }
-                            _ => indeterminate = true,
+                            (Some(_), _) => indeterminate = true,
+                            (None, _) => missing.push("yt-dlp".to_string()),
                         }
-                        match (ff.as_deref(), ff_tag.as_deref()) {
-                            (Some(first_line), Some(tag)) => {
-                                let token = crate::video_tools::ffmpeg_version_token(first_line)
-                                    .unwrap_or(first_line);
-                                if crate::video_tools::ffmpeg_needs_update(
-                                    first_line,
-                                    tag,
-                                    ffprobe_available,
-                                ) {
-                                    updates.push(if ffprobe_available {
-                                        format!("ffmpeg {} → {}", token, tag.trim())
+                        if !ffprobe_available {
+                            if let Some((_, version)) = ff.as_ref() {
+                                let detail = version
+                                    .as_deref()
+                                    .and_then(crate::video_tools::ffmpeg_version_token)
+                                    .unwrap_or("repair required");
+                                updates.push(format!("ffmpeg {detail} (ffprobe missing)"));
+                            } else {
+                                missing.push("ffmpeg".to_string());
+                            }
+                        } else {
+                            match (ff.as_ref(), ff_tag.as_deref()) {
+                                (Some((_, Some(first_line))), Some(tag)) => {
+                                    let token =
+                                        crate::video_tools::ffmpeg_version_token(first_line)
+                                            .unwrap_or(first_line);
+                                    if crate::video_tools::ffmpeg_needs_update(
+                                        first_line,
+                                        tag,
+                                        ffprobe_available,
+                                    ) {
+                                        updates.push(format!("ffmpeg {} → {}", token, tag.trim()));
                                     } else {
-                                        format!(
-                                            "ffmpeg {} → {} (ffprobe missing)",
-                                            token,
-                                            tag.trim()
-                                        )
-                                    });
-                                } else {
-                                    current.push(format!("ffmpeg {token}"));
+                                        current.push(format!("ffmpeg {token}"));
+                                    }
                                 }
+                                (Some(_), _) => indeterminate = true,
+                                (None, _) => missing.push("ffmpeg".to_string()),
                             }
-                            (Some(first_line), None) if !ffprobe_available => {
-                                let token = crate::video_tools::ffmpeg_version_token(first_line)
-                                    .unwrap_or(first_line);
-                                updates.push(format!("ffmpeg {token} (ffprobe missing)"));
-                            }
-                            (None, _) if !ffprobe_available => {
-                                updates.push("ffmpeg (ffprobe missing)".to_string());
-                            }
-                            _ => indeterminate = true,
                         }
-                        // quickjs is optional (provisioned for YouTube only):
-                        // judged when installed, never blocks the check.
-                        // If missing, offer to install it.
-                        match (qjs.as_deref(), qjs_tag.as_deref()) {
-                            (Some(installed), Some(tag))
+                        // Optional tools are offered for installation whenever
+                        // absent, even if their latest-release lookup is offline.
+                        match (qjs.as_ref(), qjs_tag.as_deref()) {
+                            (Some((_, Some(installed))), Some(tag))
                                 if crate::video_tools::tool_update_available(installed, tag) =>
                             {
                                 updates.push(format!(
@@ -1173,33 +1145,25 @@ pub fn show(
                                     tag.trim()
                                 ));
                             }
-                            (Some(installed), Some(_)) => {
+                            (Some((_, Some(installed))), Some(_)) => {
                                 current.push(format!("quickjs {}", installed.trim()));
                             }
-                            (None, Some(_)) => {
-                                missing.push(TOOL_QUICKJS.to_string());
-                            }
-                            _ => indeterminate = true,
+                            (Some(_), _) => indeterminate = true,
+                            (None, _) => missing.push(TOOL_QUICKJS.to_string()),
                         }
-                        // gallery-dl is optional (provisioned for galleries only):
-                        // judged when installed, never blocks the check.
-                        // If missing, offer to install it.
-                        match (gdl.as_deref(), gdl_tag.as_deref()) {
-                            (Some(_installed), Some(tag)) if gdl_needs_update => {
+                        match (gdl.as_ref(), gdl_tag.as_deref()) {
+                            (Some((_, Some(installed))), Some(tag)) if gdl_needs_update => {
                                 updates.push(format!(
                                     "gallery-dl {} → {}",
-                                    _installed.trim(),
+                                    installed.trim(),
                                     tag.trim()
                                 ));
                             }
-                            (Some(installed), Some(_)) => {
+                            (Some((_, Some(installed))), Some(_)) => {
                                 current.push(format!("gallery-dl {}", installed.trim()));
                             }
-                            (None, Some(_)) => {
-                                missing.push(TOOL_GALLERY_DL.to_string());
-                            }
-                            (None, _) => {}
-                            _ => indeterminate = true,
+                            (Some(_), _) => indeterminate = true,
+                            (None, _) => missing.push(TOOL_GALLERY_DL.to_string()),
                         }
                     }
                     if !missing.is_empty() || !updates.is_empty() {
@@ -1280,6 +1244,14 @@ pub fn show(
             );
         });
     }
+    // Do not make a fresh Flatpak-data profile ask for updates before its tools
+    // exist. This is a local executable-presence check, not an upstream lookup.
+    refresh_video_tools(
+        &video_tools_row,
+        &video_tools_btn,
+        &video_tools_spin,
+        &tool_action,
+    );
     video_page.add(&video_quality_group);
     video_page.add(&video_auth_group);
     video_page.add(&video_tools_group);