fix: ensure noUpdateNotifier from turbo.json is respected (#11510)

The `noUpdateNotifier` setting in `turbo.json` was not being reliably
respected because the full configuration pipeline could fail before
reaching the turbo.json source. The pipeline resolves sources in priority
order (CLI overrides → env vars → local config → global auth → global
config → turbo.json), and any error from a higher-priority source would
abort the entire pipeline via `try_fold`. The subsequent
`.unwrap_or_default()` would then return a default config with
`no_update_notifier: false`, silently discarding the turbo.json setting.

This commit:
- Adds a fallback in the shim's config provider that reads
  `noUpdateNotifier` directly from turbo.json when the full config
  pipeline does not yield `no_update_notifier: true`. This ensures the
  setting is respected even when unrelated config sources fail.
- Improves error logging when the config pipeline fails, replacing the
  silent `.unwrap_or_default()` with explicit debug logging.
- Adds tests verifying that `noUpdateNotifier` is correctly parsed from
  turbo.json and propagated through the full config build and the shim
  config resolution path.

Fixes #11510

Author: Dmitrii Troitskii

crates/turborepo-config/src/lib.rs

@@ -958,4 +958,28 @@ mod test {
             "Linked worktree should be marked as shared"
         );
     }
+
+    #[test]
+    fn test_no_update_notifier_from_turbo_json_full_build() {
+        let tmp_dir = TempDir::new().unwrap();
+        let repo_root = AbsoluteSystemPathBuf::try_from(tmp_dir.path()).unwrap();
+
+        repo_root
+            .join_component("turbo.json")
+            .create_with_contents(r#"{"noUpdateNotifier": true}"#)
+            .unwrap();
+
+        let builder = TurborepoConfigBuilder {
+            repo_root,
+            override_config: ConfigurationOptions::default(),
+            global_config_path: None,
+            environment: Some(HashMap::default()),
+        };
+
+        let config = builder.build().unwrap();
+        assert!(
+            config.no_update_notifier(),
+            "noUpdateNotifier from turbo.json should be respected"
+        );
+    }
 }

crates/turborepo-lib/src/config/funnel.rs

@@ -130,6 +130,23 @@ mod tests {
         assert_eq!(overrides.no_update_notifier, Some(true));
     }
 
+    #[test]
+    fn test_turbo_json_no_update_notifier_propagates_through_shim_config() {
+        let tmp_dir = TempDir::new().unwrap();
+        let repo_root = AbsoluteSystemPathBuf::try_from(tmp_dir.path()).unwrap();
+        repo_root
+            .join_component(CONFIG_FILE)
+            .create_with_contents(r#"{"noUpdateNotifier": true}"#)
+            .unwrap();
+
+        let config = super::resolve_configuration_for_shim(&repo_root, None).unwrap();
+        assert!(
+            config.no_update_notifier(),
+            "noUpdateNotifier from turbo.json should propagate through \
+             resolve_configuration_for_shim"
+        );
+    }
+
     #[test]
     fn test_cli_overrides_are_highest_precedence() {
         let tmp_dir = TempDir::new().unwrap();

crates/turborepo-lib/src/shim.rs

@@ -66,9 +66,62 @@ impl ConfigProvider for TurboConfigProvider {
         root: &AbsoluteSystemPath,
         root_turbo_json: Option<&AbsoluteSystemPathBuf>,
     ) -> ShimConfigurationOptions {
-        let config = crate::config::resolve_configuration_for_shim(root, root_turbo_json)
-            .unwrap_or_default();
-        ShimConfigurationOptions::new(Some(config.no_update_notifier()))
+        let config = match crate::config::resolve_configuration_for_shim(root, root_turbo_json) {
+            Ok(config) => config,
+            Err(e) => {
+                tracing::debug!("Failed to resolve configuration for shim: {e}");
+                Default::default()
+            }
+        };
+
+        // If the full config pipeline didn't yield no_update_notifier, read it
+        // directly from turbo.json as a fallback. The full config pipeline can
+        // fail (e.g. malformed global config or auth files) before it reaches
+        // the turbo.json source, silently losing this setting.
+        let no_update_notifier = if config.no_update_notifier() {
+            true
+        } else {
+            read_no_update_notifier_from_turbo_json(root, root_turbo_json)
+        };
+
+        ShimConfigurationOptions::new(Some(no_update_notifier))
+    }
+}
+
+/// Reads `noUpdateNotifier` directly from turbo.json as a fallback.
+///
+/// This is used when the full configuration pipeline does not yield a
+/// `no_update_notifier` value, which can happen if a higher-priority
+/// configuration source (global config, auth file, environment variable)
+/// errors during resolution, aborting the pipeline before turbo.json is
+/// processed.
+fn read_no_update_notifier_from_turbo_json(
+    root: &AbsoluteSystemPath,
+    root_turbo_json: Option<&AbsoluteSystemPathBuf>,
+) -> bool {
+    let turbo_json_path = root_turbo_json
+        .cloned()
+        .or_else(|| {
+            turborepo_config::resolve_turbo_config_path(root)
+                .ok()
+        });
+
+    let Some(path) = turbo_json_path else {
+        return false;
+    };
+
+    let contents = match path.read_existing_to_string() {
+        Ok(Some(contents)) => contents,
+        _ => return false,
+    };
+
+    // Parse the turbo.json and check for noUpdateNotifier
+    match turborepo_turbo_json::RawRootTurboJson::parse(&contents, "turbo.json") {
+        Ok(raw) => raw
+            .no_update_notifier
+            .map(|v| *v.as_inner())
+            .unwrap_or(false),
+        Err(_) => false,
     }
 }
 

crates/turborepo-turbo-json/src/parser.rs

@@ -391,6 +391,40 @@ mod tests {
         assert_snapshot!(msg);
     }
 
+    #[test]
+    fn test_no_update_notifier_parsed_from_root_turbo_json() {
+        let json = r#"{"noUpdateNotifier": true}"#;
+        let result = RawRootTurboJson::parse(json, "turbo.json").unwrap();
+        assert_eq!(
+            result.no_update_notifier.as_ref().map(|v| *v.as_inner()),
+            Some(true),
+            "noUpdateNotifier should be parsed from root turbo.json"
+        );
+    }
+
+    #[test]
+    fn test_no_update_notifier_parsed_from_full_turbo_json() {
+        let json = r#"{
+          "$schema": "https://turborepo.dev/schema.json",
+          "noUpdateNotifier": true,
+          "tasks": {
+            "build": {
+              "dependsOn": ["prebuild", "^build"],
+              "outputs": ["output-file.txt", "dist/**"]
+            },
+            "prebuild": {},
+            "lint": {},
+            "check-types": {}
+          }
+        }"#;
+        let result = RawRootTurboJson::parse(json, "turbo.json").unwrap();
+        assert_eq!(
+            result.no_update_notifier.as_ref().map(|v| *v.as_inner()),
+            Some(true),
+            "noUpdateNotifier should be parsed from a full turbo.json"
+        );
+    }
+
     #[test]
     fn test_unknown_key_in_task_definition() {
         // Task definitions should reject unknown keys