diff --git a/CHANGELOG.md b/CHANGELOG.md
index 43807ee..cb29594 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -25,9 +25,8 @@ is not part of this repository.
   restart of the machine.
 - The JSON of a plan carries `delayedAuto` next to `startType`, the same way `bws list --json`
   does, and `alsoStop` for a plan that also stops.
-- A Help button in the top right corner, also opened with F1. It lists the keyboard shortcuts -
-  each item does what its key does - opens the query language page and the project's website in
-  your browser, and shows the version of the program, which you can copy.
+- A Help button in the top right corner, also opened with F1. It opens the query language page
+  on the project's website in your browser.
 - After the list is exported, the foot of the window says how many entries went into which file.
   The sentence goes away as soon as you change the search.
 - "Set startup type" in the row menu, with the same four settings as the action bar.
@@ -72,6 +71,14 @@ is not part of this repository.
   both, and rows narrow each other. The row labels no longer repeat the same tooltip.
 - The row menu names its actions the way the action bar does: "Stop...", "Start...",
   "Restart...", "Force stop..." and "Force restart...". Each still opens a plan first.
+- "Show the list" on the machine overview is a blue button, so it is easy to find the first time
+  the window opens.
+- In the plan panel, the name of the entry stands out in bold in the title and in every step.
+
+### Removed
+
+- "Copy display name" and "Copy description" from the row menu. Both are still copied by "Copy
+  everything".
 
 ### Fixed
 
diff --git a/src/Bws.Gui/ExternalLinks.cs b/src/Bws.Gui/ExternalLinks.cs
index 41aa6c4..e14c653 100644
--- a/src/Bws.Gui/ExternalLinks.cs
+++ b/src/Bws.Gui/ExternalLinks.cs
@@ -11,9 +11,9 @@
 namespace Bws.Gui;
 
 /// <summary>
-/// The addresses this window hands to a browser, and the two ways it hands them over. One until
-/// 2026-09-24 - the support page - and three since the help menu (UX-GUI-014) offered the project's
-/// website and its query language page.
+/// The addresses this window hands to a browser, and the two ways it hands them over: the support
+/// page and the query language page. The help menu (UX-GUI-014) offered the project's website as a
+/// third for one day, 2026-09-24.
 ///
 /// <b>THE SECOND FILE IN THIS WINDOW ALLOWED TO START SOMETHING, and that is the owner's decision
 /// of 2026-09-23 rather than an arrangement of mine.</b> <see cref="Elevation"/> was the only one
@@ -88,9 +88,6 @@ internal static class ExternalLinks
     /// </summary>
     internal static Task<string?> OpenSupportAsync() => Supporting.Ask();
 
-    /// <summary>The project's website, from the help menu - UX-GUI-014, 2026-09-24.</summary>
-    internal const string ProjectPage = "https://betterwindowsservices.donislawdev.com/";
-
     /// <summary>
     /// The page describing the query language, from the help menu. The same address the README
     /// gives, so a person who found it there finds the same page here.
@@ -98,19 +95,14 @@ internal static class ExternalLinks
     internal const string QueryLanguagePage = "https://betterwindowsservices.donislawdev.com/query-language/";
 
     /// <summary>
-    /// The two pages the help menu offers, each with a hand-over of its own for the reason
+    /// The page the help menu offers, with a hand-over of its own for the reason
     /// <see cref="Supporting"/> has one: a second press while the shell still has the first joins
     /// it rather than starting another. THE SAME TWO WAYS AS THE SUPPORT PAGE AND NO THIRD - an
     /// elevated window hands the address to the desktop, and this adds no call into the shell.
+    /// The project's website had one beside it until 2026-09-24, when it left the menu.
     /// </summary>
-    private static readonly ShellHandover Project = Page(ProjectPage);
-
-    /// <inheritdoc cref="Project"/>
     private static readonly ShellHandover QueryLanguage = Page(QueryLanguagePage);
 
-    /// <summary>Hands the project's website to a browser, or says why it did not.</summary>
-    internal static Task<string?> OpenProjectPageAsync() => Project.Ask();
-
     /// <summary>Hands the query language page to a browser, or says why it did not.</summary>
     internal static Task<string?> OpenQueryLanguagePageAsync() => QueryLanguage.Ask();
 
diff --git a/src/Bws.Gui/HelpMenu.cs b/src/Bws.Gui/HelpMenu.cs
index 32f56af..be3e9fc 100644
--- a/src/Bws.Gui/HelpMenu.cs
+++ b/src/Bws.Gui/HelpMenu.cs
@@ -1,72 +1,34 @@
 namespace Bws.Gui;
 
 /// <summary>
-/// What the Help button offers: the keyboard shortcuts, the two pages on the project's website, and
-/// the version of this program. UX-GUI-014 with the shortcut half of UX-GUI-010, owner's decision
-/// 2026-09-24 - until that day the window named Ctrl+F, Ctrl+C and Ctrl+A nowhere and said its own
-/// version nowhere.
+/// What the Help button offers: the query language page on the project's website, and nothing
+/// else since 2026-09-24 - owner's decision.
 ///
-/// <b>A LIST OF DATA BUILT BY <see cref="RowMenu.Build"/>, NOT A SECOND MENU WRITTEN OUT</b> - GUI
-/// rules 2 and 8. An item here has exactly the shape of an item on a row: words, a key written
-/// beside them, and what a press does. So it is the row menu's entry and the row menu's item style,
-/// and the name "row" on them is the one place this reuse shows.
+/// <b>IT HELD NINE ITEMS FOR ONE DAY.</b> UX-GUI-014 built it earlier the same day with the six
+/// keyboard shortcuts, the project's website and the version of this program, and the owner cut it
+/// to this one. The price is said rather than left for somebody to find: F5, Ctrl+F,
+/// Ctrl+A and Esc are named in no text of the window again (the half of UX-GUI-010 this menu had
+/// answered), and the window no longer says its own version - `bws --version` does. Ctrl+C and
+/// Enter are still written beside their items in the row menu.
+///
+/// <b>STILL A MENU WITH ONE ITEM RATHER THAN A BUTTON THAT OPENS THE PAGE</b> - owner's choice
+/// between the two. A press on "Help" that leaves the program for a browser with nothing in between
+/// would be a surprise, and a menu can take a second item back without the button changing what
+/// it does.
 ///
-/// <b>EVERY SHORTCUT ITEM DOES WHAT IT NAMES, through the same <see cref="MainWindow.Act"/> the key
-/// goes through.</b> A menu that described the keys while a second road carried them out would be
-/// two answers to one question, which this window was caught by on 2026-09-02. The one exception is
-/// Ctrl+A, which is the grid's own key rather than one of ours, and the item asks the grid for the
-/// same thing.
+/// <b>A LIST OF DATA BUILT BY <see cref="RowMenu.Build"/>, NOT A SECOND MENU WRITTEN OUT</b> - GUI
+/// rules 2 and 8, and the item is the row menu's entry for that reason.
 ///
-/// <b>The two pages go out through <see cref="ExternalLinks"/> and nothing else</b>, exactly as
-/// Donate does - an elevated window hands the address to the desktop, and this program still
-/// connects to nothing (`ADR-19`).
+/// <b>The page goes out through <see cref="ExternalLinks"/> and nothing else</b>, exactly as Donate
+/// does - an elevated window hands the address to the desktop, and this program still connects to
+/// nothing (`ADR-19`).
 /// </summary>
 internal static class HelpMenu
 {
     internal static IReadOnlyList<IReadOnlyList<RowMenuEntry>> GroupsFor(MainWindow window) =>
     [
         [
-            new RowMenuEntry("gui.help.find", "gui.help.find.gesture", () => Pressed(window, Shortcut.FocusQuery)),
-            new RowMenuEntry("gui.help.refresh", "gui.help.refresh.gesture", () => Pressed(window, Shortcut.Refresh)),
-            new RowMenuEntry("gui.help.details", "gui.menu.details.gesture", () => Pressed(window, Shortcut.OpenDetails)),
-            new RowMenuEntry("gui.help.copy", "gui.menu.copyAll.gesture", () => Pressed(window, Shortcut.CopyRow)),
-            new RowMenuEntry("gui.help.selectAll", "gui.help.selectAll.gesture", () => Task.FromResult(window.SelectEverything())),
-            new RowMenuEntry("gui.help.back", "gui.help.back.gesture", () => Pressed(window, Shortcut.Back))
-        ],
-        [
-            new RowMenuEntry("gui.help.queryLanguage", null, () => window.OpenPage(ExternalLinks.OpenQueryLanguagePageAsync)),
-            new RowMenuEntry("gui.help.projectPage", null, () => window.OpenPage(ExternalLinks.OpenProjectPageAsync))
-        ],
-        [
-            new RowMenuEntry("gui.help.version", null, () => Copied(window), () => VersionNumber)
+            new RowMenuEntry("gui.help.queryLanguage", null, () => window.OpenPage(ExternalLinks.OpenQueryLanguagePageAsync))
         ]
     ];
-
-    /// <summary>
-    /// What the version item says and copies: the stamped number, or words saying there is none -
-    /// rule 8 of CLAUDE.md applied to one number rather than a guess that looks like one.
-    /// </summary>
-    internal static string VersionNumber => Release.Number ?? Texts.Of("gui.help.versionUnknown");
-
-    /// <summary>
-    /// A press of the key the item names. The work the key starts travels with it, so an item
-    /// that reads the machine again is awaited as the key's own press is.
-    /// </summary>
-    private static Task Pressed(MainWindow window, Shortcut shortcut)
-    {
-        window.Act(shortcut, out var work);
-
-        return work;
-    }
-
-    /// <summary>
-    /// The version on the clipboard, for somebody reporting a fault. A refusal from the clipboard is
-    /// said in the status line by <see cref="MainWindow.Put"/>, as it is for a copied row.
-    /// </summary>
-    private static Task Copied(MainWindow window)
-    {
-        window.Put(VersionNumber);
-
-        return Task.CompletedTask;
-    }
 }
