diff --git a/docs/iseberg.md b/docs/iseberg.md
index a651a6a..08ffdf0 100644
--- a/docs/iseberg.md
+++ b/docs/iseberg.md
@@ -92,11 +92,14 @@ PowerShell 7.4.0 through 7.4.5 cannot load the patched SDK's
 `System.Management.Automation` 7.4.6.500 assembly reference and are rejected up front.
 The child architecture does not need to match DT. Make `pwsh` available on PATH, or set
 `DT_ISEBERG_PSHOME` to its absolute installation directory before starting DT.
-DT checks its version and child-runtime compatibility. A short noninteractive
-`pwsh -NoProfile` probe discovers and validates the installation. DT then starts
-an owned `pwsh -NoLogo -NoProfile` child and imports the absolute path to its
-`Devolutions.Iseberg.PowerShell.dll` binary module. The module creates a custom-host execution
-runspace; it does not replace PowerShell's bootstrap console host.
+DT checks its version and child-runtime compatibility without a separate probe
+process: DT starts an owned `pwsh -NoLogo -NoProfile` child whose bootstrap first
+prints one line describing `$PSHOME`, its version, .NET runtime and architecture,
+then imports the absolute path to its `Devolutions.Iseberg.PowerShell.dll` binary
+module. DT validates that description while the module loads, so an installation
+too old to load the module still fails with the version it found. The module
+creates a custom-host execution runspace; it does not replace PowerShell's
+bootstrap console host.
 
 Parser analysis, completion, execution, host input, debugging and portable
 `$psISE` proxies run in that child. The NativeAOT parent uses typed, source-generated
