From 8745977da504bd4066a5476f6b783959ddf7c0b3 Mon Sep 17 00:00:00 2001
From: DonislawDev <contact@donislawdev.com>
Date: Tue, 29 Sep 2026 15:26:10 +0200
Subject: [PATCH] Draw the plan sheet cheaper: a shadow under it, commands in
 one field past twenty

W6 of the performance series, report items G-6 and G-7.

The shadow is a sibling under the sheet rather than an effect on it. An
effect takes its whole subtree as input, so every caret blink in the
confirmation box and every tick of a run made WPF blur the sheet again -
where WPF draws in software, as over Remote Desktop, a third to half of a
core while the box held the keyboard. As a sibling it measures the same as
no shadow at all, and the sheet's text gets ClearType back. PlanSheetFrame
carries the shape both wear, so the shadow can only be cast by the sheet.

Past twenty lines a block of commands stands in one read-only text box
instead of a box, a scroller and a Copy button per line. A stop over a
whole scope printed 334 of those as 5013 of the sheet's 7185 elements. The
new CommandBlock type answers what a block holds, how it is shown and what
Copy all carries, for both the commands and the way back, and replaces six
properties on Planned. Each section of commands binds its block as its
data, so the Copy all button's name, content, tip, tag and visibility move
into its style. ChromelessBox is split out of SearchFieldBox, since the
field is the second box that stands in a frame drawn by something else.

Entries the machine does not work without are named in one sentence per
kind over the confirmation box, rather than one sentence per plan - on a
scope stop those sentences took the footer to 465 of 551 units and left the
steps one unit tall. Gathered in the window, not in the core, because the
core's warnings reach the JSON of --dry-run. The warning about a process
that takes others with it is not gathered, since its sentence names one
entry.

Measured after the build with the same probe: a scope stop's sheet has
2534 elements instead of 7185, its body 221 units instead of 1, and opens in
about 300-410 ms instead of 460-800. With the caret in the box and software
rendering the sheet costs 2-6 ms of processor a second, against 207-262 for
the look before this change in the same process.

The markup ceiling comes down to 176 now that PlanView.xaml is 174. The
catalogue guard for tall samples asks every sample instead of PlanSheet,
which is no longer tall once its margin moved to the cell.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  11 +
 src/Bws.Gui/PlanView.xaml                     |  80 +++---
 src/Bws.Gui/PlanView.xaml.cs                  |  21 +-
 src/Bws.Gui/Themes/Plan.xaml                  | 128 +++++++++-
 src/Bws.Gui/Themes/PlanLines.xaml             |  18 +-
 src/Bws.Gui/Themes/SearchField.xaml           |  24 +-
 src/Bws.Gui/Themes/Spacing.xaml               |   3 +
 src/Bws.Gui/ViewModels/CommandBlock.cs        |  88 +++++++
 src/Bws.Gui/ViewModels/PlanWords.cs           |  43 ++++
 src/Bws.Gui/ViewModels/Planned.Forcing.cs     |   6 +-
 src/Bws.Gui/ViewModels/Planned.Sections.cs    |  69 +++---
 src/Bws.Gui/ViewModels/Planned.cs             |  27 +-
 tests/Bws.Architecture.Tests/SizeCeilings.cs  |  12 +-
 tests/Bws.Gui.Tests/CatalogueGuards.cs        |  22 +-
 tests/Bws.Gui.Tests/ContrastGuards.cs         |   3 +-
 .../CriticalEntryWindowGuards.cs              |  68 ++++++
 tests/Bws.Gui.Tests/PlanSheetCostGuards.cs    | 231 ++++++++++++++++++
 tests/Bws.Gui.Tests/PlanSheetListsTests.cs    |  64 +++++
 18 files changed, 806 insertions(+), 112 deletions(-)
 create mode 100644 src/Bws.Gui/ViewModels/CommandBlock.cs
 create mode 100644 tests/Bws.Gui.Tests/PlanSheetCostGuards.cs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6f0b0bc..b559c82 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -30,6 +30,17 @@ is not part of this repository.
   signature again. It keeps what it already knows about files whose path has not changed and
   verifies only new or changed ones. F5 still verifies everything again, so a file replaced by
   someone else in the meantime shows its new verdict after the next F5.
+- The text on the plan sheet is sharper - it is drawn with ClearType like the rest of the window.
+  The sheet's shadow looks the same, but it no longer makes the whole sheet redraw with every blink
+  of the cursor. Where the window is drawn without the graphics card, as it is over Remote Desktop,
+  that cost a third to half of a processor core for as long as the box a name is typed into was
+  waiting.
+- A plan with more than twenty commands shows them in one field that can be selected and copied,
+  instead of a box and a Copy button for every line. *Copy all* still takes all of them. The same
+  goes for the way back after a run. A plan over a whole scope opens noticeably faster.
+- When a plan touches several entries this machine does not work without, the sheet names them all
+  in one sentence instead of one sentence each. On a plan over a whole scope those sentences used
+  to push every step off the sheet.
 
 ## [0.3.0] - 2026-09-25
 
diff --git a/src/Bws.Gui/PlanView.xaml b/src/Bws.Gui/PlanView.xaml
index 96ec07c..73e5e1c 100644
--- a/src/Bws.Gui/PlanView.xaml
+++ b/src/Bws.Gui/PlanView.xaml
@@ -71,8 +71,18 @@
             THE WIDTH IS A NAME SINCE 2026-09-15 and was a raw 560 here for a fortnight - the same
             family as backlog 352, a dimension written where no guard reads it. The number did not
             move, only where it lives.
+
+            A CELL WITH TWO THINGS IN IT SINCE 2026-09-29: the shadow under, the sheet on top, both
+            filling the one rectangle the cell is given - so the shadow cannot part from the sheet
+            at any height of the footer. Why the shadow stopped being an effect ON the sheet is
+            beside PlanSheetShadow in Themes/Plan.xaml, with the measurement. The place and the size
+            are attributes rather than a style, because the catalogue builds samples of styles and
+            has nothing to build a Grid from.
         -->
-        <Border x:Name="Sheet" Style="{StaticResource PlanSheet}" Width="{StaticResource WidthPlanSheet}">
+        <Grid HorizontalAlignment="Center" VerticalAlignment="Center"
+              Margin="{StaticResource MarginPlanSheet}" Width="{StaticResource WidthPlanSheet}">
+        <Border Style="{StaticResource PlanSheetShadow}" />
+        <Border x:Name="Sheet" Style="{StaticResource PlanSheet}">
 
         <Grid>
             <Grid.RowDefinitions>
@@ -180,15 +190,10 @@
             </StackPanel>
 
             <!--
-                THE LINE ABOVE THE SCROLLING HALF, 2026-09-01, repairing what the owner called
-                things running into each other: the last visible line was cut through the middle by
-                the edge of the scrolling region with nothing saying an edge was there. A rule turns
-                the same pixels into "there is more below". Scrolls vertically and never sideways.
+                THE HALF THAT SCROLLS, under a rule - what the rule is for is beside PlanBody in
+                Themes/Plan.xaml. Scrolls vertically and never sideways.
             -->
-            <Border Grid.Row="2"
-                    BorderBrush="{StaticResource SurfacePanelEdge}"
-                    BorderThickness="{StaticResource BorderFooterRule}"
-                    Padding="{StaticResource PaddingFooter}">
+            <Border Grid.Row="2" Style="{StaticResource PlanBody}">
             <!--
                 THE WHEEL IS TAKEN IN THE TUNNEL, since 2026-09-16, because a command's own viewer
                 below would otherwise keep it - the argument is beside that viewer in PlanLines.xaml.
@@ -290,34 +295,38 @@
                         THE HEADING SHARES ITS LINE WITH "COPY ALL" SINCE 2026-09-16, here and over
                         the commands below, and the press is caught on the SECTION rather than on
                         the list: the button beside each line and the one over all of them bubble
-                        to one handler, which reads the text off whichever Tag was pressed. The
-                        button goes when there is one line - see Planned.HasSeveralCommands.
+                        to one handler, which reads the text off whichever Tag was pressed.
+
+                        EACH SECTION'S DATA IS ITS CommandBlock SINCE 2026-09-29 - W6 - so both are
+                        the same markup over different blocks: whether the section is there, the
+                        button over it, the list of lines up to twenty and the one field past that.
+                        What the button carries and when it goes are in PlanCopyAllButton, and the
+                        field is in PlanCommandsRecess and PlanCommandsField, all in PlanLines.xaml.
                     -->
                     <StackPanel x:Name="WayBackSection"
+                                DataContext="{Binding WayBackBlock}"
                                 Button.Click="CopyCommandRequested"
-                                Visibility="{Binding HasWayBack, Converter={StaticResource WhenTrue}}">
+                                Visibility="{Binding Any, Converter={StaticResource WhenTrue}}">
                         <DockPanel Margin="{StaticResource MarginSection}">
                             <!-- The ghost box: same margin, edge and padding as a line's box, so this
                                  button ends where the lines' buttons end. Argument in PlanLines.xaml. -->
                             <Border DockPanel.Dock="Right" Style="{StaticResource PlanCommandGhost}">