diff --git a/src/Bws.Gui/MainWindow.Help.cs b/src/Bws.Gui/MainWindow.Help.cs
index f834d73..c58a53c 100644
--- a/src/Bws.Gui/MainWindow.Help.cs
+++ b/src/Bws.Gui/MainWindow.Help.cs
@@ -3,8 +3,8 @@
 namespace Bws.Gui;
 
 /// <summary>
-/// The window's half of the Help button: the menu under it, F1, and the two things the menu does
-/// that are not a key press already - UX-GUI-014, owner's decision 2026-09-24.
+/// The window's half of the Help button: the menu under it, F1, and opening the page the menu
+/// offers - UX-GUI-014, owner's decision 2026-09-24.
 ///
 /// <b>A partial of its own because the constructor is at the analyser's length</b>, the reason
 /// MainWindow.Overview.cs gives for the same shape: one line there, and the wiring here. What the
@@ -15,8 +15,7 @@ public partial class MainWindow
     /// <summary>
     /// Hangs the help menu under its button. Called once, from the constructor.
     ///
-    /// <b>Built with the row menu's builder and the row menu's item style</b>, which is what makes
-    /// the key beside each shortcut appear - the style binds InputGestureText, and HelpMenu says why
+    /// <b>Built with the row menu's builder and the row menu's item style</b>, and HelpMenu says why
     /// the entry is the row's.
     /// </summary>
     private void IntroduceTheHelp()
@@ -31,17 +30,6 @@ private void IntroduceTheHelp()
     /// </summary>
     internal bool OpenHelp() => ButtonMenu.OpenUnder(Scope.Help);
 
-    /// <summary>
-    /// Picks every entry in the list - what Ctrl+A does in the grid, asked of the grid rather than
-    /// done a second way, so the menu item and the key are the same act.
-    /// </summary>
-    internal bool SelectEverything()
-    {
-        Entries.SelectAll();
-
-        return true;
-    }
-
     /// <summary>
     /// Hands one of the project's pages to a browser through <see cref="ExternalLinks"/>, and says
     /// in the status line why it did not when it did not - the same shape as the Donate button.
diff --git a/src/Bws.Gui/OverviewView.xaml b/src/Bws.Gui/OverviewView.xaml
index f3b66c6..69e3bf6 100644
--- a/src/Bws.Gui/OverviewView.xaml
+++ b/src/Bws.Gui/OverviewView.xaml
@@ -109,12 +109,7 @@
                 ending at three heights read as a mistake rather than as three independent things.
                 A row of equal cards is a row, a ragged one is a pile.
             -->
-            <Border Background="{StaticResource SurfacePanel}"
-                    BorderBrush="{StaticResource SurfacePanelEdge}"
-                    BorderThickness="{StaticResource BorderAllSides}"
-                    CornerRadius="{StaticResource CornerTile}"
-                    Margin="{StaticResource MarginTile}"
-                    Padding="{StaticResource PadTile}">
+            <Border Style="{StaticResource OverviewCard}">
                 <StackPanel>
 
                     <Button Style="{StaticResource OverviewNumber}"
@@ -223,8 +218,13 @@
                     The exit must not depend on the height of anything, and the top of a scroll is
                     the one place that holds at every size. Wrapping arrived after, as 277.
 
-                    AND IT DOES NOT WEAR THE ACCENT, backlog 270, truer up here rather than less:
-                    this is the way OFF the screen, not its action.
+                    AND IT WEARS THE ACCENT AGAIN SINCE 2026-09-24, on the owner's words that on a
+                    first run it was hidden in the background. Backlog 270 took the accent off on
+                    2026-09-01 for two reasons. One was a fault - the accent was a local Background
+                    that the library's template beat under the pointer - and PrimaryAction, which
+                    owns its template, cannot repeat it. The other was that the cards are the
+                    content and the way off should be quieter. A first-time user who cannot find
+                    the way to the list is the answer to that.
                 -->
                 <!--
                     THE GRID STRETCHES AND THE TITLE INSIDE IT DOES NOT, which is how the exit ends
@@ -252,6 +252,7 @@
                             Content="{DynamicResource gui.overview.dismiss}"
                             ToolTip="{DynamicResource gui.overview.dismiss.hint}"
                             VerticalAlignment="Center"
+                            Style="{StaticResource PrimaryAction}"
                             Click="Dismiss" />
                 </Grid>
 
diff --git a/src/Bws.Gui/PlanView.xaml b/src/Bws.Gui/PlanView.xaml
index a1779be..96ec07c 100644
--- a/src/Bws.Gui/PlanView.xaml
+++ b/src/Bws.Gui/PlanView.xaml
@@ -96,11 +96,22 @@
                     203.
                 -->
                 <StackPanel Grid.Column="0" Margin="{StaticResource MarginGroup}">
+                    <!--
+                        THE NAME SET APART SINCE 2026-09-24 - three runs, the middle one wearing
+                        NameInSentence, on one line because whitespace between inlines is a space
+                        on screen. Themes/PlanLines.xaml says the same about the steps.
+
+                        AND THE NAME FOR A SCREEN READER IS BOUND, BECAUSE RUNS TAKE IT AWAY. A
+                        TextBlock built from runs answers Text with an empty string - measured on
+                        the first build of this, where every test reading the title read nothing -
+                        and its automation peer names it from Text. Without this line the title
+                        would be silent to Narrator and to every probe reading it by name.
+                    -->
                     <TextBlock x:Name="PlanHeading"
                                AutomationProperties.AutomationId="planHeading"
-                               Text="{Binding Heading}"
+                               AutomationProperties.Name="{Binding Heading.Text}"
                                TextWrapping="Wrap"
-                               Style="{StaticResource PlanTitleText}" />
+                               Style="{StaticResource PlanTitleText}"><Run Text="{Binding Heading.Before, Mode=OneWay}" /><Run Text="{Binding Heading.Name, Mode=OneWay}" Style="{StaticResource NameInSentence}" /><Run Text="{Binding Heading.After, Mode=OneWay}" /></TextBlock>
 
                     <!--
                         THE MANAGER'S OWN NAME IN THE FIXED FACE SINCE 2026-09-02: this is the
diff --git a/src/Bws.Gui/Release.cs b/src/Bws.Gui/Release.cs
deleted file mode 100644
index 653badc..0000000
--- a/src/Bws.Gui/Release.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-using System.Reflection;
-
-namespace Bws.Gui;
-
-/// <summary>
-/// Which release this window is, for the help menu - UX-GUI-014, 2026-09-24. Until that day the
-/// window said its version nowhere, so somebody reporting a fault had nothing to copy it from.
-///
-/// <b>The same reading as the command line's Release, and a copy of it rather than a shared one on
-/// purpose.</b> Each binary reports the stamp on ITS OWN assembly - the one a person is running -
-/// and the two are built from the one Version in Directory.Build.props, so they agree unless one
-/// of them is a different build, which is exactly when a person should see the difference.
-/// </summary>
-internal static class Release
-{
-    /// <summary>
-    /// The version, without the part after a plus that the SDK appends (the source revision) -
-    /// or null when nothing was stamped, which the menu says in words (rule 8 of CLAUDE.md applied
-    /// to one number, rather than a guess that looks like one).
-    /// </summary>
-    internal static string? Number
-    {
-        get
-        {
-            var stamped = typeof(Release).Assembly
-                .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?
-                .InformationalVersion;
-
-            if (string.IsNullOrEmpty(stamped))
-            {
-                return null;
-            }
-
-            var build = stamped.IndexOf('+', StringComparison.Ordinal);
-            return build < 0 ? stamped : stamped[..build];
-        }
-    }
-}
diff --git a/src/Bws.Gui/Resources/gui.en.json b/src/Bws.Gui/Resources/gui.en.json
index 7028a64..1b029ac 100644
--- a/src/Bws.Gui/Resources/gui.en.json
+++ b/src/Bws.Gui/Resources/gui.en.json
@@ -340,8 +340,6 @@
   "gui.menu.details": "Show details",
   "gui.menu.details.gesture": "Enter",
   "gui.menu.copyName": "Copy name",
