diff --git a/CLAUDE.md b/CLAUDE.md
index f64befc..4560db3 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -130,14 +130,15 @@ Two projects, split on one axis: needs a container or not.
   `SemiPlot.Tests.Integration` carries no `xunit.runner.json`.
 - An xunit v3 test project is an executable: a hung test leaves `SemiPlot.Tests.Unit.exe` locked and
   the next build fails with MSB3027 until it is killed. The container half is bounded at two minutes.
-- The way to hang one: give `TrendChartViewModel` `ImmediateScheduler.Instance` as its UI scheduler and
-  then realise a view that subscribes to `RedrawRequested`. Its `Sample` schedules periodically, and
-  `ImmediateScheduler` runs a periodic schedule by sleeping on the calling thread, so the subscription
-  never returns. A headless test that realises the chart passes both schedulers a `TestScheduler`
-  (`UI/Chart/TrendChartViewTests.cs`, `UI/MainWindow/MainWindowTestBuilder.cs`). `PenCatalogueSync`
-  hangs the same way: its loop runs through `ScheduleAsync` and waits on `Schedule(ReadInterval)`, so a
+- The way to hang one: build `PenCatalogueSync` over `ImmediateScheduler.Instance`. Its loop runs
+  through `ScheduleAsync` and waits on `Schedule(ReadInterval)` before every read, and
+  `ImmediateScheduler` runs each wait by sleeping on the calling thread, so `Start()` never returns. A
   test builds it over a `TestScheduler` and advances one tick after `Start()`
-  (`UI/MainWindow/MainWindowTestBuilder.cs`).
+  (`UI/MainWindow/MainWindowTestBuilder.cs`). The chart's redraw hangs nothing: it is a one-shot
+  schedule, which `ImmediateScheduler` runs inline after a 33 ms sleep. A headless test that realises
+  the chart still never passes an immediate UI scheduler, because it blocks the dispatcher on every
+  redraw; it passes a `TestScheduler` or `AvaloniaScheduler.Instance`
+  (`docs/architecture/testing-strategy.md#the-ui-scheduler-in-a-realised-view`).
 - A plain `[Fact]` body runs with no `SynchronizationContext`, so an `await` on a
   `TaskCompletionSource` completed by production code resumes inline on the completing thread. A gate
   awaited by the test and completed by production code takes
@@ -313,7 +314,9 @@ No abbreviations in names.
   imperative `IsSticky =` assignments.
 - A checkable menu item reads its flag `Mode=OneWay` and writes it only through the command it
   invokes, so the command is the flag's single writer. A two-way `IsChecked` would make the control a
-  second writer and the two halves would drift.
+  second writer and the two halves would drift. The sidebar's visibility box follows the same rule: it
+  reads `PenState.IsVisible` `Mode=OneWay` and writes through `ToggleVisibilityCommand`, which reaches
+  the chart's `SetPenVisibility`, the flag's one writer.
 - A menu item without a command, or without children, is not added. A disabled placeholder renders
   and does nothing, and it also forces an exemption into `AppMenuBarTests`, which walks the declared
   `Items` and requires every leaf to carry one or the other.
diff --git a/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/ChartAxisBinderTests.cs b/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/ChartAxisBinderTests.cs
index bc6481d..5ed9609 100644
--- a/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/ChartAxisBinderTests.cs
+++ b/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/ChartAxisBinderTests.cs
@@ -48,7 +48,7 @@ public void TheActivePenSwitchedOff_DrawsNoAxisAtAll()
 		using var plot = new Plot();
 		var binder = new ChartAxisBinder(plot);
 		var pens = Pens(1, 2);
-		pens[1].IsVisible = false;
+		pens[1].SetVisibility(false);
 
 		binder.Apply([Scale(1, isActive: true), Scale(2)], pens);
 
diff --git a/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/ChartHistoryRequestCancellationTests.cs b/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/ChartHistoryRequestCancellationTests.cs
index 107aafa..a7c3fe7 100644
--- a/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/ChartHistoryRequestCancellationTests.cs
+++ b/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/ChartHistoryRequestCancellationTests.cs
@@ -122,7 +122,7 @@ public async Task AGestureEndingOnTheDrawnWindowCancelsTheReadItLeftAndReadsNoth
 
 		debouncer.Request(RequestAtNotch(1));
 		scheduler.AdvanceBy(DebounceWindow.Ticks + 1);
-		var farRead = queries.Started[1];
+		var farRead = await queries.AwaitStart(1);
 
 		debouncer.RequestNothing();
 		scheduler.AdvanceBy(DebounceWindow.Ticks + 1);
@@ -154,7 +154,7 @@ public async Task AGestureEndingOnTheDrawnWindowAfterACancelledReadReadsNothing(
 		debouncer.Request(RequestAtNotch(2));
 		scheduler.AdvanceBy(DebounceWindow.Ticks + 1);
 
-		var cancelled = queries.Started[1];
+		var cancelled = await queries.AwaitStart(1);
 		cancelled.Cancellation.IsCancellationRequested.Should().BeTrue();
 		cancelled.Gate.SetCanceled(cancelled.Cancellation);
 		await AwaitCondition(() => queries.Started.Count == 3);
@@ -191,18 +191,24 @@ public async Task AGestureEndingOnTheDrawnWindowAfterAFailedReadCancelsTheReadIt
 
 		debouncer.Request(RequestAtNotch(1));
 		scheduler.AdvanceBy(DebounceWindow.Ticks + 1);
-		queries.Started[1].Gate.SetResult(Unreachable());
+		(await queries.AwaitStart(1)).Gate.SetResult(Unreachable());
 		await AwaitCondition(() => !reportedFailures.IsEmpty);
 
 		debouncer.Request(RequestAtNotch(2));
 		scheduler.AdvanceBy(DebounceWindow.Ticks + 1);
-		var farRead = queries.Started[2];
+		var farRead = await queries.AwaitStart(2);
 
 		debouncer.RequestNothing();
 		scheduler.AdvanceBy(DebounceWindow.Ticks + 1);
 
 		farRead.Cancellation.IsCancellationRequested.Should().BeTrue();
-		queries.Started.Should().HaveCount(3);
+
+		debouncer.Request(RequestAtNotch(3));
+		scheduler.AdvanceBy(DebounceWindow.Ticks + 1);
+		await queries.AwaitStart(3);
+
+		queries.Started.Select(query => query.Request.FromUtc).Should()
+			.Equal(From, From.AddSeconds(1), From.AddSeconds(2), From.AddSeconds(3));
 	}
 
 	[Fact]
@@ -393,6 +399,15 @@ public Task<Result<IReadOnlyList<PenHistoryEnvelope>>> QueryAsync(
 			return query.Gate.Task;
 		}
 