-                                <Button Style="{StaticResource PlanCopyAllButton}"
-                                        AutomationProperties.AutomationId="planCopyAllWayBack"
-                                        AutomationProperties.Name="{DynamicResource gui.plan.copyAll}"
-                                        Content="{DynamicResource gui.plan.copyAll}"
-                                        ToolTip="{DynamicResource gui.plan.copyAll.hint}"
-                                        Visibility="{Binding HasSeveralWayBack, Converter={StaticResource WhenTrue}}"
-                                        Tag="{Binding AllWayBack}" />
+                                <Button Style="{StaticResource PlanCopyAllButton}" AutomationProperties.AutomationId="planCopyAllWayBack" />
                             </Border>
 
-                            <TextBlock Text="{DynamicResource gui.plan.wayBack}"
-                                       VerticalAlignment="Center"
-                                       Style="{StaticResource SectionHeadingText}" />
+                            <TextBlock Text="{DynamicResource gui.plan.wayBack}" Style="{StaticResource PlanCommandsHeading}" />
                         </DockPanel>
 
                         <ItemsControl x:Name="WayBackList"
                                       AutomationProperties.AutomationId="planWayBack"
-                                      ItemsSource="{Binding WayBack}"
+                                      ItemsSource="{Binding Listed}"
                                       ItemTemplate="{StaticResource PlanCommandTemplate}" />
+
+                        <Border Style="{StaticResource PlanCommandsRecess}">
+                            <TextBox x:Name="WayBackField" Style="{StaticResource PlanCommandsField}"
+                                     AutomationProperties.AutomationId="planWayBackField"
+                                     AutomationProperties.Name="{DynamicResource gui.plan.wayBack}" />
+                        </Border>
                     </StackPanel>
 
                     <!--
@@ -334,29 +343,27 @@
                         first.
                     -->
                     <StackPanel x:Name="CommandSection"
+                                DataContext="{Binding CommandBlock}"
                                 Button.Click="CopyCommandRequested"
-                                Visibility="{Binding HasCommands, Converter={StaticResource WhenTrue}}">
+                                Visibility="{Binding Any, Converter={StaticResource WhenTrue}}">
                         <DockPanel Margin="{StaticResource MarginSection}">
                             <Border DockPanel.Dock="Right" Style="{StaticResource PlanCommandGhost}">
-                                <Button x:Name="CopyAllButton"
-                                        Style="{StaticResource PlanCopyAllButton}"
-                                        AutomationProperties.AutomationId="planCopyAll"
-                                        AutomationProperties.Name="{DynamicResource gui.plan.copyAll}"
-                                        Content="{DynamicResource gui.plan.copyAll}"
-                                        ToolTip="{DynamicResource gui.plan.copyAll.hint}"
-                                        Visibility="{Binding HasSeveralCommands, Converter={StaticResource WhenTrue}}"
-                                        Tag="{Binding AllCommands}" />
+                                <Button x:Name="CopyAllButton" Style="{StaticResource PlanCopyAllButton}" AutomationProperties.AutomationId="planCopyAll" />
                             </Border>
 
-                            <TextBlock Text="{DynamicResource gui.plan.commands}"
-                                       VerticalAlignment="Center"
-                                       Style="{StaticResource SectionHeadingText}" />
+                            <TextBlock Text="{DynamicResource gui.plan.commands}" Style="{StaticResource PlanCommandsHeading}" />
                         </DockPanel>
 
                         <ItemsControl x:Name="CommandList"
                                       AutomationProperties.AutomationId="planCommands"
-                                      ItemsSource="{Binding Commands}"
+                                      ItemsSource="{Binding Listed}"
                                       ItemTemplate="{StaticResource PlanCommandTemplate}" />
+
+                        <Border Style="{StaticResource PlanCommandsRecess}">
+                            <TextBox x:Name="CommandField" Style="{StaticResource PlanCommandsField}"
+                                     AutomationProperties.AutomationId="planCommandsField"
+                                     AutomationProperties.Name="{DynamicResource gui.plan.commands}" />
+                        </Border>
                     </StackPanel>
                 </StackPanel>
             </ScrollViewer>
@@ -371,5 +378,6 @@
             <local:PlanFooter Grid.Row="3" x:Name="Footer" />
         </Grid>
         </Border>
+        </Grid>
     </Grid>
 </UserControl>
diff --git a/src/Bws.Gui/PlanView.xaml.cs b/src/Bws.Gui/PlanView.xaml.cs
index 90bd029..b7d8ae8 100644
--- a/src/Bws.Gui/PlanView.xaml.cs
+++ b/src/Bws.Gui/PlanView.xaml.cs
@@ -358,8 +358,11 @@ internal void TakeTheKeyboard() =>
     /// <summary>The entries that got no plan, as they reach the screen.</summary>
     internal IReadOnlyList<string> ProblemLines => [.. ProblemList.Items.OfType<string>()];
 
-    /// <summary>The command lines, as they reach the screen. `E5`.</summary>
-    internal IReadOnlyList<string> CommandLines => [.. CommandList.Items.OfType<string>()];
+    /// <summary>
+    /// The command lines, as they reach the screen - one box each up to twenty, one field past that
+    /// (W6, see CommandBlock). `E5`.
+    /// </summary>
+    internal IReadOnlyList<string> CommandLines => Shown(CommandList, CommandField);
 
     /// <summary>What did not work, as it reaches the screen.</summary>
     internal IReadOnlyList<string> FailureLines =>
@@ -377,8 +380,18 @@ internal void TakeTheKeyboard() =>
         [.. FailureList.Items.OfType<PlanFailure>().Where(failure => failure.HasOffer)
             .Select(failure => failure.Label)];
 
-    /// <summary>The way back, as it reaches the screen.</summary>
-    internal IReadOnlyList<string> WayBackLines => [.. WayBackList.Items.OfType<string>()];
+    /// <summary>The way back, as it reaches the screen, in either of the two shapes above.</summary>
+    internal IReadOnlyList<string> WayBackLines => Shown(WayBackList, WayBackField);
+
+    /// <summary>
+    /// The lines of one block of commands off whichever of its two shapes holds them: the list's own
+    /// items, or - when the list is empty - the field's text cut back into lines. Read off the
+    /// controls rather than the model, for the reason <see cref="StepLines"/> gives.
+    /// </summary>
+    private static IReadOnlyList<string> Shown(ItemsControl list, TextBox field) =>
+        list.Items.Count == 0 && field.Text.Length > 0
+            ? field.Text.Split(Environment.NewLine)
+            : [.. list.Items.OfType<string>()];
 
     /// <summary>What is worth knowing, as it reaches the screen.</summary>
     internal IReadOnlyList<string> WarningLines =>
diff --git a/src/Bws.Gui/Themes/Plan.xaml b/src/Bws.Gui/Themes/Plan.xaml
index d3b20d2..3c6b37a 100644
--- a/src/Bws.Gui/Themes/Plan.xaml
+++ b/src/Bws.Gui/Themes/Plan.xaml
@@ -3,8 +3,9 @@
                     xmlns:media="clr-namespace:System.Windows.Media;assembly=PresentationCore">
 
     <!--
-        WHAT THE PLAN SHEET IS: the dimming behind it, the sheet itself, the way out of it, and the
-        two blocks a section can sit in. Styles only, not one value.
+        WHAT THE PLAN SHEET IS: the dimming behind it, the sheet itself and its shadow, the way out
+        of it, the two blocks a section can sit in, and the two sections of commands. Styles only,
+        not one value.
 
         IT SPLIT IN TWO ON 2026-09-07 AND THE MARKUP RATCHET IS WHAT ASKED, for the second time in
         five days and the second time pointing at the same seam. A failure that can be escalated
@@ -221,24 +222,54 @@
         THE MARGIN IS THE MAXIMUM HEIGHT. Centred with air above and below, the sheet can never be
         taller than the window minus that air, and its body scrolls inside itself instead - so the
         buttons at the foot are always on screen. That is the fault this replaces, said as geometry.
+        The margin, the centring and the width stand on the cell PlanView.xaml wraps the sheet in
+        since 2026-09-29, so the shadow below gets exactly the rectangle the sheet gets.
+
+        THE SHAPE IS ONE STYLE AND TWO THINGS WEAR IT - the sheet and its shadow - so the shadow can
+        only ever be cast by the rectangle the sheet is (GUI rule 7).
     -->
-    <Style x:Key="PlanSheet" TargetType="Border">
+    <Style x:Key="PlanSheetFrame" TargetType="Border">
         <Setter Property="Background" Value="{StaticResource SurfacePanel}" />
         <Setter Property="BorderBrush" Value="{StaticResource SurfacePanelEdge}" />
         <Setter Property="BorderThickness" Value="{StaticResource BorderAllSides}" />
         <Setter Property="CornerRadius" Value="{StaticResource CornerPlanSheet}" />
+    </Style>
+
+    <Style x:Key="PlanSheet" TargetType="Border" BasedOn="{StaticResource PlanSheetFrame}">
         <Setter Property="Padding" Value="{StaticResource PaddingPanel}" />