-  "gui.menu.copyDisplayName": "Copy display name",
-  "gui.menu.copyDescription": "Copy description",
   "gui.menu.copyAll": "Copy everything",
   "gui.menu.copyAll.gesture": "Ctrl+C",
 
@@ -368,21 +366,8 @@
   "gui.support.slow": "Windows has not finished opening the support page, so it may still open by itself. It is at {0}, and any browser you open yourself will show it.",
 
   "gui.help.button": "Help",
-  "gui.help.hint": "The keyboard shortcuts, the query language, the project's website and the version of this program. F1 opens this too. This tool itself connects to nothing, and the two pages open in your browser.",
-  "gui.help.find": "Search the list",
-  "gui.help.find.gesture": "Ctrl+F",
-  "gui.help.refresh": "Read the machine again",
-  "gui.help.refresh.gesture": "F5",
-  "gui.help.details": "Show details of the selected entry",
-  "gui.help.copy": "Copy everything about the selected entries",
-  "gui.help.selectAll": "Select every entry in the list",
-  "gui.help.selectAll.gesture": "Ctrl+A",
-  "gui.help.back": "Close what is open, or clear the search",
-  "gui.help.back.gesture": "Esc",
+  "gui.help.hint": "The query language, on the project's website. F1 opens this too. This tool itself connects to nothing, and the page opens in your browser.",
   "gui.help.queryLanguage": "The query language, on the project's website",
-  "gui.help.projectPage": "The project's website",
-  "gui.help.version": "Version {0} - copy it",
-  "gui.help.versionUnknown": "not stamped on this build",
   "gui.link.failed": "The page did not open. {0} It is at {1}, and any browser you open yourself will show it.",
   "gui.link.slow": "Windows has not finished opening the page, so it may still open by itself. It is at {0}, and any browser you open yourself will show it.",
 