+		// A read the pipeline queued behind a landed one starts once Rx unwinds that one on the thread it
+		// resumed on, after the delivery the test observed.
+		public async Task<HeldQuery> AwaitStart(int index)
+		{
+			await AwaitCondition(() => Started.Count > index);
+
+			return Started[index];
+		}
+
 		public async Task LandAndAwaitTheNextStart(HeldQuery query)
 		{
 			var startedBefore = Started.Count;
diff --git a/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/ChartHoverReadoutTests.cs b/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/ChartHoverReadoutTests.cs
index bc9012e..049bab2 100644
--- a/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/ChartHoverReadoutTests.cs
+++ b/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/ChartHoverReadoutTests.cs
@@ -47,7 +47,7 @@ public void BuildContent_SkipsHiddenPens()
 	{
 		var visible = CreatePen(1, "Pen 1");
 		var hidden = CreatePen(2, "Pen 2");
-		hidden.IsVisible = false;
+		hidden.SetVisibility(false);
 		var pens = new[] { visible, hidden };
 		var values = new Dictionary<int, double?> { [1] = 2.0, [2] = 20.0 };
 
@@ -72,8 +72,8 @@ public void BuildContent_AllPensHidden_RendersTimestampOnly()
 	{
 		var first = CreatePen(1, "Pen 1");
 		var second = CreatePen(2, "Pen 2");
-		first.IsVisible = false;
-		second.IsVisible = false;
+		first.SetVisibility(false);
+		second.SetVisibility(false);
 		var pens = new[] { first, second };
 		var values = new Dictionary<int, double?> { [1] = 2.0, [2] = 20.0 };
 
diff --git a/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/EnvelopeLineTests.cs b/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/EnvelopeLineTests.cs
index d80bf88..9b66569 100644
--- a/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/EnvelopeLineTests.cs
+++ b/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/EnvelopeLineTests.cs
@@ -26,6 +26,8 @@ public sealed class EnvelopeLineTests
 	private const int ShortColumnCount = 2000;
 	private const int GapEvery = 500;
 	private const int TestTimeoutMilliseconds = 120_000;
+	private const int ColumnCap = 100_000;
+	private const int TrimChunk = ColumnCap / 10;
 
 	private static readonly TimeSpan _runBudget = TimeSpan.FromSeconds(60);
 	private static readonly TimeSpan _joinBudget = TimeSpan.FromSeconds(30);
@@ -89,6 +91,31 @@ public async Task Render_WhileTheUiThreadRewritesTheColumns_DoesNotThrow()
 		frames.Should().Be(FrameBudget);
 	}
 
+	[Fact]
+	public void AppendingPastTheCapTrimsOneChunk()
+	{
+		var line = new EnvelopeLine();
+		var peakCount = 0;
+
+		for (var index = 0; index <= ColumnCap; index++)
+		{
+			line.AppendColumn(new EnvelopeColumn(index, 0.0, 1.0, 0.5)).Should().BeTrue();
+			peakCount = Math.Max(peakCount, line.Columns.Count);
+		}
+
+		line.Columns.Should().HaveCount(ColumnCap + 1 - TrimChunk);
+		line.Columns[0].X.Should().Be(TrimChunk);
+		peakCount.Should().Be(ColumnCap);
+
+		for (var index = ColumnCap + 1; index < ColumnCap + TrimChunk; index++)
+		{
+			line.AppendColumn(new EnvelopeColumn(index, 0.0, 1.0, 0.5));
+		}
+
+		line.Columns.Should().HaveCount(ColumnCap);
+		line.Columns[0].X.Should().Be(TrimChunk);
+	}
+
 	private static void RenderFrame(Plot plot)
 	{
 		using var image = plot.GetImage(PlotWidth, PlotHeight);
diff --git a/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/TrendChartRenderThreadTests.cs b/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/TrendChartRenderThreadTests.cs
index eeef869..687742b 100644
--- a/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/TrendChartRenderThreadTests.cs
+++ b/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/TrendChartRenderThreadTests.cs
@@ -1,4 +1,5 @@
 using Avalonia.Headless.XUnit;
+using Avalonia.Threading;
 
 using AwesomeAssertions;
 
@@ -8,6 +9,7 @@
 
 using SemiPlot.Core.Trends;
 using SemiPlot.Tests.Unit.UI.Bridge;
+using SemiPlot.UI.Chart;
 
 using Xunit;
 
@@ -23,6 +25,10 @@ public sealed class TrendChartRenderThreadTests
 {
 	private const int PlotWidth = 400;
 	private const int PlotHeight = 300;
+
+	// The narrow canvas leaves a data area under the minimum column count, the wide one over the maximum.
+	private const int NarrowPlotWidth = 320;
+	private const int WidePlotWidth = 2600;
 	private const int FrameBudget = 300;
 	private const int JoiningPenCount = 20;
 	private const int TestTimeoutMilliseconds = 120_000;
@@ -119,8 +125,70 @@ public void ApplyCatalogue_RaisesNoNotificationWhileThePlotIsLocked()
 		raised.Should().AllSatisfy(entry => entry.IsLockHeld.Should().BeFalse());
 	}
 
+	// docs/architecture/charting.md#module-layout-avalonia-views--view-models--core-models
+	[AvaloniaFact]
+	public async Task ARepeatedDataAreaWidth_ChangesNothing()
+	{
+		using var chart = CreateChart(new TestScheduler());
+		_ = new TrendChartView { DataContext = chart };
+		await RenderFrameAsTheRenderThreadDoes(chart.Plot, NarrowPlotWidth, PlotHeight);
+		var windowChanges = 0;
+		chart.Navigation.WindowChanged += (_, _) => windowChanges++;
+		var revisionBefore = chart.ScalesRevision;
+
+		await RenderFrameAsTheRenderThreadDoes(chart.Plot, NarrowPlotWidth, PlotHeight);
+		await RenderFrameAsTheRenderThreadDoes(chart.Plot, NarrowPlotWidth, PlotHeight);
+
+		chart.Navigation.TargetColumnCount.Should().Be(HistoryColumnTarget.MinColumns);
+		windowChanges.Should().Be(0);
+		chart.ScalesRevision.Should().Be(revisionBefore);
+	}
+
+	[AvaloniaFact]
+	public async Task ANewDataAreaWidth_RetargetsTheColumnCount()
+	{
+		using var chart = CreateChart(new TestScheduler());
+		_ = new TrendChartView { DataContext = chart };
+		await RenderFrameAsTheRenderThreadDoes(chart.Plot, NarrowPlotWidth, PlotHeight);
+		chart.Navigation.TargetColumnCount.Should().Be(HistoryColumnTarget.MinColumns);
+		var windowChanges = 0;
+		chart.Navigation.WindowChanged += (_, _) => windowChanges++;
+
+		await RenderFrameAsTheRenderThreadDoes(chart.Plot, WidePlotWidth, PlotHeight);
+
+		chart.Navigation.TargetColumnCount.Should().Be(HistoryColumnTarget.MaxColumns);
+		windowChanges.Should().Be(1);
+	}
+
+	[AvaloniaFact]
+	public async Task AReboundView_ReportsTheWidthToTheNewChartAlone()
+	{
+		using var first = CreateChart(new TestScheduler());
+		using var second = CreateChart(new TestScheduler());
+		var view = new TrendChartView { DataContext = first };
+
+		view.DataContext = second;
+
+		await RenderFrameAsTheRenderThreadDoes(first.Plot, NarrowPlotWidth, PlotHeight);
+		await RenderFrameAsTheRenderThreadDoes(second.Plot, NarrowPlotWidth, PlotHeight);
+
+		first.Navigation.TargetColumnCount.Should().Be(HistoryColumnTarget.MaxColumns, "the view let go of it");
+		second.Navigation.TargetColumnCount.Should().Be(HistoryColumnTarget.MinColumns);
+	}
+
+	private static async Task RenderFrameAsTheRenderThreadDoes(Plot plot, int width, int height)
+	{
+		await Task.Run(() => RenderFrame(plot, width, height), TestContext.Current.CancellationToken);
+		Dispatcher.UIThread.RunJobs();
+	}
+
 	private static void RenderFrame(Plot plot)
 	{
-		using var image = plot.GetImage(PlotWidth, PlotHeight);
+		RenderFrame(plot, PlotWidth, PlotHeight);
+	}
+
+	private static void RenderFrame(Plot plot, int width, int height)
+	{
+		using var image = plot.GetImage(width, height);
 	}
 }
diff --git a/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/TrendChartViewModelTests.cs b/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/TrendChartViewModelTests.cs
index f20f6f8..ece1163 100644
--- a/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/TrendChartViewModelTests.cs
+++ b/SemiPlot/SemiPlot.Tests.Unit/UI/Chart/TrendChartViewModelTests.cs
@@ -36,6 +36,7 @@ namespace SemiPlot.Tests.Unit.UI.Chart;
 public sealed class TrendChartViewModelTests
 {
 	private static readonly TimeSpan _testDeadline = TimeSpan.FromSeconds(10.0);
+	private static readonly TimeSpan _redrawDelay = TimeSpan.FromMilliseconds(33.0);
 	private static readonly DateTime _from = new(2026, 6, 15, 8, 0, 0, DateTimeKind.Utc);
 	private static readonly DateTime _to = new(2026, 6, 15, 9, 0, 0, DateTimeKind.Utc);
 
@@ -45,7 +46,7 @@ public void SetPenVisibility_TogglesPenAndPlottableState()
 		var (viewModel, _, _, _) = CreateViewModel();
 		var state = viewModel.AddPen(new Pen(7, "Heater", ["Group A"], "#ff0000"));
 
-		viewModel.SetPenVisibility(7, false).Should().BeTrue();
+		viewModel.SetPenVisibility(7, false);
 
 		state.IsVisible.Should().BeFalse();
 		state.Line.IsVisible.Should().BeFalse();
@@ -326,6 +327,74 @@ public void InitialScale_RequestsARedraw()
 		redraws.Should().Be(1);
 	}
 
+	[AvaloniaFact]
+	public void AnIdleChartSchedulesNoRedraw()
+	{
+		var uiScheduler = new QueueReadingScheduler();
+		using var viewModel = CreateChartOn(uiScheduler);
+		var redraws = 0;
+		using var subscription = viewModel.RedrawRequested.Subscribe(_ => redraws++);
+
+		uiScheduler.HasQueuedWork.Should().BeFalse("a chart with nothing to redraw schedules nothing");
+
+		viewModel.SetDeltaModeEnabled(true);
+		uiScheduler.AdvanceBy(_redrawDelay.Ticks);
+
+		redraws.Should().Be(1);
+		uiScheduler.HasQueuedWork.Should().BeFalse("the redraw was one emission, not a timer left running");
+	}
+
+	[AvaloniaFact]
+	public void AChartNoViewSubscribesToSchedulesNoRedraw()
+	{
+		var uiScheduler = new QueueReadingScheduler();
+		using var viewModel = CreateChartOn(uiScheduler);
+
+		viewModel.SetDeltaModeEnabled(true);
+
+		uiScheduler.HasQueuedWork.Should().BeFalse("no view would draw the frame");
+	}
+
+	[AvaloniaFact]
+	public void DisposingTheChartCancelsTheScheduledRedraw()
+	{
+		var uiScheduler = new QueueReadingScheduler();
+		var viewModel = CreateChartOn(uiScheduler);
+		var redraws = 0;
+		using var subscription = viewModel.RedrawRequested.Subscribe(_ => redraws++);
+		viewModel.SetDeltaModeEnabled(true);
+
+		viewModel.Dispose();
+
+		uiScheduler.HasQueuedWork.Should().BeFalse("the disposed chart leaves nothing on the UI scheduler");
+		var advance = () => uiScheduler.AdvanceBy(_redrawDelay.Ticks * 2);
+		advance.Should().NotThrow();
+		redraws.Should().Be(0);
+	}
+
+	[AvaloniaFact]
+	public void ABurstOfRequestsRedrawsOncePerSpanAndOnceAfterTheLastRequest()
+	{
+		var uiScheduler = new QueueReadingScheduler();
+		using var viewModel = CreateChartOn(uiScheduler);
+		var redrawTimes = new List<TimeSpan>();
+		using var subscription = viewModel.RedrawRequested
+			.Subscribe(_ => redrawTimes.Add(TimeSpan.FromTicks(uiScheduler.Clock)));
+
+		for (var request = 0; request <= 10; request++)
+		{
+			viewModel.SetDeltaModeEnabled(request % 2 == 0);
+			uiScheduler.AdvanceBy(TimeSpan.FromMilliseconds(10.0).Ticks);
+		}
+
+		uiScheduler.AdvanceBy(TimeSpan.FromSeconds(1.0).Ticks);
+
+		redrawTimes.Should().Equal(
+			TimeSpan.FromMilliseconds(33.0),
+			TimeSpan.FromMilliseconds(73.0),
+			TimeSpan.FromMilliseconds(113.0));
+	}
+
 	[AvaloniaFact]
 	public void ManualLimits_DriveTheOwningAxisRange()
 	{
@@ -744,17 +813,19 @@ public void Realtime_AfterClearHistory_AppendsAnyTimestampAgain()
 	public void Realtime_PastTheBufferCap_DropsTheOldestColumns()
 	{
 		const int Cap = 100_000;
+		const int Appended = Cap + 10;
 		var (viewModel, _, _, _) = CreateViewModel();
 		var state = viewModel.AddPen(new Pen(1, "Pen 1", ["Group A"], "#ff0000"));
 		var t0 = new DateTime(2026, 6, 15, 8, 0, 0, DateTimeKind.Utc);
 
-		for (var index = 0; index < Cap + 10; index++)
+		for (var index = 0; index < Appended; index++)
 		{
 			state.AppendRealtime(t0.AddSeconds(index), index);
 		}
 
-		state.Line.Columns.Should().HaveCount(Cap);
-		state.Line.Columns[0].Center.Should().Be(10.0);
+		state.Line.Columns.Count.Should().BeLessThanOrEqualTo(Cap);
+		state.Line.Columns[0].Center.Should().BeGreaterThan(0.0, "the oldest columns go");
+		state.Line.Columns[^1].Center.Should().Be(Appended - 1, "the newest column stays");
 	}
 
 	[AvaloniaFact]
@@ -1643,7 +1714,7 @@ public void AFailedHistoryQueryReachesTheMessagePanelAndStillRedraws()
 		provider.FailHistory = true;
 
 		chart.RequestInitialHistory();
-		// Past the debounce window and the one sample period the recovery redraw falls into, and short of the
+		// Past the debounce window and the 33 ms the recovery redraw waits, and short of the
 		// 400 ms cap interval, which would admit a second query for the same window.
 		scheduler.AdvanceBy(TimeSpan.FromMilliseconds(200.0).Ticks);
 
@@ -1769,8 +1840,8 @@ public void AThrowOutOfTheMessagePanel_IsLoggedAndTheRealtimeApplyContinues()
 			valueWhenTheReportThrew, "the batches after the failed report still reach the pen");
 	}
 
-	// Both schedulers are virtual, unlike CreateViewModel's: these tests subscribe to RedrawRequested, whose
-	// Sample never returns on ImmediateScheduler, and they drive the realtime stream by advancing time.
+	// Both schedulers are virtual, unlike CreateViewModel's: these tests count the redraws a request schedules
+	// 33 ms ahead, and they drive the realtime stream by advancing time.
 	private static (TrendChartViewModel ViewModel, TestScheduler Scheduler, MessagePanelViewModel Panel)
 		CreateReportingViewModel(TimeSpan realtimeInterval, out FakeDataProvider provider)
 	{
@@ -1793,6 +1864,20 @@ private static (TrendChartViewModel ViewModel, TestScheduler Scheduler, MessageP
 		return (viewModel, scheduler, panel);
 	}
 
+	// The UI scheduler serves the chart alone, so whatever it holds queued is the chart's.
+	private static TrendChartViewModel CreateChartOn(QueueReadingScheduler uiScheduler)
+	{
+		var dataScheduler = new TestScheduler();
+		var provider = new FakeDataProvider(dataScheduler, TimeSpan.FromHours(1.0));
+
+		return new TrendChartViewModel(
+			CreateCoordinator(dataScheduler, provider),
+			dataScheduler,
+			uiScheduler,
+			new MessagePanelViewModel(),
+			NullLogger<TrendChartViewModel>.Instance);
+	}
+
 	// The value a held query carries, distinct from every value the fake answers with, so the assertion says
 	// which of the two results the chart ended up holding.
 	private static Result<IReadOnlyList<PenHistoryEnvelope>> StaleEnvelopes()
@@ -1886,4 +1971,9 @@ IEnumerator IEnumerable.GetEnumerator()
 			return GetEnumerator();
 		}
 	}
+
+	private sealed class QueueReadingScheduler : TestScheduler
+	{
+		public bool HasQueuedWork => GetNext() is not null;
+	}
 }
diff --git a/SemiPlot/SemiPlot.Tests.Unit/UI/Legend/TrendLegendViewModelTests.cs b/SemiPlot/SemiPlot.Tests.Unit/UI/Legend/TrendLegendViewModelTests.cs
index 7f0ecef..7b7eec3 100644
--- a/SemiPlot/SemiPlot.Tests.Unit/UI/Legend/TrendLegendViewModelTests.cs
+++ b/SemiPlot/SemiPlot.Tests.Unit/UI/Legend/TrendLegendViewModelTests.cs
@@ -60,9 +60,9 @@ public void APenInTwoGroups_IsOneRowListedUnderBothHeaders()
 		var underPressures = legend.Groups.Single(group => group.Name == "Pressures").Rows.Single();
 		underPressures.Should().BeSameAs(underHeaters);
 
-		underHeaters.IsVisible = false;
+		underHeaters.ToggleVisibilityCommand.Execute().Subscribe();
 
-		underPressures.IsVisible.Should().BeFalse();
+		underPressures.PenState.IsVisible.Should().BeFalse();
 		chart.FindPen(1)!.IsVisible.Should().BeFalse();
 	}
 
@@ -76,7 +76,7 @@ public void AnUngroupedPen_LandsUnderTheUngroupedHeader()
 		using var legend = new TrendLegendViewModel(chart);
 
 		legend.Groups.Select(group => group.Name).Should().Equal("Heaters", Resources.LegendUngroupedHeader);
-		legend.Groups[^1].Rows.Single().Name.Should().Be("Pen 2");
+		legend.Groups[^1].Rows.Single().PenState.Pen.Name.Should().Be("Pen 2");
 	}
 
 	// The rows arrive ordered by pen name, so first-appearance order and name order only agree by
@@ -128,26 +128,25 @@ public void AGroupNamedLikeTheUngroupedHeader_TakesTheUngroupedRowsRatherThanASe
 
 		legend.Groups.Should().ContainSingle();
 		legend.Groups.Single().Name.Should().Be(Resources.LegendUngroupedHeader);
-		legend.Groups.Single().Rows.Select(row => row.Name).Should().Equal("Pen 1", "Pen 2");
+		legend.Groups.Single().Rows.Select(row => row.PenState.Pen.Name).Should().Equal("Pen 1", "Pen 2");
 	}
 
-	// Dispose walks the distinct rows, not the flattened ones, and a row listed under two headers is one
-	// instance: it is reached once and its mirror subscription goes with it.
 	[AvaloniaFact]
 	public void Dispose_ReachesARowListedUnderTwoHeaders()
 	{
 		var chart = CreateChart();
 		chart.AddPen(new Pen(1, "Pen 1", ["Heaters", "Watchlist"], "#ff0000"));
+		chart.AddPen(new Pen(2, "Pen 2", ["Heaters"], "#00ff00"));
 		var legend = new TrendLegendViewModel(chart);
-		var row = legend.Groups[0].Rows.Single();
+		var row = SingleRow(legend, 1);
 
 		legend.Dispose();
-		chart.SetPenVisibility(1, false);
+		chart.SetActivePen(2);
 
-		row.IsVisible.Should().BeTrue("a disposed row no longer mirrors the chart");
+		row.IsActive.Should().BeTrue("a disposed row no longer follows the chart");
 	}
 
-	// The row's own notification still fires after the legend is gone, so only the group's disposal stops
+	// The pen state's notification still fires after the legend is gone, so only the group's disposal stops
 	// the header re-deriving from it.
 	[AvaloniaFact]
 	public void Dispose_StopsEveryHeaderFollowingItsRows()
@@ -158,7 +157,7 @@ public void Dispose_StopsEveryHeaderFollowingItsRows()
 		var heaters = Group(legend, "Heaters");
 
 		legend.Dispose();
-		heaters.Rows.Single().IsVisible = false;
+		chart.SetPenVisibility(1, false);
 
 		heaters.SwitchState.Should().BeTrue("a disposed header no longer follows its rows");
 	}
@@ -208,7 +207,7 @@ public void SwitchingOnePen_ReDerivesEveryHeaderItSitsUnder()
 		chart.AddPen(new Pen(3, "Pen 3", ["Watchlist"], "#0000ff"));
 		using var legend = new TrendLegendViewModel(chart);
 