-        <Setter Property="HorizontalAlignment" Value="Center" />
-        <Setter Property="VerticalAlignment" Value="Center" />
-        <Setter Property="Margin" Value="{StaticResource MarginPlanSheet}" />
+    </Style>
 
+    <!--
+        THE SHADOW, UNDER THE SHEET RATHER THAN ON IT SINCE 2026-09-29 - W6 of the performance
+        series, report item G-6, measured before it was chosen (performance analysis, section 5).
+
+        AN EFFECT ON AN ELEMENT TAKES ITS WHOLE SUBTREE AS THE EFFECT'S INPUT. On the sheet, every
+        redraw of anything inside it - the caret in the confirmation box, the progress line once a
+        second - had WPF blur the sheet again. Where WPF draws in software, which is the case over
+        Remote Desktop unless an application opts out, that was a third to a half of a core for as
+        long as the confirmation box held the keyboard, and 8-14% of one through a run. As a
+        sibling under the sheet it cost nothing measurable over no shadow at all in either mode:
+        WPF blurs again when what is UNDER the effect changes, not when something drawn over it
+        does - the prediction said otherwise and the third run settled it. A bitmap cache round the
+        effect added nothing measurable and drew the shadow further from the shipped one.
+
+        AND THE SHEET'S TEXT GOT ITS ClearType BACK, which is the visible half. An effect turns
+        ClearType off for everything under it - measured on the 16 826 pixels of the sheet's text
+        that differ between the two: 3 126 of them coloured in the shipped window, 15 904 with the
+        shadow moved beside the sheet. The same family CLAUDE.md records for Mica. The owner was
+        told before deciding.
+
+        NO HIT TESTING: the dimming under it keeps eating the clicks the list must not get, and the
+        shadow is never what somebody pressed. WindowLayerGuards asks by a hit test.
+
+        Black rather than a colour, and soft rather than tight: a shadow that can be SEEN as a shape
+        reads as a border drawn badly. This one only has to say that there is space between the
+        sheet and the window behind it.
+    -->
+    <Style x:Key="PlanSheetShadow" TargetType="Border" BasedOn="{StaticResource PlanSheetFrame}">
+        <Setter Property="IsHitTestVisible" Value="False" />
         <Setter Property="Effect">
             <Setter.Value>
-                <!--
-                    Black rather than a colour, and soft rather than tight: a shadow that can be
-                    SEEN as a shape reads as a border drawn badly. This one only has to say that
-                    there is space between the sheet and the window behind it.
-                -->
                 <DropShadowEffect Color="Black"
                                   BlurRadius="28"
                                   ShadowDepth="8"
@@ -248,6 +279,81 @@
         </Setter>
     </Style>
 
+    <!--
+        THE BODY OF THE SHEET - the rule over the half that scrolls, and the air inside it. It was
+        three attributes on the Border in PlanView.xaml until 2026-09-29, when that file stood on its
+        markup ceiling and W6 needed the lines - so the look went where looks live.
+
+        THE LINE ABOVE THE SCROLLING HALF, 2026-09-01, repairing what the owner called things
+        running into each other: the last visible line was cut through the middle by the edge of the
+        scrolling region with nothing saying an edge was there. A rule turns the same pixels into
+        "there is more below".
+    -->
+    <Style x:Key="PlanBody" TargetType="Border">
+        <Setter Property="BorderBrush" Value="{StaticResource SurfacePanelEdge}" />
+        <Setter Property="BorderThickness" Value="{StaticResource BorderFooterRule}" />
+        <Setter Property="Padding" Value="{StaticResource PaddingFooter}" />
+    </Style>
+
+    <!--
+        THE TWO SECTIONS OF COMMANDS - the heading, the recess and the field past twenty lines. HERE
+        RATHER THAN IN PlanLines.xaml, by that file's own rule: it holds what is drawn once per ITEM,
+        and each of these is drawn once per section of a SHEET. PlanLines.xaml is merged before this
+        file, which is what lets the recess be based on one line's box.
+    -->
+    <!-- The heading of a section of commands, centred on the line it shares with "Copy all". -->
+    <Style x:Key="PlanCommandsHeading" TargetType="TextBlock" BasedOn="{StaticResource SectionHeadingText}">
+        <Setter Property="VerticalAlignment" Value="Center" />
+    </Style>
+
+    <!--
+        MORE THAN TWENTY COMMANDS STAND IN ONE FIELD, SINCE 2026-09-29 - W6 of the performance
+        series, report item G-7, and CommandBlock carries the whole argument: a box per line cost 5013
+        of the 7185 elements of a sheet over a whole scope, and the window stood still for half a
+        second while they were built.
+
+        THE SAME RECESS AS ONE LINE, so a section reads as the same kind of thing at any length.
+        It shows only while its block says the lines stand at once.
+
+        AND ITS EDGE TAKES THE FOCUS LINE WHILE THE KEYBOARD IS IN THE FIELD, because this is the one
+        thing in the section a person selects inside, and a field with no sign of focus is one a
+        keyboard user cannot find. The edge rather than the library's line under the field - that
+        line is answered transparent by ChromelessBox, and a second kind of focus mark on this sheet
+        would be one more thing to learn. FocusLine clears 3:1 against the recess and against the
+        sheet round it, which PlanSheetCostGuards holds.
+    -->
+    <Style x:Key="PlanCommandsRecess" TargetType="Border" BasedOn="{StaticResource PlanCommandBox}">
+        <Style.Triggers>
+            <DataTrigger Binding="{Binding AtOnce}" Value="False">
+                <Setter Property="Visibility" Value="Collapsed" />
+            </DataTrigger>
+            <Trigger Property="IsKeyboardFocusWithin" Value="True">
+                <Setter Property="BorderBrush" Value="{StaticResource FocusLine}" />
+            </Trigger>
+        </Style.Triggers>
+    </Style>
+
+    <!--
+        THE FIELD ITSELF: a stock text box that can only be read. Stock because selecting, Ctrl+C,
+        the context menu and the screen reader's text pattern are what a person needs from it and
+        what a TextBlock does not give - `docs/11` 9b, "leave it stock and theme it". Read only, so
+        it never shows a caret and never redraws on a blink. Never wrapped, for the reason a single
+        line scrolls sideways: a wrapped command reads as two. Never scrolled up and down inside
+        itself - the sheet's body does that, and a scroller in a scroller is a wheel that goes to
+        the wrong one.
+    -->
+    <Style x:Key="PlanCommandsField" TargetType="TextBox" BasedOn="{StaticResource ChromelessBox}">
+        <Setter Property="IsReadOnly" Value="True" />
+        <Setter Property="Text" Value="{Binding All, Mode=OneWay}" />
+        <Setter Property="FontFamily" Value="{StaticResource TextFaceFixed}" />
+        <Setter Property="FontSize" Value="{StaticResource TextSizeNormal}" />
+        <Setter Property="Foreground" Value="{StaticResource TextOnSurface}" />
+        <Setter Property="Padding" Value="{StaticResource PadNone}" />
+        <Setter Property="TextWrapping" Value="NoWrap" />
+        <Setter Property="HorizontalScrollBarVisibility" Value="Auto" />
+        <Setter Property="VerticalScrollBarVisibility" Value="Disabled" />
+    </Style>
+
     <!--
         THE WORD ON THE BUTTON AT THE FOOT OF THE SHEET, TRIMMED RATHER THAN CUT, since 2026-09-15 -
         the day the button started naming the entry it acts on. "Stop Windows Search" is short, and
diff --git a/src/Bws.Gui/Themes/PlanLines.xaml b/src/Bws.Gui/Themes/PlanLines.xaml
index dcacff5..16a8256 100644
--- a/src/Bws.Gui/Themes/PlanLines.xaml
+++ b/src/Bws.Gui/Themes/PlanLines.xaml
@@ -168,11 +168,25 @@
         THE BUTTON THAT TAKES EVERY COMMAND OF A SECTION AT ONCE, 2026-09-16 - the owner's remark
         over a sheet with five commands and five buttons that each took one. The same quiet outline
         as the button beside a line, standing at the right end of the section's heading, and it is
-        only there when there is more than one line to take (Planned.HasSeveralCommands). Its Tag
-        carries the lines already joined, so the press bubbles to the same handler as its siblings.
+        only there when there is more than one line to take (CommandBlock.Several). Its Tag carries
+        the lines already joined, so the press bubbles to the same handler as its siblings.
+
+        WHAT IT SAYS AND WHAT IT CARRIES LIVE HERE SINCE 2026-09-29, and so does when it is there.
+        Both sections of commands wore the same six attributes, twice (GUI rule 7), in a view on its
+        markup ceiling - and since W6 each section's data is its CommandBlock, so the bindings read
+        the same names in both places and could move into one style.
     -->
     <Style x:Key="PlanCopyAllButton" TargetType="Button" BasedOn="{StaticResource PlanCopyButton}">
         <Setter Property="HorizontalAlignment" Value="Right" />