diff --git a/src/Bws.Gui/RowMenu.cs b/src/Bws.Gui/RowMenu.cs
index 06367da..7e35217 100644
--- a/src/Bws.Gui/RowMenu.cs
+++ b/src/Bws.Gui/RowMenu.cs
@@ -23,25 +23,21 @@ namespace Bws.Gui;
 public sealed class RowMenuEntry
 {
     private readonly string _gestureKey;
-    private readonly Func<string>? _filling;
 
-    /// <param name="filling">
-    /// The one value a label cannot carry in the language file - the help menu's version number,
-    /// since 2026-09-24. Asked each time the label is read, so it is never a copy taken earlier.
-    /// </param>
-    internal RowMenuEntry(string labelKey, string? gestureKey, Func<Task> act, Func<string>? filling = null)
+    // A LABEL WITH A VALUE IN IT (the help menu's version number) had a second parameter here for
+    // one day, 2026-09-24, and went with the version item.
+    internal RowMenuEntry(string labelKey, string? gestureKey, Func<Task> act)
     {
         LabelKey = labelKey;
         _gestureKey = gestureKey ?? string.Empty;
         Act = act;
-        _filling = filling;
     }
 
     /// <summary>The key of its label, which is how a test tells the items apart without reading words.</summary>
     internal string LabelKey { get; }
 
     /// <summary>What the item says, in the language of whoever is reading it.</summary>
-    public string Label => _filling is null ? Texts.Of(LabelKey) : Texts.Of(LabelKey, _filling());
+    public string Label => Texts.Of(LabelKey);
 
     /// <summary>The key that does the same thing, written beside the label - or nothing.</summary>
     public string Gesture => _gestureKey.Length == 0 ? string.Empty : Texts.Of(_gestureKey);
@@ -98,7 +94,7 @@ internal RowMenuEntry(string labelKey, Func<StartSetting, Task> chosen)
 internal static class RowMenu
 {
     /// <summary>
-    /// What the menu offers, in the order it is offered: the one thing Enter does, then the four
+    /// What the menu offers, in the order it is offered: the one thing Enter does, then the two
     /// copies, then the six verbs of the action bar.
     ///
     /// <b>"Show details" first, because it is the item the default gesture stands for.</b> Windows
@@ -121,9 +117,10 @@ internal static IReadOnlyList<IReadOnlyList<RowMenuEntry>> GroupsFor(MainWindow
                 Task.FromResult(window.OpenDetailsOfPointed()))
         ],
         [
+            // TWO COPIES SINCE 2026-09-24, not four - owner's decision, the menu held too many
+            // actions. The display name and the description went: both are in "Copy everything"
+            // below, and the name stays on its own because a script takes it alone.
             new RowMenuEntry("gui.menu.copyName", null, () => Task.FromResult(window.Copy(Copying.Name))),
-            new RowMenuEntry("gui.menu.copyDisplayName", null, () => Task.FromResult(window.Copy(Copying.DisplayName))),
-            new RowMenuEntry("gui.menu.copyDescription", null, () => Task.FromResult(window.Copy(Copying.Description))),
 
             // THE WHOLE ENTRY, AND IT IS WHAT Ctrl+C DOES TOO - owner's request, 2026-08-13.
             // Everything the catalogue knows rather than the columns that happen to be on, because
diff --git a/src/Bws.Gui/Themes/Overview.xaml b/src/Bws.Gui/Themes/Overview.xaml
index 4ed0a80..691c907 100644
--- a/src/Bws.Gui/Themes/Overview.xaml
+++ b/src/Bws.Gui/Themes/Overview.xaml
@@ -108,4 +108,20 @@
             </Setter.Value>
         </Setter>
     </Style>
+
+    <!--
+        ONE CARD'S SURFACE - the fill, the edge, the corner and the room around and inside it.
+        Moved out of OverviewView.xaml on 2026-09-24, when the way off the screen took the primary
+        action's style and the view stood one line over the markup ceiling. It is what the note at
+        the top of this file calls pure appearance with no wiring in it: the card's buttons and
+        their handlers stay in the view's template, and only what the card looks like came here.
+    -->
+    <Style x:Key="OverviewCard" 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 CornerTile}" />
+        <Setter Property="Margin" Value="{StaticResource MarginTile}" />
+        <Setter Property="Padding" Value="{StaticResource PadTile}" />
+    </Style>
 </ResourceDictionary>
diff --git a/src/Bws.Gui/Themes/PlanLines.xaml b/src/Bws.Gui/Themes/PlanLines.xaml
index a8aff97..dcacff5 100644
--- a/src/Bws.Gui/Themes/PlanLines.xaml
+++ b/src/Bws.Gui/Themes/PlanLines.xaml
@@ -47,10 +47,20 @@
         WHAT SOMEBODY ASKED FOR READS DIFFERENTLY FROM WHAT COMES ALONG, and `C2` is why: the
         plan warns that stopping three drags seven along, so the seven have to be findable at a
         glance. Subdued goes to the ones nobody asked for, which is the right way round.
+
+        THE ENTRY'S NAME IS SET APART SINCE 2026-09-24, owner's decision: ten lines of "stop" read
+        as one grey block with the names lost in it. Three runs, the middle one wearing
+        NameInSentence - the colour stays the line's, so asked and along still read differently.
+        THE THREE RUNS STAND ON ONE LINE WITH NOTHING BETWEEN THEM, and that is not tidiness:
+        whitespace between inlines in markup is a space on screen, and the spaces the sentence
+        needs are already in its parts. Mode=OneWay because a Run's Text binds both ways by
+        default and these parts cannot be written back. The automation name is bound to the
+        whole line because a TextBlock of runs answers Text with nothing - PlanView.xaml says it
+        at the title, where it was measured.
     -->
     <DataTemplate x:Key="PlanLineTemplate">
-        <TextBlock Text="{Binding Text}"
-                   TextWrapping="Wrap"
+        <TextBlock TextWrapping="Wrap"
+                   AutomationProperties.Name="{Binding Text}"
                    Margin="{StaticResource MarginBetweenControls}">
             <TextBlock.Style>
                 <Style TargetType="TextBlock" BasedOn="{StaticResource PlanStepText}">
@@ -60,8 +70,7 @@
                         </DataTrigger>
                     </Style.Triggers>
                 </Style>
-            </TextBlock.Style>
-        </TextBlock>
+            </TextBlock.Style><Run Text="{Binding Sentence.Before, Mode=OneWay}" /><Run Text="{Binding Sentence.Name, Mode=OneWay}" Style="{StaticResource NameInSentence}" /><Run Text="{Binding Sentence.After, Mode=OneWay}" /></TextBlock>
     </DataTemplate>
 
     <!--
diff --git a/src/Bws.Gui/Themes/Text.xaml b/src/Bws.Gui/Themes/Text.xaml
index 09f32cb..943846e 100644
--- a/src/Bws.Gui/Themes/Text.xaml
+++ b/src/Bws.Gui/Themes/Text.xaml
@@ -193,14 +193,36 @@
         and the name repeats what the title already named. That is wording rather than type, it
         needs an imperative form of every operation this product knows, and it is its own row of the
         backlog.
+
+        PLAIN WEIGHT SINCE 2026-09-24, AND THE WEIGHT MOVED RATHER THAN WENT. The entry's name in
+        the title wears NameInSentence below, owner's decision - and a title semibold from end to
+        end has no weight left to set a name apart with. The size stays, so the title still stands
+        over the steps at 14 against their 13.
     -->
     <Style x:Key="PlanTitleText" TargetType="TextBlock">
         <Setter Property="FontFamily" Value="{StaticResource TextFace}" />
         <Setter Property="FontSize" Value="{StaticResource TextSizeHeader}" />
-        <Setter Property="FontWeight" Value="{StaticResource TextWeightHeader}" />
+        <Setter Property="FontWeight" Value="{StaticResource TextWeightNormal}" />
         <Setter Property="Foreground" Value="{StaticResource TextOnSurface}" />
     </Style>
 
+    <!--
+        AN ENTRY'S NAME INSIDE A SENTENCE ABOUT IT, 2026-09-24, owner's decision: the plan panel
+        said "stop" six times on one sheet and the name each line was about read exactly like the
+        words around it. Worn by the middle of three runs - the plan's title and every step - and
+        ViewModels/NamedSentence.cs says how a sentence is cut there.
+
+        THE SIZE IS HERE BECAUSE THE WEIGHT IS, which is the rule PrimaryAction states: semibold has
+        a floor of 14 where plain text has 12, and a step is 13. So the name in a step is a point
+        larger than the words beside it, and TypeScaleGuards holds this style to that floor like
+        every other semibold one. No colour: a step nobody asked for is subdued, and its name stays
+        as dim as its line so asked and along still read apart.
+    -->
+    <Style x:Key="NameInSentence" TargetType="Run">
+        <Setter Property="FontSize" Value="{StaticResource TextSizeHeader}" />
+        <Setter Property="FontWeight" Value="{StaticResource TextWeightHeader}" />
+    </Style>
+
     <!--
         THIRTEEN SINCE 2026-09-02, DOWN FROM 14. This line sits in the FIXED head of the panel, so
         every point it takes is a point the scrolling body never gets - measured that day: head 179
diff --git a/src/Bws.Gui/ViewModels/Catalogue.Samples.cs b/src/Bws.Gui/ViewModels/Catalogue.Samples.cs
index 13696ae..74bf923 100644
--- a/src/Bws.Gui/ViewModels/Catalogue.Samples.cs
+++ b/src/Bws.Gui/ViewModels/Catalogue.Samples.cs
@@ -91,6 +91,16 @@ private static Sample Make(string target, Style style, string text, bool enabled
             return Sample.Of(new TextBlock(link) { TextWrapping = TextWrapping.Wrap, IsEnabled = enabled });
         }
 
+        // A RUN, since 2026-09-24, when an entry's name in the plan panel got a style of its own.
+        // The same reason as the link above: it lives inside text and cannot stand alone. A run
+        // has no disabled state to show, so that column says so rather than drawing it twice.
+        if (target == nameof(System.Windows.Documents.Run))
+        {
+            return enabled
+                ? Sample.Of(new TextBlock(new System.Windows.Documents.Run(text) { Style = style }) { TextWrapping = TextWrapping.Wrap })
+                : Sample.None(NoSuchState);
+        }
+
         FrameworkElement? element = target switch
         {
             nameof(TextBlock) => new TextBlock { Text = text, TextWrapping = TextWrapping.Wrap },
diff --git a/src/Bws.Gui/ViewModels/Catalogue.Specimens.cs b/src/Bws.Gui/ViewModels/Catalogue.Specimens.cs
index 0d4a2a2..3567cf6 100644
--- a/src/Bws.Gui/ViewModels/Catalogue.Specimens.cs
+++ b/src/Bws.Gui/ViewModels/Catalogue.Specimens.cs
@@ -167,7 +167,9 @@ private static (object Normal, object Extreme)? TemplateSpecimens(string key)
             "AgainstStartTypeCell" => (ordinary, EntryRow.Of(entries[6])),
 
             "TrimmedButtonLabel" => ("Stop Print Spooler", "Stop " + LongName + " display name"),
-            "PlanLineTemplate" => (new PlanLine("Stop Print Spooler", asked: true), new PlanLine("Stop " + LongName + " display name, which came along", asked: false)),
+            "PlanLineTemplate" => (
+                new PlanLine(new NamedSentence("1. stop ", "Spooler", " (asked for)"), asked: true),
+                new PlanLine(new NamedSentence("2. stop ", LongName + " display name", ", which came along"), asked: false)),
             "PlanSentenceTemplate" => ("Stopping this will stop the two entries that depend on it as well.", LongDescription),
             "PlanFailureTemplate" => (new PlanFailure("Windows refused to stop it: access is denied (5).", offer: null), new PlanFailure(LongDescription, offer: null)),
 
diff --git a/src/Bws.Gui/ViewModels/Copying.cs b/src/Bws.Gui/ViewModels/Copying.cs
index b860012..679c7c9 100644
--- a/src/Bws.Gui/ViewModels/Copying.cs
+++ b/src/Bws.Gui/ViewModels/Copying.cs
@@ -30,18 +30,8 @@ internal static class Copying
     /// </summary>
     internal static string? Name(IReadOnlyList<EntryRow> rows) => Joined(rows.Select(row => row.ServiceName));
 
-    /// <summary>The names a person recognises, which is what a ticket takes.</summary>
-    internal static string? DisplayName(IReadOnlyList<EntryRow> rows) =>
-        Joined(rows.Select(row => row.DisplayName));
-
-    /// <summary>
-    /// What the entries say about themselves.
-    ///
-    /// Read through the column catalogue like every other value, so a copy cannot say something the
-    /// column does not - the same rule the details panel rests on.
-    /// </summary>
-    internal static string? Description(IReadOnlyList<EntryRow> rows) =>
-        Joined(rows.Select(row => row["description"]));
+    // THE DISPLAY NAME AND THE DESCRIPTION HAD A COPY EACH UNTIL 2026-09-24, when the owner took
+    // both items off the row menu as too many. Both are still on the clipboard, inside Everything.
 
     /// <summary>
     /// Everything the window knows about each of them.
@@ -61,6 +51,9 @@ internal static class Copying
     ///
     /// <b>An entry with nothing to say is left out rather than pasted as a blank line</b>, so a copy of
     /// five entries where two have no description is three lines rather than five with gaps in it.
+    /// Since 2026-09-24 only names pass through here and a name is never empty, so no test reaches
+    /// that branch any more - it was asked through the description copy, and it is kept for the
+    /// next field copied on its own rather than taken out and forgotten.
     ///
     /// <b>WHAT THIS DOES NOT DO, AND THE FIRST VERSION OF THIS COMMENT CLAIMED IT DID:</b> a value the
     /// tool was REFUSED goes on the clipboard as the same sentence a cell shows, because that is what
diff --git a/src/Bws.Gui/ViewModels/NamedSentence.cs b/src/Bws.Gui/ViewModels/NamedSentence.cs
new file mode 100644
index 0000000..81052b1
--- /dev/null
+++ b/src/Bws.Gui/ViewModels/NamedSentence.cs
@@ -0,0 +1,69 @@
+namespace Bws.Gui.ViewModels;
+
+/// <summary>
+/// A sentence about one entry, cut where the entry's name stands, so the view can set the name
+/// apart from the words around it - owner's decision, 2026-09-24. The plan panel said "stop" six
+/// times on one sheet and the name it was about read exactly like the words beside it.
+///
+/// <b>THE LANGUAGE FILE STILL DECIDES WHERE THE NAME GOES.</b> The sentence is put together from its
+/// key as before, with <see cref="Slot"/> standing where the name belongs, and cut at that mark
+/// afterwards - so a translation that puts the name first or last is followed rather than
+/// overridden, and the key stays written where TextKeyGuards can see it.
+///
+/// <b>The name itself is never searched for the mark.</b> It is a service name, which is somebody
+/// else's input (`docs/09`), and it goes into the middle part after the cut rather than into the
+/// text being cut. Only our own words - the number, the verb, the reason - share a string with the
+/// mark, and none of them can hold a character from the private use area.
+///
+/// <b>THREE PARTS RATHER THAN A LIST OF THEM, and that is a limit said out loud.</b> One name per
+/// sentence is what the owner asked for - the title and each step - and three parts can be drawn
+/// by three runs in a theme file, which cannot name a type of this assembly (`docs/10` trap 10).
+/// A sentence naming several entries - a warning listing what comes along - would need a list and
+/// a view that is not a theme file.
+/// </summary>
+/// <remarks>Public for the reason <see cref="PlanLine"/> is: WPF cannot bind to an internal type.</remarks>
+public sealed record NamedSentence(string Before, string Name, string After)
+{
+    /// <summary>
+    /// Where the name stands while the sentence is put together - one character from Unicode's
+    /// private use area, which no word in the language file carries.
+    ///
+    /// <b>Built from its number rather than written as a literal</b>, so the source stays plain
+    /// ASCII (PublicSurfaceGuards) and no editor or tool can turn an escape into the character.
+    /// The first version was written as an escape, and a tool on the way to the disk did exactly that.
+    /// </summary>
+    internal static readonly string Slot = char.ConvertFromUtf32(0xE000);
+
+    /// <summary>The whole sentence, as a person reads it and as a test or a copy takes it.</summary>
+    public string Text => Before + Name + After;
+
+    /// <summary>
+    /// A sentence put together with <see cref="Slot"/> in place of the name, cut there.
+    ///
+    /// <b>No mark, or more than one, and the sentence comes back whole with nothing set apart</b>
+    /// - the name in every place the language file put it, and the words all correct. A
+    /// translation that dropped the name, or a template that could not be formatted and came back
+    /// untouched, reads as it would have read before this type existed.
+    /// </summary>
+    internal static NamedSentence Around(string formatted, string name)
+    {
+        ArgumentNullException.ThrowIfNull(formatted);
+        ArgumentNullException.ThrowIfNull(name);
+
+        var at = formatted.IndexOf(Slot, StringComparison.Ordinal);
+
+        if (at < 0)
+        {
+            return Unnamed(formatted);
+        }
+
+        var after = formatted[(at + Slot.Length)..];
+
+        return after.Contains(Slot, StringComparison.Ordinal)
+            ? Unnamed(formatted.Replace(Slot, name, StringComparison.Ordinal))
+            : new NamedSentence(formatted[..at], name, after);
+    }
+
+    /// <summary>A sentence with no name to set apart - the heading over several entries, or none.</summary>
+    internal static NamedSentence Unnamed(string text) => new(text, string.Empty, string.Empty);
+}
diff --git a/src/Bws.Gui/ViewModels/Planned.Title.cs b/src/Bws.Gui/ViewModels/Planned.Title.cs
index cc9e7b2..86b9bae 100644
--- a/src/Bws.Gui/ViewModels/Planned.Title.cs
+++ b/src/Bws.Gui/ViewModels/Planned.Title.cs
@@ -35,16 +35,25 @@ public sealed partial class Planned
     /// worst bug this panel could have - which is why <c>Show</c> drops the old run and why a guard
     /// holds it. Taking the title away after a run would remove the label that makes the pair
     /// readable.
+    ///
+    /// <b>CUT WHERE THE ENTRY'S NAME STANDS SINCE 2026-09-24</b>, so the panel can set the name
+    /// apart from "What stopping ... would do" - owner's decision. <see cref="NamedSentence"/> says
+    /// how, and why the language file still places the name. Several entries have a count rather
+    /// than a name, and nothing to set apart. The whole sentence is its Text.
     /// </summary>
-    public string Heading => _plan is not { } plan
-        ? string.Empty
+    public NamedSentence Heading => _plan is not { } plan
+        ? NamedSentence.Unnamed(string.Empty)
         : _run is null
             ? Asked(plan) == 1
-                ? Texts.Of("gui.plan.heading.one", PlanWords.Doing(plan.Action.Kind), Named(plan))
-                : Texts.Of("gui.plan.heading.many", PlanWords.Doing(plan.Action.Kind), Asked(plan))
+                ? NamedSentence.Around(
+                    Texts.Of("gui.plan.heading.one", PlanWords.Doing(plan.Action.Kind), NamedSentence.Slot),
+                    Named(plan))
+                : NamedSentence.Unnamed(Texts.Of("gui.plan.heading.many", PlanWords.Doing(plan.Action.Kind), Asked(plan)))
             : Asked(plan) == 1
-                ? Texts.Of("gui.plan.heading.done.one", PlanWords.Doing(plan.Action.Kind), Named(plan))
-                : Texts.Of("gui.plan.heading.done.many", PlanWords.Doing(plan.Action.Kind), Asked(plan));
+                ? NamedSentence.Around(
+                    Texts.Of("gui.plan.heading.done.one", PlanWords.Doing(plan.Action.Kind), NamedSentence.Slot),
+                    Named(plan))
+                : NamedSentence.Unnamed(Texts.Of("gui.plan.heading.done.many", PlanWords.Doing(plan.Action.Kind), Asked(plan)));
 
     /// <summary>
     /// The manager's own name for the entry, under a title that used the one a person recognises.
diff --git a/src/Bws.Gui/ViewModels/Planned.cs b/src/Bws.Gui/ViewModels/Planned.cs
index 540476b..c294f9f 100644
--- a/src/Bws.Gui/ViewModels/Planned.cs
+++ b/src/Bws.Gui/ViewModels/Planned.cs
@@ -10,13 +10,17 @@ namespace Bws.Gui.ViewModels;
 /// </remarks>
 public sealed class PlanLine
 {
-    internal PlanLine(string text, bool asked)
+    internal PlanLine(NamedSentence sentence, bool asked)
     {
-        Text = text;
+        Sentence = sentence;
         Asked = asked;
     }
 
-    public string Text { get; }
+    /// <summary>The line cut where the entry's name stands, which is what the panel draws.</summary>
+    public NamedSentence Sentence { get; }
+
+    /// <summary>The whole line, as a test, a copy or a screen reader takes it.</summary>
+    public string Text => Sentence.Text;
 
     /// <summary>
     /// Whether somebody asked for this entry, as opposed to it coming along.
@@ -198,21 +202,26 @@ public bool Showing
     /// "number, verb, name, reason" - which for a setting reads "1. set to Disabled Spooler". What a
     /// step of that kind has to say is which entry and which type, in that order, so it gets a line
     /// of its own.
+    ///
+    /// <b>Cut where the name stands since 2026-09-24</b>, so the panel can set the entry apart from
+    /// "stop" and the reason around it - <see cref="NamedSentence"/>.
     /// </summary>
-    private static string Line(PlanStep step, int number) =>
-        step.Operation == StepOperation.SetStartType
-            ? Texts.Of(
-                "gui.plan.step.startType",
-                number,
-                step.ServiceName,
-                CellFaces.SettingLabel(step.To!.Value),
-                PlanWords.Reason(step.Reason))
-            : Texts.Of(
-                "gui.plan.step",
-                number,
-                PlanWords.Word(step.Operation),
-                step.ServiceName,
-                PlanWords.Reason(step.Reason));
+    private static NamedSentence Line(PlanStep step, int number) =>
+        NamedSentence.Around(
+            step.Operation == StepOperation.SetStartType
+                ? Texts.Of(
+                    "gui.plan.step.startType",
+                    number,
+                    NamedSentence.Slot,
+                    CellFaces.SettingLabel(step.To!.Value),
+                    PlanWords.Reason(step.Reason))
+                : Texts.Of(
+                    "gui.plan.step",
+                    number,
+                    PlanWords.Word(step.Operation),
+                    NamedSentence.Slot,
+                    PlanWords.Reason(step.Reason)),
+            step.ServiceName);
 
     /// <summary>
     /// How many entries come along that nobody picked, as `C2`'s own sentence asks for it.
diff --git a/tests/Bws.Gui.Tests/ActionBarGuards.cs b/tests/Bws.Gui.Tests/ActionBarGuards.cs
index 615d28d..9a62835 100644
--- a/tests/Bws.Gui.Tests/ActionBarGuards.cs
+++ b/tests/Bws.Gui.Tests/ActionBarGuards.cs
@@ -269,7 +269,7 @@ public async Task The_start_type_menu_offers_four_settings_and_one_opens_a_plan_
         // title is the line somebody reads before changing a machine.
         Assert.Contains(
             Bws.Gui.Texts.Of("gui.plan.doing.setStartType"),
-            WpfHost.On(() => window.PlanPanel.Heading.Text),
+            WpfHost.Drawn(window.PlanPanel.Heading),
             StringComparison.Ordinal);
 
         var steps = WpfHost.On(() => string.Join(" ", window.PlanPanel.StepLines));
diff --git a/tests/Bws.Gui.Tests/ButtonGuards.cs b/tests/Bws.Gui.Tests/ButtonGuards.cs
index 49e9da0..798bb42 100644
--- a/tests/Bws.Gui.Tests/ButtonGuards.cs
+++ b/tests/Bws.Gui.Tests/ButtonGuards.cs
@@ -61,6 +61,33 @@ public void The_primary_action_wears_the_colour_that_means_press_this()
         Assert.Equal(Declared("SurfacePrimaryAction"), Colour(painted));
     }
 
+    /// <summary>
+    /// The way off the first screen wears it too, since 2026-09-24 - the owner's words were that on
+    /// a first run "Show the list" was hidden in the background, and backlog 270 had taken the
+    /// accent off it on 2026-09-01.
+    ///
+    /// <b>Asked of the button the overview draws, with its template applied</b>, rather than of
+    /// the name of the style it asks for - a style named and then beaten by a local value is how
+    /// 270 began.
+    /// </summary>
+    [Fact]
+    public void The_way_off_the_first_screen_wears_the_colour_that_means_press_this()
+    {
+        var window = WpfHost.Window();
+
+        var painted = WpfHost.On(() =>
+        {
+            var button = window.Overview.DismissButton;
+            button.ApplyTemplate();
+
+            return ((Border)button.Template.FindName("Face", button)).Background;
+        });
+
+        Assert.Equal(Declared("SurfacePrimaryAction"), Colour(painted));
+
+        WpfHost.On(window.Close);
+    }
+
     /// <summary>
     /// When it cannot be pressed it gives up the fill entirely rather than dimming it.
     ///
diff --git a/tests/Bws.Gui.Tests/CopyingAndPanelGuards.cs b/tests/Bws.Gui.Tests/CopyingAndPanelGuards.cs
index 401f7bb..ed4ccae 100644
--- a/tests/Bws.Gui.Tests/CopyingAndPanelGuards.cs
+++ b/tests/Bws.Gui.Tests/CopyingAndPanelGuards.cs
@@ -60,7 +60,8 @@ await TheClipboard.Copies(model, wanted, "Ctrl+C", async () =>
     }
 
     /// <summary>
-    /// The four menu items the owner asked for, each copying what its own label promises.
+    /// The copy items of the row menu, each copying what its own label promises. Four until
+    /// 2026-09-24, two since - the display name and the description went into "Copy everything".
     ///
     /// <b>Reached by the KEY of their label since 2026-09-15, when the menu became a list.</b>
     /// Until then they were reached by position - the first four - because the headers came from
@@ -84,10 +85,8 @@ public async Task The_context_menu_copies_what_each_item_promises()
         {
             // ASKED OF THE SELECTION RATHER THAN OF THE PANEL SINCE 2026-08-18. A copy is about the
             // rows somebody picked, which is a different set from the one entry the panel shows, and
-            // the four menu items promise the first of those.
+            // the copy items promise the first of those.
             ("gui.menu.copyName", WpfHost.On(() => Copying.Name(Picked(window)))),
-            ("gui.menu.copyDisplayName", WpfHost.On(() => Copying.DisplayName(Picked(window)))),
-            ("gui.menu.copyDescription", WpfHost.On(() => Copying.Description(Picked(window)))),
             ("gui.menu.copyAll", WpfHost.On(() => Copying.Everything(Picked(window))))
         };
 
diff --git a/tests/Bws.Gui.Tests/HelpMenuGuards.cs b/tests/Bws.Gui.Tests/HelpMenuGuards.cs
index a8abb51..87eeba1 100644
--- a/tests/Bws.Gui.Tests/HelpMenuGuards.cs
+++ b/tests/Bws.Gui.Tests/HelpMenuGuards.cs
@@ -4,24 +4,22 @@
 namespace Bws.Gui.Tests;
 
 /// <summary>
-/// The Help button and its menu - UX-GUI-014 and the shortcut half of UX-GUI-010, owner's decision
-/// 2026-09-24. Until that day the window named Ctrl+F, Ctrl+C and Ctrl+A nowhere, said its own
-/// version nowhere, and answered F1 with nothing.
+/// The Help button and its menu - UX-GUI-014, owner's decision 2026-09-24, and cut the same day to
+/// the one page it offers now (HelpMenu says what went and what that costs).
 ///
-/// <b>What is not here, said rather than left as a gap:</b> that the two pages really open in a
+/// <b>What is not here, said rather than left as a gap:</b> that the page really opens in a
 /// browser. Nobody should find out by opening one from a test run - ExternalLinksGuards holds the
-/// rule both roads follow, and the addresses are pinned below.
+/// rule every road out follows, and the address is pinned below.
 /// </summary>
 public sealed class HelpMenuGuards
 {
     /// <summary>
-    /// The menu holds the six keys, the two pages and the version, in three groups - asked of the
-    /// real menu hung on the real button. The keys are asserted on the ITEM, for the reason
-    /// RowMenuGuards gives: an entry saying "Ctrl+F" and a style never binding it would leave the
-    /// menu looking as it did before.
+    /// The menu holds the query language page and nothing else - asked of the real menu hung on the
+    /// real button, so a shortcut, the project's website or the version coming back is a red test
+    /// rather than a menu that quietly grew again.
     /// </summary>
     [Fact]
-    public void The_help_menu_names_every_key_the_pages_and_the_version()
+    public void The_help_menu_holds_the_query_language_page_and_nothing_else()
     {
         var window = WpfHost.Window();
 
@@ -37,21 +35,7 @@ public void The_help_menu_names_every_key_the_pages_and_the_version()
             _ => "?"
         }).ToList());
 
-        Assert.Equal(
-            [
-                "gui.help.find Ctrl+F",
-                "gui.help.refresh F5",
-                "gui.help.details Enter",
-                "gui.help.copy Ctrl+C",
-                "gui.help.selectAll Ctrl+A",
-                "gui.help.back Esc",
-                "-",
-                "gui.help.queryLanguage",
-                "gui.help.projectPage",
-                "-",
-                "gui.help.version"
-            ],
-            shape);
+        Assert.Equal(["gui.help.queryLanguage"], shape);
 
         WpfHost.On(window.Close);
     }