-		SingleRow(legend, 1).IsVisible = false;
+		SingleRow(legend, 1).ToggleVisibilityCommand.Execute().Subscribe();
 
 		Group(legend, "Heaters").SwitchState.Should().BeNull();
 		Group(legend, "Watchlist").SwitchState.Should().BeNull();
@@ -364,33 +363,36 @@ public void FitPanel_NarrowsTheShownWidthAndKeepsBothSlots()
 	}
 
 	[AvaloniaFact]
-	public void TogglingRowCheckbox_FlipsChartPenVisibility()
+	public void ToggleVisibilityCommand_SwitchesThePenOffAndOnAgain()
 	{
 		var chart = CreateChart();
 		chart.AddPen(new Pen(1, "Pen 1", ["Heaters"], "#ff0000"));
 		using var legend = new TrendLegendViewModel(chart);
 		var row = SingleRow(legend, 1);
 
-		row.IsVisible = false;
+		row.ToggleVisibilityCommand.Execute().Subscribe();
 
 		chart.FindPen(1)!.IsVisible.Should().BeFalse();
 
-		row.IsVisible = true;
+		row.ToggleVisibilityCommand.Execute().Subscribe();
 
 		chart.FindPen(1)!.IsVisible.Should().BeTrue();
 	}
 
 	[AvaloniaFact]
-	public void RowVisibility_MirrorsChartDrivenVisibilityChange()
+	public void TheRow_FollowsAChangeOfTheChartsPenState()
 	{
 		var chart = CreateChart();
-		chart.AddPen(new Pen(1, "Pen 1", ["Heaters"], "#ff0000"));
+		var pen = new Pen(1, "Pen 1", ["Heaters"], "#ff0000");
+		chart.AddPen(pen);
 		using var legend = new TrendLegendViewModel(chart);
 		var row = SingleRow(legend, 1);
 
 		chart.SetPenVisibility(1, false);
+		chart.ApplyCatalogue([pen with { Color = "#00ff00" }]);
 
-		row.IsVisible.Should().BeFalse();
+		row.PenState.IsVisible.Should().BeFalse();
+		row.PenState.Pen.Color.Should().Be("#00ff00");
 	}
 
 	[AvaloniaFact]
@@ -409,19 +411,6 @@ public void SelectingRow_SetsTheActivePenOnChart()
 		SingleRow(legend, 1).IsActive.Should().BeFalse();
 	}
 
-	[AvaloniaFact]
-	public void CurrentValue_ReflectsChartHistoryLoad()
-	{
-		var chart = CreateChart();
-		chart.AddPen(new Pen(1, "Pen 1", ["Heaters"], "#ff0000"));
-		using var legend = new TrendLegendViewModel(chart);
-		var row = SingleRow(legend, 1);
-
-		LoadInitialHistory(chart, _from, _to);
-
-		row.CurrentValue.Should().Be(2.0);
-	}
-
 	[AvaloniaFact]
 	public void CurrentValueText_RendersTheReadingInThePensOwnMask()
 	{
@@ -434,7 +423,6 @@ public void CurrentValueText_RendersTheReadingInThePensOwnMask()
 
 		row.CurrentValueText.Should().Be(PenValueFormat.Format(2.0, "0.000"));
 		row.CurrentValueText.Should().NotBe(PenValueFormat.Format(2.0, PenValueFormat.FallbackMask));
-		row.Unit.Should().Be("kPa");
 	}
 
 	[AvaloniaFact]
@@ -446,7 +434,6 @@ public void RowText_WithoutAValue_ReadsTheNoValuePlaceholder()
 		using var row = new TrendLegendRowViewModel(chart, penState);
 
 		row.CurrentValueText.Should().Be(Resources.NoValuePlaceholder);
-		row.Unit.Should().BeEmpty("a pen with no stored unit renders no unit run");
 	}
 
 	[AvaloniaFact]
@@ -462,9 +449,9 @@ public void Rebuild_ShowsARevisedNameColourUnitAndMask()
 		legend.Rebuild();
 
 		var row = legend.Groups.Single().Rows.Single();
-		row.Name.Should().Be("Heater 01");
-		row.ColorHex.Should().Be("#00ff00");
-		row.Unit.Should().Be("Pa");
+		row.PenState.Pen.Name.Should().Be("Heater 01");
+		row.PenState.Pen.Color.Should().Be("#00ff00");
+		row.PenState.Pen.Unit.Should().Be("Pa");
 		row.CurrentValueText.Should().Be(PenValueFormat.Format(2.0, "0.000"));
 	}
 
@@ -481,7 +468,7 @@ public void Rebuild_ListsAnAddedPenUnderItsGroupAndDropsARemovedOne()
 		legend.Rebuild();
 
 		legend.Groups.Select(group => group.Name).Should().Equal("Dampers", "Heaters");
-		SingleRow(legend, 3).IsVisible.Should().BeFalse("a pen joins with the visibility it starts with");
+		SingleRow(legend, 3).PenState.IsVisible.Should().BeFalse("a pen joins with the visibility it starts with");
 	}
 
 	[AvaloniaFact]
@@ -498,7 +485,7 @@ public void Rebuild_KeepsThePanelWidthTheCollapsedStateAndEveryRowsVisibility()
 		legend.FitPanel(900);
 		legend.ToggleExpandedCommand.Execute().Subscribe();
 		legend.ResizePanel(-30);
-		SingleRow(legend, 2).IsVisible = false;
+		SingleRow(legend, 2).ToggleVisibilityCommand.Execute().Subscribe();
 
 		chart.ApplyCatalogue(
 		[
@@ -510,9 +497,9 @@ public void Rebuild_KeepsThePanelWidthTheCollapsedStateAndEveryRowsVisibility()
 
 		legend.IsExpanded.Should().BeFalse();
 		legend.PanelWidth.Should().Be(TrendLegendViewModel.CollapsedWidth + 30);
-		SingleRow(legend, 1).IsVisible.Should().BeTrue();
-		SingleRow(legend, 2).IsVisible.Should().BeFalse();
-		SingleRow(legend, 3).IsVisible.Should().BeFalse("an EnabledOnStart revision switches no pen on");
+		SingleRow(legend, 1).PenState.IsVisible.Should().BeTrue();
+		SingleRow(legend, 2).PenState.IsVisible.Should().BeFalse();
+		SingleRow(legend, 3).PenState.IsVisible.Should().BeFalse("an EnabledOnStart revision switches no pen on");
 		Group(legend, "Heaters").SwitchState.Should().BeNull();
 	}
 
@@ -521,43 +508,26 @@ public void Rebuild_AnnouncesTheNewGroupsBeforeItDisposesTheReplacedRows()
 	{
 		var chart = CreateChart();
 		var pen = new Pen(1, "Pen 1", ["Heaters"], "#ff0000");
+		var other = new Pen(2, "Pen 2", ["Heaters"], "#00ff00");
 		chart.AddPen(pen);
+		chart.AddPen(other);
 		using var legend = new TrendLegendViewModel(chart);
 		var replacedRow = SingleRow(legend, 1);
-		var replacedMirroredOnAnnouncement = false;
+		var replacedFollowedOnAnnouncement = false;
 		legend.PropertyChanged += (_, e) =>
 		{
 			if (e.PropertyName == nameof(TrendLegendViewModel.Groups))
 			{
-				chart.SetPenVisibility(1, false);
-				replacedMirroredOnAnnouncement = !replacedRow.IsVisible;
+				chart.SetActivePen(other.PenId);
+				replacedFollowedOnAnnouncement = !replacedRow.IsActive;
 			}
 		};
 
-		chart.ApplyCatalogue([pen with { Name = "Heater 01" }]);
-		legend.Rebuild();
-		chart.SetPenVisibility(1, true);
-
-		replacedMirroredOnAnnouncement.Should().BeTrue();
-		replacedRow.IsVisible.Should().BeFalse("a disposed row no longer mirrors the chart");
-		SingleRow(legend, "Heater 01").IsVisible.Should().BeTrue();
-	}
-
-	[AvaloniaFact]
-	public void AVisibilityWriteOnAReplacedRow_ReachesNoChart()
-	{
-		var chart = CreateChart();
-		var pen = new Pen(1, "Pen 1", ["Heaters"], "#ff0000");
-		chart.AddPen(pen);
-		using var legend = new TrendLegendViewModel(chart);
-		var replacedRow = SingleRow(legend, 1);
-
-		chart.ApplyCatalogue([pen with { Color = "#00ff00" }]);
+		chart.ApplyCatalogue([pen with { Name = "Heater 01" }, other]);
 		legend.Rebuild();
-		replacedRow.IsVisible = false;
 
-		chart.FindPen(1)!.IsVisible.Should().BeTrue();
-		SingleRow(legend, 1).IsVisible.Should().BeTrue();
+		replacedFollowedOnAnnouncement.Should().BeTrue();
+		SingleRow(legend, 2).IsActive.Should().BeTrue();
 	}
 
 	private void LoadInitialHistory(TrendChartViewModel chart, DateTime from, DateTime to)
@@ -577,7 +547,7 @@ private static TrendLegendRowViewModel SingleRow(TrendLegendViewModel legend, st
 		return legend.Groups
 			.SelectMany(group => group.Rows)
 			.Distinct()
-			.Single(row => row.Name == name);
+			.Single(row => row.PenState.Pen.Name == name);
 	}
 
 	private static TrendLegendGroupViewModel Group(TrendLegendViewModel legend, string name)
diff --git a/SemiPlot/SemiPlot.Tests.Unit/UI/Legend/TrendLegendViewTests.cs b/SemiPlot/SemiPlot.Tests.Unit/UI/Legend/TrendLegendViewTests.cs
index 237418a..2691c0e 100644
--- a/SemiPlot/SemiPlot.Tests.Unit/UI/Legend/TrendLegendViewTests.cs
+++ b/SemiPlot/SemiPlot.Tests.Unit/UI/Legend/TrendLegendViewTests.cs
@@ -213,8 +213,7 @@ public void APenInTwoGroups_RendersUnderBothHeadersAndSwitchesOffInBoth()
 		var boxes = RowBoxes(window);
 		boxes.Should().HaveCount(2);
 
-		boxes[0].IsChecked = false;
-		Dispatcher.UIThread.RunJobs();
+		HeadlessInput.Click(window, boxes[0]);
 
 		boxes[1].IsChecked.Should().BeFalse();
 		chart.FindPen(1)!.IsVisible.Should().BeFalse();
@@ -301,6 +300,88 @@ public void ClicksOnTheHeader_SwitchTheGroupOnThenOffAndAMixedHeaderOnAgain()
 		chart.Pens.Should().AllSatisfy(pen => pen.IsVisible.Should().BeTrue());
 	}
 
+	[AvaloniaFact]
+	public void AClickOnARowBox_SwitchesItsPenAndTheBoxFollows()
+	{
+		var chart = CreateChart();
+		chart.AddPen(new Pen(1, "Heater 01", ["Heaters"], "#ff0000"));
+		chart.AddPen(new Pen(2, "Heater 02", ["Heaters"], "#00ff00"));
+		using var legend = new TrendLegendViewModel(chart);
+		var window = Realize(legend);
+
+		HeadlessInput.Click(window, RowBoxes(window)[0]);
+
+		BoxStates(window).Should().Equal(false, true);
+		PenStates(chart).Should().Equal(false, true);
+
+		HeadlessInput.Click(window, RowBoxes(window)[0]);
+
+		BoxStates(window).Should().Equal(true, true);
+		PenStates(chart).Should().Equal(true, true);
+	}
+
+	[AvaloniaFact]
+	public void AClickOnTheGroupSwitch_LeavesEveryRowBoxAgreeingWithItsPen()
+	{
+		var chart = CreateChart();
+		chart.AddPen(new Pen(1, "Heater 01", ["Heaters"], "#ff0000"));
+		chart.AddPen(new Pen(2, "Heater 02", ["Heaters"], "#00ff00"));
+		using var legend = new TrendLegendViewModel(chart);
+		var window = Realize(legend);
+
+		HeadlessInput.Click(window, HeaderSwitches(window).Single());
+
+		BoxStates(window).Should().Equal(false, false);
+		PenStates(chart).Should().Equal(false, false);
+
+		HeadlessInput.Click(window, HeaderSwitches(window).Single());
+
+		BoxStates(window).Should().Equal(true, true);
+		PenStates(chart).Should().Equal(true, true);
+	}
+
+	// The chart switches the pen back after a click, so the box follows only if its one-way binding
+	// outlived the click.
+	[AvaloniaFact]
+	public void APenSwitchedOnTheChart_MovesItsRowBoxBeforeAndAfterAClick()
+	{
+		var chart = CreateChart();
+		chart.AddPen(new Pen(1, "Heater 01", ["Heaters"], "#ff0000"));
+		chart.AddPen(new Pen(2, "Heater 02", ["Heaters"], "#00ff00"));
+		using var legend = new TrendLegendViewModel(chart);
+		var window = Realize(legend);
+
+		chart.SetPenVisibility(2, false);
+		Dispatcher.UIThread.RunJobs();
+
+		BoxStates(window).Should().Equal(true, false);
+
+		HeadlessInput.Click(window, RowBoxes(window)[1]);
+
+		BoxStates(window).Should().Equal(true, true);
+		PenStates(chart).Should().Equal(true, true);
+
+		chart.SetPenVisibility(2, false);
+		Dispatcher.UIThread.RunJobs();
+
+		BoxStates(window).Should().Equal(true, false);
+		PenStates(chart).Should().Equal(true, false);
+	}
+
+	[AvaloniaFact]
+	public void ARowBoxSetInCode_WritesNothingToThePen()
+	{
+		var chart = CreateChart();
+		chart.AddPen(new Pen(1, "Heater 01", ["Heaters"], "#ff0000"));
+		using var legend = new TrendLegendViewModel(chart);
+		var window = Realize(legend);
+
+		RowBoxes(window).Single().IsChecked = false;
+		Dispatcher.UIThread.RunJobs();
+
+		chart.FindPen(1)!.IsVisible.Should().BeTrue("the box is not a writer of the pen's visibility");
+	}
+
 	[AvaloniaFact]
 	public void APenSwitchedOnTheChart_ReDerivesEveryRealisedHeaderItSitsUnder()
 	{
@@ -407,6 +488,22 @@ public void TheRealisedSidebar_ShowsARenamedPensNewNameAfterARebuild()
 		RowBoxes(window).Single().IsChecked.Should().BeTrue();
 	}
 