+        <Setter Property="AutomationProperties.Name" Value="{DynamicResource gui.plan.copyAll}" />
+        <Setter Property="Content" Value="{DynamicResource gui.plan.copyAll}" />
+        <Setter Property="ToolTip" Value="{DynamicResource gui.plan.copyAll.hint}" />
+        <Setter Property="Tag" Value="{Binding All}" />
+        <Style.Triggers>
+            <DataTrigger Binding="{Binding Several}" Value="False">
+                <Setter Property="Visibility" Value="Collapsed" />
+            </DataTrigger>
+        </Style.Triggers>
     </Style>
 
     <!--
diff --git a/src/Bws.Gui/Themes/SearchField.xaml b/src/Bws.Gui/Themes/SearchField.xaml
index 9c2fc1a..db90941 100644
--- a/src/Bws.Gui/Themes/SearchField.xaml
+++ b/src/Bws.Gui/Themes/SearchField.xaml
@@ -87,13 +87,19 @@
     </Style>
 
     <!--
-        THE TEXT BOX IN THE MIDDLE OF THE FIELD, WITH ITS OWN CHROME MADE INVISIBLE. The library's
-        template stays - caret, selection, IME and the automation peer are the stock control's - and
-        the brushes that template draws its fill and lines with are answered transparent from this
-        style's own resources, which the template finds before the application's. No error template:
-        the frame says a mistake.
+        A STOCK TEXT BOX WITH ITS OWN CHROME MADE INVISIBLE, for a box that stands inside a frame
+        somebody else draws. The library's template stays - caret, selection, IME and the automation
+        peer are the stock control's - and the brushes that template draws its fill and lines with
+        are answered transparent from this style's own resources, which the template finds before
+        the application's (`docs/10` trap 32, the half that works). No error template: whatever
+        draws the frame says a mistake.
+
+        ITS OWN STYLE SINCE 2026-09-29, when the plan sheet's field of commands became the second
+        box to need exactly this - GUI rule 7. It was the search box's alone until then. The
+        resources are found through BasedOn as well: an element's lookup walks its style and the
+        style that one is based on, measured the same day on a TextBox before this was split.
     -->
-    <Style x:Key="SearchFieldBox" TargetType="TextBox" BasedOn="{StaticResource {x:Type TextBox}}">
+    <Style x:Key="ChromelessBox" TargetType="TextBox" BasedOn="{StaticResource {x:Type TextBox}}">
         <Style.Resources>
             <SolidColorBrush x:Key="TextControlBackground" Color="Transparent" />
             <SolidColorBrush x:Key="TextControlBackgroundFocused" Color="Transparent" />
@@ -103,9 +109,13 @@
         </Style.Resources>
         <Setter Property="Background" Value="{x:Static media:Brushes.Transparent}" />
         <Setter Property="BorderThickness" Value="{StaticResource BorderNone}" />
+        <Setter Property="Validation.ErrorTemplate" Value="{x:Null}" />
+    </Style>
+
+    <!-- THE TEXT BOX IN THE MIDDLE OF THE FIELD - the frame round it is SearchFieldFrame above. -->
+    <Style x:Key="SearchFieldBox" TargetType="TextBox" BasedOn="{StaticResource ChromelessBox}">
         <Setter Property="Padding" Value="{StaticResource PadSearchText}" />
         <Setter Property="VerticalContentAlignment" Value="Center" />
-        <Setter Property="Validation.ErrorTemplate" Value="{x:Null}" />
     </Style>
 
     <!--
diff --git a/src/Bws.Gui/Themes/Spacing.xaml b/src/Bws.Gui/Themes/Spacing.xaml
index 3f46b30..8331a01 100644
--- a/src/Bws.Gui/Themes/Spacing.xaml
+++ b/src/Bws.Gui/Themes/Spacing.xaml
@@ -58,6 +58,9 @@
     <Thickness x:Key="MarginBetweenControls">0,0,8,0</Thickness>
     <Thickness x:Key="MarginNone">0</Thickness>
 
+    <!-- No air inside a control whose frame somebody else draws and pads - the field of commands on the plan sheet. -->
+    <Thickness x:Key="PadNone">0</Thickness>
+
     <!-- The gap between a mark and its word. The mark itself is ShapeMark, in Values.xaml. -->
     <Thickness x:Key="MarginAfterShape">0,0,8,0</Thickness>
 
diff --git a/src/Bws.Gui/ViewModels/CommandBlock.cs b/src/Bws.Gui/ViewModels/CommandBlock.cs
new file mode 100644
index 0000000..969763d
--- /dev/null
+++ b/src/Bws.Gui/ViewModels/CommandBlock.cs
@@ -0,0 +1,88 @@
+namespace Bws.Gui.ViewModels;
+
+/// <summary>
+/// One block of commands on the plan sheet - the equivalent commands before a run, the way back
+/// after one - and how the sheet shows them: a line at a time with a copy button beside each, or,
+/// past <see cref="ListedUpTo"/> lines, all of them in one field that can only be read.
+///
+/// <b>WHY A THRESHOLD AT ALL - W6 of the performance series, report item G-7, 2026-09-29.</b> One
+/// line is a box, a scroller, a text and a button, about fifteen elements. A stop over the whole
+/// Services scope on the owner's machine had 334 of them - 5013 of the sheet's 7185 elements - and
+/// the window did not answer for 0.46-0.8 s while the sheet was built (measured in process by
+/// tools/gui-probe/row-cost.ps1 -PlanCost, numbers in the performance analysis, section 5, "W6").
+/// Past a screenful nobody copies commands one at a time, so the button beside each line is what
+/// the threshold gives up, and "Copy all" plus selecting inside the field is what stays. The
+/// owner's decision of the same day.
+///
+/// <b>A TYPE RATHER THAN MORE PROPERTIES ON <see cref="Planned"/></b>, which stood at the ceiling
+/// of methods a type may carry. Whether a block has anything, more than one thing, what it copies
+/// and how it is shown are one answer about one list, and both blocks ask it the same way - so this
+/// replaced the six properties that used to answer it twice.
+///
+/// <b>Immutable.</b> A new block is made when its lines change, so every binding reading one of
+/// these reads the same answer, and the joined text is made once rather than once per binding.
+/// </summary>
+/// <remarks>
+/// Public because WPF cannot see an internal type from outside this assembly - the reason
+/// <see cref="PlanLine"/> gives.
+/// </remarks>
+public sealed class CommandBlock
+{
+    /// <summary>
+    /// The most lines shown one at a time.
+    ///
+    /// <b>Twenty, because that is past a screenful.</b> The body of the sheet over a plan of fifty
+    /// entries, in a window at its opening size, was a view 351 units tall (measured W6), which
+    /// holds about a dozen command lines - so a list longer than this is one nobody reads a line at
+    /// a time. The same plan measured 843 elements for its 56 commands, so twenty lines cost about
+    /// three hundred: the price of a list short enough to use.
+    /// </summary>
+    public const int ListedUpTo = 20;
+
+    /// <summary>A block with nothing in it - no plan, or a section that has nothing to say yet.</summary>
+    public static CommandBlock None { get; } = new([]);
+
+    /// <param name="lines">The commands, one per line, in the order they are to be run.</param>
+    public CommandBlock(IReadOnlyList<string> lines)
+    {
+        ArgumentNullException.ThrowIfNull(lines);
+
+        Lines = lines;
+
+        // THE PLATFORM'S LINE ENDING RATHER THAN A BARE NEWLINE, because what this is for is pasting
+        // into a Windows terminal, which runs the lines one after another. Joined here rather than in
+        // the view, which holds layout and bindings and nothing else (GUI rule 11).
+        All = string.Join(Environment.NewLine, lines);
+    }
+
+    /// <summary>Every command, one per line.</summary>
+    public IReadOnlyList<string> Lines { get; }
+
+    /// <summary>
+    /// Whether the block has anything to show - what takes its heading off the screen with it when
+    /// it has not (backlog 203: a heading over nothing states something false).
+    /// </summary>
+    public bool Any => Lines.Count > 0;
+
+    /// <summary>
+    /// Whether the block is worth a button that takes all of it at once - the owner's request of
+    /// 2026-09-16, made over a sheet with five commands and five buttons that each took one.
+    ///
+    /// <b>More than one, not at least one.</b> Over a single command "Copy all" beside "Copy" is two
+    /// buttons for one thing, and the second would be the one somebody wonders about.
+    /// </summary>
+    public bool Several => Lines.Count > 1;
+
+    /// <summary>Whether the lines stand in one field rather than one box each - see <see cref="ListedUpTo"/>.</summary>
+    public bool AtOnce => Lines.Count > ListedUpTo;
+
+    /// <summary>
+    /// The lines shown one at a time, and NOTHING past the threshold rather than the lines with the
+    /// list hidden. The list then holds nothing it does not show, so whether WPF builds boxes for the
+    /// items of a collapsed list - not measured here - has no way to cost anything.
+    /// </summary>
+    public IReadOnlyList<string> Listed => AtOnce ? [] : Lines;
+
+    /// <summary>Every command joined one per line, as the clipboard and the one field hold them.</summary>
+    public string All { get; }
+}
diff --git a/src/Bws.Gui/ViewModels/PlanWords.cs b/src/Bws.Gui/ViewModels/PlanWords.cs
index 72823f8..5816605 100644
--- a/src/Bws.Gui/ViewModels/PlanWords.cs
+++ b/src/Bws.Gui/ViewModels/PlanWords.cs
@@ -159,6 +159,49 @@ internal static class PlanWords
             nameof(warning), warning.Kind, EquivalentCommand.Unhandled)
     };
 