@@ -73,79 +57,13 @@ public void F1_opens_the_help_menu()
     }
 
     /// <summary>
-    /// The version item carries the number this build was stamped with and nothing after a plus -
-    /// the part the SDK appends for the source revision is not a version anybody reports.
+    /// The page is the project's own, over https, and the button says before it is pressed that the
+    /// tool itself connects to nothing - the one moment a person could feel `ADR-19` was broken is
+    /// the moment a browser appears.
     /// </summary>
     [Fact]
-    public void The_version_item_says_the_stamped_number()
+    public void The_page_is_the_projects_own_over_https()
     {
-        var number = HelpMenu.VersionNumber;
-
-        Assert.NotEqual(Texts.Of("gui.help.versionUnknown"), number);
-        Assert.DoesNotContain("+", number, StringComparison.Ordinal);
-        Assert.True(char.IsDigit(number[0]), $"A version starts with a digit, and this one is \"{number}\".");
-
-        var window = WpfHost.Window();
-        var entry = WpfHost.On(() => window.Scope.Help.ContextMenu!.Items.OfType<MenuItem>()
-            .Select(item => (RowMenuEntry)item.DataContext)
-            .Single(one => one.LabelKey == "gui.help.version"));
-
-        Assert.Equal(Texts.Of("gui.help.version", number), entry.Label);
-
-        WpfHost.On(window.Close);
-    }
-
-    /// <summary>
-    /// "Select every entry" does what Ctrl+A does in the grid - asked of the grid, so the item and
-    /// the key are one act.
-    /// </summary>
-    [Fact]
-    public async Task Selecting_every_entry_picks_every_row_in_the_list()
-    {
-        var window = await PlanFixture.Ready();
-
-        Assert.True(WpfHost.On(() => window.SelectEverything()));
-
-        Assert.Equal(
-            WpfHost.On(() => window.Entries.Items.Count),
-            WpfHost.On(() => window.Entries.SelectedItems.Count));
-
-        WpfHost.On(window.Close);
-    }
-
-    /// <summary>
-    /// An item for a key does what the key does, through the same act - asked of Esc, which with
-    /// nothing open clears the search. A menu that only described the keys would pass every test
-    /// above and fail this one.
-    /// </summary>
-    [Fact]
-    public async Task A_shortcut_item_does_what_its_key_does()
-    {
-        var window = await PlanFixture.Ready();
-        var model = WpfHost.On(() => (Bws.Gui.ViewModels.MainViewModel)window.DataContext);
-
-        WpfHost.On(() => model.QueryText = "status:running");
-
-        var back = WpfHost.On(() => window.Scope.Help.ContextMenu!.Items.OfType<MenuItem>()
-            .Select(item => (RowMenuEntry)item.DataContext)
-            .Single(entry => entry.LabelKey == "gui.help.back"));
-
-        await WpfHost.On(() => back.Act());
-
-        Assert.Equal(string.Empty, WpfHost.On(() => model.QueryText));
-
-        WpfHost.On(window.Close);
-    }
-
-    /// <summary>
-    /// The two pages are the project's own, over https, and the button says before it is pressed
-    /// that the tool itself connects to nothing - the one moment a person could feel `ADR-19` was
-    /// broken is the moment a browser appears.
-    /// </summary>
-    [Fact]
-    public void The_pages_are_the_projects_own_over_https()
-    {
-        Assert.Equal("https://betterwindowsservices.donislawdev.com/", ExternalLinks.ProjectPage);
         Assert.Equal("https://betterwindowsservices.donislawdev.com/query-language/", ExternalLinks.QueryLanguagePage);
         Assert.Contains("connects to nothing", Texts.Of("gui.help.hint"), StringComparison.Ordinal);
     }