+	[AvaloniaFact]
+	public void TheRealisedRow_ShowsARevisedUnitWithoutARebuild()
+	{
+		var chart = CreateChart();
+		var pen = new Pen(1, "Chamber pressure", ["Pressures"], "#ff0000", "kPa", "0.000");
+		chart.AddPen(pen);
+		using var legend = new TrendLegendViewModel(chart);
+		LoadInitialHistory(chart);
+		var window = Realize(legend);
+
+		chart.ApplyCatalogue([pen with { Unit = "Pa" }]);
+		Dispatcher.UIThread.RunJobs();
+
+		RowTexts(SingleRow(window)).Should().Equal("Chamber pressure", PenValueFormat.Format(2.0, "0.000"), "Pa");
+	}
+
 	private static Window Realize(TrendLegendViewModel legend)
 	{
 		var window = new Window { Width = 320, Height = 400, Content = new TrendLegendView { DataContext = legend } };
@@ -442,6 +539,16 @@ private static IReadOnlyList<CheckBox> RowBoxes(Window window)
 		return [.. Descendants<CheckBox>(window).Where(box => box.Name != "GroupSwitch")];
 	}
 
+	private static IReadOnlyList<bool?> BoxStates(Window window)
+	{
+		return [.. RowBoxes(window).Select(box => box.IsChecked)];
+	}
+
+	private static IReadOnlyList<bool> PenStates(TrendChartViewModel chart)
+	{
+		return [.. chart.Pens.Select(pen => pen.IsVisible)];
+	}
+
 	private static Border SingleRow(Window window)
 	{
 		return Descendants<Border>(window).Single(border => border.Name == "RowRoot");
diff --git a/SemiPlot/SemiPlot.Tests.Unit/UI/MainWindow/MainWindowViewTests.cs b/SemiPlot/SemiPlot.Tests.Unit/UI/MainWindow/MainWindowViewTests.cs
index 1d9fd29..10c269c 100644
--- a/SemiPlot/SemiPlot.Tests.Unit/UI/MainWindow/MainWindowViewTests.cs
+++ b/SemiPlot/SemiPlot.Tests.Unit/UI/MainWindow/MainWindowViewTests.cs
@@ -133,12 +133,13 @@ public async Task TheRestartNowButton_OfTheSettingsDialog_StartsACopyAndClosesTh
 			await stand.ViewModel.ShowSettingsCommand.Execute();
 			await HeadlessWait.Until(() => window.OwnedWindows.OfType<SettingsDialog>().Any());
 			var dialog = window.OwnedWindows.OfType<SettingsDialog>().Single();
-			var settings = dialog.DataContext.Should().BeOfType<SettingsViewModel>().Which;
+			dialog.DataContext.Should().BeOfType<SettingsViewModel>();
 
 			HeadlessInput.Type(dialog, dialog.FindControl<TextBox>("SettingsPassword")!, "secret");
 			HeadlessInput.Click(dialog, dialog.FindControl<Button>("SettingsSaveButton")!);
-			await HeadlessWait.Until(() => settings.IsRestartPending);
-			HeadlessInput.Click(dialog, dialog.FindControl<Button>("SettingsRestartNow")!);
+			var restartNow = dialog.FindControl<Button>("SettingsRestartNow")!;
+			await HeadlessWait.Until(() => restartNow.IsEffectivelyEnabled);
+			HeadlessInput.Click(dialog, restartNow);
 			Dispatcher.UIThread.RunJobs();
 
 			started.Should().ContainSingle();
diff --git a/SemiPlot/SemiPlot.Tests.Unit/UI/MainWindow/PenCatalogueApplierTests.cs b/SemiPlot/SemiPlot.Tests.Unit/UI/MainWindow/PenCatalogueApplierTests.cs
index 8b9e374..f7788b2 100644
--- a/SemiPlot/SemiPlot.Tests.Unit/UI/MainWindow/PenCatalogueApplierTests.cs
+++ b/SemiPlot/SemiPlot.Tests.Unit/UI/MainWindow/PenCatalogueApplierTests.cs
@@ -37,7 +37,7 @@ public void ADeltaAddingAPenToAChartWithPens_ReachesTheChartAndTheSidebarAndRead
 		AdvanceOneRead(stand);
 
 		viewModel.ChartViewModel.FindPen(3).Should().NotBeNull();
-		viewModel.LegendViewModel.Groups.SelectMany(group => group.Rows).Select(row => row.Name).Should()
+		viewModel.LegendViewModel.Groups.SelectMany(group => group.Rows).Select(row => row.PenState.Pen.Name).Should()
 			.Equal("Pen 1", "Pen 2", "Pen 3");
 		stand.Provider.ExtentQueryCount.Should().Be(extentQueriesAtStart + 1);
 		viewModel.MessagePanel.Entries.Should().BeEmpty();
@@ -303,7 +303,7 @@ public void AnApplyAwaitingTheExtentAtDisposal_AppliesNothingAndReportsNothing()
 
 	private static IEnumerable<string> LegendRowNames(MainWindowViewModel viewModel)
 	{
-		return viewModel.LegendViewModel.Groups.SelectMany(group => group.Rows).Select(row => row.Name);
+		return viewModel.LegendViewModel.Groups.SelectMany(group => group.Rows).Select(row => row.PenState.Pen.Name);
 	}
 
 	// A window wider than the archive, at the live edge, starts before the first sample.
diff --git a/SemiPlot/SemiPlot.Tests.Unit/UI/Minimap/MinimapPointerInputTests.cs b/SemiPlot/SemiPlot.Tests.Unit/UI/Minimap/MinimapPointerInputTests.cs
index b5243b9..4df5487 100644
--- a/SemiPlot/SemiPlot.Tests.Unit/UI/Minimap/MinimapPointerInputTests.cs
+++ b/SemiPlot/SemiPlot.Tests.Unit/UI/Minimap/MinimapPointerInputTests.cs
@@ -126,8 +126,7 @@ private static TrendCoordinator CreateCoordinator(TestScheduler scheduler)
 	}
 
 	// The chart view model is here for its navigation controller alone, the instance the minimap receives in
-	// production; its UI scheduler is AvaloniaScheduler for the reason ChartViewTestBuilder records, and
-	// the 33 ms timer that scheduler starts is why each test disposes the view model.
+	// production.
 	private static TrendChartViewModel CreateChartViewModel(TrendCoordinator coordinator, TestScheduler scheduler)
 	{
 		return new TrendChartViewModel(
diff --git a/SemiPlot/SemiPlot.Tests.Unit/UI/Settings/SettingsViewTests.cs b/SemiPlot/SemiPlot.Tests.Unit/UI/Settings/SettingsViewTests.cs
index d16fd2f..d2c9472 100644
--- a/SemiPlot/SemiPlot.Tests.Unit/UI/Settings/SettingsViewTests.cs
+++ b/SemiPlot/SemiPlot.Tests.Unit/UI/Settings/SettingsViewTests.cs
@@ -239,7 +239,7 @@ public async Task TheRestartNowButton_AppearsWithTheNoticeAndRunsTheHandedRestar
 			var other = viewModel.Languages.First(choice => choice.Token != viewModel.SelectedLanguage!.Token);
 			Pick(dialog, Named<ComboBox>(dialog, "SettingsLanguage"), other);
 			HeadlessInput.Click(dialog, Named<Button>(dialog, "SettingsSaveButton"));
-			await HeadlessWait.Until(() => viewModel.IsRestartPending);
+			await HeadlessWait.Until(() => button.IsEffectivelyEnabled);
 
 			button.IsEffectivelyVisible.Should().BeTrue();
 			notice.IsEffectivelyVisible.Should().BeTrue();
diff --git a/SemiPlot/SemiPlot.Tests.Unit/UI/Startup/StartupFailureWindowTests.cs b/SemiPlot/SemiPlot.Tests.Unit/UI/Startup/StartupFailureWindowTests.cs
index 7569c77..6ff9bab 100644
--- a/SemiPlot/SemiPlot.Tests.Unit/UI/Startup/StartupFailureWindowTests.cs
+++ b/SemiPlot/SemiPlot.Tests.Unit/UI/Startup/StartupFailureWindowTests.cs
@@ -265,14 +265,15 @@ public async Task TheSettingsDialog_OverAnEmptyPassword_WritesItIntoTheExistingC
 
 			save.IsEffectivelyEnabled.Should().BeTrue(settings.ValidationMessage);
 			HeadlessInput.Click(dialog, save);
-			await HeadlessWait.Until(() => settings.IsRestartPending);
+			var restartNow = dialog.FindControl<Button>("SettingsRestartNow")!;
+			await HeadlessWait.Until(() => restartNow.IsEffectivelyEnabled);
 
 			var connectionDirectory = Path.Combine(configDirectory, StartupProbe.ConnectionDirectoryName);
 			PostgresConnectionLoader.Load(connectionDirectory).Value.Password.Should().Be("secret");
 			Directory.GetFiles(connectionDirectory).Should().ContainSingle().Which.Should().EndWith("connection.yaml");
 			viewModel.MessagePanel.Entries.Should().BeEmpty();
 
-			HeadlessInput.Click(dialog, dialog.FindControl<Button>("SettingsRestartNow")!);
+			HeadlessInput.Click(dialog, restartNow);
 			Dispatcher.UIThread.RunJobs();
 
 			started.Should().Be(1);
diff --git a/SemiPlot/SemiPlot.UI/Chart/ChartPenSet.cs b/SemiPlot/SemiPlot.UI/Chart/ChartPenSet.cs
index e03055d..c4b4d4d 100644
--- a/SemiPlot/SemiPlot.UI/Chart/ChartPenSet.cs
+++ b/SemiPlot/SemiPlot.UI/Chart/ChartPenSet.cs
@@ -69,7 +69,7 @@ private void Add(Pen pen)
 		line.Axes.XAxis = _plot.Axes.Bottom;
 		_plot.Add.Plottable(line);
 
-		_pensById.Add(pen.PenId, new TrendPenState(pen, line) { IsVisible = pen.EnabledOnStart });
+		_pensById.Add(pen.PenId, new TrendPenState(pen, line));
 		_settingsById.Add(pen.PenId, PenScaleSettings.InitialFor(pen));
 	}
 
diff --git a/SemiPlot/SemiPlot.UI/Chart/ChartRedrawSchedule.cs b/SemiPlot/SemiPlot.UI/Chart/ChartRedrawSchedule.cs
new file mode 100644
index 0000000..b659b7a
--- /dev/null
+++ b/SemiPlot/SemiPlot.UI/Chart/ChartRedrawSchedule.cs
@@ -0,0 +1,48 @@
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+
+namespace SemiPlot.UI.Chart;
+
+// docs/architecture/charting.md#module-layout-avalonia-views--view-models--core-models
+public sealed class ChartRedrawSchedule : IDisposable
+{
+	private static readonly TimeSpan _redrawDelay = TimeSpan.FromMilliseconds(33);
+	private readonly IScheduler _uiScheduler;
+	private readonly Subject<Unit> _redraws = new();
+	private IDisposable _scheduledRedraw = Disposable.Empty;
+	private bool _isRedrawScheduled;
+
+	public ChartRedrawSchedule(IScheduler uiScheduler)
+	{
+		_uiScheduler = uiScheduler;
+		Redraws = _redraws.AsObservable();
+	}
+
+	public IObservable<Unit> Redraws { get; }
+
+	public void Request()
+	{
+		if (_isRedrawScheduled || !_redraws.HasObservers)
+		{
+			return;
+		}
+
+		_isRedrawScheduled = true;
+		_scheduledRedraw = _uiScheduler.Schedule(_redrawDelay, Emit);
+	}
+
+	public void Dispose()
+	{
+		_scheduledRedraw.Dispose();
+		_redraws.Dispose();
+	}
+
+	private void Emit()
+	{
+		_isRedrawScheduled = false;
+		_redraws.OnNext(Unit.Default);
+	}
+}
diff --git a/SemiPlot/SemiPlot.UI/Chart/EnvelopeLine.cs b/SemiPlot/SemiPlot.UI/Chart/EnvelopeLine.cs
index 1dc9355..7a9bb02 100644
--- a/SemiPlot/SemiPlot.UI/Chart/EnvelopeLine.cs
+++ b/SemiPlot/SemiPlot.UI/Chart/EnvelopeLine.cs
@@ -12,6 +12,7 @@ namespace SemiPlot.UI.Chart;
 public sealed class EnvelopeLine : IPlottable
 {
 	private const int MaxColumns = 100_000;
+	private const int TrimChunk = MaxColumns / 10;
 
 	private readonly LineStyle _stroke = new() { Width = 1f };
 	private readonly List<EnvelopePoint> _pathPoints = [];
@@ -132,10 +133,9 @@ internal bool AppendColumn(EnvelopeColumn column)
 
 			_columns.Add(column);
 
-			var overflow = _columns.Count - MaxColumns;
-			if (overflow > 0)
+			if (_columns.Count > MaxColumns)
 			{
-				_columns.RemoveRange(0, overflow);
+				_columns.RemoveRange(0, TrimChunk);
 			}
 
 			return true;
diff --git a/SemiPlot/SemiPlot.UI/Chart/TrendChartView.axaml.cs b/SemiPlot/SemiPlot.UI/Chart/TrendChartView.axaml.cs
index 4d1452b..02f0b02 100644
--- a/SemiPlot/SemiPlot.UI/Chart/TrendChartView.axaml.cs
+++ b/SemiPlot/SemiPlot.UI/Chart/TrendChartView.axaml.cs
@@ -37,10 +37,6 @@ public partial class TrendChartView : UserControl
 	private VerticalLine? _deltaSecondLine;
 	private Point? _dragOrigin;
 
-	// Render-thread state: read and written by OnPlotRenderFinished, and reset on the UI thread when the
-	// bound plot changes so the first frame of the new plot always reports.
-	private float _lastRenderedDataAreaWidth = float.NaN;
-
 	// -1 until the bound plot is painted once, so the first scale revision always repaints.
 	private int _paintedAxisCount = -1;
 
@@ -122,19 +118,14 @@ private void ApplyChartPalette()
 		_paintedAxisCount = _viewModel?.AxisCount ?? -1;
 	}
 
-	// This runs on the render thread, so the report is posted back to the UI thread against the view model
-	// the frame was drawn for, not whichever one is bound when the post is dispatched.
-	private void OnPlotRenderFinished(object? sender, RenderDetails renderDetails)
+	// docs/architecture/charting.md#module-layout-avalonia-views--view-models--core-models
+	private static EventHandler<RenderDetails> ReportDataAreaWidthTo(TrendChartViewModel renderedViewModel)
 	{
-		var dataAreaWidth = renderDetails.DataRect.Width;
-		if (dataAreaWidth.Equals(_lastRenderedDataAreaWidth))
+		return (_, renderDetails) =>
 		{
-			return;
-		}
-
-		_lastRenderedDataAreaWidth = dataAreaWidth;
-		var renderedViewModel = _viewModel;
-		Dispatcher.UIThread.Post(() => renderedViewModel?.ReportDataAreaWidth(dataAreaWidth));
+			var dataAreaWidth = renderDetails.DataRect.Width;
+			Dispatcher.UIThread.Post(() => renderedViewModel.ReportDataAreaWidth(dataAreaWidth));
+		};
 	}
 
 	private void OnDataContextChanged(object? sender, EventArgs eventArgs)