+    /// <summary>
+    /// Warnings in words, with the two kinds that name entries this machine does not work without
+    /// gathered into ONE sentence each, naming every such entry once.
+    ///
+    /// <b>W6 of the performance series, 2026-09-29, and it was found on a picture rather than by a
+    /// test.</b> The core raises one of these per plan that stops or disables such an entry, and the
+    /// owner's machine has seven of them - so on a stop over the whole Services scope the footer,
+    /// which stands these sentences over the box a name is typed into and never scrolls, grew a
+    /// sentence per plan and took 465 of the sheet's 551 units. The body holding the steps was left
+    /// one unit tall: the preview of a stop over 334 entries showed none of them. The sentences
+    /// already had a plural ("{1} of these are ones this machine does not work without: {2}"), so
+    /// one sentence naming all of them says what the many said. The owner's decision of that day.
+    ///
+    /// <b>Here and not in the core</b>, because the core's warnings reach the JSON of --dry-run,
+    /// which is a public contract, and one warning per plan is what that contract promises.
+    ///
+    /// <b>The warning about a process that takes others with it is NOT gathered</b>, because its
+    /// sentence names the entry whose process it is ({0}), and one sentence would pin every other
+    /// entry's processes on the first. A forcing plan carries one entry, so there is one of those.
+    /// </summary>
+    internal static IReadOnlyList<string> Describe(IEnumerable<PlanWarning> warnings)
+    {
+        ArgumentNullException.ThrowIfNull(warnings);
+
+        var sentences = new List<string>();
+
+        foreach (var kind in warnings.GroupBy(warning => warning.Kind))
+        {
+            if (kind.Key is PlanWarningKind.CriticalService or PlanWarningKind.CriticalStartType)
+            {
+                string[] named = [.. kind.SelectMany(warning => warning.Related).Distinct(StringComparer.OrdinalIgnoreCase)];
+
+                sentences.Add(Describe(kind.First() with { Related = named }));
+            }
+            else
+            {
+                sentences.AddRange(kind.Select(Describe));
+            }
+        }
+
+        return sentences;
+    }
+
     /// <summary>
     /// A refusal in words, with the entry it belongs to named first.
     ///
diff --git a/src/Bws.Gui/ViewModels/Planned.Forcing.cs b/src/Bws.Gui/ViewModels/Planned.Forcing.cs
index ec35efb..b95c230 100644
--- a/src/Bws.Gui/ViewModels/Planned.Forcing.cs
+++ b/src/Bws.Gui/ViewModels/Planned.Forcing.cs
@@ -168,10 +168,14 @@ or PlanWarningKind.CriticalService
     ///
     /// <b>One string rather than a list</b>, so the footer binds one TextBlock the way it binds
     /// <see cref="TypeToConfirm"/>, and the tree keeps one node for a reader to meet.
+    ///
+    /// <b>One sentence per kind rather than per warning since 2026-09-29</b> - a stop over a whole
+    /// scope stood a sentence here for every plan touching such an entry and left no room for a
+    /// single step. PlanWords.Describe over a list says what it gathers and what it does not.
     /// </summary>
     public string Danger => !NeedsTyping || _plan is not { } plan
         ? string.Empty
-        : string.Join(Environment.NewLine, plan.Warnings.Where(Heavy).Select(PlanWords.Describe));
+        : string.Join(Environment.NewLine, PlanWords.Describe(plan.Warnings.Where(Heavy)));
 
     /// <summary>Whether there is a reason for the ask to show - true exactly when the box is.</summary>
     public bool HasDanger => Danger.Length > 0;
diff --git a/src/Bws.Gui/ViewModels/Planned.Sections.cs b/src/Bws.Gui/ViewModels/Planned.Sections.cs
index 76ae85e..cfed459 100644
--- a/src/Bws.Gui/ViewModels/Planned.Sections.cs
+++ b/src/Bws.Gui/ViewModels/Planned.Sections.cs
@@ -1,3 +1,5 @@
+using Bws.Core.Planning;
+
 namespace Bws.Gui.ViewModels;
 
 /// <summary>
@@ -51,16 +53,21 @@ public sealed partial class Planned
     public bool HasSubtitle => Subtitle.Length > 0;
 
     /// <summary>
-    /// Whether the command that would ask for the same thing still belongs on screen.
+    /// The command that would ask for the same thing, as the sheet shows it - and nothing once
+    /// something was asked.
     ///
-    /// <b>False once there is a result, and that is `E5` read as it was written rather than as a
+    /// <b>Empty once there is a result, and that is `E5` read as it was written rather than as a
     /// field that happens to be full.</b> The equivalent command is part of the PREVIEW - the plan
     /// rendered as something a person could type INSTEAD of pressing - which is why it was built
     /// before this window could run anything at all. After a run it describes something that has
     /// already happened, and it sits directly under the way back, so the last thing a reader meets
     /// scanning up from the button is the command they do not want.
+    ///
+    /// <b>A block rather than a list and five questions about it since 2026-09-29</b> - W6, where
+    /// what the sheet shows past twenty lines became one field. <see cref="ViewModels.CommandBlock"/>
+    /// says why, and the section binds it as its data so the same markup serves the way back.
     /// </summary>
-    public bool HasCommands => _run is null && Commands.Count > 0;
+    public CommandBlock CommandBlock => _run is null ? _commandBlock : CommandBlock.None;
 
     /// <summary>Whether an entry is named by more than one plan.</summary>
     public bool HasOverlapping => Overlapping.Length > 0;
@@ -74,34 +81,29 @@ public sealed partial class Planned
     /// <summary>Whether anything failed. Never true before a run.</summary>
     public bool HasFailures => Failures.Count > 0;
 
-    /// <summary>Whether there is a way back. Never true before a run.</summary>
-    public bool HasWayBack => WayBack.Count > 0;
-
     /// <summary>
-    /// Whether the commands are worth a button that takes all of them at once - the owner's
-    /// request of 2026-09-16, made over a sheet with five of them and five buttons that each took
-    /// one.
+    /// The way back, as the sheet shows it - empty before a run.
     ///
-    /// <b>More than one, not at least one.</b> Over a single command "Copy all" beside "Copy" is
-    /// two buttons for one thing, and the second would be the one somebody wonders about.
+    /// <b>Made once per run and kept</b>, so the reversals are rendered once rather than on every
+    /// read, and the section keeps the same block through every raise that is not a new run.
     /// </summary>
-    public bool HasSeveralCommands => Commands.Count > 1;
-
-    /// <summary>The same question about the way back.</summary>
-    public bool HasSeveralWayBack => WayBack.Count > 1;
-
-    /// <summary>
-    /// Every command, one per line, as the clipboard should hold them.
-    ///
-    /// <b>The platform's line ending rather than a bare newline</b>, because what this is for is
-    /// pasting into a Windows terminal, which runs the lines one after another - and the join is
-    /// done here rather than in the view, which holds layout and bindings and nothing else (GUI
-    /// rule 11).
-    /// </summary>
-    public string AllCommands => string.Join(Environment.NewLine, Commands);
-
-    /// <summary>The whole way back, one command per line.</summary>
-    public string AllWayBack => string.Join(Environment.NewLine, WayBack);
+    public CommandBlock WayBackBlock
+    {
+        get
+        {
+            if (_run is not { } run)
+            {
+                return CommandBlock.None;
+            }
+
+            if (!ReferenceEquals(_wayBack.Of, run))
+            {
+                _wayBack = (run, new CommandBlock([.. run.Reversal.Select(EquivalentCommand.For)]));
+            }
+
+            return _wayBack.Block;
+        }
+    }
 
     /// <summary>
     /// That every section may have appeared or gone.
@@ -154,7 +156,7 @@ private void RaiseTheCounts()
         // sheet stops being a problem the moment a plan with nothing to wait for hides the box,
         // and becomes one again when the next plan shows it.
         RaiseTheProblem();
-        Raise(nameof(HasCommands));
+        Raise(nameof(CommandBlock));
         Raise(nameof(HasOverlapping));
         Raise(nameof(HasWarnings));
 
@@ -163,12 +165,9 @@ private void RaiseTheCounts()
         Raise(nameof(Warnings));
         Raise(nameof(HasProblems));
         Raise(nameof(HasFailures));
-        Raise(nameof(HasWayBack));
 
-        // The button over each list of commands, and what it carries - both follow the lists.
-        Raise(nameof(HasSeveralCommands));
-        Raise(nameof(AllCommands));
-        Raise(nameof(HasSeveralWayBack));
-        Raise(nameof(AllWayBack));
+        // Whether each block is there, how it is shown and what "Copy all" carries all come with
+        // the block itself since 2026-09-29, so one raise each says all of it.
+        Raise(nameof(WayBackBlock));
     }
 }