diff --git a/tests/Bws.Gui.Tests/PlanNameGuards.cs b/tests/Bws.Gui.Tests/PlanNameGuards.cs
new file mode 100644
index 0000000..a8d2200
--- /dev/null
+++ b/tests/Bws.Gui.Tests/PlanNameGuards.cs
@@ -0,0 +1,132 @@
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Documents;
+using System.Windows.Media;
+using Bws.Core.Planning;
+using Bws.Gui.ViewModels;
+
+namespace Bws.Gui.Tests;
+
+/// <summary>
+/// The entry's name set apart in the plan panel - owner's decision, 2026-09-24. A sheet saying
+/// "stop" six times read as one block, with the name each line was about lost in it.
+///
+/// <b>Half of this is about the cut and half about the window</b>, because either can be wrong on
+/// its own: a sentence cut in the right place and drawn with a space too many between its runs, or
+/// drawn perfectly with the weight on the wrong word.
+/// </summary>
+public sealed class PlanNameGuards
+{
+    [Fact]
+    public void A_sentence_is_cut_where_the_name_stands()
+    {
+        var cut = NamedSentence.Around($"1. stop {NamedSentence.Slot} (asked for)", "Spooler");
+
+        Assert.Equal(new NamedSentence("1. stop ", "Spooler", " (asked for)"), cut);
+        Assert.Equal("1. stop Spooler (asked for)", cut.Text);
+    }
+
+    /// <summary>
+    /// No mark, or two, and the sentence comes back whole with nothing set apart - every word
+    /// still right, which is what it read like before names were set apart at all.
+    /// </summary>
+    [Fact]
+    public void A_sentence_without_exactly_one_mark_comes_back_whole()
+    {
+        Assert.Equal(
+            NamedSentence.Unnamed("What stopping these 2 entries would do"),
+            NamedSentence.Around("What stopping these 2 entries would do", "Spooler"));
+
+        Assert.Equal(
+            NamedSentence.Unnamed("Spooler, and again Spooler"),
+            NamedSentence.Around($"{NamedSentence.Slot}, and again {NamedSentence.Slot}", "Spooler"));
+    }
+
+    /// <summary>
+    /// A service name is somebody else's input (`docs/09`), so one holding the mark itself must
+    /// come through whole rather than be cut a second time.
+    /// </summary>
+    [Fact]
+    public void A_name_holding_the_mark_itself_is_kept_whole()
+    {
+        var odd = "odd" + NamedSentence.Slot + "name";
+
+        var cut = NamedSentence.Around($"1. stop {NamedSentence.Slot} (asked for)", odd);
+
+        Assert.Equal(new NamedSentence("1. stop ", odd, " (asked for)"), cut);
+    }
+
+    /// <summary>
+    /// On the window: the title and a step each draw the name heavier than the words beside it,
+    /// and the words read exactly as the model says - three runs with markup whitespace between
+    /// them would put a space on screen that no sentence has.
+    /// </summary>
+    [Fact]
+    public async Task The_panel_draws_the_name_heavier_and_every_word_as_the_model_says()
+    {
+        var window = await PlanFixture.Ready();
+        var model = WpfHost.On(() => (MainViewModel)window.DataContext);
+
+        WpfHost.On(() =>
+        {
+            window.Entries.UnselectAll();
+            window.Entries.SelectedItem = model.Rows.First(row => row.ServiceName == "Spooler");
+        });
+        WpfHost.Settled();
+
+        Assert.True(await WpfHost.On(() => window.Preview(ActionKind.Stop)));
+
+        var (title, step) = WpfHost.On(() =>
+        {
+            window.Left = -4000;
+            window.Show();
+            window.UpdateLayout();
+
+            var container = (DependencyObject)window.PlanPanel.StepList.ItemContainerGenerator.ContainerFromIndex(0);
+
+            return (Drawn(window.PlanPanel.Heading), Drawn(Descendants(container).OfType<TextBlock>().First()));
+        });
+
+        var heading = WpfHost.On(() => model.Planned.Heading.Text);
+        var line = WpfHost.On(() => model.Planned.Steps[0].Text);
+
+        Assert.Equal((heading, heading), (title.Text, title.Spoken));
+        Assert.Equal(("Print Spooler", true), (title.Name, title.NameIsHeavier));
+
+        Assert.Equal((line, line), (step.Text, step.Spoken));
+        Assert.Equal(("Spooler", true), (step.Name, step.NameIsHeavier));
+
+        WpfHost.On(window.Close);
+    }
+
+    /// <summary>
+    /// What a block of runs draws, and what it says to a screen reader - two answers, because a
+    /// TextBlock built from runs answers Text with nothing and its name has to be bound (PlanView.xaml).
+    /// </summary>
+    private static (string Text, string Spoken, string Name, bool NameIsHeavier) Drawn(TextBlock block)
+    {
+        var runs = block.Inlines.OfType<Run>().ToList();
+
+        return (
+            WpfHost.Drawn(block),
+            System.Windows.Automation.AutomationProperties.GetName(block),
+            runs[1].Text,
+            runs[1].FontWeight.ToOpenTypeWeight() > runs[0].FontWeight.ToOpenTypeWeight()
+                && runs[1].FontWeight.ToOpenTypeWeight() > runs[2].FontWeight.ToOpenTypeWeight());
+    }
+
+    private static IEnumerable<DependencyObject> Descendants(DependencyObject parent)
+    {
+        for (var at = 0; at < VisualTreeHelper.GetChildrenCount(parent); at++)
+        {
+            var child = VisualTreeHelper.GetChild(parent, at);
+
+            yield return child;
+
+            foreach (var deeper in Descendants(child))
+            {
+                yield return deeper;
+            }
+        }
+    }
+}
diff --git a/tests/Bws.Gui.Tests/PlanReportGuards.cs b/tests/Bws.Gui.Tests/PlanReportGuards.cs
index 26bac2c..87aef4b 100644
--- a/tests/Bws.Gui.Tests/PlanReportGuards.cs
+++ b/tests/Bws.Gui.Tests/PlanReportGuards.cs
@@ -44,12 +44,12 @@ public async Task The_title_stops_asking_what_would_happen_once_something_has()
         Assert.True(await WpfHost.On(() => window.Preview(ActionKind.Stop)));
         WpfHost.Settled();
 