@@ -155,14 +146,14 @@ private void OnDataContextChanged(object? sender, EventArgs eventArgs)
 				_ => _axisScaleFlyout.Hide(),
 				ReportFailureOf(nameof(AxisScalePanelViewModel.CloseRequests))));
 
-		_lastRenderedDataAreaWidth = float.NaN;
 		var renderManager = _viewModel.Plot.RenderManager;
-		renderManager.RenderFinished += OnPlotRenderFinished;
+		var reportDataAreaWidth = ReportDataAreaWidthTo(_viewModel);
+		renderManager.RenderFinished += reportDataAreaWidth;
 
 		// RenderFinished is a plain delegate property, so the removal keeps the empty-delegate contract
 		// instead of leaving null behind.
 		_disposables.Add(Disposable.Create(() => renderManager.RenderFinished =
-			(renderManager.RenderFinished - OnPlotRenderFinished) ?? _noRenderFinishedHandler));
+			(renderManager.RenderFinished - reportDataAreaWidth) ?? _noRenderFinishedHandler));
 
 		// Assigned in place rather than via Plot.Axes.DateTimeTicksBottom(), which would replace the shared
 		// bottom-X axis instance the plottables are pinned to.
diff --git a/SemiPlot/SemiPlot.UI/Chart/TrendChartViewModel.cs b/SemiPlot/SemiPlot.UI/Chart/TrendChartViewModel.cs
index 301dbd1..065eafb 100644
--- a/SemiPlot/SemiPlot.UI/Chart/TrendChartViewModel.cs
+++ b/SemiPlot/SemiPlot.UI/Chart/TrendChartViewModel.cs
@@ -21,24 +21,21 @@ namespace SemiPlot.UI.Chart;
 
 public sealed class TrendChartViewModel : ReactiveObject, IDisposable
 {
-	private static readonly TimeSpan _redrawThrottle = TimeSpan.FromMilliseconds(33);
 	private static readonly TimeSpan _historyDebounceWindow = TimeSpan.FromMilliseconds(150);
 	private static readonly TimeSpan _historyCapInterval = TimeSpan.FromMilliseconds(400);
+	private readonly TrendCoordinator _coordinator;
+	private readonly MessagePanelViewModel _messagePanel;
+	private readonly ILogger<TrendChartViewModel> _logger;
+	private readonly ChartRedrawSchedule _redrawSchedule;
 	private readonly ChartAxisBinder _axisBinder;
 	private readonly ChartPenSet _penSet;
-
-	private readonly TrendCoordinator _coordinator;
 	private readonly ChartCursorReader _cursorReader;
 	private readonly ChartDeltaCursorReader _deltaCursorReader;
+	private readonly ChartRealtimeApplier _realtimeApplier;
+	private readonly ChartHistoryRequestDebouncer _historyDebouncer;
 	private readonly CompositeDisposable _disposables = [];
 	private readonly Dictionary<int, PenHistoryEnvelope> _envelopesById = [];
-	private readonly ChartHistoryRequestDebouncer _historyDebouncer;
-	private readonly ILogger<TrendChartViewModel> _logger;
-	private readonly MessagePanelViewModel _messagePanel;
-	private readonly ChartRealtimeApplier _realtimeApplier;
-	private readonly Subject<Unit> _redrawRequests = new();
 	private readonly PenScaleModel _scaleModel = new();
-
 	private readonly Dictionary<int, PenScale> _scalesByPenId = [];
 	private readonly Subject<Unit> _historyApplied = new();
 	private bool _isDisposed;
@@ -60,6 +57,7 @@ public TrendChartViewModel(
 		_coordinator = coordinator;
 		_messagePanel = messagePanel;
 		_logger = logger;
+		_redrawSchedule = new ChartRedrawSchedule(uiScheduler);
 		_axisBinder = new ChartAxisBinder(Plot);
 		_penSet = new ChartPenSet(Plot, _axisBinder);
 		_cursorReader = new ChartCursorReader(_penSet.ById, _envelopesById);
@@ -78,10 +76,6 @@ public TrendChartViewModel(
 		Navigation.WindowChanged += OnNavigationWindowChanged;
 		AxisScale = new AxisScalePanelViewModel(this);
 
-		RedrawRequested = _redrawRequests
-			.Sample(_redrawThrottle, uiScheduler)
-			.ObserveOn(uiScheduler);
-
 		_disposables.Add(_coordinator.RealtimeBatches
 			.Subscribe(ApplyRealtimeBatch));
 		_disposables.Add(_coordinator.RealtimeFailures
@@ -117,7 +111,7 @@ private set
 
 	public IReadOnlyDictionary<int, PenScaleSettings> ScaleSettings => _penSet.ScaleSettings;
 
-	public IObservable<Unit> RedrawRequested { get; }
+	public IObservable<Unit> RedrawRequested => _redrawSchedule.Redraws;
 
 	/// <summary>
 	/// One pulse per history result applied, on the UI scheduler.
@@ -189,7 +183,7 @@ public void Dispose()
 		_historyDebouncer.Dispose();
 		AxisScale.Dispose();
 		_disposables.Dispose();
-		_redrawRequests.Dispose();
+		_redrawSchedule.Dispose();
 		_historyApplied.Dispose();
 		Plot.Dispose();
 	}
@@ -204,7 +198,7 @@ public void Dispose()
 		return _penSet.ById.GetValueOrDefault(penId);
 	}
 
-	// Disposal is tolerated silently because a render can still deliver a width after the window has closed.
+	// A render can deliver a width after the window has closed.
 	public void ReportDataAreaWidth(double dataAreaWidthPixels)
 	{
 		if (_isDisposed || !(dataAreaWidthPixels > 0.0))
@@ -273,22 +267,20 @@ public void WidenToArchiveExtent(ArchiveExtent extent)
 		}
 	}
 
-	public bool SetPenVisibility(int penId, bool isVisible)
+	public void SetPenVisibility(int penId, bool isVisible)
 	{
 		ObjectDisposedException.ThrowIf(_isDisposed, this);
 
 		if (FindPen(penId) is not { } state)
 		{
-			return false;
+			return;
 		}
 
-		state.IsVisible = isVisible;
+		state.SetVisibility(isVisible);
 		ActivateAVisiblePen();
 		this.RaisePropertyChanged(nameof(DrawnPenId));
 		ApplyAxisModel();
 		RequestRedraw();
-
-		return true;
 	}
 
 	// Only a visible pen's axis may be drawn, so a switched-off pen is refused rather than activated:
@@ -682,6 +674,6 @@ public void ReportFailure(Exception failure)
 
 	private void RequestRedraw()
 	{
-		_redrawRequests.OnNext(Unit.Default);
+		_redrawSchedule.Request();
 	}
 }
diff --git a/SemiPlot/SemiPlot.UI/Chart/TrendPenState.cs b/SemiPlot/SemiPlot.UI/Chart/TrendPenState.cs
index 85a194e..bc79c31 100644
--- a/SemiPlot/SemiPlot.UI/Chart/TrendPenState.cs
+++ b/SemiPlot/SemiPlot.UI/Chart/TrendPenState.cs
@@ -12,6 +12,7 @@ public TrendPenState(Pen pen, EnvelopeLine line)
 	{
 		Pen = pen;
 		Line = line;
+		IsVisible = pen.EnabledOnStart;
 		RestyleLine();
 	}
 
@@ -26,12 +27,12 @@ public Pen Pen
 	public bool IsVisible
 	{
 		get;
-		set
+		private set
 		{
 			this.RaiseAndSetIfChanged(ref field, value);
 			Line.IsVisible = value;
 		}
-	} = true;
+	}
 
 	public double? CurrentValue
 	{
@@ -46,6 +47,11 @@ public void Revise(Pen pen)
 		RestyleLine();
 	}
 
+	internal void SetVisibility(bool isVisible)
+	{
+		IsVisible = isVisible;
+	}
+
 	public void LoadHistory(PenHistoryEnvelope envelope)
 	{
 		var columns = new List<EnvelopeColumn>(envelope.Timestamps.Count);
diff --git a/SemiPlot/SemiPlot.UI/Legend/TrendLegendGroupViewModel.cs b/SemiPlot/SemiPlot.UI/Legend/TrendLegendGroupViewModel.cs
index 9c897e2..6ad2ca9 100644
--- a/SemiPlot/SemiPlot.UI/Legend/TrendLegendGroupViewModel.cs
+++ b/SemiPlot/SemiPlot.UI/Legend/TrendLegendGroupViewModel.cs
@@ -19,7 +19,7 @@ public TrendLegendGroupViewModel(string name, bool hasHeader, IReadOnlyList<Tren
 		Rows = rows;
 
 		_switchState = rows
-			.Select(row => row.WhenAnyValue(visibleRow => visibleRow.IsVisible))
+			.Select(row => row.PenState.WhenAnyValue(state => state.IsVisible))
 			.CombineLatest()
 			.Select(DeriveSwitchState)
 			.ToProperty(this, group => group.SwitchState);
@@ -63,7 +63,7 @@ private void SwitchGroup()
 
 		foreach (var row in Rows)
 		{
-			row.IsVisible = switchOn;
+			row.SetVisibility(switchOn);
 		}
 	}
 }