diff --git a/src/Bws.Gui/ViewModels/Planned.cs b/src/Bws.Gui/ViewModels/Planned.cs
index 1bb69f1..14676c2 100644
--- a/src/Bws.Gui/ViewModels/Planned.cs
+++ b/src/Bws.Gui/ViewModels/Planned.cs
@@ -62,6 +62,17 @@ public sealed partial class Planned : Checked
     private BulkPlan? _plan;
     private BulkRun? _run;
 
+    /// <summary>The equivalent commands of the plan on screen - see <see cref="Commands"/>.</summary>
+    private CommandBlock _commandBlock = CommandBlock.None;
+
+    /// <summary>
+    /// The way back of the run it was made for. Kept rather than made on every read, so the reversals
+    /// are rendered once per run rather than once per read - the fault G-7 found in the commands
+    /// above - and the section bound to it keeps the same block, and its boxes, through every raise
+    /// that is not a new run.
+    /// </summary>
+    private (BulkRun? Of, CommandBlock Block) _wayBack = (null, CommandBlock.None);
+
     /// <summary>How many steps the plan on screen has, counted once when it is shown rather than on every step of a run.</summary>
     private int _stepsInPlan;
 
@@ -311,8 +322,9 @@ public IReadOnlyList<PlanWarningLine> Warnings
     ///
     /// <b>Rendered once, when the plan is shown, since 2026-09-28</b> - G-7 of the external
     /// performance report: four bindings read this, and each read rendered every command again.
+    /// Held in a <see cref="ViewModels.CommandBlock"/> since 2026-09-29, which is what the sheet binds.
     /// </summary>
-    public IReadOnlyList<string> Commands { get; private set; } = [];
+    public IReadOnlyList<string> Commands => _commandBlock.Lines;
 
     /// <summary>
     /// Where this panel is in the only sequence it has: nothing done, doing it, done.
@@ -371,10 +383,11 @@ private static string Reported(BulkRun run) => Arrived(run) == run.Runs.Count
     /// entry - so a restart that ended where it began says nothing, and a selection dealt with
     /// dependants first hands the lines back in an order whose first line works. All of that is
     /// `NetEffect` in the core, and none of it is decided here.
+    ///
+    /// <b>Rendered once per run since 2026-09-29</b>, kept in <see cref="WayBackBlock"/> - which is
+    /// what the sheet binds, for the reason <see cref="Commands"/> gives.
     /// </summary>
-    public IReadOnlyList<string> WayBack => _run is not { } run
-        ? []
-        : [.. run.Reversal.Select(EquivalentCommand.For)];
+    public IReadOnlyList<string> WayBack => WayBackBlock.Lines;
 
     /// <summary>
     /// Puts a plan on screen, and says whether there was anything to put there.