-        var asked = WpfHost.On(() => window.PlanPanel.Heading.Text);
+        var asked = WpfHost.Drawn(window.PlanPanel.Heading);
 
         WpfHost.On(() => panel.Finished(Ran(panel)));
         WpfHost.Settled();
 
-        var reported = WpfHost.On(() => window.PlanPanel.Heading.Text);
+        var reported = WpfHost.Drawn(window.PlanPanel.Heading);
 
         Assert.NotEqual(asked, reported);
         Assert.NotEmpty(reported);
diff --git a/tests/Bws.Gui.Tests/PlanViewGuards.cs b/tests/Bws.Gui.Tests/PlanViewGuards.cs
index a6f4d74..e961c63 100644
--- a/tests/Bws.Gui.Tests/PlanViewGuards.cs
+++ b/tests/Bws.Gui.Tests/PlanViewGuards.cs
@@ -55,7 +55,7 @@ public async Task What_it_shows_is_the_plan_for_the_picked_rows()
         Assert.True(await WpfHost.On(() => window.Preview(ActionKind.Stop)));
         WpfHost.Settled();
 
-        var heading = WpfHost.On(() => window.PlanPanel.Heading.Text);
+        var heading = WpfHost.Drawn(window.PlanPanel.Heading);
         var steps = WpfHost.On(() => window.PlanPanel.StepLines);
         var notice = WpfHost.On(() => window.PlanPanel.Notice.Text);
 
