feat: report resolved async mode + handler breadcrumbs (issue #35 follow-up)

Part A — SynchronizationContextInstalled:
- New public read-only bool on ConsoleWindowSystem reflecting the resolved
  async model. Set in Run(), reset on shutdown. Lets user/library code query
  which mode is active instead of inferring from options.

Part B — Lazy-formatted BlockedIn breadcrumbs (zero per-dispatch allocation):
- Replace private volatile _currentCallback with separate volatile frame
  fields (window/control/op/label) + UiCallbackScope ref struct guard and
  watchdog-side FormatCurrentCallback().
- Instrument all three chokepoints: input (key/click/scroll/capture in
  WindowEventDispatcher), drain (per-action label), render (per-window in
  WindowRenderer.PaintDOM — window-level only to keep DOM paint allocation-free).
- EnqueueOnUIThread/InvokeAsync gain optional label overloads that surface in
  BlockedIn (e.g. "Click on 'Editor' / ButtonControl", "UIAction: SaveTimer").

Docs: THREADING_AND_ASYNC.md covers the new property, the IsOnUIThread /
InvokeRequired equivalence, label overloads, and richer BlockedIn content.

Backward compatible: only one new public member; UiOp/UiCallbackScope are
internal; existing overloads preserved. Tests added; full suite 3329 green.

Author: nickprotop

SharpConsoleUI.Tests/Core/ConsoleWindowSystemWatchdogTests.cs

@@ -41,4 +41,102 @@ public void Unresponsive_Raised_WithDrainPhase_WhenLoopBlocks()
 		Assert.True(ok, "Unresponsive event did not fire");
 		Assert.Equal(MainLoopPhase.Drain, captured!.Phase);
 	}
+
+	[Fact]
+	public void Unresponsive_BlockedIn_NamesLabelledQueuedAction()
+	{
+		var opts = new ConsoleWindowSystemOptions() with
+		{
+			Watchdog = new WatchdogOptions(StaleThresholdMs: 50, UnresponsiveThresholdMs: 120, PollIntervalMs: 40, ShowUnresponsiveBanner: false)
+		};
+		var sys = new ConsoleWindowSystem(RenderMode.Buffer, options: opts);
+
+		UnresponsiveEventArgs? captured = null;
+		sys.Unresponsive += (s, e) => captured = e;
+
+		var t = new Thread(() => { try { sys.Run(); } catch { } }) { IsBackground = true };
+		t.Start();
+		// Labelled queued action that blocks the Drain phase — label should surface in BlockedIn.
+		sys.EnqueueOnUIThread(() => Thread.Sleep(400), label: "SaveTimer");
+
+		var ok = WaitFor(() => captured != null, timeoutMs: 3000);
+		sys.Shutdown(0);
+		t.Join(2000);
+
+		Assert.True(ok, "Unresponsive event did not fire");
+		Assert.Equal(MainLoopPhase.Drain, captured!.Phase);
+		Assert.Equal("UIAction: SaveTimer", captured.BlockedIn);
+	}
+
+	// ---- FormatCurrentCallback formatting matrix (internal, exercised directly) ----
+
+	[Fact]
+	public void FormatCurrentCallback_ReturnsNull_WhenNoFrameSet()
+	{
+		var sys = new ConsoleWindowSystem(RenderMode.Buffer);
+		Assert.Null(sys.FormatCurrentCallback());
+	}
+
+	[Fact]
+	public void FormatCurrentCallback_FreeFormLabel_FormatsAsOpColonLabel()
+	{
+		var sys = new ConsoleWindowSystem(RenderMode.Buffer);
+		sys.SetFrameLabel("SaveTimer");
+		Assert.Equal("UIAction: SaveTimer", sys.FormatCurrentCallback());
+	}
+
+	[Fact]
+	public void FormatCurrentCallback_StructuredWindowAndControl_NamesBoth()
+	{
+		var sys = new ConsoleWindowSystem(RenderMode.Buffer);
+		var window = new Window(sys) { Title = "Editor" };
+		var control = new SharpConsoleUI.Controls.MarkupControl(new System.Collections.Generic.List<string> { "x" });
+		sys.SetFrame(window, control, UiOp.Click);
+		Assert.Equal("Click on 'Editor' / MarkupControl", sys.FormatCurrentCallback());
+	}
+
+	[Fact]
+	public void FormatCurrentCallback_WindowOnly_OmitsControlClause()
+	{
+		var sys = new ConsoleWindowSystem(RenderMode.Buffer);
+		var window = new Window(sys) { Title = "Dashboard" };
+		sys.SetFrame(window, null, UiOp.Render);
+		Assert.Equal("Render on 'Dashboard'", sys.FormatCurrentCallback());
+	}
+
+	// ---- UiCallbackScope restore semantics ----
+
+	[Fact]
+	public void UiCallbackScope_RestoresPreviousFrame_OnDispose()
+	{
+		var sys = new ConsoleWindowSystem(RenderMode.Buffer);
+		var window = new Window(sys) { Title = "Outer" };
+		sys.SetFrame(window, null, UiOp.Key);
+
+		using (new UiCallbackScope(sys, "Inner"))
+		{
+			Assert.Equal("UIAction: Inner", sys.FormatCurrentCallback());
+		}
+
+		// Outer frame restored after the scope exits.
+		Assert.Equal("Key on 'Outer'", sys.FormatCurrentCallback());
+	}
+
+	[Fact]
+	public void UiCallbackScope_Nested_InnermostWins_OuterRestored()
+	{
+		var sys = new ConsoleWindowSystem(RenderMode.Buffer);
+
+		using (new UiCallbackScope(sys, "A"))
+		{
+			Assert.Equal("UIAction: A", sys.FormatCurrentCallback());
+			using (new UiCallbackScope(sys, "B"))
+			{
+				Assert.Equal("UIAction: B", sys.FormatCurrentCallback());
+			}
+			Assert.Equal("UIAction: A", sys.FormatCurrentCallback());
+		}
+
+		Assert.Null(sys.FormatCurrentCallback());
+	}
 }