@@ -415,7 +428,8 @@ internal bool Show(BulkPlan plan, string? shownAs = null, string? because = null
         // for five different ones, with nothing on screen to say the two do not belong together.
         _plan = plan;
         _stepsInPlan = plan.Steps.Count();
-        Commands = EquivalentCommand.For(plan);
+        _commandBlock = new CommandBlock(EquivalentCommand.For(plan));
+        _wayBack = (null, CommandBlock.None);
         _run = null;
         Busy = false;
         Progress = string.Empty;
@@ -455,8 +469,9 @@ internal bool Hide()
 
         _plan = null;
         _stepsInPlan = 0;
-        Commands = [];
+        _commandBlock = CommandBlock.None;
         _warnings = null;
+        _wayBack = (null, CommandBlock.None);
         _run = null;
         _shownAs = string.Empty;
         _because = string.Empty;
diff --git a/tests/Bws.Architecture.Tests/SizeCeilings.cs b/tests/Bws.Architecture.Tests/SizeCeilings.cs
index c44b17e..423ac72 100644
--- a/tests/Bws.Architecture.Tests/SizeCeilings.cs
+++ b/tests/Bws.Architecture.Tests/SizeCeilings.cs
@@ -44,12 +44,16 @@ internal static class SizeCeilings
     internal const int ShippedFilesNearLongest = 8;
 
     /// <summary>
-    /// 178 lines of markup, PlanView.xaml. OverviewView.xaml is 171 and Themes/Catalogue.xaml 168, so
-    /// the top three stand within ten lines of each other.
+    /// 176 lines of markup, Themes/Controls.xaml, since 2026-09-29 - PlanView.xaml stood on 178 and
+    /// came down to 174 when W6 moved the look of its two sections of commands and its body into
+    /// Themes/Plan.xaml. Themes/Catalogue.xaml is 168 and OverviewView.xaml 163.
     /// </summary>
-    internal const int LongestShippedMarkupFile = 178;
+    internal const int LongestShippedMarkupFile = 176;
 
-    /// <summary>Five at 125 or more: PlanView, OverviewView, Catalogue, Controls and Chips.</summary>
+    /// <summary>
+    /// Five at 124 or more (70% of 176 is 123.2): Controls, PlanView, Catalogue, OverviewView and
+    /// Chips. PlanFooter.xaml stands one line under, at 123.
+    /// </summary>
     internal const int MarkupFilesNearLongest = 5;
 
     /// <summary>
diff --git a/tests/Bws.Gui.Tests/CatalogueGuards.cs b/tests/Bws.Gui.Tests/CatalogueGuards.cs
index f33f198..3cea1e8 100644
--- a/tests/Bws.Gui.Tests/CatalogueGuards.cs
+++ b/tests/Bws.Gui.Tests/CatalogueGuards.cs
@@ -511,18 +511,30 @@ private static IEnumerable<DependencyObject> Descendants(DependencyObject root)
     /// it - the plan sheet was drawn as two faint edges until 2026-09-16 because its own margin
     /// pushed its content past a 96 pixel clip. Both halves: the model marks it, and the theme
     /// declares the taller ceiling the style reaches for.
+    ///
+    /// <b>EVERY SAMPLE'S FLAG IS ITS MEASUREMENT, SINCE 2026-09-29</b>, rather than PlanSheet's
+    /// flag being true. W6 moved the sheet's margin to the cell it stands in with its shadow, and
+    /// measured the same day no style or template sample is taller than the row any more - the
+    /// tallest is SuggestionList at 86.6 of 96. So the direction "raised when past the row" has no
+    /// real sample to show it today, and that is the price: this holds that the flag never says
+    /// anything the measurement does not, and the next tall style is marked by the same line.
     /// </summary>
     [Fact]
     public void A_sample_taller_than_the_row_is_given_the_taller_ceiling()
     {
-        var sheet = WpfHost.On(() => Catalogue.Read(WpfHost.Resources))
+        var row = WpfHost.On(() => (double)WpfHost.Resources["HeightCatalogueSample"]);
+
+        var wrong = WpfHost.On(() => Catalogue.Read(WpfHost.Resources)
             .SelectMany(group => group.Entries)
-            .Single(entry => entry.Key == "PlanSheet");
+            .SelectMany(entry => new[] { (entry.Key, Sample: entry.Normal), (entry.Key, Sample: entry.Extreme) })
+            .Where(one => one.Sample.Element is { } element && one.Sample.Tall != element.DesiredSize.Height > row)
+            .Select(one => string.Create(
+                System.Globalization.CultureInfo.InvariantCulture,
+                $"{one.Key} measures {one.Sample.Element!.DesiredSize.Height:F1} and is marked tall={one.Sample.Tall}"))
+            .ToList());
 
-        Assert.NotNull(sheet.Normal.Element);
-        Assert.True(sheet.Normal.Tall, "PlanSheet measures past the row ceiling and is not marked tall.");
+        Assert.True(wrong.Count == 0, string.Join(Environment.NewLine, wrong));
 
-        var row = WpfHost.On(() => (double)WpfHost.Resources["HeightCatalogueSample"]);
         var tall = WpfHost.On(() => (double)WpfHost.Resources["HeightCatalogueTall"]);
 
         Assert.True(tall > row, $"The taller ceiling ({tall}) is not taller than the row ceiling ({row}).");
diff --git a/tests/Bws.Gui.Tests/ContrastGuards.cs b/tests/Bws.Gui.Tests/ContrastGuards.cs
index 47bb787..3b376fc 100644
--- a/tests/Bws.Gui.Tests/ContrastGuards.cs
+++ b/tests/Bws.Gui.Tests/ContrastGuards.cs
@@ -323,7 +323,8 @@ static double Channel(byte value)
         return (0.2126 * Channel(colour.R)) + (0.7152 * Channel(colour.G)) + (0.0722 * Channel(colour.B));
     }
 
-    private static double Contrast(Color first, Color second)
+    /// <summary>WCAG 2.2 contrast ratio. Internal so a guard about one surface uses this arithmetic rather than a copy.</summary>
+    internal static double Contrast(Color first, Color second)
     {
         var a = Luminance(first);
         var b = Luminance(second);
diff --git a/tests/Bws.Gui.Tests/CriticalEntryWindowGuards.cs b/tests/Bws.Gui.Tests/CriticalEntryWindowGuards.cs
index bde347c..efe6e6e 100644
--- a/tests/Bws.Gui.Tests/CriticalEntryWindowGuards.cs
+++ b/tests/Bws.Gui.Tests/CriticalEntryWindowGuards.cs
@@ -81,8 +81,76 @@ public void An_ordinary_stop_of_anything_else_asks_for_nothing()
         Assert.True(panel.CanCarryOut);
     }
 
+    /// <summary>
+    /// <b>ONE SENTENCE PER KIND OVER THE BOX, NAMING EVERY SUCH ENTRY ONCE - W6, 2026-09-29.</b> A
+    /// stop over a whole scope carried one of these per plan, and the footer, which never scrolls,
+    /// grew until the body holding the steps was one unit tall. One entry keeps today's sentence
+    /// word for word, the same entry twice is named once, and the two kinds stay two sentences,
+    /// because one is about now and the other about the next boot.
+    /// </summary>
+    [Fact]
+    public void Entries_the_machine_does_not_work_without_are_named_in_one_sentence_per_kind()
+    {
+        var panel = new Planned { Elevated = true };
+
+        panel.Show(Each(PlanWarningKind.CriticalService, "RpcSs", "PlugPlay", "LSM", "RpcSs"));
+
+        var danger = panel.Danger.Split(Environment.NewLine);
+
+        Assert.Single(danger);
+        Assert.Equal(
+            Bws.Gui.Texts.Of("gui.plan.warning.critical.many", "RpcSs", 3, "RpcSs, PlugPlay, LSM"),
+            danger[0]);
+
+        panel.Show(Each(PlanWarningKind.CriticalService, "RpcSs"));
+
+        Assert.Equal(Bws.Gui.Texts.Of("gui.plan.warning.critical.one", "RpcSs", 1, "RpcSs"), panel.Danger);
+
+        panel.Show(Stopping("Spooler", PlanWarningKind.CriticalService, PlanWarningKind.CriticalStartType));
+
+        Assert.Equal(2, panel.Danger.Split(Environment.NewLine).Length);
+    }
+
+    /// <summary>
+    /// <b>The warning about a process that takes others with it is NOT gathered</b>, because its
+    /// sentence names the entry whose process it is - one sentence would pin every other entry's
+    /// processes on the first. Two of them stay two sentences.
+    /// </summary>
+    [Fact]
+    public void A_process_that_takes_others_with_it_keeps_a_sentence_of_its_own()
+    {
+        var panel = new Planned { Elevated = true };
+
+        panel.Show(Each(PlanWarningKind.TerminationTakesWithIt, "Spooler", "W32Time"));
+
+        Assert.Equal(2, panel.Danger.Split(Environment.NewLine).Length);
+        Assert.Contains("Spooler", panel.Danger, StringComparison.Ordinal);
+        Assert.Contains("W32Time", panel.Danger, StringComparison.Ordinal);
+    }
+
     // -- fixtures --------------------------------------------------------------------------
 
+    /// <summary>
+    /// An ordinary stop of several entries, each plan carrying one warning of the kind named about
+    /// its own entry - the shape a stop over a whole scope gives the footer. A name given twice is
+    /// two plans naming the same entry, which the sentence must name once.
+    /// </summary>
+    private static BulkPlan Each(PlanWarningKind kind, params string[] names) => new()
+    {
+        Action = new BulkAction(ActionKind.Stop, names),
+        Plans =
+        [
+            .. names.Select(name => new OperationPlan
+            {
+                Action = new ServiceAction(ActionKind.Stop, name),
+                Steps = [new PlanStep(name, name, StepOperation.Stop, StepReason.Requested)],
+                Warnings = [new PlanWarning(kind, name, [name])],
+                Problems = []
+            })
+        ],
+        Problems = []
+    };
+
     /// <summary>
     /// An ordinary stop - no terminate step and no forcing verb - carrying the warnings named.
     ///
diff --git a/tests/Bws.Gui.Tests/PlanSheetCostGuards.cs b/tests/Bws.Gui.Tests/PlanSheetCostGuards.cs
new file mode 100644
index 0000000..622cef8
--- /dev/null
+++ b/tests/Bws.Gui.Tests/PlanSheetCostGuards.cs
@@ -0,0 +1,231 @@
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Effects;
+using Bws.Core.Planning;
+using Bws.Gui.ViewModels;
+using static Bws.Gui.Tests.PlanFixture;
+
+namespace Bws.Gui.Tests;
+
+/// <summary>
+/// What the plan sheet costs to draw and to build - W6 of the performance series, 2026-09-29,
+/// report items G-6 and G-7. The shadow lies under the sheet rather than on it, and past twenty
+/// commands a block stands in one field rather than a box per line.
+///
+/// <b>Its own file because both are about cost and neither about what the sheet says</b>, and
+/// because PlanViewGuards stands past the length the ratchet calls long.
+/// </summary>
+public sealed class PlanSheetCostGuards
+{
+    /// <summary>
+    /// <b>THE SHEET WEARS NO EFFECT, AND ITS SHADOW LIES UNDER IT IN THE SAME RECTANGLE.</b> An
+    /// effect on the sheet made WPF blur the sheet again on every caret blink and every tick of a
+    /// run - a third to a half of a core where WPF draws in software, which is Remote Desktop - and
+    /// turned ClearType off for all its text. Asked of the laid out panel rather than of the
+    /// markup: the shadow must end up where the sheet is, at the size the sheet is.
+    /// </summary>
+    [Fact]
+    public async Task The_sheet_wears_no_effect_and_its_shadow_lies_under_it_in_the_same_rectangle()
+    {
+        var window = await Ready();
+
+        Assert.True(await WpfHost.On(() => window.Preview(ActionKind.Stop)));
+        WpfHost.Settled();
+
+        var (effect, shadowed, hit, under, same) = WpfHost.On(() =>
+        {
+            LaidOut(window, 800);
+
+            var sheet = window.PlanPanel.TheSheet;
+            var cell = (Panel)sheet.Parent;
+            var shadow = cell.Children.OfType<Border>().First();
+
+            return (
+                sheet.Effect,
+                shadow.Effect is DropShadowEffect,
+                shadow.IsHitTestVisible,
+                cell.Children.IndexOf(shadow) < cell.Children.IndexOf(sheet),
+                shadow.RenderSize == sheet.RenderSize
+                    && shadow.TranslatePoint(default, cell) == sheet.TranslatePoint(default, cell));
+        });
+
+        Assert.Null(effect);
+        Assert.True(shadowed, "nothing in the sheet's cell casts a shadow - the sheet stands flat on the window");
+        Assert.False(hit, "the shadow takes the pointer - it is never what somebody pressed");
+        Assert.True(under, "the shadow is declared after the sheet, so it is drawn over it");
+        Assert.True(same, "the shadow does not have the sheet's rectangle, so it can part from the sheet");
+
+        WpfHost.On(window.Close);
+    }
+
+    /// <summary>
+    /// <b>PAST TWENTY COMMANDS THE SHEET HOLDS THEM IN ONE FIELD AND BUILDS NO BOX PER LINE.</b> A
+    /// stop over a whole scope printed 334 lines as 5013 of the sheet's 7185 elements and stood the
+    /// window still for half a second. At twenty the list stays - the threshold is a screenful, not
+    /// a preference - and at twenty one the field takes every line, can only be read, and "Copy
+    /// all" carries exactly what it shows.
+    /// </summary>
+    [Fact]
+    public async Task Past_twenty_commands_the_sheet_holds_them_in_one_field_and_builds_no_box_per_line()
+    {
+        var window = await Ready();
+        var model = WpfHost.On(() => (MainViewModel)window.DataContext);
+
+        foreach (var count in new[] { CommandBlock.ListedUpTo, CommandBlock.ListedUpTo + 1 })
+        {
+            Assert.True(WpfHost.On(() => model.Planned.Show(Over(count))));
+            WpfHost.Settled();
+
+            var (boxes, field, lines, readOnly, carried) = WpfHost.On(() =>
+            {
+                LaidOut(window, 800);
+
+                var panel = window.PlanPanel;
+
+                return (
+                    panel.CommandList.Items.Count,
+                    ((FrameworkElement)panel.CommandField.Parent).Visibility,
+                    panel.CommandLines,
+                    panel.CommandField.IsReadOnly,
+                    panel.CopyAllButton.Tag as string);
+            });
+
+            var atOnce = count > CommandBlock.ListedUpTo;
+
+            Assert.Equal(atOnce ? 0 : count, boxes);
+            Assert.Equal(atOnce ? Visibility.Visible : Visibility.Collapsed, field);
+            Assert.Equal(WpfHost.On(() => model.Planned.Commands), lines);
+            Assert.True(readOnly);
+            Assert.Equal(string.Join(Environment.NewLine, lines), carried);
+        }
+
+        WpfHost.On(window.Close);
+    }
+
+    /// <summary>
+    /// The wheel over the field scrolls the SHEET. A text box keeps a scroller of its own, and a
+    /// scroller marks the wheel handled whether or not it has anywhere to go - the owner's remark of
+    /// 2026-09-16 over the line boxes, which the body answers by taking the wheel in the tunnel.
+    /// Raised as the input system raises it: the preview first, the bubbling one only if nobody took
+    /// the preview.
+    /// </summary>
+    [Fact]
+    public async Task The_wheel_over_the_field_of_commands_scrolls_the_sheet()
+    {
+        var window = await Ready();
+        var model = WpfHost.On(() => (MainViewModel)window.DataContext);
+
+        Assert.True(WpfHost.On(() => model.Planned.Show(Over(CommandBlock.ListedUpTo + 5))));
+        WpfHost.Settled();
+
+        var (scrollable, after) = WpfHost.On(() =>
+        {
+            LaidOut(window, 260);
+
+            var body = window.PlanPanel.Body;
+            var field = window.PlanPanel.CommandField;
+            var preview = new MouseWheelEventArgs(Mouse.PrimaryDevice, Environment.TickCount, -120)
+            {
+                RoutedEvent = UIElement.PreviewMouseWheelEvent,
+                Source = field
+            };
+
+            field.RaiseEvent(preview);
+
+            if (!preview.Handled)
+            {
+                field.RaiseEvent(new MouseWheelEventArgs(Mouse.PrimaryDevice, Environment.TickCount, -120)
+                {
+                    RoutedEvent = UIElement.MouseWheelEvent,
+                    Source = field
+                });
+            }
+
+            window.PlanPanel.UpdateLayout();
+
+            return (body.ScrollableHeight, body.VerticalOffset);
+        });
+
+        Assert.True(scrollable > 0, "the sheet's body has nowhere to scroll at this height, so the wheel proves nothing here");
+        Assert.True(after > 0, "the wheel over the field moved the sheet by nothing - the field's own scroller kept it");
+
+        WpfHost.On(window.Close);
+    }
+
+    /// <summary>
+    /// <b>BOTH BOXES THAT STAND IN SOMEBODY ELSE'S FRAME FIND THEIR CHROME ANSWERED TRANSPARENT.</b>
+    /// The brushes live in ChromelessBox's own resources since 2026-09-29, and the search box and
+    /// the field of commands reach them through BasedOn. Asked of the built boxes in the running
+    /// theme, the way the library's template asks: a box that stopped finding them would draw a
+    /// second fill and a second line inside its frame.
+    /// </summary>
+    [Fact]
+    public async Task Both_boxes_in_a_frame_of_their_own_find_the_library_chrome_answered_transparent()
+    {
+        var window = await Ready();
+
+        var found = WpfHost.On(() =>
+            new[] { window.Search.QueryBox, window.PlanPanel.CommandField, window.PlanPanel.WayBackField }
+                .SelectMany(box => new[] { "TextControlBackground", "ControlStrokeColorDefaultBrush", "TextControlFocusedBorderBrush" }
+                    .Select(key => (box.Name, key, brush: box.TryFindResource(key) as SolidColorBrush)))
+                .Where(one => one.brush?.Color != Colors.Transparent)
+                .Select(one => $"{one.Name} finds {one.key} as {one.brush?.Color.ToString(System.Globalization.CultureInfo.InvariantCulture) ?? "nothing"}")
+                .ToList());
+
+        Assert.True(found.Count == 0, string.Join(Environment.NewLine, found));
+
+        WpfHost.On(window.Close);
+    }
+
+    /// <summary>
+    /// The edge the field's recess takes while the keyboard is in it clears 3:1 against the recess
+    /// inside it and the sheet outside it - WCAG 2.2 SC 1.4.11. Whether the edge LIGHTS is a live
+    /// window's question, because a window built for a test never holds the keyboard.
+    /// </summary>
+    [Fact]
+    public void The_focus_edge_of_the_field_of_commands_clears_its_ratio_on_both_sides()
+    {
+        var edge = WpfHost.Declared("FocusLine");
+
+        foreach (var side in new[] { "SurfaceCommandBox", "SurfacePanel" })
+        {
+            var ratio = ContrastGuards.Contrast(edge, WpfHost.Declared(side));
+
+            Assert.True(ratio >= 3.0, $"FocusLine against {side} measures {ratio:F2}, and an edge that shows focus needs 3.0");
+        }
+    }
+
+    // -- fixtures --------------------------------------------------------------------------
+
+    /// <summary>The plan panel laid out as a window of 1000 by the height given would lay it out.</summary>
+    private static void LaidOut(MainWindow window, double height)
+    {
+        window.PlanPanel.Measure(new Size(1000, height));
+        window.PlanPanel.Arrange(new Rect(0, 0, 1000, height));
+        window.PlanPanel.UpdateLayout();
+    }
+
+    /// <summary>A stop over as many made up entries as asked, one step and one command each.</summary>
+    private static BulkPlan Over(int count)
+    {
+        string[] names = [.. Enumerable.Range(1, count).Select(n => $"Entry{n}")];
+
+        return new BulkPlan
+        {
+            Action = new BulkAction(ActionKind.Stop, names),
+            Plans =
+            [
+                .. names.Select(name => new OperationPlan
+                {
+                    Action = new ServiceAction(ActionKind.Stop, name),
+                    Steps = [new PlanStep(name, name, StepOperation.Stop, StepReason.Requested)],
+                    Warnings = [],
+                    Problems = []
+                })
+            ],
+            Problems = []
+        };
+    }
+}
diff --git a/tests/Bws.Gui.Tests/PlanSheetListsTests.cs b/tests/Bws.Gui.Tests/PlanSheetListsTests.cs
index 3a8a342..0766ca2 100644
--- a/tests/Bws.Gui.Tests/PlanSheetListsTests.cs
+++ b/tests/Bws.Gui.Tests/PlanSheetListsTests.cs
@@ -35,6 +35,70 @@ public void The_commands_and_the_warnings_are_the_same_lists_however_often_they_
         Assert.Empty(panel.Warnings);
     }
 