diff --git a/scripts/Install-IsebergTestPowerShell.ps1 b/scripts/Install-IsebergTestPowerShell.ps1
index 5b6253c..42a7c8e 100644
--- a/scripts/Install-IsebergTestPowerShell.ps1
+++ b/scripts/Install-IsebergTestPowerShell.ps1
@@ -55,7 +55,9 @@ if (-not (Test-Path -LiteralPath $executable -PathType Leaf)) {
     New-Item -ItemType Directory -Path $engineDirectory -Force | Out-Null
     $asset = if ($IsWindows) { "PowerShell-$version-$rid.zip" } else { "powershell-$version-$rid.tar.gz" }
     $archive = Join-Path $root $asset
-    Invoke-WebRequest "https://github.com/PowerShell/PowerShell/releases/download/v$version/$asset" -OutFile $archive
+    # GitHub release downloads intermittently return 5xx pages; retry before failing the job.
+    Invoke-WebRequest "https://github.com/PowerShell/PowerShell/releases/download/v$version/$asset" -OutFile $archive `
+        -MaximumRetryCount 4 -RetryIntervalSec 15
     if ((Get-FileHash -LiteralPath $archive -Algorithm SHA256).Hash -ne $hashes[$rid]) {
         throw "PowerShell test runtime checksum mismatch: $archive"
     }
diff --git a/src/Devolutions.Terminal.App/Connections/PowerShellInstallation.cs b/src/Devolutions.Terminal.App/Connections/PowerShellInstallation.cs
deleted file mode 100644
index 50e3900..0000000
--- a/src/Devolutions.Terminal.App/Connections/PowerShellInstallation.cs
+++ /dev/null
@@ -1,92 +0,0 @@
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-using System.Text.Json;
-using System.Text.Json.Serialization;
-using Iseberg.Core;
-
-namespace Devolutions.Terminal.App.Connections;
-
-public sealed record PowerShellInstallation(string Home, string Version, string RuntimeVersion, string Architecture)
-{
-    public const string HomeVariable = "DT_ISEBERG_PSHOME";
-    public static Version MinimumVersion => PowerShellCompatibility.MinimumVersion;
-
-    public static PowerShellInstallation Find()
-    {
-        var home = Environment.GetEnvironmentVariable(HomeVariable);
-        var executable = OperatingSystem.IsWindows() ? "pwsh.exe" : "pwsh";
-        var start = new ProcessStartInfo(string.IsNullOrWhiteSpace(home) ? executable : Path.Combine(home, executable))
-        {
-            UseShellExecute = false,
-            CreateNoWindow = true,
-            RedirectStandardOutput = true,
-            RedirectStandardError = true
-        };
-        foreach (var argument in new[]
-        {
-            "-NoLogo", "-NoProfile", "-NonInteractive", "-Command",
-            """
-            [pscustomobject]@{
-                Home = $PSHOME
-                Version = $PSVersionTable.PSVersion.ToString()
-                RuntimeVersion = [Environment]::Version.ToString()
-                Architecture = [System.Runtime.InteropServices.RuntimeInformation]::ProcessArchitecture.ToString()
-            } | ConvertTo-Json -Compress
-            """
-        })
-            start.ArgumentList.Add(argument);
-
-        using var process = new Process { StartInfo = start };
-        try { process.Start(); }
-        catch (Win32Exception exception)
-        {
-            throw new InvalidOperationException(
-                $"Install PowerShell {PowerShellCompatibility.SupportedVersions} on PATH, or set {HomeVariable} to its installation directory.", exception);
-        }
-        var output = process.StandardOutput.ReadToEndAsync();
-        var error = process.StandardError.ReadToEndAsync();
-        if (!process.WaitForExit(15000))
-        {
-            process.Kill(entireProcessTree: true);
-            process.WaitForExit();
-            throw new InvalidOperationException("PowerShell did not respond to the installation check within 15 seconds.");
-        }
-        if (process.ExitCode != 0)
-            throw new InvalidOperationException($"PowerShell installation check failed: {error.GetAwaiter().GetResult().Trim()}");
-        PowerShellInstallation installation;
-        try
-        {
-            installation = JsonSerializer.Deserialize(output.GetAwaiter().GetResult(),
-                PowerShellInstallationJsonContext.Default.PowerShellInstallation)
-                ?? throw new InvalidOperationException("PowerShell returned an empty installation description.");
-        }
-        catch (JsonException exception)
-        {
-            throw new InvalidOperationException("PowerShell returned an invalid installation description.", exception);
-        }
-        installation.Validate();
-        return installation;
-    }
-
-    public void Validate()
-    {
-        if (!System.Version.TryParse(Version, out var version) ||
-            !PowerShellCompatibility.IsSupportedVersion(version))
-            throw new InvalidOperationException($"Iseberg requires PowerShell {PowerShellCompatibility.SupportedVersions}; found {Version}.");
-        if (!System.Version.TryParse(RuntimeVersion, out var runtime) ||
-            !PowerShellCompatibility.IsSupportedRuntime(version, runtime))
-            throw new InvalidOperationException($"PowerShell {version.Major}.{version.Minor} requires its bundled .NET {PowerShellCompatibility.RuntimeMajor(version)} runtime; found {RuntimeVersion}.");
-        if (!Enum.TryParse<System.Runtime.InteropServices.Architecture>(Architecture, out var architecture) ||
-            !Enum.IsDefined(architecture))
-            throw new InvalidOperationException($"PowerShell returned an unknown process architecture: {Architecture}.");
-        if (string.IsNullOrWhiteSpace(Home) || !Path.IsPathFullyQualified(Home) ||
-            !File.Exists(Path.Combine(Home, "System.Management.Automation.dll")) ||
-            !File.Exists(Path.Combine(Home, "pwsh.dll")))
-            throw new InvalidOperationException($"PowerShell installation is incomplete: {Home}.");
-    }
-
-}
-
-[JsonSerializable(typeof(PowerShellInstallation))]
-internal sealed partial class PowerShellInstallationJsonContext : JsonSerializerContext;
diff --git a/src/Devolutions.Terminal.App/Connections/PowerShellIseRuntime.cs b/src/Devolutions.Terminal.App/Connections/PowerShellIseRuntime.cs
deleted file mode 100644
index 0ae80fc..0000000
--- a/src/Devolutions.Terminal.App/Connections/PowerShellIseRuntime.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-#if POWERSHELL_ISE
-namespace Devolutions.Terminal.App.Connections;
-
-public static class PowerShellIseRuntime
-{
-    private static readonly object Sync = new();
-    private static Task? _initialization;
-
-    public static Task InitializeAsync()
-    {
-        lock (Sync)
-        {
-            // A failed discovery can be retried after the user installs PowerShell or changes the override.
-            if (_initialization is null || _initialization.IsFaulted)
-                _initialization = Task.Run(() => PowerShellInstallation.Find());
-            return _initialization;
-        }
-    }
-}
-#endif
diff --git a/src/Devolutions.Terminal.App/Devolutions.Terminal.App.csproj b/src/Devolutions.Terminal.App/Devolutions.Terminal.App.csproj
index 5c6bdb8..a58d617 100644
--- a/src/Devolutions.Terminal.App/Devolutions.Terminal.App.csproj
+++ b/src/Devolutions.Terminal.App/Devolutions.Terminal.App.csproj
@@ -8,9 +8,6 @@
   <PropertyGroup Condition="'$(EnablePowerShellIse)' == 'true'">
     <DefineConstants>$(DefineConstants);POWERSHELL_ISE</DefineConstants>
   </PropertyGroup>
-  <ItemGroup Condition="'$(EnablePowerShellIse)' != 'true'">
-    <Compile Remove="Connections\PowerShellInstallation.cs" />
-  </ItemGroup>
 
   <ItemGroup>
     <PackageReference Include="Avalonia" />
diff --git a/src/Devolutions.Terminal.App/Views/MainWindow.PowerShellIse.cs b/src/Devolutions.Terminal.App/Views/MainWindow.PowerShellIse.cs
index ab794a4..3a36f9c 100644
--- a/src/Devolutions.Terminal.App/Views/MainWindow.PowerShellIse.cs
+++ b/src/Devolutions.Terminal.App/Views/MainWindow.PowerShellIse.cs
@@ -23,7 +23,7 @@ private async Task<TerminalTab> CreatePowerShellIseTabAsync(
 #if POWERSHELL_ISE
         if (_isClosed || _closeConfirmationPending || _applicationClosePending)
             throw new InvalidOperationException("Cannot open Iseberg while DT is closing.");
-        await PowerShellIseRuntime.InitializeAsync().ConfigureAwait(true);
+        // The session's own pwsh reports and validates its installation during startup.
         return await CreatePowerShellIseTabCoreAsync(profile, restored, regenerateIdentities).ConfigureAwait(true);
 #else
         await Task.CompletedTask;
diff --git a/src/Devolutions.Terminal.App/Views/MainWindow.axaml.cs b/src/Devolutions.Terminal.App/Views/MainWindow.axaml.cs
index 35cbec9..a158068 100644
--- a/src/Devolutions.Terminal.App/Views/MainWindow.axaml.cs
+++ b/src/Devolutions.Terminal.App/Views/MainWindow.axaml.cs
@@ -1801,6 +1801,16 @@ private void BeginTabDrag(TerminalTab tab, Control control, PointerPressedEventA
             return;
         }
 
+        // A press on a nested button (the close X) belongs to that button. This
+        // handler also sees handled events, so capturing here would steal the
+        // nested button's pointer capture and it would never raise Click.
+        if (e.Source is Visual source &&
+            Avalonia.VisualTree.VisualExtensions.FindAncestorOfType<Button>(source, includeSelf: true) is { } pressed &&
+            !ReferenceEquals(pressed, control))
+        {
+            return;
+        }
+
         _draggedTab = tab;
         _dragStart = e.GetPosition(TabStrip);
         e.Pointer.Capture(control);
diff --git a/src/Devolutions.Terminal.Ise/Iseberg.Core/PowerShellInstallation.cs b/src/Devolutions.Terminal.Ise/Iseberg.Core/PowerShellInstallation.cs
new file mode 100644
index 0000000..ee83ff1
--- /dev/null
+++ b/src/Devolutions.Terminal.Ise/Iseberg.Core/PowerShellInstallation.cs
@@ -0,0 +1,61 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Iseberg.Core;
+
+/// <summary>What the bridge's pwsh reports about itself before it loads the bridge module.</summary>
+public sealed record PowerShellInstallation(string Home, string Version, string RuntimeVersion, string Architecture)
+{
+    public const string HomeVariable = "DT_ISEBERG_PSHOME";
+    /// <summary>Prefix of the single stdout line written by <see cref="ReportScript"/>.</summary>
+    public const string ReportPrefix = "DT-ISEBERG-INSTALLATION:";
+    public static Version MinimumVersion => PowerShellCompatibility.MinimumVersion;
+
+    /// <summary>
+    /// Runs first in the bridge bootstrap, before the net8.0 module is imported, so a pwsh that cannot
+    /// load the module still describes itself and fails with an actionable message.
+    /// </summary>
+    public static string ReportScript { get; } =
+        "[Console]::Out.WriteLine('" + ReportPrefix + "' + ([pscustomobject]@{ " +
+        "Home = $PSHOME; " +
+        "Version = $PSVersionTable.PSVersion.ToString(); " +
+        "RuntimeVersion = [Environment]::Version.ToString(); " +
+        "Architecture = [System.Runtime.InteropServices.RuntimeInformation]::ProcessArchitecture.ToString() " +
+        "} | ConvertTo-Json -Compress))";
+
+    public static string MissingMessage =>
+        $"Install PowerShell {PowerShellCompatibility.SupportedVersions} on PATH, or set {HomeVariable} to its installation directory.";
+
+    public static PowerShellInstallation Parse(string json)
+    {
+        try
+        {
+            return JsonSerializer.Deserialize(json, PowerShellInstallationJsonContext.Default.PowerShellInstallation)
+                ?? throw new InvalidOperationException("PowerShell returned an empty installation description.");
+        }
+        catch (JsonException exception)
+        {
+            throw new InvalidOperationException("PowerShell returned an invalid installation description.", exception);
+        }
+    }
+
+    public void Validate()
+    {
+        if (!System.Version.TryParse(Version, out var version) ||
+            !PowerShellCompatibility.IsSupportedVersion(version))
+            throw new InvalidOperationException($"Iseberg requires PowerShell {PowerShellCompatibility.SupportedVersions}; found {Version}.");
+        if (!System.Version.TryParse(RuntimeVersion, out var runtime) ||
+            !PowerShellCompatibility.IsSupportedRuntime(version, runtime))
+            throw new InvalidOperationException($"PowerShell {version.Major}.{version.Minor} requires its bundled .NET {PowerShellCompatibility.RuntimeMajor(version)} runtime; found {RuntimeVersion}.");
+        if (!Enum.TryParse<System.Runtime.InteropServices.Architecture>(Architecture, out var architecture) ||
+            !Enum.IsDefined(architecture))
+            throw new InvalidOperationException($"PowerShell returned an unknown process architecture: {Architecture}.");
+        if (string.IsNullOrWhiteSpace(Home) || !Path.IsPathFullyQualified(Home) ||
+            !File.Exists(Path.Combine(Home, "System.Management.Automation.dll")) ||
+            !File.Exists(Path.Combine(Home, "pwsh.dll")))
+            throw new InvalidOperationException($"PowerShell installation is incomplete: {Home}.");
+    }
+}
+
+[JsonSerializable(typeof(PowerShellInstallation))]
+internal sealed partial class PowerShellInstallationJsonContext : JsonSerializerContext;
diff --git a/src/Devolutions.Terminal.Ise/Iseberg.Core/PowerShellSession.cs b/src/Devolutions.Terminal.Ise/Iseberg.Core/PowerShellSession.cs
index 3c45ed7..b69ed5b 100644
--- a/src/Devolutions.Terminal.Ise/Iseberg.Core/PowerShellSession.cs
+++ b/src/Devolutions.Terminal.Ise/Iseberg.Core/PowerShellSession.cs
@@ -13,6 +13,7 @@ public sealed class PowerShellSession : IAsyncDisposable
     private readonly object sync = new();
     private readonly CancellationTokenSource lifetime = new();
     private readonly StringBuilder diagnostics = new();
+    private readonly TaskCompletionSource<string?> installationReport = new(TaskCreationOptions.RunContinuationsAsynchronously);
     private BridgeConnection? connection;
     private NamedPipeServerStream? pipe;
     private Process? child;
@@ -75,7 +76,9 @@ public async Task InitializeAsync()
         {
             if (!Path.IsPathFullyQualified(ModulePath) || !File.Exists(ModulePath))
                 throw new FileNotFoundException("The DT-owned Iseberg PowerShell bridge module is missing.", ModulePath);
-            var executable = ExecutablePath ?? PowerShellProcessDiscovery.FindExecutable();
+            string executable;
+            try { executable = ExecutablePath ?? PowerShellProcessDiscovery.FindExecutable(); }
+            catch (FileNotFoundException exception) { throw new InvalidOperationException(PowerShellInstallation.MissingMessage, exception); }
             var endpoint = "dt-iseberg-" + Guid.NewGuid().ToString("N");
             var authentication = Convert.ToHexString(RandomNumberGenerator.GetBytes(32));
             var challenge = Convert.ToHexString(RandomNumberGenerator.GetBytes(32));
@@ -87,19 +90,22 @@ public async Task InitializeAsync()
                 RedirectStandardInput = true, RedirectStandardOutput = true, RedirectStandardError = true
             };
             using var parent = Process.GetCurrentProcess();
-            var bootstrap = "Import-Module -Name '" + ModulePath.Replace("'", "''") +
+            var bootstrap = PowerShellInstallation.ReportScript + "; Import-Module -Name '" + ModulePath.Replace("'", "''") +
                 "' -ErrorAction Stop; Start-IsebergBridge -PipeName '" + endpoint +
                 "' -ParentProcessId " + Environment.ProcessId +
                 " -ParentStartTimeUtcTicks " + parent.StartTime.ToUniversalTime().Ticks;
             foreach (var argument in new[] { "-NoLogo", "-NoProfile", "-NonInteractive", "-Command", bootstrap })
                 start.ArgumentList.Add(argument);
             start.Environment[IseBridgeProtocol.AuthenticationEnvironment] = authentication;
-            child = Process.Start(start) ?? throw new InvalidOperationException("The PowerShell bridge did not start.");
+            try { child = Process.Start(start) ?? throw new InvalidOperationException("The PowerShell bridge did not start."); }
+            catch (System.ComponentModel.Win32Exception exception) { throw new InvalidOperationException(PowerShellInstallation.MissingMessage, exception); }
             // Native programs inherit this stdin: give them end-of-input rather than DT's (or a hidden) console.
             child.StandardInput.Close();
-            outputDrain = DrainAsync(child.StandardOutput);
+            outputDrain = DrainOutputAsync(child.StandardOutput);
             errorDrain = DrainAsync(child.StandardError);
             exitObservation = ObserveExitAsync(child);
+            // The bootstrap describes pwsh before importing the module, so this overlaps the module load.
+            (await ReadInstallationAsync().ConfigureAwait(false)).Validate();
             await pipe.WaitForConnectionAsync(lifetime.Token).WaitAsync(TimeSpan.FromSeconds(30), lifetime.Token).ConfigureAwait(false);
             connection = new(pipe) { Request = HandleRequestAsync, Event = HandleEvent };
             connection.Disconnected += OnDisconnected;
@@ -399,6 +405,37 @@ private async Task<JsonElement> HandleRequestAsync(string operation, JsonElement
         }
     }
 
+    private async Task<PowerShellInstallation> ReadInstallationAsync()
+    {
+        using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(15));
+        string? report;
+        try { report = await installationReport.Task.WaitAsync(timeout.Token).ConfigureAwait(false); }
+        catch (OperationCanceledException) when (timeout.IsCancellationRequested)
+        {
+            throw new InvalidOperationException("PowerShell did not respond to the installation check within 15 seconds.");
+        }
+        // Without a report, pwsh failed before it could describe itself.
+        return report is null
+            ? throw new InvalidOperationException($"PowerShell installation check failed: {StartupDiagnostics()}")
+            : PowerShellInstallation.Parse(report);
+    }
+    private async Task DrainOutputAsync(StreamReader reader)
+    {
+        try
+        {
+            while (await reader.ReadLineAsync(lifetime.Token).ConfigureAwait(false) is { } line)
+            {
+                // The bootstrap's installation report is the only stdout line with meaning.
+                if (!installationReport.Task.IsCompleted &&
+                    line.StartsWith(PowerShellInstallation.ReportPrefix, StringComparison.Ordinal))
+                    installationReport.TrySetResult(line[PowerShellInstallation.ReportPrefix.Length..]);
+                else
+                    AppendDiagnostics(line + Environment.NewLine);
+            }
+        }
+        catch (Exception exception) when (exception is IOException or OperationCanceledException or ObjectDisposedException) { }
+        finally { installationReport.TrySetResult(null); }
+    }
     private async Task DrainAsync(StreamReader reader)
     {
         try
@@ -406,17 +443,19 @@ private async Task DrainAsync(StreamReader reader)
             var buffer = new char[4096];
             int read;
             while ((read = await reader.ReadAsync(buffer, lifetime.Token).ConfigureAwait(false)) != 0)
-            {
-                // Raw stdout/stderr is diagnostics, never a second script-output transport.
-                lock (sync)
-                {
-                    if (diagnostics.Length + read > 16384) diagnostics.Remove(0, Math.Min(diagnostics.Length, read));
-                    diagnostics.Append(buffer, 0, read);
-                }
-            }
+                AppendDiagnostics(buffer.AsSpan(0, read));
         }
         catch (Exception exception) when (exception is IOException or OperationCanceledException or ObjectDisposedException) { }
     }
+    // Raw stdout/stderr is diagnostics, never a second script-output transport.
+    private void AppendDiagnostics(ReadOnlySpan<char> text)
+    {
+        lock (sync)
+        {
+            if (diagnostics.Length + text.Length > 16384) diagnostics.Remove(0, Math.Min(diagnostics.Length, text.Length));
+            diagnostics.Append(text);
+        }
+    }
     private async Task ObserveExitAsync(Process process)
     {
         await process.WaitForExitAsync().ConfigureAwait(false);
diff --git a/src/Devolutions.Terminal.Ise/Iseberg.PowerShell/ManagedPowerShellSession.Bridge.cs b/src/Devolutions.Terminal.Ise/Iseberg.PowerShell/ManagedPowerShellSession.Bridge.cs
index a88d93e..110b3f8 100644
--- a/src/Devolutions.Terminal.Ise/Iseberg.PowerShell/ManagedPowerShellSession.Bridge.cs
+++ b/src/Devolutions.Terminal.Ise/Iseberg.PowerShell/ManagedPowerShellSession.Bridge.cs
@@ -8,6 +8,13 @@ public sealed partial class ManagedPowerShellSession
     private static Iseberg.Core.CompletionResult ToCompletion(System.Management.Automation.CompletionResult result) =>
         new(result.CompletionText, result.ListItemText, (Iseberg.Core.CompletionResultType)(long)result.ResultType, result.ToolTip);
 
+    // PowerShell reports ReplacementIndex/Length of -1 when it found nothing to replace
+    // (e.g. empty or whitespace-only input); anchor that as an empty span at the cursor.
+    private static CompletionSet ToCompletionSet(CommandCompletion result, int cursor) =>
+        result.ReplacementIndex < 0 || result.ReplacementLength < 0
+            ? new(cursor, 0, result.CompletionMatches.Select(ToCompletion).ToArray())
+            : new(result.ReplacementIndex, result.ReplacementLength, result.CompletionMatches.Select(ToCompletion).ToArray());
+
     internal SessionStatus Status() => new(State, Prompt, Version, LocalRunspaceId, RunspaceId,
         IsRunspacePushed, IsRemote, RemoteComputerName, IsDebuggerPaused, IsNestedPromptActive, NestedPrompt);
 
diff --git a/src/Devolutions.Terminal.Ise/Iseberg.PowerShell/ManagedPowerShellSession.Debugger.cs b/src/Devolutions.Terminal.Ise/Iseberg.PowerShell/ManagedPowerShellSession.Debugger.cs
index bfc221f..dac2e5d 100644
--- a/src/Devolutions.Terminal.Ise/Iseberg.PowerShell/ManagedPowerShellSession.Debugger.cs
+++ b/src/Devolutions.Terminal.Ise/Iseberg.PowerShell/ManagedPowerShellSession.Debugger.cs
@@ -245,7 +245,7 @@ private Task<CompletionSet> CompletePausedAsync(string text, int cursor, Cancell
             var command = new PSCommand().AddCommand("TabExpansion2").AddArgument(text).AddArgument(cursor);
             var result = Inspect(command).Select(value => value.BaseObject).OfType<CommandCompletion>().FirstOrDefault()
                 ?? throw new InvalidOperationException("PowerShell completion did not return a completion result.");
-            return new CompletionSet(result.ReplacementIndex, result.ReplacementLength, result.CompletionMatches.Select(ToCompletion).ToArray());
+            return ToCompletionSet(result, cursor);
         }, cancellationToken);
 
     public Task<IReadOnlyList<DebugBreakpoint>> GetBreakpointsAsync() =>
diff --git a/src/Devolutions.Terminal.Ise/Iseberg.PowerShell/ManagedPowerShellSession.cs b/src/Devolutions.Terminal.Ise/Iseberg.PowerShell/ManagedPowerShellSession.cs
index 5088197..62265c2 100644
--- a/src/Devolutions.Terminal.Ise/Iseberg.PowerShell/ManagedPowerShellSession.cs
+++ b/src/Devolutions.Terminal.Ise/Iseberg.PowerShell/ManagedPowerShellSession.cs
@@ -302,15 +302,10 @@ public Task SetBreakpointsAsync(string path, IEnumerable<int> lines) =>
 
     /// <summary>Completes text at a zero-based cursor offset in the current runspace or paused debugger context.</summary>
     public Task<CompletionSet> CompleteAsync(string text, int cursor, CancellationToken cancellationToken = default) =>
-        State == SessionState.NestedPrompt ? NestedQueryAsync(shell =>
-        {
-            var result = CommandCompletion.CompleteInput(text, cursor, null, shell);
-            return new CompletionSet(result.ReplacementIndex, result.ReplacementLength, result.CompletionMatches.Select(ToCompletion).ToArray());
-        }, cancellationToken) : State == SessionState.Debugging ? CompletePausedAsync(text, cursor, cancellationToken) : QueryAsync(shell =>
-        {
-            var result = CommandCompletion.CompleteInput(text, cursor, null, shell);
-            return new CompletionSet(result.ReplacementIndex, result.ReplacementLength, result.CompletionMatches.Select(ToCompletion).ToArray());
-        }, cancellationToken);
+        State == SessionState.NestedPrompt
+            ? NestedQueryAsync(shell => ToCompletionSet(CommandCompletion.CompleteInput(text, cursor, null, shell), cursor), cancellationToken)
+            : State == SessionState.Debugging ? CompletePausedAsync(text, cursor, cancellationToken)
+            : QueryAsync(shell => ToCompletionSet(CommandCompletion.CompleteInput(text, cursor, null, shell), cursor), cancellationToken);
 
     public Task<IReadOnlyList<CommandDescription>> GetCommandsAsync(CancellationToken cancellationToken = default) =>
         QueryAsync<IReadOnlyList<CommandDescription>>(shell =>
diff --git a/src/Devolutions.Terminal/App.axaml.cs b/src/Devolutions.Terminal/App.axaml.cs
index 5952104..49f8227 100644
--- a/src/Devolutions.Terminal/App.axaml.cs
+++ b/src/Devolutions.Terminal/App.axaml.cs
@@ -23,9 +23,6 @@ public partial class TerminalApp : Application
     public override void Initialize()
     {
         AvaloniaXamlLoader.Load(this);
-#if DEBUG
-        this.AttachDeveloperTools();
-#endif
     }
 
     public override void OnFrameworkInitializationCompleted()
diff --git a/tests/Devolutions.Terminal.App.Tests/PortableIseInstallationTests.cs b/tests/Devolutions.Terminal.App.Tests/PortableIseInstallationTests.cs
index 75230bd..6929fbd 100644
--- a/tests/Devolutions.Terminal.App.Tests/PortableIseInstallationTests.cs
+++ b/tests/Devolutions.Terminal.App.Tests/PortableIseInstallationTests.cs
@@ -1,4 +1,4 @@
-using Devolutions.Terminal.App.Connections;
+using System.Diagnostics;
 using Iseberg.Core;
 using Xunit;
 
@@ -94,10 +94,100 @@ public void RelativeInstallationHomeIsRejected()
         Assert.Contains("incomplete", error.Message);
     }
 
+    [Fact]
+    public async Task ReportScriptOutputFromInstalledPowerShellParsesAndValidates()
+    {
+        var info = new ProcessStartInfo(PowerShellProcessDiscovery.FindExecutable())
+        {
+            UseShellExecute = false, RedirectStandardOutput = true, RedirectStandardError = true, CreateNoWindow = true
+        };
+        foreach (var argument in new[] { "-NoLogo", "-NoProfile", "-NonInteractive", "-Command", PowerShellInstallation.ReportScript })
+            info.ArgumentList.Add(argument);
+        using var process = Process.Start(info)!;
+        var output = await process.StandardOutput.ReadToEndAsync().WaitAsync(TimeSpan.FromSeconds(30));
+        await process.WaitForExitAsync().WaitAsync(TimeSpan.FromSeconds(30));
+
+        var report = Assert.Single(output.Split('\n', StringSplitOptions.TrimEntries),
+            line => line.StartsWith(PowerShellInstallation.ReportPrefix, StringComparison.Ordinal));
+        var installation = PowerShellInstallation.Parse(report[PowerShellInstallation.ReportPrefix.Length..]);
+        installation.Validate();
+        Assert.True(PowerShellProcessDiscovery.IsSupportedVersion(Version.Parse(installation.Version)));
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData("{not json")]
+    [InlineData("null")]
+    public void MalformedReportIsRejected(string report)
+    {
+        var error = Assert.Throws<InvalidOperationException>(() => PowerShellInstallation.Parse(report));
+        Assert.Contains("installation description", error.Message);
+    }
+
+    [Fact]
+    public async Task SessionRejectsUnsupportedPowerShellFromItsOwnReport()
+    {
+        // A pwsh too old to load the net8.0 bridge module must still fail with the version it found,
+        // not after the bridge pipe times out.
+        var report = PowerShellInstallation.ReportPrefix + "{\"Home\":\"" + home.Replace("\\", "\\\\", StringComparison.Ordinal) +
+            "\",\"Version\":\"7.3.0\",\"RuntimeVersion\":\"7.0.0\",\"Architecture\":\"X64\"}";
+        await using var session = new PowerShellSession { ExecutablePath = FakePowerShell("old-pwsh", stdout: report) };
+
+        var error = await Assert.ThrowsAsync<InvalidOperationException>(() =>
+            session.InitializeAsync().WaitAsync(TimeSpan.FromSeconds(20)));
+
+        Assert.Equal($"Iseberg requires PowerShell {PowerShellCompatibility.SupportedVersions}; found 7.3.0.", error.Message);
+        Assert.Equal(SessionState.Failed, session.State);
+    }
+
+    [Fact]
+    public async Task SessionReportsPowerShellThatExitsWithoutDescribingItself()
+    {
+        await using var session = new PowerShellSession { ExecutablePath = FakePowerShell("broken-pwsh", stdout: null) };
+
+        var error = await Assert.ThrowsAsync<InvalidOperationException>(() =>
+            session.InitializeAsync().WaitAsync(TimeSpan.FromSeconds(20)));
+
+        Assert.StartsWith("PowerShell installation check failed:", error.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task SessionReportsMissingPowerShellWithInstallGuidance()
+    {
+        await using var session = new PowerShellSession
+        {
+            ExecutablePath = Path.Combine(home, OperatingSystem.IsWindows() ? "missing-pwsh.exe" : "missing-pwsh")
+        };
+
+        var error = await Assert.ThrowsAsync<InvalidOperationException>(() =>
+            session.InitializeAsync().WaitAsync(TimeSpan.FromSeconds(20)));
+
+        Assert.Equal(PowerShellInstallation.MissingMessage, error.Message);
+        Assert.Contains(PowerShellInstallation.HomeVariable, error.Message);
+    }
+
+    // A stand-in for pwsh that ignores its arguments: it prints one stdout line (or nothing) and,
+    // when it printed one, stays alive like a bridge still loading its module.
+    private string FakePowerShell(string name, string? stdout)
+    {
+        if (OperatingSystem.IsWindows())
+        {
+            var script = Path.Combine(home, name + ".cmd");
+            File.WriteAllText(script, stdout is null
+                ? "@echo off\r\necho fake pwsh failed before reporting 1>&2\r\nexit /b 3\r\n"
+                : $"@echo off\r\necho {stdout}\r\nping -n 30 127.0.0.1 >nul\r\n");
+            return script;
+        }
+        var shell = Path.Combine(home, name);
+        File.WriteAllText(shell, stdout is null
+            ? "#!/bin/sh\necho 'fake pwsh failed before reporting' >&2\nexit 3\n"
+            : $"#!/bin/sh\nprintf '%s\\n' '{stdout}'\nsleep 30\n");
+        File.SetUnixFileMode(shell, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute);
+        return shell;
+    }
+
     public void Dispose()
     {
-        File.Delete(Path.Combine(home, "System.Management.Automation.dll"));
-        File.Delete(Path.Combine(home, "pwsh.dll"));
-        Directory.Delete(home);
+        Directory.Delete(home, recursive: true);
     }
 }
diff --git a/tests/Devolutions.Terminal.App.Tests/PortableIseRuntimeFixture.cs b/tests/Devolutions.Terminal.App.Tests/PortableIseRuntimeFixture.cs
index d05c6ce..58a9c3b 100644
--- a/tests/Devolutions.Terminal.App.Tests/PortableIseRuntimeFixture.cs
+++ b/tests/Devolutions.Terminal.App.Tests/PortableIseRuntimeFixture.cs
@@ -1,4 +1,3 @@
-using Devolutions.Terminal.App.Connections;
 using Iseberg.Core;
 using Xunit;
 
@@ -10,7 +9,6 @@ public sealed class PortableIseRuntimeFixture : IAsyncLifetime
 
     public async ValueTask InitializeAsync()
     {
-        await PowerShellIseRuntime.InitializeAsync().WaitAsync(TimeSpan.FromSeconds(60));
         await Analysis.InitializeAsync().WaitAsync(TimeSpan.FromSeconds(60));
     }
 
diff --git a/tests/Devolutions.Terminal.UI.Tests/DispatcherWait.cs b/tests/Devolutions.Terminal.UI.Tests/DispatcherWait.cs
new file mode 100644
index 0000000..3d58811
--- /dev/null
+++ b/tests/Devolutions.Terminal.UI.Tests/DispatcherWait.cs
@@ -0,0 +1,20 @@
+using System.Diagnostics;
+using Avalonia.Threading;
+
+namespace Devolutions.Terminal.UI.Tests;
+
+/// <summary>Polls a UI-thread condition, yielding to dispatcher work between checks.</summary>
+internal static class DispatcherWait
+{
+    public static async Task UntilAsync(Func<bool> condition, Func<string> diagnostic)
+    {
+        var elapsed = Stopwatch.StartNew();
+        while (!condition())
+        {
+            if (elapsed.Elapsed > TimeSpan.FromSeconds(30))
+                throw new TimeoutException(diagnostic());
+            // Yield to dispatcher work, not wall-clock timing or an arbitrary sleep.
+            await Dispatcher.UIThread.InvokeAsync(() => { }, DispatcherPriority.Background);
+        }
+    }
+}
diff --git a/tests/Devolutions.Terminal.UI.Tests/IsebergNativeContinuationTests.cs b/tests/Devolutions.Terminal.UI.Tests/IsebergNativeContinuationTests.cs
index 535c1bd..2e5fd75 100644
--- a/tests/Devolutions.Terminal.UI.Tests/IsebergNativeContinuationTests.cs
+++ b/tests/Devolutions.Terminal.UI.Tests/IsebergNativeContinuationTests.cs
@@ -845,6 +845,33 @@ await WaitForAsync(() => session.Engine.State == SessionState.Ready && connectio
         await SubmitTokenAsync(tab, "'DT-INVALID-STILL-USABLE'", "DT-INVALID-STILL-USABLE");
     });
 
+    [AvaloniaTheory]
+    [InlineData("")]
+    [InlineData("   ")]
+    public async Task CompletionWithNothingToReplaceAnchorsEmptySpanAtCaret(string text)
+    {
+        await InitializeRuntimeAsync();
+        await EmptyCompletionCoreAsync(text);
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static Task EmptyCompletionCoreAsync(string text) => WithNativeHostAsync(async tab =>
+    {
+        // PowerShell returns ReplacementIndex/Length = -1 here; the session must not pass that on.
+        var session = Assert.Single(tab.Workbench.Workbench.Sessions);
+        var completion = await session.Engine.CompleteAsync(text, text.Length).WaitAsync(TimeSpan.FromSeconds(30));
+        Assert.Equal(text.Length, completion.Start);
+        Assert.Equal(0, completion.Length);
+        Assert.Empty(completion.Matches);
+
+        var editor = tab.Workbench.FindControl<Iseberg.Editor.PowerShellEditorControl>("ScriptEditorControl")!;
+        editor.Document.Text = text;
+        editor.CaretOffset = text.Length;
+        var result = await editor.RequestCompletionAsync().WaitAsync(TimeSpan.FromSeconds(30));
+        Assert.Equal(new Iseberg.Editor.EditorTextSpan(text.Length, 0), result.ReplacementSpan);
+        Assert.True(result.Items.IsEmpty);
+    });
+
     private static Popup ConsolePopup(DtIsebergConsole console) =>
         Assert.Single(console.View.GetLogicalDescendants().OfType<Popup>(),
             popup => ReferenceEquals(popup.PlacementTarget, console.Terminal));
diff --git a/tests/Devolutions.Terminal.UI.Tests/PortableIseEditorRuntimeFixture.cs b/tests/Devolutions.Terminal.UI.Tests/PortableIseEditorRuntimeFixture.cs
index 62dee3d..78b5ef1 100644
--- a/tests/Devolutions.Terminal.UI.Tests/PortableIseEditorRuntimeFixture.cs
+++ b/tests/Devolutions.Terminal.UI.Tests/PortableIseEditorRuntimeFixture.cs
@@ -1,4 +1,3 @@
-using Devolutions.Terminal.App.Connections;
 using Iseberg.Core;
 using Xunit;
 
@@ -10,7 +9,6 @@ public sealed class PortableIseEditorRuntimeFixture : IAsyncLifetime
 
     public async ValueTask InitializeAsync()
     {
-        await PowerShellIseRuntime.InitializeAsync().WaitAsync(TimeSpan.FromSeconds(60));
         await Analysis.InitializeAsync().WaitAsync(TimeSpan.FromSeconds(60));
     }
 
diff --git a/tests/Devolutions.Terminal.UI.Tests/PowerShellIseTabTests.cs b/tests/Devolutions.Terminal.UI.Tests/PowerShellIseTabTests.cs
index 1d32eb2..b73b15d 100644
--- a/tests/Devolutions.Terminal.UI.Tests/PowerShellIseTabTests.cs
+++ b/tests/Devolutions.Terminal.UI.Tests/PowerShellIseTabTests.cs
@@ -17,16 +17,6 @@ namespace Devolutions.Terminal.UI.Tests;
 
 public sealed class PowerShellIseTabTests
 {
-    [AvaloniaFact]
-    public async Task RuntimeInitializationReturnsCachedSuccessfulTask()
-    {
-        await InitializeRuntimeAsync();
-        var first = PowerShellIseRuntime.InitializeAsync();
-        await first.WaitAsync(TimeSpan.FromSeconds(60));
-        Assert.True(first.IsCompletedSuccessfully);
-        Assert.Same(first, PowerShellIseRuntime.InitializeAsync());
-    }
-
     [AvaloniaTheory]
     [InlineData(false)]
     [InlineData(true)]
diff --git a/tests/Devolutions.Terminal.UI.Tests/PowerShellIseTestHarness.cs b/tests/Devolutions.Terminal.UI.Tests/PowerShellIseTestHarness.cs
index 61133be..7142391 100644
--- a/tests/Devolutions.Terminal.UI.Tests/PowerShellIseTestHarness.cs
+++ b/tests/Devolutions.Terminal.UI.Tests/PowerShellIseTestHarness.cs
@@ -67,23 +67,22 @@ public void Dispose()
 
 internal static class PowerShellIseTestHarness
 {
-    public static async Task InitializeRuntimeAsync()
+    private static readonly Lazy<Task> PowerShellPreflight = new(async () =>
     {
-        await PowerShellIseRuntime.InitializeAsync().WaitAsync(TimeSpan.FromSeconds(60));
-    }
+        var version = await Iseberg.Core.PowerShellProcessDiscovery.GetVersionAsync();
+        Assert.True(Iseberg.Core.PowerShellProcessDiscovery.IsSupportedVersion(version),
+            $"Iseberg tests require a supported pwsh; found {version}.");
+    });
 
-    public static async Task WaitForAsync(Func<bool> condition, Func<string> diagnostic)
+    /// <summary>Fails fast, once per run, when the pwsh Iseberg sessions use is missing or unsupported.</summary>
+    public static async Task InitializeRuntimeAsync()
     {
-        var elapsed = Stopwatch.StartNew();
-        while (!condition())
-        {
-            if (elapsed.Elapsed > TimeSpan.FromSeconds(30))
-                throw new TimeoutException(diagnostic());
-            // Yield to dispatcher work, not wall-clock timing or an arbitrary sleep.
-            await Dispatcher.UIThread.InvokeAsync(() => { }, DispatcherPriority.Background);
-        }
+        await PowerShellPreflight.Value.WaitAsync(TimeSpan.FromSeconds(60));
     }
 
+    public static Task WaitForAsync(Func<bool> condition, Func<string> diagnostic) =>
+        DispatcherWait.UntilAsync(condition, diagnostic);
+
     public static async Task<Window> NewDialogAsync(Window owner, IReadOnlyCollection<Window> before, Task request)
     {
         await WaitForAsync(
diff --git a/tests/Devolutions.Terminal.UI.Tests/WindowActionRegistrationTests.cs b/tests/Devolutions.Terminal.UI.Tests/WindowActionRegistrationTests.cs
index c294134..7836c49 100644
--- a/tests/Devolutions.Terminal.UI.Tests/WindowActionRegistrationTests.cs
+++ b/tests/Devolutions.Terminal.UI.Tests/WindowActionRegistrationTests.cs
@@ -1,7 +1,11 @@
+using Avalonia;
+using Avalonia.Headless;
 using Avalonia.Headless.XUnit;
 using Avalonia.Automation;
 using Avalonia.Controls;
+using Avalonia.Input;
 using Avalonia.Threading;
+using Avalonia.VisualTree;
 using Devolutions.Terminal.Settings;
 using Devolutions.Terminal.App.Routing;
 using Devolutions.Terminal.App.Views;
@@ -110,6 +114,51 @@ [new ActionAndArgs(
         Assert.DoesNotContain(window.CaptureLayout().Tabs, tab => tab.Title == "Settings");
     }
 
+    [AvaloniaFact]
+    public async Task ClickingTabCloseButtonClosesTheTab()
+    {
+        var window = new MainWindow(0, string.Empty, SettingsOnlyStartup);
+        window.Show();
+        try
+        {
+            await window.ActivateAsync(new TerminalWindowActivation(
+                null,
+                null,
+                null,
+                null,
+                TerminalWindowLaunchMode.Default,
+                [new ActionAndArgs(
+                    ShortcutAction.OpenSettings,
+                    new OpenSettingsArgs(SettingsTarget.SettingsUI))]));
+            window.UpdateLayout();
+            Dispatcher.UIThread.RunJobs();
+            Assert.Contains(window.Tabs, static tab => tab.IsSettingsTab);
+
+            // The close X is a Button nested in the tab header Button. Drive it with real
+            // pointer input so the press bubbles through the header's drag tracking.
+            var header = window.GetVisualDescendants().OfType<Button>().Single(button =>
+                button.GetVisualDescendants().OfType<TextBlock>().Any(text => text.Text == "Settings"));
+            var close = header.GetVisualDescendants().OfType<Button>()
+                .Single(button => button.Content is Avalonia.Controls.Shapes.Path);
+            var center = close.TranslatePoint(new Point(close.Bounds.Width / 2, close.Bounds.Height / 2), window);
+            Assert.NotNull(center);
+            Assert.Same(close, (window.InputHitTest(center.Value) as Visual)?.FindAncestorOfType<Button>(includeSelf: true));
+            var clicked = false;
+            close.Click += (_, _) => clicked = true;
+            window.MouseDown(center.Value, MouseButton.Left);
+            window.MouseUp(center.Value, MouseButton.Left);
+
+            // Closing is asynchronous (confirmation and hosted-content preparation).
+            await DispatcherWait.UntilAsync(
+                () => !window.Tabs.Any(static tab => tab.IsSettingsTab),
+                () => $"Clicking the close button did not close the Settings tab (Click raised: {clicked}).");
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
     [AvaloniaFact]
     public async Task ClosedSettingsTabIsNotRestoredAsATerminal()
     {