diff --git a/SemiPlot/SemiPlot.UI/Legend/TrendLegendRowViewModel.cs b/SemiPlot/SemiPlot.UI/Legend/TrendLegendRowViewModel.cs
index ec2d6ae..fd0eeb6 100644
--- a/SemiPlot/SemiPlot.UI/Legend/TrendLegendRowViewModel.cs
+++ b/SemiPlot/SemiPlot.UI/Legend/TrendLegendRowViewModel.cs
@@ -1,3 +1,4 @@
+using System.Reactive;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 
@@ -12,26 +13,14 @@ namespace SemiPlot.UI.Legend;
 public sealed class TrendLegendRowViewModel : ReactiveObject, IDisposable
 {
 	private readonly TrendChartViewModel _chartViewModel;
-	private readonly TrendPenState _penState;
-	private readonly int _penId;
-	private readonly ObservableAsPropertyHelper<double?> _currentValue;
 	private readonly ObservableAsPropertyHelper<string> _currentValueText;
 	private readonly ObservableAsPropertyHelper<bool> _isActive;
 	private readonly CompositeDisposable _subscriptions = [];
-	private bool _isVisible;
-	private bool _isSettingVisibilityFromChart;
 
 	public TrendLegendRowViewModel(TrendChartViewModel chartViewModel, TrendPenState penState)
 	{
 		_chartViewModel = chartViewModel;
-		_penState = penState;
-		_penId = penState.Pen.PenId;
-		_isVisible = penState.IsVisible;
-
-		_currentValue = penState
-			.WhenAnyValue(state => state.CurrentValue)
-			.ToProperty(this, row => row.CurrentValue);
-		_subscriptions.Add(_currentValue);
+		PenState = penState;
 
 		_currentValueText = penState
 			.WhenAnyValue(state => state.CurrentValue)
@@ -39,43 +28,23 @@ public TrendLegendRowViewModel(TrendChartViewModel chartViewModel, TrendPenState
 			.ToProperty(this, row => row.CurrentValueText);
 		_subscriptions.Add(_currentValueText);
 
-		_subscriptions.Add(penState
-			.WhenAnyValue(state => state.IsVisible)
-			.Subscribe(MirrorVisibilityFromChart));
-
 		_isActive = chartViewModel
 			.WhenAnyValue(chart => chart.ActivePenId)
-			.Select(activePenId => activePenId == _penId)
+			.Select(activePenId => activePenId == penState.Pen.PenId)
 			.ToProperty(this, row => row.IsActive);
 		_subscriptions.Add(_isActive);
-	}
 
-	public string Name => _penState.Pen.Name;
-
-	public IReadOnlyList<string> Groups => _penState.Pen.Groups;
-
-	public string ColorHex => _penState.Pen.Color;
+		ToggleVisibilityCommand = ReactiveCommand.Create(() => SetVisibility(!PenState.IsVisible));
+		_subscriptions.Add(ToggleVisibilityCommand);
+	}
 
-	public string Unit => _penState.Pen.Unit ?? string.Empty;
+	public TrendPenState PenState { get; }
 
 	public bool IsActive => _isActive.Value;
 
-	public double? CurrentValue => _currentValue.Value;
-
 	public string CurrentValueText => _currentValueText.Value;
 
-	public bool IsVisible
-	{
-		get => _isVisible;
-		set
-		{
-			this.RaiseAndSetIfChanged(ref _isVisible, value);
-			if (!_isSettingVisibilityFromChart && !_subscriptions.IsDisposed)
-			{
-				_chartViewModel.SetPenVisibility(_penId, value);
-			}
-		}
-	}
+	public ReactiveCommand<Unit, Unit> ToggleVisibilityCommand { get; }
 
 	public void Dispose()
 	{
@@ -84,25 +53,17 @@ public void Dispose()
 
 	public void Select()
 	{
-		_chartViewModel.SetActivePen(_penId);
+		_chartViewModel.SetActivePen(PenState.Pen.PenId);
 	}
 
-	// The provider accepted or dropped the mask already: docs/architecture/charting.md.
-	private static string FormatReading(double? value, string? mask)
+	public void SetVisibility(bool isVisible)
 	{
-		return value is { } reading ? PenValueFormat.Format(reading, mask) : Resources.NoValuePlaceholder;
+		_chartViewModel.SetPenVisibility(PenState.Pen.PenId, isVisible);
 	}
 
-	private void MirrorVisibilityFromChart(bool isVisible)
+	// The provider accepted or dropped the mask already: docs/architecture/charting.md.
+	private static string FormatReading(double? value, string? mask)
 	{
-		_isSettingVisibilityFromChart = true;
-		try
-		{
-			IsVisible = isVisible;
-		}
-		finally
-		{
-			_isSettingVisibilityFromChart = false;
-		}
+		return value is { } reading ? PenValueFormat.Format(reading, mask) : Resources.NoValuePlaceholder;
 	}
 }
diff --git a/SemiPlot/SemiPlot.UI/Legend/TrendLegendView.axaml b/SemiPlot/SemiPlot.UI/Legend/TrendLegendView.axaml
index 616abf6..42b0de8 100644
--- a/SemiPlot/SemiPlot.UI/Legend/TrendLegendView.axaml
+++ b/SemiPlot/SemiPlot.UI/Legend/TrendLegendView.axaml
@@ -91,7 +91,8 @@
                                                       VerticalAlignment="Center">
 
                                                     <CheckBox Grid.Column="0"
-                                                              IsChecked="{Binding IsVisible}"
+                                                              IsChecked="{Binding PenState.IsVisible, Mode=OneWay}"
+                                                              Command="{Binding ToggleVisibilityCommand}"
                                                               VerticalAlignment="Center"
                                                               Margin="0,0,4,0" />
 
@@ -101,10 +102,10 @@
                                                             CornerRadius="6"
                                                             Margin="0,0,6,0"
                                                             VerticalAlignment="Center"
-                                                            Background="{Binding ColorHex, Converter={x:Static legend:LegendConverters.HexToBrush}}" />
+                                                            Background="{Binding PenState.Pen.Color, Converter={x:Static legend:LegendConverters.HexToBrush}}" />
 
                                                     <TextBlock Grid.Column="2"
-                                                               Text="{Binding Name}"
+                                                               Text="{Binding PenState.Pen.Name}"
                                                                VerticalAlignment="Center" />
 
                                                     <TextBlock Grid.Column="3"
@@ -116,7 +117,7 @@
 
                                                     <TextBlock Grid.Column="4"
                                                                Name="RowUnit"
-                                                               Text="{Binding Unit}"
+                                                               Text="{Binding PenState.Pen.Unit}"
                                                                IsVisible="{Binding $parent[UserControl].DataContext.IsExpanded}"
                                                                Foreground="{DynamicResource AppSecondaryForegroundBrush}"
                                                                Margin="4,0,0,0"
diff --git a/SemiPlot/SemiPlot.UI/Legend/TrendLegendViewModel.cs b/SemiPlot/SemiPlot.UI/Legend/TrendLegendViewModel.cs
index 6b8ee64..2f3d1f7 100644
--- a/SemiPlot/SemiPlot.UI/Legend/TrendLegendViewModel.cs
+++ b/SemiPlot/SemiPlot.UI/Legend/TrendLegendViewModel.cs
@@ -134,7 +134,7 @@ private static IReadOnlyList<TrendLegendRowViewModel> BuildRows(TrendChartViewMo
 
 	private static IReadOnlyList<TrendLegendGroupViewModel> BuildGroups(IReadOnlyList<TrendLegendRowViewModel> rows)
 	{
-		if (rows.All(row => row.Groups.Count == 0))
+		if (rows.All(row => row.PenState.Pen.Groups.Count == 0))
 		{
 			return rows.Count > 0 ? [new TrendLegendGroupViewModel(string.Empty, hasHeader: false, rows)] : [];
 		}
@@ -144,7 +144,7 @@ private static IReadOnlyList<TrendLegendGroupViewModel> BuildGroups(IReadOnlyLis
 		return
 		[
 			.. rows
-				.SelectMany(row => (row.Groups.Count == 0 ? [ungroupedHeader] : row.Groups)
+				.SelectMany(row => (row.PenState.Pen.Groups is { Count: > 0 } groups ? groups : [ungroupedHeader])
 					.Select(name => (Name: name, Row: row)))
 				.GroupBy(entry => entry.Name, StringComparer.Ordinal)
 				.OrderBy(group => string.Equals(group.Key, ungroupedHeader, StringComparison.Ordinal))
diff --git a/docs/architecture/bench.md b/docs/architecture/bench.md
index 7a6bc6b..e6dd2b4 100644
--- a/docs/architecture/bench.md
+++ b/docs/architecture/bench.md
@@ -352,11 +352,11 @@ own size — the headless platform draws nothing. Capture loss is driven through
 `PlatformCaptureLost` leaves the guard green.
 
 **A test that builds `TrendChartView` needs a UI scheduler that can defer.** `TrendChartViewModel`
-builds `RedrawRequested` as `Sample(33 ms, uiScheduler)`, and `Sample` on
-`ImmediateScheduler.Instance` blocks the calling thread forever — the symptom is a silent hang under
-`TrendChartView.OnDataContextChanged`. Pass `AvaloniaScheduler.Instance` or a `TestScheduler`, and
-dispose every view model built on the Avalonia scheduler inside the test body, since each holds a
-33 ms dispatcher timer.
+schedules each redraw once, 33 ms ahead on its UI scheduler. `ImmediateScheduler.Instance` runs that
+schedule inline after sleeping 33 ms on the calling thread, so every redraw blocks the dispatcher and
+paints inside the call that asked for it. Pass `AvaloniaScheduler.Instance` or a `TestScheduler`, and
+dispose every view model built on the Avalonia scheduler inside the test body, since a scheduled
+redraw is a 33 ms dispatcher timer that only the dispose cancels.
 
 **What the guards do not cover.** The Win32 backend and the desktop `AppBuilder` chain are exercised
 by nothing headless; a desktop-only registration the chain is missing fails at `AppBuilder.Setup` in
diff --git a/docs/architecture/charting.md b/docs/architecture/charting.md
index e6b847f..fed9183 100644
--- a/docs/architecture/charting.md
+++ b/docs/architecture/charting.md
@@ -62,7 +62,10 @@ points outside it, so a frame that meets a history load waits for the one `AddRa
 not for the conversion ahead of it: `LoadHistory` converts into a list local to the call and hands it over
 in one `ReplaceColumns`. The colour and the line style sit under the same lock: a catalogue read can
 change both after the first frame, so `Restyle` writes both on the UI thread and `Render` reads both
-under the lock.
+under the lock. The list is capped at 100 000 columns, and the cap trims in chunks of one tenth: the
+append that passes it removes the oldest 10 000 columns in one `RemoveRange`. The list then lives between
+90 000 and 100 000 columns, and the shift under the lock runs once per 10 000 appends instead of on every
+append.
 
 **The plot's own lists and the render thread.** ScottPlot's `Plot.Render` holds `Plot.Sync` for the
 whole frame, and the plottable and axis lists it walks are ScottPlot's own, so the column lock cannot
@@ -90,9 +93,13 @@ would move it across the plot as the active pen changes. Non-active axes are
 `IsVisible = false`, and the active-pen switch toggles visibility without rebuilding. Scaling is
 driven per-axis via `SetLimitsY(min, max, axis)` from the Core `PenScaleModel` output (no global
 `AutoScale`). Every plottable is pinned to `plot.Axes.Bottom` explicitly at creation, so all pens
-share one X axis and per-pen axes are Y-only. Redraws are coalesced to 30 FPS via a
-`Sample(33 ms)` redraw seam driving `AvaPlot.Refresh()`. Only data/window/visibility/gesture/
-delta-toggle changes drive ScottPlot redraws (through that throttled seam); hover and pointer-exit do
+share one X axis and per-pen axes are Y-only. Redraws are coalesced to at most 30 FPS by the
+`RedrawRequested` seam driving `AvaPlot.Refresh()`, which `Chart/ChartRedrawSchedule` owns for the view
+model: a redraw request schedules one emission 33 ms
+ahead on the UI scheduler unless one is already scheduled, and the requests inside that span join it.
+An idle chart, and a chart no view subscribes to, schedules no redraw; `Dispose` cancels a scheduled
+emission. Only data/window/visibility/gesture/
+delta-toggle changes drive ScottPlot redraws (through that coalescing seam); hover and pointer-exit do
 **not** call `AvaPlot.Refresh()`. A pointer-move updates only the cheap Avalonia cursor overlay, which
 is repositioned from the `RedrawRequested` seam (after `Refresh()`) and on `SizeChanged`. Keeping the
 re-rasterization off the per-pointer-event path is the point of the overlay.
@@ -165,8 +172,10 @@ models, backed by renderer-agnostic models in `SemiPlot.Core`. Responsibilities:
 - `Chart/TrendPenState` — one pen's `EnvelopeLine`, `IsVisible`, `CurrentValue`, and the
   history-load / realtime-append / fold logic that drives those mutators. `Revise(Pen)` replaces the
   pen, which raises `Pen` like `IsVisible` and `CurrentValue`, and restyles the line; `IsVisible` and the
-  loaded history stay. Nothing binds to `Pen`: the hover readout reads it per pointer move and the
-  sidebar reads it when it builds a row.
+  loaded history stay. `IsVisible` is seeded from `Pen.EnabledOnStart` at construction and has a private
+  setter; the internal `SetVisibility`, which `TrendChartViewModel.SetPenVisibility` alone calls, is its
+  one writer, and a method is what no binding can reach. The hover readout reads `Pen` per pointer move;
+  the sidebar row binds through it.
 - `Chart/ChartAxisBinder` — applies the `PenScaleModel` output to ScottPlot Y axes (one left axis per
   pen, `SetLimitsY`, shared-X pinning).
 - `Chart/ChartNavigationController` — owns the `TrendNavigationModel`, the layer ladder, the live-edge
@@ -180,8 +189,9 @@ models, backed by renderer-agnostic models in `SemiPlot.Core`. Responsibilities:
   in the same style as the navigation bar's `IsSticky`. That seam carries the `DataRect` of the frame just
   rasterised; `Plot.LastRender` read after `Refresh()` would still describe the previous frame, so a
   resize could leave the layer computed for the old canvas with nothing scheduled to correct it.
-  `RenderFinished` fires on Avalonia's render thread, so the report is posted to the UI thread, and only
-  a changed width is posted.
+  `RenderFinished` fires on Avalonia's render thread, so the handler posts every frame's width to the
+  UI thread and keeps no state of its own. A repeated width changes nothing: `SetTargetColumnCount` drops
+  an unchanged quantised count.
   A changed *quantised* count re-queries the window even when the layer survives, because it also
   invalidates the decimation width the visible data was fetched at. The re-query keys on the quantised
   count while the query resolution follows the unquantised width, so a resize inside the deadband
@@ -215,6 +225,9 @@ models, backed by renderer-agnostic models in `SemiPlot.Core`. Responsibilities:
 - `Chart/ChartRealtimeApplier` — the append-vs-fold rule per layer for incoming `RealtimeBatch`es.
   It walks each `PenRealtimeValues` on that pen's own timestamps, never on the batch's union, and
   hands the union's last timestamp to `ChartNavigationController.OnLiveEdge`.
+- `Chart/ChartRedrawSchedule` — the redraw coalescer behind `RedrawRequested`: the subject, the UI
+  scheduler, the scheduled emission and its flag. `Request()` schedules nothing while an emission is
+  pending or nothing observes; `Dispose()` cancels the pending one.
 - `Chart/ChartCursorReader` / `ChartDeltaCursorReader` — view-side state wrapping the Core cursor
   models, resolving the visible / active pens (`ChartDeltaCursorReader.FormatReadout` formats Δt/Δy).
 - `Chart/ChartHoverReadout` — pure static `BuildContent`: builds the readout string (local timestamp +
@@ -234,42 +247,47 @@ models, backed by renderer-agnostic models in `SemiPlot.Core`. Responsibilities:
   sticky toggle, delta-mode toggle + inline Δt/Δy readout (ReactiveUI commands). Autoscale, the two
   limit boxes and set-limits left with the axis scale panel taking them over; the layer label left
   for the status bar.
-- `Legend/TrendLegendView` + `TrendLegendViewModel` (+ group / row VMs and the converters) — the
-  grouped sidebar. A row carries the on/off box, a round colour dot, the name, the current value in
-  the pen's own mask and the unit; nothing in it is editable but the box, which an allowlist test over
-  the built row template holds. A header is a section caption, not a bold name: smaller text in
+- `Legend/TrendLegendView` + `TrendLegendViewModel` (+ group / row VMs and the converters) — the grouped
+  sidebar. A row carries the on/off box, a round colour dot, the name, the current value in the pen's own
+  mask and the unit; nothing in it is editable but the box, which an allowlist test over the built row
+  template holds. A header is a section caption, not a bold name: smaller text in
   `AppSecondaryForegroundBrush`, set in capitals by `LegendConverters.ToCapitals`, a one-pixel
   `AppSubtleLineBrush` line above every header but the first (a `:nth-child(1)` style hides the first),
-  and the rows under a header indented so their box starts where the caption starts. The active row
-  keeps the regular weight and is marked by an `AppAccentFillBrush` background and a 3 px `AppAccentBrush`
-  bar on its left edge, both following `IsActive`. A pen draws once and is listed under every group it belongs to, so one
-  row view model appears under several headers and `Dispose` walks the distinct list. Every drawn header,
-  the ungrouped one included, carries a switch box: `TrendLegendGroupViewModel.SwitchState` is derived
-  from its rows (all on true, all off false, mixed null) and stored nowhere, the box reads it
-  `Mode=OneWay`, and `SwitchGroupCommand`, its one writer, switches every row on unless all are on, then
-  off. The rows route to the chart one by one, so every other header a shared pen sits under
-  re-derives. `BuildGroups` keys every row by its groups, an ungrouped row by the ungrouped header, in
-  one ordinal `GroupBy`, so a group named like the ungrouped header takes the ungrouped rows; headers
-  sort alphabetically in the current culture, the ungrouped one last. It constructs every group view
-  model once per build, because a replaced group would keep its subscriptions on the rows. `Rebuild()`,
-  called after every catalogue read that changed something, builds new rows and groups from the chart's
-  `Pens`, assigns `Groups`, which raises `PropertyChanged`, and only then disposes the rows and groups
-  it replaced, so no binding reads a disposed row; a replaced row's visibility write reaches no chart.
-  A row reads its pen's name, colour, unit, mask and visibility when it is built, so a rebuilt row shows
-  the stored change and every pen keeps its visibility. `IsExpanded` is the
-  panel's one state flag: collapsed, the row drops the value and the unit. The panel keeps two session
-  width slots, expanded (starts at 280) and collapsed (starts at 168), and `PanelWidth` shows the slot
-  of the current state, clamped to at least `PanelMinWidth` (120) and to the room that leaves the chart
-  at least `ChartMinWidth` (320). `FitPanel` is the one writer of that room: `MainWindow.axaml.cs` calls
-  it in `OnLoaded` and on every `SizeChanged` of the content grid, so the
-  chart floor holds from the first frame, and a shrink narrows the shown width without writing a slot,
-  so growing the window back restores it. The widths and `IsExpanded` are the panel's own fields, so a
-  `Rebuild()` keeps them. A `Thumb` between the chart and the panel is the drag handle:
-  its `DragDelta` handler calls `ResizePanel`, the only writer of the shown slot, which applies the
-  same clamp. Semi ships no `Thumb` theme, so the handle carries its own template, a `Border` painting
-  its `Background`; without one it draws nothing and a press never reaches it. The handle shows only
-  while `IsLegendVisible` holds. Nothing persists the state or the widths —
-  every start opens expanded at 280.
+  and the rows under a header indented so their box starts where the caption starts. The active row keeps
+  the regular weight and is marked by an `AppAccentFillBrush` background and a 3 px `AppAccentBrush` bar
+  on its left edge, both following `IsActive`. A pen draws once and is listed under every group it
+  belongs to, so one row view model appears under several headers and `Dispose` walks the distinct list.
+  Every drawn header, the ungrouped one included, carries a switch box:
+  `TrendLegendGroupViewModel.SwitchState` is derived from its rows' pen states (all on true, all off
+  false, mixed null) and stored nowhere, the box reads it `Mode=OneWay`, and `SwitchGroupCommand`, its
+  one writer, switches every row on unless all are on, then off. A pen's visibility is
+  `TrendPenState.IsVisible` alone, and the chart's `SetPenVisibility` is its one writer: the row keeps no
+  flag, exposes the chart's state as `PenState`, and its box reads `PenState.IsVisible` `Mode=OneWay` and
+  writes through `ToggleVisibilityCommand`, the pattern of a checkable menu item. The box command and the
+  header switch both reach the chart through the row's `SetVisibility`, one row at a time, so every other
+  header a shared pen sits under re-derives. `BuildGroups` keys every row by its groups, an ungrouped row
+  by the ungrouped header, in one ordinal `GroupBy`, so a group named like the ungrouped header takes the
+  ungrouped rows; headers sort alphabetically in the current culture, the ungrouped one last. It
+  constructs every group view model once per build, because a replaced group would keep its subscriptions
+  on the rows. `Rebuild()`, called after every catalogue read that changed something, builds new rows and
+  groups from the chart's `Pens`, assigns `Groups`, which raises `PropertyChanged`, and only then
+  disposes the rows and groups it replaced, so no binding reads a disposed row. A row binds its pen's
+  name, colour and unit through `PenState.Pen`, which a revision replaces, so they follow a revision
+  without a rebuild; it formats each reading under the mask `PenState.Pen` carries when that reading
+  arrives, so a revised mask shows from the next reading or the next rebuild. Its box reads the pen
+  state the chart keeps, so every pen keeps its visibility. `IsExpanded` is the panel's one state flag: collapsed, the row drops
+  the value and the unit. The panel keeps two session width slots, expanded (starts at 280) and collapsed
+  (starts at 168), and `PanelWidth` shows the slot of the current state, clamped to at least
+  `PanelMinWidth` (120) and to the room that leaves the chart at least `ChartMinWidth` (320). `FitPanel`
+  is the one writer of that room: `MainWindow.axaml.cs` calls it in `OnLoaded` and on every `SizeChanged`
+  of the content grid, so the chart floor holds from the first frame, and a shrink narrows the shown
+  width without writing a slot, so growing the window back restores it. The widths and `IsExpanded` are
+  the panel's own fields, so a `Rebuild()` keeps them. A `Thumb` between the chart and the panel is the
+  drag handle: its `DragDelta` handler calls `ResizePanel`, the only writer of the shown slot, which
+  applies the same clamp. Semi ships no `Thumb` theme, so the handle carries its own template, a `Border`
+  painting its `Background`; without one it draws nothing and a press never reaches it. The handle shows
+  only while `IsLegendVisible` holds. Nothing persists the state or the widths — every start opens
+  expanded at 280.
 - `Minimap/MinimapView` + `MinimapViewModel` — Canvas-based archive-overview strip; navigates via the
   shared `ChartNavigationController` (see trend-interaction.md).
 - `MainWindow/TrendWindow` — builds the window's parts once, in dependency order, and disposes them in
diff --git a/docs/architecture/testing-strategy.md b/docs/architecture/testing-strategy.md
index 5aff1d2..2689136 100644
--- a/docs/architecture/testing-strategy.md
+++ b/docs/architecture/testing-strategy.md
@@ -178,14 +178,16 @@ history path. A 45 s drag capture passes when `RenderOnce` averages 10 ms or les
 ## The UI scheduler in a realised view
 
 A test that realises `TrendChartView` never passes `ImmediateScheduler.Instance` as the chart's UI
-scheduler. The view subscribes to `RedrawRequested`, whose `Sample` schedules periodically, and
-`ImmediateScheduler.SchedulePeriodic` sleeps on the calling thread: the subscription never returns
-and the test hangs. Two schedulers work in its place.
+scheduler. The view subscribes to `RedrawRequested`, and each redraw request schedules one emission
+33 ms ahead. `ImmediateScheduler` runs it inline after sleeping 33 ms on the calling thread, so every
+redraw blocks the dispatcher and paints inside the call that asked for it, which production never does.
+The schedule is one-shot, so nothing hangs; the hang belongs to `PenCatalogueSync`'s wait loop alone
+(`CLAUDE.md`, Test). Two schedulers work in its place.
 
 | Scheduler | When | Cost |
 | --- | --- | --- |
 | `TestScheduler` | the test drives time itself | none |
-| `AvaloniaScheduler.Instance` | the test needs the production seam, as `ChartPointerInputTests` does | the periodic timer lives on the shared headless dispatcher until the view model is disposed, so the test disposes it |
+| `AvaloniaScheduler.Instance` | the test needs the production seam, as `ChartPointerInputTests` does | a scheduled redraw is a 33 ms timer on the shared headless dispatcher until it fires or the view model is disposed, so the test disposes it |
 
 The same holds for a window that realises the chart indirectly: `ChartTestBuilder.CreateChart`, which the
 sidebar tests build on, hands its charts a virtual UI scheduler for this reason alone. Its
diff --git a/docs/architecture/trend-feature-spec.md b/docs/architecture/trend-feature-spec.md
index 176959c..09396a4 100644
--- a/docs/architecture/trend-feature-spec.md
+++ b/docs/architecture/trend-feature-spec.md
@@ -99,6 +99,7 @@ Acceptance-criterion labels: "UI" — verified in the running application; "Core
 ### PN-4 — Enable/disable a pen (visibility) (MUST)
 **Definition.** A pen can be hidden/shown (a checkbox in the legend, two-way sync with the visibility flag). A hidden pen is not drawn and does not participate in the hover readout.
 **Acceptance.** UI: toggling visibility in the legend removes/restores the pen's line; the flag is synchronized between the legend and the chart without looping (guard).
+**Note.** As-built there is nothing to synchronize and no guard: the legend box reads the chart's pen state one way and writes only through the chart's `SetPenVisibility` (charting.md, `Legend/TrendLegendView`).
 
 ### PN-5 — Color and line style (MUST)
 **Definition.** A pen's color and line style: interpolated (a straight line between points) and stepped (Stepped). Style is mapped to the render in `TrendPenState`.
@@ -216,7 +217,7 @@ Acceptance-criterion labels: "UI" — verified in the running application; "Core
 **Acceptance.** Core/test: feeding a point on a coarse layer widens the Min/Max of the last column without adding a new raw point.
 
 ### RT-4 — Update/render parameters (NICE)
-**Definition.** A data-update interval, pixel-aware thinning, a redraw FPS cap (overlay reposition from a throttled RedrawRequested ~30 FPS).
+**Definition.** A data-update interval, pixel-aware thinning, a redraw FPS cap (overlay reposition from a coalesced RedrawRequested ~30 FPS).
 **Acceptance.** UI: redraw is no more frequent than the given FPS; pointer-move does not initiate a full plot redraw.
 
 ---
diff --git a/docs/architecture/trend-interaction.md b/docs/architecture/trend-interaction.md
index cbb6635..c04da7c 100644
--- a/docs/architecture/trend-interaction.md
+++ b/docs/architecture/trend-interaction.md
@@ -123,13 +123,13 @@ as-built mechanics that realize them:
   stored sample and renders the missing left span as data (§TM-3).
 - **Zoom history is debounced off the UI thread** (§DA-9). Gesture-driven re-queries flow through a
   single chokepoint (`Chart/ChartHistoryRequestDebouncer`): `Throttle` collapses rapid notches to one
-  trailing request after the gesture goes quiet, the query runs on the data scheduler, one at a time,
-  and the newest window that arrived while it ran runs when it lands (so a read slower than the cap
-  still completes, and the newest window is the last applied). Per-zoom redraws are coalesced through
-  the 30 FPS `Sample(33 ms)`
-  redraw seam, not an inline refresh. The startup `RequestInitialHistory` is an ordinary request on
-  that path, so the initial load and gestures share one latest-wins history path; the first-snap
-  `TrackDataExtents` path stays non-requerying (single initial load).
+  trailing request after the gesture goes quiet, the query runs on the data scheduler, one at a time, and
+  the newest window that arrived while it ran runs when it lands (so a read slower than the cap still
+  completes, and the newest window is the last applied). Per-zoom redraws are coalesced through the
+  redraw seam, one emission 33 ms after the first request of a span, not an inline refresh. The startup
+  `RequestInitialHistory` is an ordinary request on that path, so the initial load and gestures share one
+  latest-wins history path; the first-snap `TrackDataExtents` path stays non-requerying (single initial
+  load).
 - **Axis scaling gestures (as-built):** entering min/max = fixed manual limits (§AY-3); View -> Pen
   scale -> Autoscale (§AY-4) and View -> Pen scale -> Restore initial scale act on the active pen, and
   the panel's two buttons act on the pen the panel was opened for. The axis scale panel is the only
@@ -188,7 +188,7 @@ so there is one left-button gesture, not overlapping hidden branches.
   `Chart/ChartHoverReadout.BuildContent` string: the local timestamp plus every *visible* pen's value
   at the cursor X (one line per pen; gap or missing pen → dash). The overlay is suppressed while a drag
   is in progress or delta mode is active (`IsDragging || IsDeltaModeEnabled`) and is repositioned from
-  the throttled `RedrawRequested` seam (after `Refresh()`) and on `SizeChanged` so it tracks
+  the coalesced `RedrawRequested` seam (after `Refresh()`) and on `SizeChanged` so it tracks
   pan/zoom/resize/live-edge without per-event re-renders.
 - **Delta cursors (Δt / Δy) via an explicit navigation-bar mode.** The bar's "Delta" toggle
   (`NavigationBarViewModel.IsDeltaModeEnabled`) sets the chart into `DeltaPlacement`: two left clicks
diff --git a/docs/plans/20260929-window-per-process.md b/docs/plans/20260929-window-per-process.md
index f0dd55d..1ea2ba5 100644
--- a/docs/plans/20260929-window-per-process.md
+++ b/docs/plans/20260929-window-per-process.md
@@ -421,9 +421,10 @@ that starts before the first sample is read once instead of once per cap interva
 columns in one `RemoveRange`. The list lives between 90 000 and 100 000 columns, and the shift runs once
 per 10 000 appends.
 
-**Data-area width.** `OnPlotRenderFinished` only posts the width, and
-`TrendChartViewModel.ReportDataAreaWidth` ignores a width equal to the last one it applied. The view keeps
-no width field.
+**Data-area width.** `RenderFinished` carries the `ReportDataAreaWidthTo(TrendChartViewModel)` closure,
+which reads no view field and posts every frame's width to the view model it was built for. A repeated
+width changes nothing, because `SetTargetColumnCount` drops an unchanged quantised count, so neither the
+view nor the view model keeps a width field.
 
 **Idle redraw.** `RequestRedraw` schedules one emission 33 ms ahead on the UI scheduler unless one is
 already scheduled; requests inside that span join it. The flag and the scheduled handle are UI-thread
@@ -999,11 +1000,13 @@ The rule after this task:
 - Modify: `SemiPlot/SemiPlot.Tests.Unit/UI/Chart/EnvelopeLineTests.cs`
 - Modify: `docs/architecture/charting.md`
 
-- [ ] trim `MaxColumns / 10` once the count passes `MaxColumns`
-- [ ] write `AppendingPastTheCapTrimsOneChunk`: the count after the trim, the oldest surviving X, and no
+- [x] trim `MaxColumns / 10` once the count passes `MaxColumns`
+- [x] write `AppendingPastTheCapTrimsOneChunk`: the count after the trim, the oldest surviving X, and no
       count above `MaxColumns + 1`
-- [ ] `charting.md`: the cap trims in chunks of one tenth
-- [ ] run the unit tests - must pass before task 12
+- [x] ➕ `TrendChartViewModelTests.Realtime_PastTheBufferCap_DropsTheOldestColumns` pinned the one-column
+      trim; it now expects the chunk
+- [x] `charting.md`: the cap trims in chunks of one tenth
+- [x] run the unit tests - must pass before task 12
 
 ### Task 12: Keep the data-area width on the UI thread
 
@@ -1012,10 +1015,14 @@ The rule after this task:
 - Modify: `SemiPlot/SemiPlot.UI/Chart/TrendChartViewModel.cs`
 - Modify: `SemiPlot/SemiPlot.Tests.Unit/UI/Chart/TrendChartRenderThreadTests.cs`
 
-- [ ] delete `_lastRenderedDataAreaWidth`; `OnPlotRenderFinished` posts every width
-- [ ] `ReportDataAreaWidth` ignores a width equal to the last applied one
-- [ ] write tests: a repeated width changes nothing; a new width re-targets the column count
-- [ ] run the unit tests - must pass before task 13
+- [x] delete `_lastRenderedDataAreaWidth`; `OnPlotRenderFinished` posts every width
+      (➕ as built: the handler is a closure over the bound view model, so it reads no view field either)
+- [x] `ReportDataAreaWidth` ignores a width equal to the last applied one
+      (➕ after review: `SetTargetColumnCount` already drops an unchanged quantised count, so the
+      view-model field went)
+- [x] write tests: a repeated width changes nothing; a new width re-targets the column count
+- [x] ➕ `charting.md`: the render seam posts every width and the view model drops a repeat
+- [x] run the unit tests - must pass before task 13
 
 ### Task 13: Let an idle chart schedule nothing
 
@@ -1028,14 +1035,18 @@ The rule after this task:
 - Modify: `docs/architecture/bench.md`
 - Modify: `docs/architecture/testing-strategy.md`
 
-- [ ] replace `Sample` and the trailing `ObserveOn` (`TrendChartViewModel.cs:79-81`) with the one-shot
+- [x] replace `Sample` and the trailing `ObserveOn` (`TrendChartViewModel.cs:79-81`) with the one-shot
       schedule Technical Details states
-- [ ] write `AnIdleChartSchedulesNoRedraw` on a `TestScheduler`, and a burst test: requests over 100 ms give
+      (➕ as built: a request with no subscriber schedules nothing, as the hot subject under `Sample` dropped
+      it, so a chart on `ImmediateScheduler` with no view never sleeps 33 ms per request)
+- [x] write `AnIdleChartSchedulesNoRedraw` on a `TestScheduler`, and a burst test: requests over 100 ms give
       one redraw per 33 ms span and one after the last request
-- [ ] rewrite the redraw and hang statements in `CLAUDE.md` (Test), `charting.md:92`,
+      (➕ as built: `ABurstOfRequestsRedrawsOncePerSpanAndOnceAfterTheLastRequest`; both read a UI
+      `TestScheduler` the chart alone uses, and both fail on the `Sample` pipeline)
+- [x] rewrite the redraw and hang statements in `CLAUDE.md` (Test), `charting.md:92`,
       `trend-interaction.md:128`, `bench.md:346-352` and `testing-strategy.md:166-169`: the redraw is a
       one-shot schedule, and the periodic-schedule hang remains for `PenCatalogueSync`'s wait only
-- [ ] run the unit tests - must pass before task 14
+- [x] run the unit tests - must pass before task 14
 
 ### Task 14: Give pen visibility one writer
 
@@ -1046,14 +1057,22 @@ The rule after this task:
 - Modify: `SemiPlot/SemiPlot.Tests.Unit/UI/Legend/TrendLegendViewModelTests.cs`
 - Modify: `SemiPlot/SemiPlot.Tests.Unit/UI/Legend/TrendLegendViewTests.cs`
 
-- [ ] the row exposes the pen state and `ToggleVisibilityCommand`; delete the row's `IsVisible` setter and
+- [x] the row exposes the pen state and `ToggleVisibilityCommand`; delete the row's `IsVisible` setter and
       `_isSettingVisibilityFromChart`
-- [ ] the group derives its switch from the pen states and switches through the rows' command path
-- [ ] the row's `CheckBox` binds through the pen state one way plus the command; the allowlist in
+      (➕ as built: the row's `IsVisible` goes whole, getter included, so nothing on the row can drift; the
+      command and the group both call the row's `SetVisibility`; ➕ after review: its replaced-row guard
+      went, because nothing calls a replaced row)
+- [x] the group derives its switch from the pen states and switches through the rows' command path
+- [x] the row's `CheckBox` binds through the pen state one way plus the command; the allowlist in
       `TrendLegendViewTests` still holds
-- [ ] write tests: a row click, a group switch and a chart-side change each leave the checkbox and the pen
+- [x] write tests: a row click, a group switch and a chart-side change each leave the checkbox and the pen
       in agreement
-- [ ] run the unit tests - must pass before task 15
+      (➕ as built: `AClickOnARowBox_SwitchesItsPenAndTheBoxFollows`,
+      `AClickOnTheGroupSwitch_LeavesEveryRowBoxAgreeingWithItsPen`,
+      `APenSwitchedOnTheChart_MovesItsRowBoxBeforeAndAfterAClick`, and `ARowBoxSetInCode_WritesNothingToThePen`
+      pinning the one-way binding)
+- [x] ➕ `charting.md` and `trend-feature-spec.md` PN-4: one source, one writer, no guard
+- [x] run the unit tests - must pass before task 15
 
 ### Group G: logs and backlog (PR 7)
 
@@ -1085,7 +1104,9 @@ The rule after this task:
       - `throw exception;` in `ArchiveExceptionMapper.cs:28`;
       - the undisposed bounds subscription in `MinimapView.axaml.cs:29`;
       - the double UI hop in `MinimapViewModel.LoadExtentAsync` (`:86-87`);
-      - the per-pointer-move allocation in the cursor read
+      - the per-pointer-move allocation in the cursor read;
+      - ➕ the debouncer's 400 ms `Sample` timer, which runs on the data scheduler for the chart's
+        lifetime even while it is idle (`ChartHistoryRequestDebouncer.cs:55-56`)
 - [ ] delete the two stale bullets at `backlog.md:81-90`
 - [ ] run `git grep -n "bench-demo.ps1\|LiveWithin" -- docs/plans/backlog.md` - prints nothing
 
@@ -1116,42 +1137,41 @@ The rule after this task:
 - branch: another-instance
 - branch: live-theme
 - branch: history-pipeline
+- branch: render-path
 
 ## Verify it yourself
 
-Group E (Tasks 9 and 10) only; Groups A-D shipped as #97, #98, #99, #102 and #103, Groups F-G are later
-branches.
+Group F (Tasks 11-14) only; Groups A-E shipped as #97, #98, #99, #102, #103 and #104, Group G is a later
+branch.
 
 1. Build and tests, from the repository root:
    - `dotnet build SemiPlot.slnx` - 0 warnings, 0 errors.
-   - `dotnet test SemiPlot/SemiPlot.Tests.Unit/SemiPlot.Tests.Unit.csproj` - 1580 passed.
+   - `dotnet test SemiPlot/SemiPlot.Tests.Unit/SemiPlot.Tests.Unit.csproj` - 1591 passed.
    - `dotnet test SemiPlot/SemiPlot.Tests.Integration/SemiPlot.Tests.Integration.csproj` - 138 passed
      (needs Docker; do not run it at the same time as the unit suite).
-2. The history pipeline, by test (`dotnet test <project> --filter "FullyQualifiedName~<name>"`); none of
-   them exists on `master`:
-   - `ChartHistoryRequestCancellationTests`: `APacedRequestNeverCancelsTheQueryInFlight`,
-     `AGestureEndCancelsTheLeftBehindQuery`, `ACancelledQueryReportsNothing`,
-     `AGestureEndNeverWaitsForTheCancelToReachTheServer`, `DisposingNeverWaitsForTheCancelToReachTheServer`
-     - a drag never cancels, its end cancels the read it left, a cancel reports nothing, and Npgsql's cancel
-     request never runs on the UI thread or under a lock;
-   - `ChartHistoryRequestDebouncerTests.AFailedApplyCanBeRequestedAgain` and
-     `TrendChartViewModelTests.AWindowWhoseApplyThrewIsReadAgainOnTheNextMove`,
-     `AnApplyThatThrowsPartWayLeavesNoBandFetched` - a window whose apply threw is read again;
-   - `TrendChartViewModelTests.AGestureEndingBackInsideTheFetchedBandCancelsTheReadItLeft`,
-     `AReadForAnOlderPenSetLeavesTheNewPensReadRunning`, `APenThatComesBackWhileTheRemovalsReadIsHeldIsReadAgain`
-     - the drawn window has one owner, per pen set;
-   - `TrendChartViewModelTests.AnArchiveYoungerThanTheWindowIsReadOnce`,
-     `AZoomOutPastTheArchiveFollowedByNowReadsTheWindowOnce` - an idle chart whose window starts before the
-     first sample reads once (on the branch before `70c98ef` it read every 200 ms);
-   - `PenCatalogueApplierTests.ADeltaAddingAPenWithOlderRows_WhoseReadLandsBeforeTheExtent_ReadsTheOlderRowsInView`,
-     `ADeltaGivingAChartThatLostItsPensAPenWithOlderRows_ReadsAndPansBackToThem` - two gaps present on
-     `master` (failing there), fixed here;
-   - integration: `PostgresHistoryReadTests.AReadCancelledMidStatementThrowsInsteadOfFailing` (Raw and
-     Minute) - a read cancelled while a lock holds it ends in `OperationCanceledException`, not a fault.
-3. On the demo stand (`dotnet run --project SemiPlot/SemiPlot.AppHost`), acceptance step 7:
-   - drag the chart across a Raw window for about 3 s and release: the strip fills during the drag, and the
-     final window appears within one read of the release; no archive fault appears in the message panel;
-   - drag out of the drawn band and back into it, then release: the window stays drawn and does not flicker
-     to another band;
-   - leave the window idle for a minute: the log shows no repeated history reads;
-   - close the window while a long drag is in flight: it closes at once.
+   - Acceptance Evidence item 6, `git grep -nE "_isSettingVisibilityFromChart|_lastRenderedDataAreaWidth|Sample\(_redrawThrottle" -- SemiPlot`,
+     prints nothing.
+2. The render path and the legend, by test (`dotnet test <project> --filter "FullyQualifiedName~<name>"`);
+   none of them exists on `master`:
+   - `EnvelopeLineTests.AppendingPastTheCapTrimsOneChunk` - the cap trims one tenth at once;
+   - `TrendChartRenderThreadTests`: `ARepeatedDataAreaWidth_ChangesNothing`,
+     `ANewDataAreaWidth_RetargetsTheColumnCount`, `AReboundView_ReportsTheWidthToTheNewChartAlone` - each
+     frame's width reaches the view model it was drawn for, on the UI thread;
+   - `TrendChartViewModelTests`: `AnIdleChartSchedulesNoRedraw`, `AChartNoViewSubscribesToSchedulesNoRedraw`,
+     `ABurstOfRequestsRedrawsOncePerSpanAndOnceAfterTheLastRequest`, `DisposingTheChartCancelsTheScheduledRedraw`
+     - the redraw is one coalescing schedule, and nothing is queued while idle or after dispose;
+   - `TrendLegendViewTests`: `AClickOnARowBox_SwitchesItsPenAndTheBoxFollows`,
+     `AClickOnTheGroupSwitch_LeavesEveryRowBoxAgreeingWithItsPen`,
+     `APenSwitchedOnTheChart_MovesItsRowBoxBeforeAndAfterAClick`, `ARowBoxSetInCode_WritesNothingToThePen`,
+     `TheRealisedRow_ShowsARevisedUnitWithoutARebuild`, and
+     `TrendLegendViewModelTests.TheRow_FollowsAChangeOfTheChartsPenState` - the box and the pen never disagree,
+     and the box writes only through its command.
+3. On the demo stand (`dotnet run --project SemiPlot/SemiPlot.AppHost`):
+   - in the sidebar, untick a pen's box: its line disappears and the box stays unticked; tick it again;
+   - switch a group off and on with its header switch: every row box in the group follows, and each line
+     with it; switch one row back by hand, then the group switch again: no box disagrees with its line;
+   - in `Edit` -> `Pens and groups`, change a pen's unit and name: within 5 s the sidebar row shows both,
+     and the pen keeps its visibility;
+   - resize the window narrow and wide again: the chart redraws at the new width with no flicker;
+   - pan to a historical window off the live edge and leave it: Task Manager shows the viewer at about
+     0% CPU.