SharpConsoleUI.Tests/Core/SynchronizationContextInstalledTests.cs

@@ -0,0 +1,72 @@
+// -----------------------------------------------------------------------
+// ConsoleEx - A simple console window system for .NET Core
+//
+// Author: Nikolaos Protopapas
+// Email: nikolaos.protopapas@gmail.com
+// License: MIT
+// -----------------------------------------------------------------------
+
+using System;
+using System.Threading;
+using SharpConsoleUI;
+using SharpConsoleUI.Configuration;
+using SharpConsoleUI.Drivers;
+using Xunit;
+
+namespace SharpConsoleUI.Tests.Core;
+
+[Collection("TimingSensitive")]
+public class SynchronizationContextInstalledTests
+{
+	private static bool WaitFor(Func<bool> condition, int timeoutMs = 3000)
+	{
+		var deadline = DateTime.UtcNow.AddMilliseconds(timeoutMs);
+		while (DateTime.UtcNow < deadline) { if (condition()) return true; Thread.Sleep(25); }
+		return condition();
+	}
+
+	[Fact]
+	public void False_BeforeRun()
+	{
+		var sys = new ConsoleWindowSystem(RenderMode.Buffer);
+		Assert.False(sys.SynchronizationContextInstalled);
+	}
+
+	[Fact]
+	public void True_DuringRun_WhenOptedIn_AndFalse_AfterShutdown()
+	{
+		var opts = new ConsoleWindowSystemOptions() with { InstallSynchronizationContext = true };
+		var sys = new ConsoleWindowSystem(RenderMode.Buffer, options: opts);
+
+		var t = new Thread(() => { try { sys.Run(); } catch { } }) { IsBackground = true };
+		t.Start();
+
+		var becameTrue = WaitFor(() => sys.SynchronizationContextInstalled, timeoutMs: 3000);
+		sys.Shutdown(0);
+		t.Join(2000);
+
+		Assert.True(becameTrue, "SynchronizationContextInstalled never became true during Run()");
+		Assert.False(sys.SynchronizationContextInstalled, "Should reset to false after Run() returns");
+	}
+
+	[Fact]
+	public void False_DuringRun_WhenNotOptedIn()
+	{
+		var opts = new ConsoleWindowSystemOptions() with { InstallSynchronizationContext = false };
+		var sys = new ConsoleWindowSystem(RenderMode.Buffer, options: opts);
+
+		bool? observedDuringRun = null;
+		var t = new Thread(() => { try { sys.Run(); } catch { } }) { IsBackground = true };
+		t.Start();
+
+		// Give the loop a moment to start, then observe the resolved state from a queued action.
+		sys.EnqueueOnUIThread(() => observedDuringRun = sys.SynchronizationContextInstalled);
+		WaitFor(() => observedDuringRun.HasValue, timeoutMs: 3000);
+
+		sys.Shutdown(0);
+		t.Join(2000);
+
+		Assert.True(observedDuringRun.HasValue, "Queued observation never ran");
+		Assert.False(observedDuringRun!.Value);
+	}
+}