diff --git a/docs/user-guide/api-reference.md b/docs/user-guide/api-reference.md
index 162f0ef..4f4870a 100644
--- a/docs/user-guide/api-reference.md
+++ b/docs/user-guide/api-reference.md
@@ -320,6 +320,8 @@ Applies MSBuild property overrides to the staged `efcpt-config.json` file. This
 | `EfcptFingerprintFile` | `$(EfcptOutput)fingerprint.txt` | Fingerprint cache location |
 | `EfcptStampFile` | `$(EfcptOutput).efcpt.stamp` | Generation stamp file |
 | `EfcptDetectGeneratedFileChanges` | `false` | Detect changes to generated `.g.cs` files and trigger regeneration. **Warning**: When enabled, manual edits to generated files will be overwritten. |
+| `EfcptAutoDetectWarningLevel` | `Info` | Severity for SQL project/connection string auto-detection messages. Valid values: `None`, `Info`, `Warn`, `Error` |
+| `EfcptSdkVersionWarningLevel` | `Warn` | Severity for SDK version update notifications. Valid values: `None`, `Info`, `Warn`, `Error` |
 
 ### Config Override Properties
 
diff --git a/docs/user-guide/sdk.md b/docs/user-guide/sdk.md
index ce82b0e..3b7e5d8 100644
--- a/docs/user-guide/sdk.md
+++ b/docs/user-guide/sdk.md
@@ -242,10 +242,19 @@ warning EFCPT002: A newer version of JD.Efcpt.Sdk is available: 1.1.0 (current:
 ```
 
 Configuration options:
-- `EfcptCheckForUpdates` - Enable/disable version checking (default: `false`)
+- `EfcptCheckForUpdates` - Enable/disable version checking (default: `false` for package references, `true` for SDK references)
+- `EfcptSdkVersionWarningLevel` - Control severity of update notifications: `None`, `Info`, `Warn` (default), or `Error`
 - `EfcptUpdateCheckCacheHours` - Hours to cache the result (default: `24`)
 - `EfcptForceUpdateCheck` - Bypass cache and always check (default: `false`)
 
+Example: Make version updates informational instead of warnings:
+
+```xml
+<PropertyGroup>
+    <EfcptSdkVersionWarningLevel>Info</EfcptSdkVersionWarningLevel>
+</PropertyGroup>
+```
+
 ### Use global.json for Centralized Management
 
 When you have multiple projects, use `global.json` to manage SDK versions in one place:
diff --git a/docs/user-guide/troubleshooting.md b/docs/user-guide/troubleshooting.md
index 005629b..4122eb3 100644
--- a/docs/user-guide/troubleshooting.md
+++ b/docs/user-guide/troubleshooting.md
@@ -354,9 +354,41 @@ JD.Efcpt.Build task assemblies target .NET 8.0+ and cannot run on the .NET Frame
 2. Build from command line with `dotnet build`
 3. Set `EfcptEnabled=false` to disable code generation if you only need to compile the project
 
+### EFCPT001: Auto-Detection Informational Message
+
+**Type:** Informational (configurable)
+
+**Message:**
+```
+EFCPT001: No SQL project references found in project; using SQL project detected from solution: path/to/project.sqlproj
+```
+or
+```
+EFCPT001: No .sqlproj found. Using auto-discovered connection string.
+```
+
+**Cause:**
+The build automatically detected a SQL project from the solution or a connection string from configuration files when no explicit reference was provided. This is expected behavior in zero-config scenarios.
+
+**Severity Control:**
+Control the message severity using `EfcptAutoDetectWarningLevel`:
+```xml
+<PropertyGroup>
+  <!-- Valid values: None, Info, Warn, Error -->
+  <EfcptAutoDetectWarningLevel>Info</EfcptAutoDetectWarningLevel>
+</PropertyGroup>
+```
+
+**Default:** `Info` (informational message)
+
+**Solutions:**
+- If you want to suppress this message entirely, set `EfcptAutoDetectWarningLevel=None`
+- If you want to make it a warning, set `EfcptAutoDetectWarningLevel=Warn`
+- To be explicit about your SQL project or connection string, configure `EfcptSqlProj`, `EfcptConnectionString`, or other relevant properties
+
 ### EFCPT002: Newer SDK Version Available
 
-**Type:** Warning (opt-in)
+**Type:** Warning (opt-in, configurable)
 
 **Message:**
 ```
@@ -366,6 +398,17 @@ EFCPT002: A newer version of JD.Efcpt.Sdk is available: X.Y.Z (current: A.B.C)
 **Cause:**
 When `EfcptCheckForUpdates` is enabled, the build checks NuGet for newer SDK versions. This warning indicates an update is available.
 
+**Severity Control:**
+Control the message severity using `EfcptSdkVersionWarningLevel`:
+```xml
+<PropertyGroup>
+  <!-- Valid values: None, Info, Warn, Error -->
+  <EfcptSdkVersionWarningLevel>Warn</EfcptSdkVersionWarningLevel>
+</PropertyGroup>
+```
+
+**Default:** `Warn` (warning message)
+
 **Solutions:**
 1. Update your project's `Sdk` attribute: `Sdk="JD.Efcpt.Sdk/X.Y.Z"`
 2. Or update `global.json` if using centralized version management:
@@ -376,9 +419,10 @@ When `EfcptCheckForUpdates` is enabled, the build checks NuGet for newer SDK ver
      }
    }
    ```
-3. To suppress this warning, set `EfcptCheckForUpdates=false`
+3. To change the severity level, set `EfcptSdkVersionWarningLevel` to `None`, `Info`, `Warn`, or `Error`
+4. To disable version checking entirely, set `EfcptCheckForUpdates=false`
 
-**Note:** This check is opt-in and disabled by default. Results are cached for 24 hours to minimize network calls.
+**Note:** This check is opt-in for package references and opt-out for SDK references. Results are cached for 24 hours to minimize network calls.
 
 ## Error Messages
 
diff --git a/src/JD.Efcpt.Build.Tasks/BuildLog.cs b/src/JD.Efcpt.Build.Tasks/BuildLog.cs
index c1dc2a8..70a58ef 100644
--- a/src/JD.Efcpt.Build.Tasks/BuildLog.cs
+++ b/src/JD.Efcpt.Build.Tasks/BuildLog.cs
@@ -50,6 +50,14 @@ public interface IBuildLog
     /// <param name="code">The error code.</param>
     /// <param name="message">The error message.</param>
     void Error(string code, string message);
+
+    /// <summary>
+    /// Logs a message at the specified severity level with an optional code.
+    /// </summary>
+    /// <param name="level">The message severity level.</param>
+    /// <param name="message">The message to log.</param>
+    /// <param name="code">Optional message code.</param>
+    void Log(MessageLevel level, string message, string? code = null);
 }
 
 /// <summary>
@@ -89,6 +97,32 @@ public void Error(string code, string message)
         => log.LogError(subcategory: null, code, helpKeyword: null,
                         file: null, lineNumber: 0, columnNumber: 0,
                         endLineNumber: 0, endColumnNumber: 0, message);
+
+    /// <inheritdoc />
+    public void Log(MessageLevel level, string message, string? code = null)
+    {
+        switch (level)
+        {
+            case MessageLevel.None:
+                // Do nothing
+                break;
+            case MessageLevel.Info:
+                log.LogMessage(MessageImportance.High, message);
+                break;
+            case MessageLevel.Warn:
+                if (!string.IsNullOrEmpty(code))
+                    Warn(code, message);
+                else
+                    Warn(message);
+                break;
+            case MessageLevel.Error:
+                if (!string.IsNullOrEmpty(code))
+                    Error(code, message);
+                else
+                    Error(message);
+                break;
+        }
+    }
 }
 
 /// <summary>
@@ -124,4 +158,7 @@ public void Error(string message) { }
 
     /// <inheritdoc />
     public void Error(string code, string message) { }
+
+    /// <inheritdoc />
+    public void Log(MessageLevel level, string message, string? code = null) { }
 }
diff --git a/src/JD.Efcpt.Build.Tasks/CheckSdkVersion.cs b/src/JD.Efcpt.Build.Tasks/CheckSdkVersion.cs
index 4e33a46..6d9c230 100644
--- a/src/JD.Efcpt.Build.Tasks/CheckSdkVersion.cs
+++ b/src/JD.Efcpt.Build.Tasks/CheckSdkVersion.cs
@@ -46,6 +46,12 @@ public class CheckSdkVersion : Microsoft.Build.Utilities.Task
     /// </summary>
     public bool ForceCheck { get; set; }
 
+    /// <summary>
+    /// Controls the severity level for SDK version update messages.
+    /// Valid values: "None", "Info", "Warn", "Error". Defaults to "Warn".
+    /// </summary>
+    public string WarningLevel { get; set; } = "Warn";
+
     /// <summary>
     /// The latest version available on NuGet (output).
     /// </summary>
@@ -103,17 +109,62 @@ private void CheckAndWarn()
             latest > current)
         {
             UpdateAvailable = true;
-            Log.LogWarning(
-                subcategory: null,
-                warningCode: "EFCPT002",
-                helpKeyword: null,
-                file: null,
-                lineNumber: 0,
-                columnNumber: 0,
-                endLineNumber: 0,
-                endColumnNumber: 0,
-                message: $"A newer version of JD.Efcpt.Sdk is available: {LatestVersion} (current: {CurrentVersion}). " +
-                         $"Update your project's Sdk attribute or global.json to use the latest version.");
+            EmitVersionUpdateMessage();
+        }
+    }
+
+    /// <summary>
+    /// Emits the version update message at the configured severity level.
+    /// Protected virtual to allow testing without reflection.
+    /// </summary>
+    protected virtual void EmitVersionUpdateMessage()
+    {
+        var level = MessageLevelHelpers.Parse(WarningLevel, MessageLevel.Warn);
+        var message = $"A newer version of JD.Efcpt.Sdk is available: {LatestVersion} (current: {CurrentVersion}). " +
+                     $"Update your project's Sdk attribute or global.json to use the latest version.";
+        
+        switch (level)
+        {
+            case MessageLevel.None:
+                // Do nothing
+                break;
+            case MessageLevel.Info:
+                Log.LogMessage(
+                    subcategory: null,
+                    code: "EFCPT002",
+                    helpKeyword: null,
+                    file: null,
+                    lineNumber: 0,
+                    columnNumber: 0,
+                    endLineNumber: 0,
+                    endColumnNumber: 0,
+                    importance: MessageImportance.High,
+                    message: message);
+                break;
+            case MessageLevel.Warn:
+                Log.LogWarning(
+                    subcategory: null,
+                    warningCode: "EFCPT002",
+                    helpKeyword: null,
+                    file: null,
+                    lineNumber: 0,
+                    columnNumber: 0,
+                    endLineNumber: 0,
+                    endColumnNumber: 0,
+                    message: message);
+                break;
+            case MessageLevel.Error:
+                Log.LogError(
+                    subcategory: null,
+                    errorCode: "EFCPT002",
+                    helpKeyword: null,
+                    file: null,
+                    lineNumber: 0,
+                    columnNumber: 0,
+                    endLineNumber: 0,
+                    endColumnNumber: 0,
+                    message: message);
+                break;
         }
     }
 
diff --git a/src/JD.Efcpt.Build.Tasks/MessageLevel.cs b/src/JD.Efcpt.Build.Tasks/MessageLevel.cs
new file mode 100644
index 0000000..951b2e8
--- /dev/null
+++ b/src/JD.Efcpt.Build.Tasks/MessageLevel.cs
@@ -0,0 +1,27 @@
+namespace JD.Efcpt.Build.Tasks;
+
+/// <summary>
+/// Defines the severity level for build messages.
+/// </summary>
+public enum MessageLevel
+{
+    /// <summary>
+    /// No message is emitted.
+    /// </summary>
+    None,
+
+    /// <summary>
+    /// Message is emitted as informational (low priority).
+    /// </summary>
+    Info,
+
+    /// <summary>
+    /// Message is emitted as a warning.
+    /// </summary>
+    Warn,
+
+    /// <summary>
+    /// Message is emitted as an error.
+    /// </summary>
+    Error
+}
diff --git a/src/JD.Efcpt.Build.Tasks/MessageLevelHelpers.cs b/src/JD.Efcpt.Build.Tasks/MessageLevelHelpers.cs
new file mode 100644
index 0000000..50a5fce
--- /dev/null
+++ b/src/JD.Efcpt.Build.Tasks/MessageLevelHelpers.cs
@@ -0,0 +1,52 @@
+namespace JD.Efcpt.Build.Tasks;
+
+/// <summary>
+/// Helper methods for working with <see cref="MessageLevel"/>.
+/// </summary>
+public static class MessageLevelHelpers
+{
+    /// <summary>
+    /// Parses a string into a <see cref="MessageLevel"/>.
+    /// </summary>
+    /// <param name="value">The string value to parse (case-insensitive).</param>
+    /// <param name="defaultValue">The default value to return if parsing fails.</param>
+    /// <returns>The parsed <see cref="MessageLevel"/>.</returns>
+    public static MessageLevel Parse(string? value, MessageLevel defaultValue)
+    {
+        return TryParse(value, out var result) ? result : defaultValue;
+    }
+
+    /// <summary>
+    /// Tries to parse a string into a <see cref="MessageLevel"/>.
+    /// </summary>
+    /// <param name="value">The string value to parse (case-insensitive).</param>
+    /// <param name="result">The parsed <see cref="MessageLevel"/>.</param>
+    /// <returns><c>true</c> if parsing succeeded; otherwise, <c>false</c>.</returns>
+    public static bool TryParse(string? value, out MessageLevel result)
+    {
+        result = MessageLevel.None;
+
+        if (string.IsNullOrWhiteSpace(value))
+            return false;
+
+        var normalized = value.Trim().ToLowerInvariant();
+        switch (normalized)
+        {
+            case "none":
+                result = MessageLevel.None;
+                return true;
+            case "info":
+                result = MessageLevel.Info;
+                return true;
+            case "warn":
+            case "warning":
+                result = MessageLevel.Warn;
+                return true;
+            case "error":
+                result = MessageLevel.Error;
+                return true;
+            default:
+                return false;
+        }
+    }
+}
diff --git a/src/JD.Efcpt.Build.Tasks/ResolveSqlProjAndInputs.cs b/src/JD.Efcpt.Build.Tasks/ResolveSqlProjAndInputs.cs
index d012400..d9d938f 100644
--- a/src/JD.Efcpt.Build.Tasks/ResolveSqlProjAndInputs.cs
+++ b/src/JD.Efcpt.Build.Tasks/ResolveSqlProjAndInputs.cs
@@ -170,6 +170,14 @@ public sealed class ResolveSqlProjAndInputs : Task
     /// </value>
     public string DumpResolvedInputs { get; set; } = "false";
 
+    /// <summary>
+    /// Controls the severity level for SQL project or connection string auto-detection messages.
+    /// </summary>
+    /// <value>
+    /// Valid values: "None", "Info", "Warn", "Error". Defaults to "Info".
+    /// </value>
+    public string AutoDetectWarningLevel { get; set; } = "Info";
+
     /// <summary>
     /// Resolved full path to the SQL project to use.
     /// </summary>
@@ -384,7 +392,8 @@ private TargetContext DetermineMode(BuildLog log)
         if (string.IsNullOrWhiteSpace(connectionString))
             return null;
 
-        log.Info("No .sqlproj found. Using auto-discovered connection string.");
+        var level = MessageLevelHelpers.Parse(AutoDetectWarningLevel, MessageLevel.Info);
+        log.Log(level, "No .sqlproj found. Using auto-discovered connection string.", "EFCPT001");
         return new(true, connectionString, "");
     }
 
@@ -531,7 +540,9 @@ private string ResolveSqlProjWithValidation(BuildLog log)
             var fallback = TryResolveFromSolution();
             if (!string.IsNullOrWhiteSpace(fallback))
             {
-                log.Warn("No SQL project references found in project; using SQL project detected from solution: " + fallback);
+                var level = MessageLevelHelpers.Parse(AutoDetectWarningLevel, MessageLevel.Info);
+                var message = "No SQL project references found in project; using SQL project detected from solution: " + fallback;
+                log.Log(level, message, "EFCPT001");
                 sqlRefs.Add(fallback);
             }
         }
diff --git a/src/JD.Efcpt.Build/buildTransitive/JD.Efcpt.Build.props b/src/JD.Efcpt.Build/buildTransitive/JD.Efcpt.Build.props
index baebb6c..349905b 100644
--- a/src/JD.Efcpt.Build/buildTransitive/JD.Efcpt.Build.props
+++ b/src/JD.Efcpt.Build/buildTransitive/JD.Efcpt.Build.props
@@ -60,6 +60,18 @@
     <EfcptLogVerbosity Condition="'$(EfcptLogVerbosity)'==''">minimal</EfcptLogVerbosity>
     <EfcptDumpResolvedInputs Condition="'$(EfcptDumpResolvedInputs)'==''">false</EfcptDumpResolvedInputs>
 
+    <!--
+      Warning Level Configuration: Controls the severity of build-time diagnostic messages.
+      
+      EfcptAutoDetectWarningLevel: Severity for SQL project or connection string auto-detection.
+      Valid values: "None", "Info", "Warn", "Error". Defaults to "Info".
+      
+      EfcptSdkVersionWarningLevel: Severity for SDK version update notifications.
+      Valid values: "None", "Info", "Warn", "Error". Defaults to "Warn".
+    -->
+    <EfcptAutoDetectWarningLevel Condition="'$(EfcptAutoDetectWarningLevel)'==''">Info</EfcptAutoDetectWarningLevel>
+    <EfcptSdkVersionWarningLevel Condition="'$(EfcptSdkVersionWarningLevel)'==''">Warn</EfcptSdkVersionWarningLevel>
+
     <!--
       SDK Version Check: Opt-in feature to check for newer SDK versions on NuGet.
       Enable with EfcptCheckForUpdates=true. Results are cached to avoid network
diff --git a/src/JD.Efcpt.Build/buildTransitive/JD.Efcpt.Build.targets b/src/JD.Efcpt.Build/buildTransitive/JD.Efcpt.Build.targets
index 3482662..fbd0eee 100644
--- a/src/JD.Efcpt.Build/buildTransitive/JD.Efcpt.Build.targets
+++ b/src/JD.Efcpt.Build/buildTransitive/JD.Efcpt.Build.targets
@@ -109,7 +109,8 @@
         CurrentVersion="$(EfcptSdkVersion)"
         PackageId="JD.Efcpt.Sdk"
         CacheHours="$(EfcptUpdateCheckCacheHours)"
-        ForceCheck="$(EfcptForceUpdateCheck)">
+        ForceCheck="$(EfcptForceUpdateCheck)"
+        WarningLevel="$(EfcptSdkVersionWarningLevel)">
       <Output TaskParameter="LatestVersion" PropertyName="_EfcptLatestVersion" />
       <Output TaskParameter="UpdateAvailable" PropertyName="_EfcptUpdateAvailable" />
     </CheckSdkVersion>
@@ -136,7 +137,8 @@
         EfcptConnectionString="$(EfcptConnectionString)"
         EfcptAppSettings="$(EfcptAppSettings)"
         EfcptAppConfig="$(EfcptAppConfig)"
-        EfcptConnectionStringName="$(EfcptConnectionStringName)">
+        EfcptConnectionStringName="$(EfcptConnectionStringName)"
+        AutoDetectWarningLevel="$(EfcptAutoDetectWarningLevel)">
       <Output TaskParameter="SqlProjPath" PropertyName="_EfcptSqlProj" />
       <Output TaskParameter="ResolvedConfigPath" PropertyName="_EfcptResolvedConfig" />
       <Output TaskParameter="ResolvedRenamingPath" PropertyName="_EfcptResolvedRenaming" />
diff --git a/tests/JD.Efcpt.Build.Tests/CheckSdkVersionTests.cs b/tests/JD.Efcpt.Build.Tests/CheckSdkVersionTests.cs
index cec8fd4..69981a2 100644
--- a/tests/JD.Efcpt.Build.Tests/CheckSdkVersionTests.cs
+++ b/tests/JD.Efcpt.Build.Tests/CheckSdkVersionTests.cs
@@ -281,6 +281,143 @@ await Given("a cache with latest version 1.2.0", () =>
 
     #endregion
 
+    #region Warning Level Tests
+
+    [Scenario("Warning level None emits no message")]
+    [Fact]
+    public async Task Warning_level_none_emits_nothing()
+    {
+        await Given("a cache with latest version 2.0.0", () =>
+                CreateSetupWithCache("2.0.0", DateTime.UtcNow.AddMinutes(-5)))
+            .When("task executes with current version 1.0.0 and warning level None", s =>
+            {
+                var task = new TestableCheckSdkVersion
+                {
+                    BuildEngine = s.Engine,
+                    CurrentVersion = "1.0.0",
+                    WarningLevel = "None",
+                    CacheFilePath = s.CacheFile
+                };
+                var success = task.Execute();
+                return new TaskResult(s, task, success);
+            })
+            .Then("task succeeds", r => r.Success)
+            .And("no warning is logged", r => r.Setup.Engine.Warnings.Count == 0)
+            .And("no error is logged", r => r.Setup.Engine.Errors.Count == 0)
+            .And("update is available", r => r.Task.UpdateAvailable)
+            .Finally(r => r.Setup.Folder.Dispose())
+            .AssertPassed();
+    }
+
+    [Scenario("Warning level Info emits informational message")]
+    [Fact]
+    public async Task Warning_level_info_emits_info()
+    {
+        await Given("a cache with latest version 2.0.0", () =>
+                CreateSetupWithCache("2.0.0", DateTime.UtcNow.AddMinutes(-5)))
+            .When("task executes with current version 1.0.0 and warning level Info", s =>
+            {
+                var task = new TestableCheckSdkVersion
+                {
+                    BuildEngine = s.Engine,
+                    CurrentVersion = "1.0.0",
+                    WarningLevel = "Info",
+                    CacheFilePath = s.CacheFile
+                };
+                var success = task.Execute();
+                return new TaskResult(s, task, success);
+            })
+            .Then("task succeeds", r => r.Success)
+            .And("no warning is logged", r => r.Setup.Engine.Warnings.Count == 0)
+            .And("no error is logged", r => r.Setup.Engine.Errors.Count == 0)
+            .And("info message is logged", r => r.Setup.Engine.Messages.Count > 0)
+            .And("update is available", r => r.Task.UpdateAvailable)
+            .Finally(r => r.Setup.Folder.Dispose())
+            .AssertPassed();
+    }
+
+    [Scenario("Warning level Warn emits warning (default behavior)")]
+    [Fact]
+    public async Task Warning_level_warn_emits_warning()
+    {
+        await Given("a cache with latest version 2.0.0", () =>
+                CreateSetupWithCache("2.0.0", DateTime.UtcNow.AddMinutes(-5)))
+            .When("task executes with current version 1.0.0 and warning level Warn", s =>
+            {
+                var task = new TestableCheckSdkVersion
+                {
+                    BuildEngine = s.Engine,
+                    CurrentVersion = "1.0.0",
+                    WarningLevel = "Warn",
+                    CacheFilePath = s.CacheFile
+                };
+                var success = task.Execute();
+                return new TaskResult(s, task, success);
+            })
+            .Then("task succeeds", r => r.Success)
+            .And("warning is logged", r => r.Setup.Engine.Warnings.Count == 1)
+            .And("warning code is EFCPT002", r =>
+                r.Setup.Engine.Warnings[0].Code == "EFCPT002")
+            .And("update is available", r => r.Task.UpdateAvailable)
+            .Finally(r => r.Setup.Folder.Dispose())
+            .AssertPassed();
+    }
+
+    [Scenario("Warning level Error emits error")]
+    [Fact]
+    public async Task Warning_level_error_emits_error()
+    {
+        await Given("a cache with latest version 2.0.0", () =>
+                CreateSetupWithCache("2.0.0", DateTime.UtcNow.AddMinutes(-5)))
+            .When("task executes with current version 1.0.0 and warning level Error", s =>
+            {
+                var task = new TestableCheckSdkVersion
+                {
+                    BuildEngine = s.Engine,
+                    CurrentVersion = "1.0.0",
+                    WarningLevel = "Error",
+                    CacheFilePath = s.CacheFile
+                };
+                var success = task.Execute();
+                return new TaskResult(s, task, success);
+            })
+            .Then("task succeeds", r => r.Success)
+            .And("error is logged", r => r.Setup.Engine.Errors.Count == 1)
+            .And("error code is EFCPT002", r =>
+                r.Setup.Engine.Errors[0].Code == "EFCPT002")
+            .And("update is available", r => r.Task.UpdateAvailable)
+            .Finally(r => r.Setup.Folder.Dispose())
+            .AssertPassed();
+    }
+
+    [Scenario("Invalid warning level defaults to Warn")]
+    [Fact]
+    public async Task Invalid_warning_level_defaults_to_warn()
+    {
+        await Given("a cache with latest version 2.0.0", () =>
+                CreateSetupWithCache("2.0.0", DateTime.UtcNow.AddMinutes(-5)))
+            .When("task executes with current version 1.0.0 and invalid warning level", s =>
+            {
+                var task = new TestableCheckSdkVersion
+                {
+                    BuildEngine = s.Engine,
+                    CurrentVersion = "1.0.0",
+                    WarningLevel = "InvalidLevel",
+                    CacheFilePath = s.CacheFile
+                };
+                var success = task.Execute();
+                return new TaskResult(s, task, success);
+            })
+            .Then("task succeeds", r => r.Success)
+            .And("warning is logged (default behavior)", r => r.Setup.Engine.Warnings.Count == 1)
+            .And("warning code is EFCPT002", r =>
+                r.Setup.Engine.Warnings[0].Code == "EFCPT002")
+            .Finally(r => r.Setup.Folder.Dispose())
+            .AssertPassed();
+    }
+
+    #endregion
+
     /// <summary>
     /// Testable version of CheckSdkVersion that allows overriding the cache file path.
     /// </summary>
@@ -311,7 +448,8 @@ private bool ExecuteWithTestCache()
                     if (DateTime.UtcNow - cachedTime < TimeSpan.FromHours(CacheHours))
                     {
                         LatestVersion = cachedVersion;
-                        CheckAndWarnInternal();
+                        // Call the private helper method that checks versions and emits message if needed
+                        EmitVersionUpdateMessageIfNeeded();
                         return true;
                     }
                 }
@@ -328,6 +466,30 @@ private bool ExecuteWithTestCache()
             }
         }
 
+        /// <summary>
+        /// Checks versions and emits message if update is available.
+        /// Extracted for testability.
+        /// </summary>
+        private void EmitVersionUpdateMessageIfNeeded()
+        {
+            if (string.IsNullOrEmpty(LatestVersion) || string.IsNullOrEmpty(CurrentVersion))
+                return;
+
+            if (TryParseVersion(CurrentVersion, out var current) &&
+                TryParseVersion(LatestVersion, out var latest) &&
+                latest > current)
+            {
+                UpdateAvailable = true;
+                EmitVersionUpdateMessage();
+            }
+        }
+
+        private static bool TryParseVersion(string versionString, out Version version)
+        {
+            var cleanVersion = versionString.Split('-')[0];
+            return Version.TryParse(cleanVersion, out version!);
+        }
+
         private bool TryReadTestCache(out string version, out DateTime cacheTime)
         {
             version = "";
@@ -349,35 +511,5 @@ private bool TryReadTestCache(out string version, out DateTime cacheTime)
                 return false;
             }
         }
-
-        private void CheckAndWarnInternal()
-        {
-            if (string.IsNullOrEmpty(LatestVersion) || string.IsNullOrEmpty(CurrentVersion))
-                return;
-
-            if (TryParseVersionInternal(CurrentVersion, out var current) &&
-                TryParseVersionInternal(LatestVersion, out var latest) &&
-                latest > current)
-            {
-                UpdateAvailable = true;
-                Log.LogWarning(
-                    subcategory: null,
-                    warningCode: "EFCPT002",
-                    helpKeyword: null,
-                    file: null,
-                    lineNumber: 0,
-                    columnNumber: 0,
-                    endLineNumber: 0,
-                    endColumnNumber: 0,
-                    message: $"A newer version of JD.Efcpt.Sdk is available: {LatestVersion} (current: {CurrentVersion}). " +
-                             $"Update your project's Sdk attribute or global.json to use the latest version.");
-            }
-        }
-
-        private static bool TryParseVersionInternal(string versionString, out Version version)
-        {
-            var cleanVersion = versionString.Split('-')[0];
-            return Version.TryParse(cleanVersion, out version!);
-        }
     }
 }
diff --git a/tests/JD.Efcpt.Build.Tests/MessageLevelHelpersTests.cs b/tests/JD.Efcpt.Build.Tests/MessageLevelHelpersTests.cs
new file mode 100644
index 0000000..4dab27b
--- /dev/null
+++ b/tests/JD.Efcpt.Build.Tests/MessageLevelHelpersTests.cs
@@ -0,0 +1,97 @@
+using JD.Efcpt.Build.Tasks;
+using TinyBDD;
+using TinyBDD.Xunit;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace JD.Efcpt.Build.Tests;
+
+/// <summary>
+/// Tests for the MessageLevelHelpers utility class.
+/// </summary>
+[Feature("MessageLevelHelpers: parse and validate message severity levels")]
+[Collection(nameof(AssemblySetup))]
+public sealed class MessageLevelHelpersTests(ITestOutputHelper output) : TinyBddXunitBase(output)
+{
+    [Scenario("Parse valid level names (case-insensitive)")]
+    [Theory]
+    [InlineData("None", MessageLevel.None)]
+    [InlineData("none", MessageLevel.None)]
+    [InlineData("NONE", MessageLevel.None)]
+    [InlineData("Info", MessageLevel.Info)]
+    [InlineData("info", MessageLevel.Info)]
+    [InlineData("INFO", MessageLevel.Info)]
+    [InlineData("Warn", MessageLevel.Warn)]
+    [InlineData("warn", MessageLevel.Warn)]
+    [InlineData("Warning", MessageLevel.Warn)]
+    [InlineData("warning", MessageLevel.Warn)]
+    [InlineData("Error", MessageLevel.Error)]
+    [InlineData("error", MessageLevel.Error)]
+    [InlineData("ERROR", MessageLevel.Error)]
+    public async Task Parse_valid_level_names(string input, MessageLevel expected)
+    {
+        await Given($"input string '{input}'", () => input)
+            .When("parsing with default fallback", s => MessageLevelHelpers.Parse(s, MessageLevel.Info))
+            .Then("returns expected level", result => result == expected)
+            .AssertPassed();
+    }
+
+    [Scenario("Parse invalid level returns default")]
+    [Theory]
+    [InlineData("invalid", MessageLevel.Info)]
+    [InlineData("unknown", MessageLevel.Warn)]
+    [InlineData("", MessageLevel.Error)]
+    [InlineData(null, MessageLevel.None)]
+    [InlineData("   ", MessageLevel.Info)]
+    public async Task Parse_invalid_level_returns_default(string? input, MessageLevel defaultValue)
+    {
+        await Given($"input string '{input ?? "null"}'", () => input)
+            .When("parsing with default value", s => MessageLevelHelpers.Parse(s, defaultValue))
+            .Then("returns default value", result => result == defaultValue)
+            .AssertPassed();
+    }
+
+    [Scenario("TryParse valid level names")]
+    [Theory]
+    [InlineData("None", MessageLevel.None)]
+    [InlineData("Info", MessageLevel.Info)]
+    [InlineData("Warn", MessageLevel.Warn)]
+    [InlineData("Warning", MessageLevel.Warn)]
+    [InlineData("Error", MessageLevel.Error)]
+    public async Task TryParse_valid_level_names(string input, MessageLevel expected)
+    {
+        await Given($"input string '{input}'", () => input)
+            .When("trying to parse", s => MessageLevelHelpers.TryParse(s, out var result) ? (true, result) : (false, MessageLevel.None))
+            .Then("succeeds", r => r.Item1)
+            .And("returns expected level", r => r.Item2 == expected)
+            .AssertPassed();
+    }
+
+    [Scenario("TryParse invalid level fails")]
+    [Theory]
+    [InlineData("invalid")]
+    [InlineData("unknown")]
+    [InlineData("")]
+    [InlineData(null)]
+    [InlineData("   ")]
+    public async Task TryParse_invalid_level_fails(string? input)
+    {
+        await Given($"input string '{input ?? "null"}'", () => input)
+            .When("trying to parse", s => MessageLevelHelpers.TryParse(s, out var result) ? (true, result) : (false, MessageLevel.None))
+            .Then("fails", r => !r.Item1)
+            .AssertPassed();
+    }
+
+    [Scenario("Parse handles whitespace")]
+    [Theory]
+    [InlineData("  None  ", MessageLevel.None)]
+    [InlineData("\tInfo\t", MessageLevel.Info)]
+    [InlineData(" Warn ", MessageLevel.Warn)]
+    public async Task Parse_handles_whitespace(string input, MessageLevel expected)
+    {
+        await Given($"input with whitespace '{input}'", () => input)
+            .When("parsing", s => MessageLevelHelpers.Parse(s, MessageLevel.Info))
+            .Then("returns expected level", result => result == expected)
+            .AssertPassed();
+    }
+}
diff --git a/tests/JD.Efcpt.Build.Tests/ResolveSqlProjAndInputsTests.cs b/tests/JD.Efcpt.Build.Tests/ResolveSqlProjAndInputsTests.cs
index 71c3c8c..7bdbb5d 100644
--- a/tests/JD.Efcpt.Build.Tests/ResolveSqlProjAndInputsTests.cs
+++ b/tests/JD.Efcpt.Build.Tests/ResolveSqlProjAndInputsTests.cs
@@ -278,7 +278,7 @@ await Given("project with solution-level SQL project", SetupSolutionScanInputs)
             .When("execute task with solution scan", ExecuteTaskSolutionScan)
             .Then("task succeeds", r => r.Success)
             .And("sql project path resolved", r => r.Task.SqlProjPath == Path.GetFullPath(r.Setup.SqlProj))
-            .And("warning logged", r => r.Setup.Engine.Warnings.Count == 1)
+            .And("info message logged", r => r.Setup.Engine.Messages.Count > 0)
             .Finally(r => r.Setup.Folder.Dispose())
             .AssertPassed();
     }
@@ -291,7 +291,7 @@ await Given("project with slnx SQL project", SetupSlnxScanInputs)
             .When("execute task with solution scan", ExecuteTaskSolutionScan)
             .Then("task succeeds", r => r.Success)
             .And("sql project path resolved", r => r.Task.SqlProjPath == Path.GetFullPath(r.Setup.SqlProj))
-            .And("warning logged", r => r.Setup.Engine.Warnings.Count == 1)
+            .And("info message logged", r => r.Setup.Engine.Messages.Count > 0)
             .Finally(r => r.Setup.Folder.Dispose())
             .AssertPassed();
     }