+    /// <summary>
+    /// Up to twenty commands stand one at a time, and from the twenty first they stand at once in
+    /// one field and the list is EMPTY - W6, G-7: a box per line cost 5013 of the 7185 elements of
+    /// a sheet over a whole scope. Empty rather than hidden, so nobody builds those boxes at all.
+    /// </summary>
+    [Fact]
+    public void Past_twenty_lines_the_commands_stand_at_once_and_the_list_holds_none()
+    {
+        string[] twenty = [.. Enumerable.Range(1, CommandBlock.ListedUpTo).Select(n => $"bws stop Entry{n}")];
+        var under = new CommandBlock(twenty);
+        var over = new CommandBlock([.. twenty, "bws stop Entry21"]);
+
+        Assert.False(under.AtOnce);
+        Assert.Equal(twenty, under.Listed);
+        Assert.True(over.AtOnce);
+        Assert.Empty(over.Listed);
+        Assert.Equal(21, over.Lines.Count);
+        Assert.Equal(string.Join(Environment.NewLine, over.Lines), over.All);
+
+        // "Copy all" over several, never over one, and nothing at all over nothing.
+        Assert.True(over.Several);
+        Assert.False(new CommandBlock(["bws stop Spooler"]).Several);
+        Assert.False(CommandBlock.None.Any);
+
+        // And the plan's own block follows its size: twenty one entries, twenty one lines at once.
+        var panel = new Planned { Elevated = true };
+
+        Assert.True(panel.Show(Over(ActionKind.Stop, [.. Enumerable.Range(1, 21).Select(n => $"Entry{n}")])));
+        Assert.True(panel.CommandBlock.AtOnce);
+        Assert.Equal(panel.Commands, panel.CommandBlock.Lines);
+    }
+
+    /// <summary>
+    /// The way back is rendered once per run and kept - the block the sheet binds is the same one
+    /// however often it is read, a new run makes a new one, and the commands that would ask for the
+    /// same thing go once something was asked (`E5`) while the plan's own list stays.
+    /// </summary>
+    [Fact]
+    public void The_way_back_is_made_once_per_run_and_the_commands_go_once_something_was_asked()
+    {
+        var panel = new Planned { Elevated = true };
+
+        Assert.True(panel.Show(Over(ActionKind.Stop, "Spooler", "W32Time")));
+        Assert.True(panel.CommandBlock.Any);
+        Assert.Same(CommandBlock.None, panel.WayBackBlock);
+
+        panel.Finished(PlanFixture.Ran(panel));
+
+        var first = panel.WayBackBlock;
+
+        Assert.NotEmpty(first.Lines);
+        Assert.Same(first, panel.WayBackBlock);
+        Assert.Same(CommandBlock.None, panel.CommandBlock);
+        Assert.NotEmpty(panel.Commands);
+
+        panel.Finished(PlanFixture.Ran(panel));
+
+        Assert.NotSame(first, panel.WayBackBlock);
+        Assert.Equal(first.Lines, panel.WayBackBlock.Lines);
+
+        Assert.True(panel.Hide());
+        Assert.Same(CommandBlock.None, panel.WayBackBlock);
+    }
+
     private static BulkPlan Over(ActionKind kind, params string[] names) => new()
     {
         Action = new BulkAction(kind, names),