@@ -104,7 +104,7 @@ public async Task The_title_names_the_entry_the_way_a_person_does_with_the_manag
 
         Assert.Contains(
             "Print Spooler",
-            WpfHost.On(() => window.PlanPanel.Heading.Text),
+            WpfHost.Drawn(window.PlanPanel.Heading),
             StringComparison.Ordinal);
 
         Assert.Equal("Spooler", WpfHost.On(() => window.PlanPanel.Subtitle.Text));
diff --git a/tests/Bws.Gui.Tests/PluralGuards.cs b/tests/Bws.Gui.Tests/PluralGuards.cs
index a42b701..00413ff 100644
--- a/tests/Bws.Gui.Tests/PluralGuards.cs
+++ b/tests/Bws.Gui.Tests/PluralGuards.cs
@@ -327,7 +327,7 @@ private static void Differ(string one, string many)
     /// <summary>Everything the panel would put on a screen, as flat lines.</summary>
     private static List<string> Everything(Planned panel) =>
     [
-        panel.Heading,
+        panel.Heading.Text,
         panel.Notice,
         panel.Extra,
         panel.Overlapping,
diff --git a/tests/Bws.Gui.Tests/RowMenuGuards.cs b/tests/Bws.Gui.Tests/RowMenuGuards.cs
index 17a14ed..a5f3219 100644
--- a/tests/Bws.Gui.Tests/RowMenuGuards.cs
+++ b/tests/Bws.Gui.Tests/RowMenuGuards.cs
@@ -40,8 +40,6 @@ public sealed class RowMenuGuards
         "gui.menu.details",
         "-",
         "gui.menu.copyName",
-        "gui.menu.copyDisplayName",
-        "gui.menu.copyDescription",
         "gui.menu.copyAll",
         "-",
         "gui.action.stop",
@@ -84,8 +82,11 @@ public void The_menu_starts_with_show_details_and_writes_its_key_beside_it()
 
         // AND Ctrl+C BESIDE "Copy everything" SINCE 2026-09-24 - UX-GUI-010 found the key named in
         // no text of the window, and that item is what the key does. On the item, for the reason
-        // above.
-        Assert.Equal("Ctrl+C", WpfHost.On(() => ((MenuItem)items[5]).InputGestureText));
+        // above. Found by its key rather than by its place, since the menu lost two copies on
+        // 2026-09-24 and a place is what moves.
+        Assert.Equal("Ctrl+C", WpfHost.On(() => items.OfType<MenuItem>()
+            .Single(item => item.DataContext is RowMenuEntry { LabelKey: "gui.menu.copyAll" })
+            .InputGestureText));
 
         // Every entry has words, and only those two have a key.
         foreach (var entry in WpfHost.On(() => items.OfType<MenuItem>().Select(item => (RowMenuEntry)item.DataContext).ToList()))
diff --git a/tests/Bws.Gui.Tests/SelectionGuards.cs b/tests/Bws.Gui.Tests/SelectionGuards.cs
index 9a79c1b..50c1df4 100644
--- a/tests/Bws.Gui.Tests/SelectionGuards.cs
+++ b/tests/Bws.Gui.Tests/SelectionGuards.cs
@@ -1,5 +1,4 @@
 using System.Windows.Controls;
-using Bws.Core;
 using Bws.Gui.ViewModels;
 
 namespace Bws.Gui.Tests;
@@ -120,57 +119,14 @@ public void A_menu_opened_on_a_row_inside_the_selection_keeps_the_whole_selectio
         WpfHost.On(window.Close);
     }
 
-    /// <summary>
-    /// An entry with nothing to say is left out rather than pasted as a blank line.
-    ///
-    /// <b>WRITTEN THE OTHER WAY ROUND FIRST AND THE FAILURE IS WHY THIS COMMENT EXISTS.</b> It claimed
-    /// that a value the tool could not read is dropped, and asserted it against specimens that have a
-    /// description - so it failed, and the claim turned out to be false about the code as well: a
-    /// REFUSED value renders as the sentence a cell shows and does go on the clipboard. Telling those
-    /// apart would mean matching text against the language file from inside the copy path. The comment
-    /// on Copying.Joined now says so instead of the opposite.
-    ///
-    /// What is true, and is what this checks: an ABSENT value contributes no line at all, so a copy of
-    /// two entries where one has nothing to say is one line rather than two with a gap.
-    /// </summary>
-    [Fact]
-    public void An_entry_with_nothing_to_say_contributes_no_line()
-    {
-        var window = WpfHost.Window();
-
-        var rows = WpfHost.On(() =>
-        {
-            var said = EntryRow.Of(Rows.Entry("Spooler", "Print Spooler"));
-            var silent = EntryRow.Of(Rows.Entry("W32Time", "Windows Time") with
-            {
-                Description = Reading<string>.Absent()
-            });
-
-            window.Entries.ItemsSource = new[] { said, silent };
-            window.Entries.SelectedItem = said;
-            window.Entries.SelectedItems.Add(silent);
-
-            return new[] { said, silent };
-        });
-
-        WpfHost.Settled();
-
-        Assert.Equal(2, WpfHost.On(() => window.Entries.SelectedItems.Count));
-        Assert.Equal("Spooler description", Copying.Description(Picked(window)));
-
-        // Both are still there when the field is one every entry has, so the line above is about the
-        // empty value rather than about the second row having been dropped from the selection.
-        Assert.Equal("Spooler" + Environment.NewLine + "W32Time", Copying.Name(Picked(window)));
-
-        WpfHost.On(window.Close);
-    }
+    // AN ENTRY WITH NOTHING TO SAY CONTRIBUTING NO LINE was asked here through the description copy
+    // until 2026-09-24, when that copy left the row menu. The name copy cannot ask it - a name is
+    // never empty - and Copying.Joined says so beside the branch.
 
     [Fact]
     public void Nothing_picked_is_nothing_to_copy_rather_than_an_empty_line()
     {
         Assert.Null(Copying.Name([]));
-        Assert.Null(Copying.DisplayName([]));
-        Assert.Null(Copying.Description([]));
         Assert.Null(Copying.Everything([]));
     }
 
diff --git a/tests/Bws.Gui.Tests/WindowGuards.cs b/tests/Bws.Gui.Tests/WindowGuards.cs
index 8307cf3..35f60eb 100644
--- a/tests/Bws.Gui.Tests/WindowGuards.cs
+++ b/tests/Bws.Gui.Tests/WindowGuards.cs
@@ -99,7 +99,6 @@ public async Task With_no_row_chosen_there_is_nothing_to_copy()
         // Nothing picked, so there is nothing to copy - and null rather than an empty string is what
         // lets Ctrl+C be handed back to whatever is behind this window instead of being swallowed.
         Assert.Null(Copying.Name([]));
-        Assert.Null(Copying.DisplayName([]));
     }
 
     /// <summary>
@@ -464,6 +463,5 @@ public async Task The_chosen_row_is_what_a_copy_would_take()
         model.Chosen.Row = model.Rows[0];
 
         Assert.Equal("Spooler", Copying.Name([model.Rows[0]]));
-        Assert.Equal("Print Spooler", Copying.DisplayName([model.Rows[0]]));
     }
 }
diff --git a/tests/Bws.Gui.Tests/WpfHost.cs b/tests/Bws.Gui.Tests/WpfHost.cs
index 0a10bb3..8091b11 100644
--- a/tests/Bws.Gui.Tests/WpfHost.cs
+++ b/tests/Bws.Gui.Tests/WpfHost.cs
@@ -55,6 +55,14 @@ internal static class WpfHost
     internal static void Settled() =>
         Thread.Value.Invoke(() => { }, DispatcherPriority.ContextIdle);
 
+    /// <summary>
+    /// The words a TextBlock draws, run by run - for a block built from runs, whose Text answers
+    /// with nothing (measured 2026-09-24 on the plan panel's title, PlanView.xaml says it there).
+    /// A block that holds plain Text has one run, so this answers the same for both.
+    /// </summary>
+    internal static string Drawn(System.Windows.Controls.TextBlock block) =>
+        On(() => string.Concat(block.Inlines.OfType<System.Windows.Documents.Run>().Select(run => run.Text)));
+
     /// <summary>
     /// Waits until something on the window is true, and fails rather than waiting forever.
     ///