From a35b01381fcf88009b0bb29bebaf9214b3c1bbe0 Mon Sep 17 00:00:00 2001
From: Eli Pinkerton <wallstop@wallstopstudios.com>
Date: Sat, 10 Oct 2026 06:00:25 +0000
Subject: [PATCH 1/5] Fix the docs copy against the window behavior

The rebrand left the docs behind the renamed window, and three claims
contradicted the code (INCONSISTENCIES I-01..I-03). A processor whose
Accepts list is null is skipped during discovery, so it is never
offered, not offered for every type. Splitter widths persist through
EditorPrefs keys, never with the settings asset, so the pane-width
clause drops out of the shared-state sentence. The persistence toggle
reads Persist State in Settings Asset on screen, so the docs now name
that label and describe the default as off. The settings tooltip had
the two save locations swapped; it now matches the field. The row
actions are the four buttons on each row, not controls above the
object list, and menu paths read Tools > Wallstop Studios >
DxVisualizer per the 147 rename.

Fixes #153. Progresses #149 and #146.
---
 CHANGELOG.md                                  |  2 +
 .../Data/DataVisualizerSettings.cs            |  4 +-
 README.md                                     | 40 +++++++++----------
 docs/extending.md                             |  2 +-
 docs/getting-started.md                       | 15 +++----
 docs/index.md                                 | 12 +++---
 docs/managing-assets.md                       |  2 +-
 docs/organizing.md                            | 23 ++++++-----
 docs/search-and-filter.md                     |  2 +-
 docs/troubleshooting.md                       |  4 +-
 10 files changed, 56 insertions(+), 50 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3ec5c26..ef9b809 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -18,6 +18,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ### Fixed
 
+- Fix the docs copy to match the window: a processor without an `Accepts` list is never offered, pane widths always save in editor preferences, and persistence docs use the
+  on-screen **Persist State in Settings Asset** label. The settings tooltip now names the correct save location. (#153, #149)
 - `BaseDataObject` asset ids no longer change on validation: an asset keeps its authored id, and only an empty id fills from the asset GUID. Created and cloned assets still get a
   fresh id (#137).
 
diff --git a/Editor/DataVisualizer/Data/DataVisualizerSettings.cs b/Editor/DataVisualizer/Data/DataVisualizerSettings.cs
index 2bb5503..244c059 100644
--- a/Editor/DataVisualizer/Data/DataVisualizerSettings.cs
+++ b/Editor/DataVisualizer/Data/DataVisualizerSettings.cs
@@ -15,7 +15,9 @@ public sealed class DataVisualizerSettings : ScriptableObject
 
         public string DataFolderPath => _dataFolderPath;
 
-        [Tooltip("If true, window state (selection, order, collapse) is saved in a special ScriptableObject. If false, state is saved within this settings asset file.")]
+        [Tooltip(
+            "If true, window state (selection, order, collapse) is saved within this settings asset file. If false, state is saved as JSON to a per-user file in Unity's persistent data path."
+        )]
         public bool persistStateInSettingsAsset;
 
         [Tooltip("If true, when selecting an Object, it will be selected in the Inspector.")]
diff --git a/README.md b/README.md
index b57377b..63ff23c 100644
--- a/README.md
+++ b/README.md
@@ -1,15 +1,15 @@
-# Data Visualizer
+# DxVisualizer
 
 > **🤖 AI Assistance Disclosure**
 >
 > The early versions of Data Visualizer were heavily human-authored. More recent development has been a mix of human effort and AI assistance: human authors lead design,
 > architecture, and review, while AI tools assist with feature development, bug detection, performance optimization, and documentation.
 
-Data Visualizer streamlines working with ScriptableObject-heavy systems by centralizing asset management, inspection, and batch operations in a single window. Instead of hunting
+DxVisualizer streamlines working with ScriptableObject-heavy systems by centralizing asset management, inspection, and batch operations in a single window. Instead of hunting
 through the Project panel and repeatedly switching contexts, you get a namespace-organized view of all your data types with inline editing, batch operations, and workflow
 automation.
 
-Data Visualizer is free forever: no subscriptions, no paid upgrades, no feature-gated tiers. The full source is MIT-licensed, and every capability documented here ships in the free
+DxVisualizer is free forever: no subscriptions, no paid upgrades, no feature-gated tiers. The full source is MIT-licensed, and every capability documented here ships in the free
 package.
 
 This guide captures the key points from the companion [video walkthrough](https://youtu.be/3oUxUSKNyhw) while keeping the instructions project-agnostic. A browsable version of this
@@ -17,8 +17,8 @@ documentation, with per-topic pages, is published at <https://wallstop.github.io
 
 ## Getting Started
 
-Open **Tools → Wallstop Studios → Data Visualizer** and dock it alongside the Inspector. The tool persists your layout, selection, and tracked types between sessions, so you can
-jump back into your workflow immediately.
+Open **Tools → Wallstop Studios → DxVisualizer** and dock it alongside the Inspector. The tool persists your layout, selection, and tracked types between sessions, so you can jump
+back into your workflow immediately.
 
 ## Window Layout
 
@@ -72,12 +72,12 @@ Three controls above the Namespace panel populate your catalog:
 
 **Search Types** queries Unity's known ScriptableObject types. Add individual types or entire namespaces in one operation.
 
-**Scan Asset Folder** crawls a folder recursively, discovering all ScriptableObject types and wiring up existing instances. Ideal for bootstrapping Data Visualizer on established
+**Scan Asset Folder** crawls a folder recursively, discovering all ScriptableObject types and wiring up existing instances. Ideal for bootstrapping DxVisualizer on established
 projects.
 
 **Scan Scripts Folder** targets source folders containing ScriptableObject classes. Use this when you've written new types but haven't created any assets yet.
 
-Removing types or namespaces is non-destructive—it only stops Data Visualizer from tracking them. Your assets remain untouched on disk.
+Removing types or namespaces is non-destructive—it only stops DxVisualizer from tracking them. Your assets remain untouched on disk.
 
 Organize the catalog to match your team's mental model. The structure persists across sessions, so everyone can navigate consistently.
 
@@ -102,14 +102,14 @@ removes its labels, and the filter re-applies immediately.
 ![Settings popover with persistence toggles and data folder field](https://raw.githubusercontent.com/wallstop/DataVisualizer/main/docs/images/data-visualizer-settings.png)
 _Settings popover. Regenerated from the live window by the docs capture pipeline._
 
-**Persist State in UserState** (the default) stores the selected namespace and type, the selected object per type, namespace, type, and object ordering, collapse state, tracked
-types, per-type label filters, and the per-type processor scope in a per-user JSON file instead of a shared project asset. Each developer keeps a private arrangement and version
-control stays free of layout churn.
+With **Persist State in Settings Asset** off (the default), the window stores the selected namespace and type, the selected object per type, namespace, type, and object ordering,
+collapse state, tracked types, per-type label filters, and the per-type processor scope in a per-user JSON file instead of a shared project asset. Each developer keeps a private
+arrangement and version control stays free of layout churn.
 
-Turning the setting off stores the same state inside a `DataVisualizerSettings` asset in the project, which suits a team that wants one shared arrangement. Data Visualizer creates
-one at `Assets/Editor/DataVisualizerSettings.asset` on first use if no such asset exists. Switching between the two copies the current state across.
+Turning **Persist State in Settings Asset** on stores the same state inside a `DataVisualizerSettings` asset in the project, which suits a team that wants one shared arrangement.
+DxVisualizer creates one at `Assets/Editor/DataVisualizerSettings.asset` on first use if no such asset exists. Switching between the two copies the current state across.
 
-**Select Active Object** syncs selection between Data Visualizer and Unity's Inspector window. Useful for cross-referencing assets in other editor windows.
+**Select Active Object** syncs selection between DxVisualizer and Unity's Inspector window. Useful for cross-referencing assets in other editor windows.
 
 **Data Folder** defines where new assets land, each in a per-type folder named after its full namespace. Click the path to ping the current folder, or browse to set a new default.
 
@@ -126,8 +126,8 @@ toggles, scrollers, and inspector surfaces. Action colors remain distinct: dange
 for cancel/move, and emphasis for alternate toggle modes. **Reset Theme** keeps the compact Data Folder button sizing, clears the saved selection, and restores Classic. Selecting
 the Classic asset gives the same appearance but keeps an explicit selection.
 
-Create a theme with **Assets → Create → Wallstop Studios → DataVisualizer → Data Visualizer Theme**. Assign a `.uss` asset to its **Style Sheet** field, then choose the theme in
-the window's **Settings → Theme** field. Keep your theme and stylesheet under an `Editor` folder; they are editor-only assets.
+Create a theme with **Assets → Create → Wallstop Studios → DxVisualizer → DxVisualizer Theme**. Assign a `.uss` asset to its **Style Sheet** field, then choose the theme in the
+window's **Settings → Theme** field. Keep your theme and stylesheet under an `Editor` folder; they are editor-only assets.
 
 The selected theme follows the existing project/user persistence setting. Switching that setting copies the current selection. Choose **Classic (Default / Reset)** or use **Reset
 Theme** to restore the package style. A missing theme falls back to the package style without discarding its saved GUID; reset clears that reference too.
@@ -145,9 +145,9 @@ For example, this stylesheet changes the accent, standard button states, window
 }
 ```
 
-The override stylesheet is applied after the package stylesheet. Standard control rules are scoped to `.dataviz-root` inside the Data Visualizer window. Normal USS selector
-precedence still applies, and explicit inline styles take priority. Data color swatches and label colors remain data-driven; IMGUI and custom third-party inspector styling are not
-replaced. Use `Nord.uss` or `Dracula.uss` as palette references; copy them under your project's `Editor` folder before customizing rather than editing installed package files. The
+The override stylesheet is applied after the package stylesheet. Standard control rules are scoped to `.dataviz-root` inside the DxVisualizer window. Normal USS selector precedence
+still applies, and explicit inline styles take priority. Data color swatches and label colors remain data-driven; IMGUI and custom third-party inspector styling are not replaced.
+Use `Nord.uss` or `Dracula.uss` as palette references; copy them under your project's `Editor` folder before customizing rather than editing installed package files. The
 `--dataviz-background` and `--dataviz-input` tokens control the window and input surfaces. Semantic `--dataviz-danger`, `--dataviz-positive`, `--dataviz-secondary`,
 `--dataviz-warning`, and `--dataviz-emphasis` tokens each have a matching `--dataviz-on-*` foreground token for filled states. Theme changes apply to the open window without
 reselecting or reopening: editing the applied theme's stylesheet, changing its Style Sheet reference, or renaming/moving the assets updates immediately, and deleting the applied
@@ -155,7 +155,7 @@ theme falls back to the package style while keeping the saved GUID semantics.
 
 ## Extensibility
 
-Data Visualizer exposes several extension points for custom workflows:
+DxVisualizer exposes several extension points for custom workflows:
 
 **Attributes** let you override display namespace or friendly names on ScriptableObject classes. `[CustomDataVisualization(Namespace = "...", TypeName = "...")]` replaces the
 namespace group and the display name the window shows. Without it the window files a type under the last segment of its C# namespace. Useful when code organization doesn't match
@@ -173,7 +173,7 @@ Derived classes override only what they need—GUID generation, cache resets, co
 without writing per-asset editor scripts.
 
 **UI Toolkit Extensions** render custom UI alongside the default inspector. Return a `VisualElement` tree—graphs, thumbnails, validation badges, or any UI Toolkit component—from
-`IGUIProvider.BuildGUI` (or `BaseDataObject.BuildGUI`) and Data Visualizer slots it in below the inspector. The `DataVisualizerGUIContext` argument carries the selected asset's
+`IGUIProvider.BuildGUI` (or `BaseDataObject.BuildGUI`) and DxVisualizer slots it in below the inspector. The `DataVisualizerGUIContext` argument carries the selected asset's
 `SerializedObject` for writing changes back. Because the entire window runs on UI Toolkit, this approach scales to complex dashboards without leaving the unified workflow.
 
 **Processors** are plain `IDataProcessor` classes that the window discovers with no registration. `Name` labels the button, `Description` is its tooltip, `Accepts` lists the types
diff --git a/docs/extending.md b/docs/extending.md
index 4351424..4c8abdc 100644
--- a/docs/extending.md
+++ b/docs/extending.md
@@ -169,7 +169,7 @@ Odin integration is optional. The package has no dependency on Odin and compiles
 ## Removing a type from the catalog
 
 Types deriving from `BaseDataObject` and types carrying `[CustomDataVisualization]` are managed for you and have no remove button. Other tracked types can be removed with the **X**
-on their row or their namespace header. Removing a type stops Data Visualizer from tracking it; the assets stay on disk.
+on their row or their namespace header. Removing a type stops DxVisualizer from tracking it; the assets stay on disk.
 
 ## Next steps
 
diff --git a/docs/getting-started.md b/docs/getting-started.md
index 976984a..436767a 100644
--- a/docs/getting-started.md
+++ b/docs/getting-started.md
@@ -19,7 +19,7 @@ Unity imports the package, and the menu item appears.
 
 ## Open the window
 
-Select **Tools → Wallstop Studios → Data Visualizer**, then dock it next to the Inspector. The window has three panels:
+Select **Tools → Wallstop Studios → DxVisualizer**, then dock it next to the Inspector. The window has three panels:
 
 - **Namespaces and types** (left) lists your ScriptableObject types by C# namespace. Expand a namespace, then select a type to load its instances.
 - **Objects** (center) lists every instance of the selected type. One row is selected at a time.
@@ -33,7 +33,7 @@ Three controls above the namespace panel fill the catalog:
 - **Scan Asset Folder** crawls a folder and registers the types and existing assets it finds. Use it to adopt a project that already has data.
 - **Scan Scripts Folder** registers types from source folders, which is the right choice before you create any assets.
 
-Removing a type or namespace only stops Data Visualizer from tracking it. Your assets stay on disk.
+Removing a type or namespace only stops DxVisualizer from tracking it. Your assets stay on disk.
 
 ![Manage-visible-types popover listing the project's ScriptableObject types](images/data-visualizer-import.png)
 
@@ -45,8 +45,8 @@ _Type search popover over the namespace panel. Regenerated from the live window
 2. Select an instance in the middle panel.
 3. Edit a field in the right panel. The change saves immediately, as in Unity's own Inspector.
 
-Use the buttons above the object list to manage the selection: **Clone** writes a copy with a `Clone` suffix beside the original, **Rename** renames the asset on disk, **Move**
-retargets it to another folder, and **Delete** removes it after you confirm.
+Each object row carries four action buttons: **Clone** writes a copy with a `Clone` suffix beside the original, **Rename** renames the asset on disk, **Move** retargets it to
+another folder, and **Delete** removes it after you confirm.
 
 ## Create an asset
 
@@ -73,11 +73,12 @@ Ordering, collapse state, tracked types, and your selection persist between sess
 
 Under **Settings**, choose where that state lives:
 
-- **Persist State in UserState** (default) stores it in your local user cache, so each developer keeps a private arrangement and version control stays free of layout churn.
+- Leaving **Persist State in Settings Asset** off (the default) stores it in your local user cache, so each developer keeps a private arrangement and version control stays free of
+  layout churn.
 - The project settings asset stores the state in the repository, which suits a team that wants one shared arrangement.
 
-**Select Active Object** mirrors your Data Visualizer selection in Unity's Inspector, and **Data Folder** sets where new assets are created. New assets land in a per-type folder
-under it; clones stay beside their original.
+**Select Active Object** mirrors your DxVisualizer selection in Unity's Inspector, and **Data Folder** sets where new assets are created. New assets land in a per-type folder under
+it; clones stay beside their original.
 
 ## While the editor is playing
 
diff --git a/docs/index.md b/docs/index.md
index 5d466ab..3892a3d 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -1,11 +1,11 @@
-# Data Visualizer
+# DxVisualizer
 
-Data Visualizer is a Unity editor window for ScriptableObject-heavy projects. It gathers your data in one place: a catalog of your ScriptableObject types organized by namespace, a
+DxVisualizer is a Unity editor window for ScriptableObject-heavy projects. It gathers your data in one place: a catalog of your ScriptableObject types organized by namespace, a
 list of every instance of the selected type, and the inspector for the asset you picked. You edit, reorder, and batch-process data without moving between the Project panel and the
 Inspector.
 
-Data Visualizer is free forever. There are no subscriptions, no paid upgrades, and no feature-gated tiers. The full source is MIT-licensed, and every capability described here
-ships in the free package.
+DxVisualizer is free forever. There are no subscriptions, no paid upgrades, and no feature-gated tiers. The full source is MIT-licensed, and every capability described here ships
+in the free package.
 
 ![Data Visualizer layout with namespace, object, and inspector columns](images/data-visualizer-layout.png)
 
@@ -31,11 +31,11 @@ _Full window overview. Regenerated from the live window by the docs capture pipe
 2. Select **+**, then **Add package from git URL**.
 3. Enter `https://github.com/wallstop/DataVisualizer.git` and select **Add**.
 
-Open the window with **Tools → Wallstop Studios → Data Visualizer**. [Getting started](getting-started.md) walks through the first session.
+Open the window with **Tools → Wallstop Studios → DxVisualizer**. [Getting started](getting-started.md) walks through the first session.
 
 !!! note
 
-    Data Visualizer is alpha software. It was built for wallstop studios'
+    DxVisualizer is alpha software. It was built for wallstop studios'
     internal use, there is no support commitment yet, and breaking changes can
     arrive in any release. Feel free to use it, and report what breaks.
 
diff --git a/docs/managing-assets.md b/docs/managing-assets.md
index d3363a8..73a2a05 100644
--- a/docs/managing-assets.md
+++ b/docs/managing-assets.md
@@ -51,7 +51,7 @@ The asset keeps its file name.
 ## Processors
 
 The **Processors** area sits below the namespace panel. It lists every `IDataProcessor` implementation in your project whose `Accepts` list covers the selected type, sorted by
-name. A processor with no `Accepts` list applies to every type. The collapsed header shows how many processors are listed; the area is hidden entirely when none apply.
+name. A processor with no `Accepts` list is never offered. The collapsed header shows how many processors are listed; the area is hidden entirely when none apply.
 
 Clicking a processor opens a confirmation that names the processor and the number of objects it will receive. Confirming runs `Process`, saves assets, refreshes the AssetDatabase,
 and schedules a window refresh. A processor that throws is caught: the exception is logged and an **Error running processor '…'** dialog reports the message. Other processors are
diff --git a/docs/organizing.md b/docs/organizing.md
index e6f5eb7..03c34ab 100644
--- a/docs/organizing.md
+++ b/docs/organizing.md
@@ -23,7 +23,7 @@ Each object row has **↑** and **↓**, which move that object to the top or bo
 
 Objects can also be dragged directly. The list reorders as you drag, and the new order is saved.
 
-The **X** on a namespace header or a type row removes it from Data Visualizer. This is not destructive: your assets stay on disk. Removal is offered only for types that are neither
+The **X** on a namespace header or a type row removes it from DxVisualizer. This is not destructive: your assets stay on disk. Removal is offered only for types that are neither
 `BaseDataObject` subclasses nor types carrying `[CustomDataVisualization]`, because the window manages those types for you.
 
 ## Collapsing namespaces
@@ -43,20 +43,21 @@ collapse state, the types you track, the per-type label filters, and the per-typ
 
 ### Persist in user state
 
-**Persist State in UserState** is the default. State is written as JSON to `DataVisualizerUserState.json` in Unity's per-user persistent data path. Each developer keeps a private
-arrangement and version control stays free of layout churn.
+Leaving **Persist State in Settings Asset** off (the default) writes state as JSON to `DataVisualizerUserState.json` in Unity's per-user persistent data path. Each developer keeps
+a private arrangement and version control stays free of layout churn.
 
 ### Persist in a project settings asset
 
-Turning the setting off stores the same state inside a `DataVisualizerSettings` asset in the project. Data Visualizer creates one at `Assets/Editor/DataVisualizerSettings.asset` on
-first use if no `DataVisualizerSettings` asset exists, and uses the first one it finds if you have several. This suits a team that wants one shared arrangement, at the cost of
-layout churn in version control.
+Turning **Persist State in Settings Asset** on stores the same state inside a `DataVisualizerSettings` asset in the project. DxVisualizer creates one at
+`Assets/Editor/DataVisualizerSettings.asset` on first use if no `DataVisualizerSettings` asset exists, and uses the first one it finds if you have several. This suits a team that
+wants one shared arrangement, at the cost of layout churn in version control.
 
 Switching between the two copies the current state across, so you do not lose your arrangement when you toggle.
 
 ### What is never shared
 
-The Data Folder, the `selectActiveObject` preference, and the pane widths stay with the `DataVisualizerSettings` asset regardless of where the window state lives.
+The Data Folder and the `selectActiveObject` preference stay with the `DataVisualizerSettings` asset regardless of where the window state lives; the pane widths always stay in
+editor preferences.
 
 ## Other settings
 
@@ -65,7 +66,7 @@ The **Settings** popover opens from the **…** button in the header row.
 ![Settings popover with persistence toggles and data folder field](images/data-visualizer-settings.png) _Settings popover. Regenerated from the live window by the docs capture
 pipeline._
 
-- **Select Active Object** mirrors your Data Visualizer selection in Unity's own Inspector, for cross-referencing assets in other editor windows.
+- **Select Active Object** mirrors your DxVisualizer selection in Unity's own Inspector, for cross-referencing assets in other editor windows.
 - **Theme** picks the appearance. See [Themes](#themes).
 - **Data Folder** is where new assets are created. Click the path to ping the folder, or **Select** to browse. The target must be inside `Assets`. Clones are unaffected: they stay
   beside their original.
@@ -83,11 +84,11 @@ appearance but keeps an explicit selection.
 
 ### Your own theme
 
-Create one with **Assets → Create → Wallstop Studios → DataVisualizer → Data Visualizer Theme**, assign a `.uss` asset to its **Style Sheet** field, then pick it in **Settings →
+Create one with **Assets → Create → Wallstop Studios → DxVisualizer → DxVisualizer Theme**, assign a `.uss` asset to its **Style Sheet** field, then pick it in **Settings →
 Theme**. Keep the theme and its stylesheet under an `Editor` folder; they are editor-only assets.
 
-The stylesheet you assign is applied after the package stylesheet, and standard control rules are scoped to `.dataviz-root` inside the Data Visualizer window. Ordinary USS
-precedence still applies, and inline styles win. Data color swatches and label colors stay data-driven, and IMGUI or third-party inspector styling is not replaced.
+The stylesheet you assign is applied after the package stylesheet, and standard control rules are scoped to `.dataviz-root` inside the DxVisualizer window. Ordinary USS precedence
+still applies, and inline styles win. Data color swatches and label colors stay data-driven, and IMGUI or third-party inspector styling is not replaced.
 
 Override the tokens you need rather than restyling controls:
 
diff --git a/docs/search-and-filter.md b/docs/search-and-filter.md
index fc6583a..229849a 100644
--- a/docs/search-and-filter.md
+++ b/docs/search-and-filter.md
@@ -1,6 +1,6 @@
 # Search and filtering
 
-Data Visualizer has three separate finders. Each one narrows a different thing, and they do not affect each other.
+DxVisualizer has three separate finders. Each one narrows a different thing, and they do not affect each other.
 
 | Finder        | Where it is                                 | What it narrows               |
 | ------------- | ------------------------------------------- | ----------------------------- |
diff --git a/docs/troubleshooting.md b/docs/troubleshooting.md
index a5a0c53..0dd7a11 100644
--- a/docs/troubleshooting.md
+++ b/docs/troubleshooting.md
@@ -54,7 +54,7 @@ preferred size is kept separately and restored when the space returns. See [Pane
 
 ## The arrangement did not load
 
-State lives in one of two places, chosen by **Persist State in UserState**:
+State lives in one of two places, chosen by the **Persist State in Settings Asset** toggle:
 
 - User state: `DataVisualizerUserState.json` in Unity's per-user persistent data path. Each developer has a private copy.
 - Project asset: a `DataVisualizerSettings` asset, created at `Assets/Editor/DataVisualizerSettings.asset` on first use if none exists.
@@ -101,5 +101,5 @@ recompile, and report up to date before the next edit, then re-run.
 - [Search and filtering](search-and-filter.md) — what each finder matches.
 - [Managing assets](managing-assets.md) — asset operations and processors.
 - [Organizing your data](organizing.md) — layout, themes, persistence.
-- [Issues](https://github.com/wallstop/DataVisualizer/issues) — known problems and where to report new ones. Data Visualizer is alpha software; a report with the console output and
+- [Issues](https://github.com/wallstop/DataVisualizer/issues) — known problems and where to report new ones. DxVisualizer is alpha software; a report with the console output and
   Unity version helps a lot.

From e3647b7d9bb43d070869e3d592cfc0e0e72f1ae5 Mon Sep 17 00:00:00 2001
From: Eli Pinkerton <wallstop@wallstopstudios.com>
Date: Sat, 10 Oct 2026 06:03:18 +0000
Subject: [PATCH 2/5] Skip harness self-tests when their surface is unchanged

The llm-lint workflow's slowest step is the self-test suite (71s of the
97s Windows job), and it ran on every triggered push or PR even when
only docs or C# changed, which cannot affect any self-test outcome. A
shared scope module now decides from the changed paths; the workflow
resolves the base sha, fetches it shallowly when checkout did not
include it, and runs the suite only when the harness surface (scripts,
.llm, .github, .devcontainer, .config, manifests) moved. The verdict
fails safe: an unresolvable base always runs the suite. Coverage is
unchanged - every surface change still runs the full suite on both
operating systems.
---
 .github/workflows/llm-lint.yml            |  18 +++
 scripts/harness-scope.psm1                |  91 +++++++++++++
 scripts/harness-scope.psm1.meta           |   7 +
 scripts/should-run-self-tests.ps1         |  32 +++++
 scripts/should-run-self-tests.ps1.meta    |   7 +
 scripts/tests/test-harness-scope.ps1      | 155 ++++++++++++++++++++++
 scripts/tests/test-harness-scope.ps1.meta |   7 +
 7 files changed, 317 insertions(+)
 create mode 100644 scripts/harness-scope.psm1
 create mode 100644 scripts/harness-scope.psm1.meta
 create mode 100644 scripts/should-run-self-tests.ps1
 create mode 100644 scripts/should-run-self-tests.ps1.meta
 create mode 100644 scripts/tests/test-harness-scope.ps1
 create mode 100644 scripts/tests/test-harness-scope.ps1.meta

diff --git a/.github/workflows/llm-lint.yml b/.github/workflows/llm-lint.yml
index 3b65786..27f9633 100644
--- a/.github/workflows/llm-lint.yml
+++ b/.github/workflows/llm-lint.yml
@@ -112,7 +112,25 @@ jobs:
       - name: Enforce assembly warning policy
         run: pwsh -NoProfile -File scripts/lint-assembly-warnings.ps1
 
+      - name: Resolve the harness self-test scope
+        id: self-test-scope
+        shell: bash
+        env:
+          BASE_SHA: ${{ github.event.pull_request.base.sha || github.event.before }}
+        run: |
+          set -euo pipefail
+          if [ -n "${BASE_SHA}" ] && [ "${BASE_SHA}" != "0000000000000000000000000000000000000000" ] && ! git cat-file -e "${BASE_SHA}^{commit}" 2>/dev/null; then
+            git fetch --depth=1 origin "${BASE_SHA}" || true
+          fi
+          verdict="$(pwsh -NoProfile -File scripts/should-run-self-tests.ps1 -BaseSha "${BASE_SHA:-}")"
+          echo "self-tests=${verdict}" >> "${GITHUB_OUTPUT}"
+
+      # The self-tests only verify the harness surface (scripts, .llm, CI and
+      # devcontainer wiring, package manifests). Skip them when that surface
+      # is untouched; every surface change still runs the full suite on both
+      # operating systems.
       - name: Run harness self-tests
+        if: steps.self-test-scope.outputs.self-tests != 'skip'
         run: pwsh -NoProfile -File scripts/tests/run-all.ps1
 
       - name: Enforce .llm file length limit
diff --git a/scripts/harness-scope.psm1 b/scripts/harness-scope.psm1
new file mode 100644
index 0000000..aeef86b
--- /dev/null
+++ b/scripts/harness-scope.psm1
@@ -0,0 +1,91 @@
+Set-StrictMode -Version 2.0
+
+# The harness self-tests (scripts/tests/test-*.ps1) verify this repository's
+# agent tooling: lint scripts, the release pipeline, MCP configuration, and
+# the devcontainer. This module is the single source of truth for which paths
+# can change a self-test outcome, so the CI skip logic and the local fast
+# check always agree. Edit only here.
+
+$script:SelfTestSurfacePrefixes = @(
+    'scripts/',
+    '.llm/',
+    '.github/',
+    '.devcontainer/',
+    '.config/'
+)
+
+$script:SelfTestSurfaceFiles = @(
+    'package.json',
+    'package-lock.json',
+    'opencode.json',
+    '.pre-commit-config.yaml'
+)
+
+function Test-SurfacePath {
+    param([string]$Path)
+
+    if ([string]::IsNullOrWhiteSpace($Path)) {
+        return $false
+    }
+
+    $normalized = ($Path -replace '\\', '/') -replace '^\./', ''
+    $normalized = $normalized.TrimStart('/')
+
+    foreach ($prefix in $script:SelfTestSurfacePrefixes) {
+        if ($normalized.StartsWith($prefix)) {
+            return $true
+        }
+    }
+
+    foreach ($file in $script:SelfTestSurfaceFiles) {
+        if ($normalized -eq $file) {
+            return $true
+        }
+    }
+
+    return $false
+}
+
+function Get-CommittedChangedFiles {
+    param(
+        [string]$RepoRoot,
+        [string]$BaseSha,
+        [string]$HeadSha = 'HEAD'
+    )
+
+    $output = & git -C $RepoRoot diff --name-only $BaseSha $HeadSha 2>$null
+    return @($output | Where-Object { $_ })
+}
+
+function Get-WorkingTreeChangedFiles {
+    param([string]$RepoRoot)
+
+    $tracked = & git -C $RepoRoot diff --name-only HEAD 2>$null
+    $untracked = & git -C $RepoRoot ls-files --others --exclude-standard 2>$null
+    return @((@($tracked) + @($untracked)) | Where-Object { $_ })
+}
+
+function Test-HarnessSurfaceChanged {
+    param(
+        [string]$RepoRoot,
+        [string]$BaseSha
+    )
+
+    $paths = @(Get-CommittedChangedFiles -RepoRoot $RepoRoot -BaseSha $BaseSha)
+    $paths += @(Get-WorkingTreeChangedFiles -RepoRoot $RepoRoot)
+
+    foreach ($path in $paths) {
+        if (Test-SurfacePath -Path $path) {
+            return $true
+        }
+    }
+
+    return $false
+}
+
+Export-ModuleMember -Function @(
+    'Test-SurfacePath',
+    'Get-CommittedChangedFiles',
+    'Get-WorkingTreeChangedFiles',
+    'Test-HarnessSurfaceChanged'
+)
diff --git a/scripts/harness-scope.psm1.meta b/scripts/harness-scope.psm1.meta
new file mode 100644
index 0000000..8741b64
--- /dev/null
+++ b/scripts/harness-scope.psm1.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 4fcfaba0a133443d9de1b8b56eb9d644
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/scripts/should-run-self-tests.ps1 b/scripts/should-run-self-tests.ps1
new file mode 100644
index 0000000..25533bd
--- /dev/null
+++ b/scripts/should-run-self-tests.ps1
@@ -0,0 +1,32 @@
+# Prints 'run' or 'skip' on stdout: whether the harness self-test suite must
+# execute for the changes between -BaseSha and HEAD. CI's llm-lint workflow
+# consults this before spending its slowest step (scripts/tests/run-all.ps1)
+# on a change that cannot affect any self-test outcome. The verdict fails
+# safe: whenever the base cannot be resolved, the suite runs.
+
+param(
+    [string]$RepoRoot = (Split-Path -Parent $PSScriptRoot),
+    [string]$BaseSha = ''
+)
+
+Set-StrictMode -Version 2.0
+
+if ([string]::IsNullOrWhiteSpace($BaseSha) -or $BaseSha -eq '0000000000000000000000000000000000000000') {
+    Write-Output 'run'
+    exit 0
+}
+
+$resolved = & git -C $RepoRoot rev-parse --verify --quiet "$BaseSha^{commit}"
+if ($LASTEXITCODE -ne 0 -or [string]::IsNullOrWhiteSpace($resolved)) {
+    Write-Output 'run'
+    exit 0
+}
+
+Import-Module (Join-Path $PSScriptRoot 'harness-scope.psm1')
+$changed = Test-HarnessSurfaceChanged -RepoRoot $RepoRoot -BaseSha $BaseSha
+if ($changed) {
+    Write-Output 'run'
+} else {
+    Write-Output 'skip'
+}
+exit 0
diff --git a/scripts/should-run-self-tests.ps1.meta b/scripts/should-run-self-tests.ps1.meta
new file mode 100644
index 0000000..98b3aac
--- /dev/null
+++ b/scripts/should-run-self-tests.ps1.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 1cd5d8c6d3e746c9bc623bc039910da6
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/scripts/tests/test-harness-scope.ps1 b/scripts/tests/test-harness-scope.ps1
new file mode 100644
index 0000000..7861097
--- /dev/null
+++ b/scripts/tests/test-harness-scope.ps1
@@ -0,0 +1,155 @@
+Set-StrictMode -Version 2.0
+
+$script:TestFailureCount = 0
+. (Join-Path $PSScriptRoot 'TestHelpers.ps1')
+
+$repoRoot = Split-Path -Parent (Split-Path -Parent $PSScriptRoot)
+$modulePath = Join-Path $repoRoot 'scripts/harness-scope.psm1'
+$wrapperPath = Join-Path $repoRoot 'scripts/should-run-self-tests.ps1'
+
+Import-Module $modulePath
+
+Write-Host '== Harness scope self-tests =='
+
+function New-ScopeRepo {
+    $repo = New-TempRoot -Prefix 'harness-scope-'
+    & git init -q $repo 2>&1 | Out-Null
+    & git -C $repo config user.email 'agent@example.com' 2>&1 | Out-Null
+    & git -C $repo config user.name 'Agent' 2>&1 | Out-Null
+    Write-FixtureFile -Root $repo -RelativePath 'README.md' -Content "base`n"
+    Write-FixtureFile -Root $repo -RelativePath 'scripts/keep.js' -Content "// base`n"
+    & git -C $repo add -A 2>&1 | Out-Null
+    & git -C $repo commit -q -m 'base' 2>&1 | Out-Null
+    return $repo
+}
+
+function Invoke-ScopeCommit {
+    param([string]$Repo, [hashtable]$Files)
+
+    foreach ($relativePath in $Files.Keys) {
+        Write-FixtureFile -Root $Repo -RelativePath $relativePath -Content $Files[$relativePath]
+    }
+    & git -C $Repo add -A 2>&1 | Out-Null
+    & git -C $Repo commit -q -m 'change' 2>&1 | Out-Null
+}
+
+function Invoke-ShouldRun {
+    param([string]$Repo, [string]$BaseSha)
+
+    $output = (& pwsh -NoProfile -File $wrapperPath -RepoRoot $Repo -BaseSha $BaseSha 2>&1 | Out-String).Trim()
+    Assert-True ($LASTEXITCODE -eq 0) "the wrapper must exit 0 (got $LASTEXITCODE): $output"
+    return $output
+}
+
+# The verdict must fail safe: an unusable base always runs the suite, while a
+# resolvable base skips only when every changed path sits outside the surface
+# the self-tests verify.
+Invoke-TestCase 'Skips_ADocsOnlyCommit' {
+    $repo = New-ScopeRepo
+    try {
+        $base = (& git -C $repo rev-parse HEAD)
+        Invoke-ScopeCommit -Repo $repo -Files @{ 'README.md' = "changed`n" }
+        Assert-True ((Invoke-ShouldRun -Repo $repo -BaseSha $base) -eq 'skip') 'a docs-only commit must skip the suite'
+    } finally {
+        Remove-TempRoot -Path $repo
+    }
+}
+
+Invoke-TestCase 'Skips_ACSharpOnlyCommit' {
+    $repo = New-ScopeRepo
+    try {
+        $base = (& git -C $repo rev-parse HEAD)
+        Invoke-ScopeCommit -Repo $repo -Files @{ 'Editor/Foo.cs' = "class Foo { }`n" }
+        Assert-True ((Invoke-ShouldRun -Repo $repo -BaseSha $base) -eq 'skip') 'a C#-only commit must skip the suite'
+    } finally {
+        Remove-TempRoot -Path $repo
+    }
+}
+
+Invoke-TestCase 'Runs_ForAScriptsCommit' {
+    $repo = New-ScopeRepo
+    try {
+        $base = (& git -C $repo rev-parse HEAD)
+        Invoke-ScopeCommit -Repo $repo -Files @{ 'scripts/keep.js' = "// changed`n" }
+        Assert-True ((Invoke-ShouldRun -Repo $repo -BaseSha $base) -eq 'run') 'a scripts commit must run the suite'
+    } finally {
+        Remove-TempRoot -Path $repo
+    }
+}
+
+Invoke-TestCase 'Runs_ForHarnessDirectoryCommits' {
+    $repo = New-ScopeRepo
+    try {
+        $base = (& git -C $repo rev-parse HEAD)
+        foreach ($path in @('.llm/context.md', '.github/workflows/pipeline.yml', '.devcontainer/install-npm-tools.sh', '.config/dotnet-tools.json')) {
+            Write-FixtureFile -Root $repo -RelativePath $path -Content "changed`n"
+            & git -C $repo add -A 2>&1 | Out-Null
+            & git -C $repo commit -q -m 'surface change' 2>&1 | Out-Null
+            Assert-True ((Invoke-ShouldRun -Repo $repo -BaseSha $base) -eq 'run') "a change under $path must run the suite"
+        }
+    } finally {
+        Remove-TempRoot -Path $repo
+    }
+}
+
+Invoke-TestCase 'Runs_ForARootManifestCommit' {
+    $repo = New-ScopeRepo
+    try {
+        $base = (& git -C $repo rev-parse HEAD)
+        Invoke-ScopeCommit -Repo $repo -Files @{ 'package.json' = "{}`n" }
+        Assert-True ((Invoke-ShouldRun -Repo $repo -BaseSha $base) -eq 'run') 'a package.json commit must run the suite'
+    } finally {
+        Remove-TempRoot -Path $repo
+    }
+}
+
+Invoke-TestCase 'Runs_ForAnUntrackedSurfaceFile' {
+    $repo = New-ScopeRepo
+    try {
+        $base = (& git -C $repo rev-parse HEAD)
+        Invoke-ScopeCommit -Repo $repo -Files @{ 'README.md' = "changed`n" }
+        Write-FixtureFile -Root $repo -RelativePath 'scripts/new.js' -Content "// new`n"
+        Assert-True ((Invoke-ShouldRun -Repo $repo -BaseSha $base) -eq 'run') 'an untracked scripts file must run the suite'
+    } finally {
+        Remove-TempRoot -Path $repo
+    }
+}
+
+Invoke-TestCase 'Runs_ForAWorkingTreeSurfaceEdit' {
+    $repo = New-ScopeRepo
+    try {
+        $base = (& git -C $repo rev-parse HEAD)
+        Invoke-ScopeCommit -Repo $repo -Files @{ 'README.md' = "changed`n" }
+        Write-FixtureFile -Root $repo -RelativePath 'scripts/keep.js' -Content "// dirty`n"
+        Assert-True ((Invoke-ShouldRun -Repo $repo -BaseSha $base) -eq 'run') 'an uncommitted scripts edit must run the suite'
+    } finally {
+        Remove-TempRoot -Path $repo
+    }
+}
+
+Invoke-TestCase 'Runs_WhenTheBaseCannotBeResolved' {
+    $repo = New-ScopeRepo
+    try {
+        foreach ($base in @('deadbeefdeadbeefdeadbeefdeadbeefdeadbeef', '0000000000000000000000000000000000000000', '')) {
+            Assert-True ((Invoke-ShouldRun -Repo $repo -BaseSha $base) -eq 'run') "an unusable base '$base' must run the suite"
+        }
+    } finally {
+        Remove-TempRoot -Path $repo
+    }
+}
+
+Invoke-TestCase 'SurfacePath_MatchesTheDeclaredSurfaceOnly' {
+    foreach ($path in @('scripts/lint.js', 'scripts\nested\lint.js', './.llm/context.md', '.github/workflows/ci.yml', 'package.json', 'package-lock.json', 'opencode.json', '.pre-commit-config.yaml')) {
+        Assert-True (Test-SurfacePath -Path $path) "$path must match the surface"
+    }
+    foreach ($path in @('README.md', 'docs/index.md', 'Editor/Foo.cs', 'Tests/Editor/Foo.cs', 'sub/package.json', 'docs/images/logo.png', '')) {
+        Assert-True (-not (Test-SurfacePath -Path $path)) "'$path' must not match the surface"
+    }
+}
+
+if ($script:TestFailureCount -gt 0) {
+    Write-Host "harness-scope self-tests: $($script:TestFailureCount) failed"
+    exit 1
+}
+Write-Host 'harness-scope self-tests: all passed'
+exit 0
diff --git a/scripts/tests/test-harness-scope.ps1.meta b/scripts/tests/test-harness-scope.ps1.meta
new file mode 100644
index 0000000..9007586
--- /dev/null
+++ b/scripts/tests/test-harness-scope.ps1.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: e5be68ee8dd64214b080876591fbc32a
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

From 06f2bb06d7a1f457a0967dd22c0d36087917b1e4 Mon Sep 17 00:00:00 2001
From: Eli Pinkerton <wallstop@wallstopstudios.com>
Date: Sat, 10 Oct 2026 06:07:10 +0000
Subject: [PATCH 3/5] Add a changed-files fast check for local iteration

The validation ladder reruns whole-tree formatting, every harness lint,
the full self-test suite, and npm pack for any edit, so a one-line fix
costs around a minute per iteration. npm run check:fast now classifies
the paths changed since origin/main and runs only the groups that can
fail: CSharpier plus the C# source lints for .cs, prettier plus the
changelog cap for .md, the harness lints and self-tests for the harness
surface, npm pack for the package payload, and the assembly, release,
and line-ending guards for their own files. It reuses the scope module
the CI skip logic uses, so both verdicts stay identical. The full
ladder still gates review.
---
 .llm/context.md                        |   3 +
 .llm/skills/ship-changes/SKILL.md      |   1 +
 package.json                           |   1 +
 scripts/fast-check.ps1                 | 175 +++++++++++++++++++++++++
 scripts/fast-check.ps1.meta            |   7 +
 scripts/tests/test-fast-check.ps1      |  93 +++++++++++++
 scripts/tests/test-fast-check.ps1.meta |   7 +
 7 files changed, 287 insertions(+)
 create mode 100644 scripts/fast-check.ps1
 create mode 100644 scripts/fast-check.ps1.meta
 create mode 100644 scripts/tests/test-fast-check.ps1
 create mode 100644 scripts/tests/test-fast-check.ps1.meta

diff --git a/.llm/context.md b/.llm/context.md
index ab9a2c2..7ed4f1e 100644
--- a/.llm/context.md
+++ b/.llm/context.md
@@ -137,6 +137,9 @@ See the generated [Skills Index](./skills/index.md). Regenerate it after adding
 
 ### Validation Ladder (Run After Each Change)
 
+Per-iteration speed: run `npm run check:fast` first (formats and lints only the files changed since `origin/main`, and skips harness self-tests when their surface is unchanged).
+The full ladder below gates review.
+
 ```bash
 dotnet tool restore
 dotnet tool run csharpier -- format Editor Runtime Tests
diff --git a/.llm/skills/ship-changes/SKILL.md b/.llm/skills/ship-changes/SKILL.md
index bf19d54..21c8f35 100644
--- a/.llm/skills/ship-changes/SKILL.md
+++ b/.llm/skills/ship-changes/SKILL.md
@@ -13,6 +13,7 @@ Run the narrowest sufficient layer; escalate on failure:
 
 | Layer | Scope | Command |
 | --- | --- | --- |
+| Fast check | changed files | `npm run check:fast` |
 | Pre-commit hook | staged files | automatic (`pre-commit` + `.pre-commit-config.yaml`) |
 | C# member layout | all C# types | `npm run lint:csharp-member-order` |
 | Markdown formatting | tracked Markdown | `npm run format:md:check` |
diff --git a/package.json b/package.json
index 1c31235..0c1e8d2 100644
--- a/package.json
+++ b/package.json
@@ -42,6 +42,7 @@
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "lint:llm": "pwsh -NoProfile -File scripts/lint-llm-instructions.ps1",
+    "check:fast": "pwsh -NoProfile -File scripts/fast-check.ps1",
     "lint:llm:fix": "pwsh -NoProfile -File scripts/lint-llm-instructions.ps1 -Fix",
     "lint:assembly-warnings": "pwsh -NoProfile -File scripts/lint-assembly-warnings.ps1",
     "lint:csharp-member-order": "node scripts/lint-csharp-member-order.js",
diff --git a/scripts/fast-check.ps1 b/scripts/fast-check.ps1
new file mode 100644
index 0000000..f123f7b
--- /dev/null
+++ b/scripts/fast-check.ps1
@@ -0,0 +1,175 @@
+# Runs only the validation relevant to the files changed since -Base, so an
+# agent iterating on a two-file change checks in seconds instead of running
+# the whole ladder. The full ladder in .llm/context.md still gates review.
+# PlanOnly prints the classification without executing any tool, which is
+# what the self-tests exercise on machines without the .NET toolchain.
+
+param(
+    [string]$RepoRoot = (Split-Path -Parent $PSScriptRoot),
+    [string]$Base = '',
+    [switch]$PlanOnly
+)
+
+Set-StrictMode -Version 2.0
+
+Import-Module (Join-Path $PSScriptRoot 'harness-scope.psm1')
+
+function Resolve-BaseSha {
+    param([string]$RepoRoot, [string]$Base)
+
+    if (-not [string]::IsNullOrWhiteSpace($Base)) {
+        $resolved = & git -C $RepoRoot rev-parse --verify --quiet "$Base^{commit}"
+        if ($LASTEXITCODE -eq 0 -and $resolved) {
+            return $resolved
+        }
+    }
+
+    $main = & git -C $RepoRoot rev-parse --verify --quiet 'origin/main'
+    if ($LASTEXITCODE -eq 0 -and $main) {
+        $mergeBase = & git -C $RepoRoot merge-base HEAD $main 2>$null
+        if ($LASTEXITCODE -eq 0 -and $mergeBase) {
+            return $mergeBase
+        }
+    }
+
+    return (& git -C $RepoRoot rev-parse HEAD)
+}
+
+function Get-FastCheckPlan {
+    param([string]$RepoRoot, [string]$BaseSha)
+
+    $changed = @(Get-CommittedChangedFiles -RepoRoot $RepoRoot -BaseSha $BaseSha)
+    $changed += @(Get-WorkingTreeChangedFiles -RepoRoot $RepoRoot)
+    $changed = @($changed | Sort-Object -Unique)
+
+    return [pscustomobject]@{
+        BaseSha = $BaseSha
+        CSharp = @($changed | Where-Object { $_ -match '\.cs$' })
+        Markdown = @($changed | Where-Object { $_ -match '\.md$' })
+        Harness = @($changed | Where-Object { Test-SurfacePath -Path $_ }).Count -gt 0
+        Packaging = @($changed | Where-Object { $_ -match '^(Editor|Runtime)/' -or $_ -eq 'package.json' }).Count -gt 0
+        AssemblyConfig = @($changed | Where-Object { $_ -match '\.(asmdef|ruleset|rsp)$' -or $_ -match '\.dll\.meta$' }).Count -gt 0
+        ReleaseSurface = @($changed | Where-Object { $_ -eq '.github/workflows/release.yml' -or $_ -eq '.llm/references/RELEASING.md' }).Count -gt 0
+        LineEndings = @($changed | Where-Object { $_ -eq '.editorconfig' -or $_ -eq '.gitattributes' }).Count -gt 0
+    }
+}
+
+function Assert-NativeExit {
+    param([string]$Description)
+
+    if ($LASTEXITCODE -ne 0) {
+        throw "$Description exited with $LASTEXITCODE"
+    }
+}
+
+$script:Failures = @()
+
+function Invoke-FastCheckStep {
+    param([string]$Name, [scriptblock]$Action)
+
+    $stopwatch = [System.Diagnostics.Stopwatch]::StartNew()
+    try {
+        & $Action
+        Write-Host ("[fast-check] {0} ok ({1:n1}s)" -f $Name, $stopwatch.Elapsed.TotalSeconds)
+    } catch {
+        Write-Host ("[fast-check] {0} FAILED ({1:n1}s): {2}" -f $Name, $stopwatch.Elapsed.TotalSeconds, $_.Exception.Message)
+        $script:Failures += $Name
+    }
+}
+
+$baseSha = Resolve-BaseSha -RepoRoot $RepoRoot -Base $Base
+$plan = Get-FastCheckPlan -RepoRoot $RepoRoot -BaseSha $baseSha
+
+if ($PlanOnly) {
+    Write-Host "[fast-check] plan for base $($plan.BaseSha)"
+    Write-Host "[fast-check] csharp: $($plan.CSharp -join ', ')"
+    Write-Host "[fast-check] markdown: $($plan.Markdown -join ', ')"
+    foreach ($group in @('Harness', 'Packaging', 'AssemblyConfig', 'ReleaseSurface', 'LineEndings')) {
+        Write-Host "[fast-check] $group : $($plan.$group)"
+    }
+    exit 0
+}
+
+Write-Host "[fast-check] validating changes since $($plan.BaseSha)"
+Push-Location $RepoRoot
+try {
+    if ($plan.CSharp.Count -gt 0) {
+        Invoke-FastCheckStep -Name 'csharp format + lints' -Action {
+            & dotnet tool run csharpier -- format @($plan.CSharp)
+            Assert-NativeExit -Description 'csharpier format'
+            & node scripts/lint-csharp-member-order.js
+            Assert-NativeExit -Description 'member-order lint'
+            & node scripts/lint-csharp-null-assertions.js
+            Assert-NativeExit -Description 'null-assertions lint'
+            & node scripts/lint-csharp-usings.js
+            Assert-NativeExit -Description 'usings lint'
+        }
+    }
+
+    if ($plan.Markdown.Count -gt 0) {
+        Invoke-FastCheckStep -Name 'markdown format' -Action {
+            & npx --no-install prettier --write @($plan.Markdown)
+            Assert-NativeExit -Description 'prettier write'
+        }
+        if ($plan.Markdown -contains 'CHANGELOG.md') {
+            Invoke-FastCheckStep -Name 'changelog length' -Action {
+                & node scripts/lint-changelog-length.js
+                Assert-NativeExit -Description 'changelog length lint'
+            }
+        }
+    }
+
+    if ($plan.Harness) {
+        Invoke-FastCheckStep -Name 'harness lints + self-tests' -Action {
+            & pwsh -NoProfile -File scripts/generate-skills-index.ps1
+            Assert-NativeExit -Description 'generate-skills-index'
+            $drift = & git status --porcelain -- .llm/skills/index.md
+            if ($drift) {
+                throw '.llm/skills/index.md is stale; run scripts/generate-skills-index.ps1 and commit the result.'
+            }
+            & pwsh -NoProfile -File scripts/lint-llm-instructions.ps1
+            Assert-NativeExit -Description 'llm-instructions lint'
+            & pwsh -NoProfile -File scripts/lint-file-lengths.ps1
+            Assert-NativeExit -Description 'file-lengths lint'
+            & pwsh -NoProfile -File scripts/tests/run-all.ps1
+            Assert-NativeExit -Description 'harness self-tests'
+        }
+    }
+
+    if ($plan.Packaging) {
+        Invoke-FastCheckStep -Name 'npm pack' -Action {
+            & npm pack --dry-run --no-audit --no-fund
+            Assert-NativeExit -Description 'npm pack'
+        }
+    }
+
+    if ($plan.AssemblyConfig) {
+        Invoke-FastCheckStep -Name 'assembly warnings' -Action {
+            & pwsh -NoProfile -File scripts/lint-assembly-warnings.ps1
+            Assert-NativeExit -Description 'assembly warnings lint'
+        }
+    }
+
+    if ($plan.ReleaseSurface) {
+        Invoke-FastCheckStep -Name 'release secrets' -Action {
+            & node scripts/lint-release-secrets.js
+            Assert-NativeExit -Description 'release secrets lint'
+        }
+    }
+
+    if ($plan.LineEndings) {
+        Invoke-FastCheckStep -Name 'line endings' -Action {
+            & node scripts/lint-line-endings.js
+            Assert-NativeExit -Description 'line endings lint'
+        }
+    }
+} finally {
+    Pop-Location
+}
+
+if ($script:Failures.Count -gt 0) {
+    Write-Host "[fast-check] failed: $($script:Failures -join ', ')"
+    exit 1
+}
+Write-Host '[fast-check] passed'
+exit 0
diff --git a/scripts/fast-check.ps1.meta b/scripts/fast-check.ps1.meta
new file mode 100644
index 0000000..b935795
--- /dev/null
+++ b/scripts/fast-check.ps1.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 641239916d1c44a39b333cf2c73a1148
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/scripts/tests/test-fast-check.ps1 b/scripts/tests/test-fast-check.ps1
new file mode 100644
index 0000000..348badc
--- /dev/null
+++ b/scripts/tests/test-fast-check.ps1
@@ -0,0 +1,93 @@
+Set-StrictMode -Version 2.0
+
+$script:TestFailureCount = 0
+. (Join-Path $PSScriptRoot 'TestHelpers.ps1')
+
+$repoRoot = Split-Path -Parent (Split-Path -Parent $PSScriptRoot)
+$fastCheckPath = Join-Path $repoRoot 'scripts/fast-check.ps1'
+
+Write-Host '== Fast-check plan self-tests =='
+
+function New-PlanRepo {
+    $repo = New-TempRoot -Prefix 'fast-check-'
+    & git init -q $repo 2>&1 | Out-Null
+    & git -C $repo config user.email 'agent@example.com' 2>&1 | Out-Null
+    & git -C $repo config user.name 'Agent' 2>&1 | Out-Null
+    Write-FixtureFile -Root $repo -RelativePath 'README.md' -Content "base`n"
+    Write-FixtureFile -Root $repo -RelativePath 'scripts/keep.js' -Content "// base`n"
+    & git -C $repo add -A 2>&1 | Out-Null
+    & git -C $repo commit -q -m 'base' 2>&1 | Out-Null
+    return $repo
+}
+
+function Invoke-PlanOnly {
+    param([string]$Repo)
+
+    $output = (& pwsh -NoProfile -File $fastCheckPath -RepoRoot $Repo -PlanOnly 2>&1 | Out-String)
+    Assert-True ($LASTEXITCODE -eq 0) "the plan must exit 0 (got $LASTEXITCODE): $output"
+    return $output
+}
+
+# The plan drives every group the fast check can run, so each case pins one
+# classification against a fixture tree.
+Invoke-TestCase 'Plan_SplitsGroupsByChangedPath' {
+    $repo = New-PlanRepo
+    try {
+        Write-FixtureFile -Root $repo -RelativePath 'Editor/Foo.cs' -Content "class Foo { }`n"
+        Write-FixtureFile -Root $repo -RelativePath 'docs/guide.md' -Content "guide`n"
+        Write-FixtureFile -Root $repo -RelativePath 'scripts/new.js' -Content "// new`n"
+        Write-FixtureFile -Root $repo -RelativePath 'package.json' -Content "{}`n"
+        $output = Invoke-PlanOnly -Repo $repo
+        Assert-True ($output -match 'csharp: Editor/Foo\.cs') "the plan must list the C# file: $output"
+        Assert-True ($output -match 'markdown: docs/guide\.md') "the plan must list the Markdown file: $output"
+        Assert-True ($output -match 'Harness : True') 'a scripts change must plan the harness group'
+        Assert-True ($output -match 'Packaging : True') 'an Editor change must plan the packaging group'
+        Assert-True ($output -match 'AssemblyConfig : False') 'an unrelated tree must not plan the assembly group'
+    } finally {
+        Remove-TempRoot -Path $repo
+    }
+}
+
+Invoke-TestCase 'Plan_IgnoresDocsOnlyTrees' {
+    $repo = New-PlanRepo
+    try {
+        Write-FixtureFile -Root $repo -RelativePath 'docs/guide.md' -Content "guide`n"
+        Write-FixtureFile -Root $repo -RelativePath 'README.md' -Content "changed`n"
+        $output = Invoke-PlanOnly -Repo $repo
+        Assert-True ($output -match 'Harness : False') 'a docs-only tree must skip the harness group'
+        Assert-True ($output -match 'Packaging : False') 'a docs-only tree must skip the packaging group'
+        Assert-True ($output -match 'csharp: \r?\n') 'a docs-only tree must list no C# files'
+    } finally {
+        Remove-TempRoot -Path $repo
+    }
+}
+
+Invoke-TestCase 'Plan_CoversUntrackedAndWorkingTreeFiles' {
+    $repo = New-PlanRepo
+    try {
+        Write-FixtureFile -Root $repo -RelativePath 'Runtime/Thing.cs' -Content "class Thing { }`n"
+        $output = Invoke-PlanOnly -Repo $repo
+        Assert-True ($output -match 'csharp: Runtime/Thing\.cs') 'an untracked C# file must be planned'
+        Assert-True ($output -match 'Packaging : True') 'an untracked Runtime file must plan packaging'
+    } finally {
+        Remove-TempRoot -Path $repo
+    }
+}
+
+Invoke-TestCase 'Plan_FallsBackToHeadWhenNoBaseExists' {
+    $repo = New-PlanRepo
+    try {
+        Write-FixtureFile -Root $repo -RelativePath 'CHANGELOG.md' -Content "## [Unreleased]`n`n### Added`n`n- Something. (#1)`n"
+        $output = Invoke-PlanOnly -Repo $repo
+        Assert-True ($output -match 'markdown: CHANGELOG\.md') 'a fixture without origin/main must still plan the working tree'
+    } finally {
+        Remove-TempRoot -Path $repo
+    }
+}
+
+if ($script:TestFailureCount -gt 0) {
+    Write-Host "fast-check self-tests: $($script:TestFailureCount) failed"
+    exit 1
+}
+Write-Host 'fast-check self-tests: all passed'
+exit 0
diff --git a/scripts/tests/test-fast-check.ps1.meta b/scripts/tests/test-fast-check.ps1.meta
new file mode 100644
index 0000000..a4cfa69
--- /dev/null
+++ b/scripts/tests/test-fast-check.ps1.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 270316da4d424c6694de8b7d4fa0be60
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

From ae166834e61806814762d288d91496b956aa3556 Mon Sep 17 00:00:00 2001
From: Eli Pinkerton <wallstop@wallstopstudios.com>
Date: Sat, 10 Oct 2026 06:08:17 +0000
Subject: [PATCH 4/5] Note that code identifiers keep the DataVisualizer name

The rebrand renamed the product and menu paths, and the extending page
was missing the handoff note that namespaces, types, and assemblies are
unchanged, so readers could not tell whether their code needed edits.

Refs #149.
---
 docs/extending.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/extending.md b/docs/extending.md
index 4c8abdc..992f861 100644
--- a/docs/extending.md
+++ b/docs/extending.md
@@ -1,7 +1,7 @@
 # Extending the window
 
 The runtime assembly is part of the package and carries the extension surface, so your types compile against it in both the editor and a player build. Everything on this page is
-public API.
+public API. Code identifiers keep the `DataVisualizer` name — namespaces, types, and assemblies are unchanged by the rebrand, so your code needs no edits.
 
 ## Display attributes
 

From e6fbad767676b7314a40409b4b099702cb50cfc0 Mon Sep 17 00:00:00 2001
From: Eli Pinkerton <wallstop@wallstopstudios.com>
Date: Sat, 10 Oct 2026 14:53:17 +0000
Subject: [PATCH 5/5] Stop the fast check from formatting deleted paths

Bugbot on PR 164 found that the plan fed every changed .cs and .md
path to csharpier and prettier, including deletions and the old path
of a rename, so the first delete or rename on a branch broke
check:fast for every later iteration. Group triggers still see the
full changed list - deleting a harness file must keep running the
self-tests, and deleting the changelog must fail closed per its
contract - but the formatter lists now keep only paths that exist on
disk. Three fixture cases pin the shape: working-tree deletions,
committed deletions, and the rename old-path. The pattern joins the
forbidden list with the other guards-that-lie rows.
---
 .llm/references/forbidden-patterns.md |  1 +
 scripts/fast-check.ps1                |  9 +++-
 scripts/tests/test-fast-check.ps1     | 63 ++++++++++++++++++++++++++-
 3 files changed, 69 insertions(+), 4 deletions(-)

diff --git a/.llm/references/forbidden-patterns.md b/.llm/references/forbidden-patterns.md
index ba36e22..685ee4d 100644
--- a/.llm/references/forbidden-patterns.md
+++ b/.llm/references/forbidden-patterns.md
@@ -36,5 +36,6 @@ Patterns that must not appear in this codebase, with the compliant alternative.
 | Static mutable state with no documented reason or teardown reset                                                                                                               | document why it is static, weak-key by lifecycle owner, unregister on every removal path, and reset it in the owning window's `Cleanup()` (`AssetGuidTypeIndex.Shared` suspension reset and the theme-selection ownership registry are the precedents)        | static editor state outlives windows and strands cross-window state (PR #122 review finding)                                                                                                                                                                                                      |
 | `using` directives above the `namespace` declaration                                                                                                                           | place them inside the namespace block; file-level usings are sanctioned only for namespaceless assembly-attribute files and `[assembly: ...]` preambles like `InternalsVisibleTo` (`npm run lint:csharp-usings` enforces this, `:fix` moves the simple cases) | one namespace-scoped convention keeps the file header stable and the rule mechanically checkable (#124)                                                                                                                                                                                           |
 | A guard that reads a machine-readable config resolves only part of a construct, such as the first `{a,b}` alternative, a nested group, or one level of a nested mapping        | resolve every alternative and nesting level, or refuse the pattern with the file and line that uses it                                                                                                                                                        | a partially-read rule still matches its own representative path, so the guard passes while the real configuration disagrees; refusing beats guessing (PR #131 review finding in `scripts/lint-line-endings.js`)                                                                                   |
+| Passing a changed-path list (diff, status, hook payload) straight into a file-argument tool — formatter, linter, packager                                                      | keep group triggers on the full changed list, but filter every file-argument invocation to paths that still exist on disk (`Test-Path` against the repo root)                                                                                                 | deletions and rename old-paths appear in `git diff --name-only` but not on disk, so one ordinary delete or rename makes the tool fail and the whole check useless afterwards (PR #164 Bugbot finding in `scripts/fast-check.ps1`)                                                                 |
 | A guard that names the argument forms it rejects and passes everything it does not name                                                                                        | require the exact arguments the policy permits, and report the file with every argument found                                                                                                                                                                 | a switch the reader does not recognize turns off the policy the guard claims to enforce, so `-nowarn:1701` or `-warnaserror-` in a `csc.rsp` passed the guard that owns warnings-as-errors (`scripts/lint-assembly-warnings.ps1`, #132)                                                           |
 | Pixel or region validation that records UI Toolkit subtrees without checking whether they render                                                                               | filter candidates through a rendered check before measuring — `display:none` ancestor chain, resolved per-element visibility, and positive area (`DocsImageCapture.IsRenderedForCapture` precedent)                                                           | a `display:none` subtree reports laid-out children but paints nothing, so its clamped one-pixel sample always fails and rejects a faithful capture; persisted namespace collapse makes hidden rows a normal host state (PR #140 review finding)                                                   |
diff --git a/scripts/fast-check.ps1 b/scripts/fast-check.ps1
index f123f7b..9b2fbae 100644
--- a/scripts/fast-check.ps1
+++ b/scripts/fast-check.ps1
@@ -41,11 +41,16 @@ function Get-FastCheckPlan {
     $changed = @(Get-CommittedChangedFiles -RepoRoot $RepoRoot -BaseSha $BaseSha)
     $changed += @(Get-WorkingTreeChangedFiles -RepoRoot $RepoRoot)
     $changed = @($changed | Sort-Object -Unique)
+    # Deletions and rename old-paths appear in a git diff but not on disk.
+    # Group triggers below still see every changed path - deleting a harness
+    # file must keep running the self-tests - but the formatter lists feed
+    # file-argument tools (csharpier, prettier), which fail on missing paths.
+    $existing = @($changed | Where-Object { Test-Path -LiteralPath (Join-Path $RepoRoot $_) })
 
     return [pscustomobject]@{
         BaseSha = $BaseSha
-        CSharp = @($changed | Where-Object { $_ -match '\.cs$' })
-        Markdown = @($changed | Where-Object { $_ -match '\.md$' })
+        CSharp = @($existing | Where-Object { $_ -match '\.cs$' })
+        Markdown = @($existing | Where-Object { $_ -match '\.md$' })
         Harness = @($changed | Where-Object { Test-SurfacePath -Path $_ }).Count -gt 0
         Packaging = @($changed | Where-Object { $_ -match '^(Editor|Runtime)/' -or $_ -eq 'package.json' }).Count -gt 0
         AssemblyConfig = @($changed | Where-Object { $_ -match '\.(asmdef|ruleset|rsp)$' -or $_ -match '\.dll\.meta$' }).Count -gt 0
diff --git a/scripts/tests/test-fast-check.ps1 b/scripts/tests/test-fast-check.ps1
index 348badc..df66ba3 100644
--- a/scripts/tests/test-fast-check.ps1
+++ b/scripts/tests/test-fast-check.ps1
@@ -21,9 +21,13 @@ function New-PlanRepo {
 }
 
 function Invoke-PlanOnly {
-    param([string]$Repo)
+    param([string]$Repo, [string]$Base = '')
 
-    $output = (& pwsh -NoProfile -File $fastCheckPath -RepoRoot $Repo -PlanOnly 2>&1 | Out-String)
+    if ($Base) {
+        $output = (& pwsh -NoProfile -File $fastCheckPath -RepoRoot $Repo -Base $Base -PlanOnly 2>&1 | Out-String)
+    } else {
+        $output = (& pwsh -NoProfile -File $fastCheckPath -RepoRoot $Repo -PlanOnly 2>&1 | Out-String)
+    }
     Assert-True ($LASTEXITCODE -eq 0) "the plan must exit 0 (got $LASTEXITCODE): $output"
     return $output
 }
@@ -85,6 +89,61 @@ Invoke-TestCase 'Plan_FallsBackToHeadWhenNoBaseExists' {
     }
 }
 
+# Deletions and rename old-paths show up in a git diff but no longer exist on
+# disk; the plan must hand formatters only files that are actually there.
+Invoke-TestCase 'Plan_ExcludesWorkingTreeDeletionsFromFormatGroups' {
+    $repo = New-PlanRepo
+    try {
+        Write-FixtureFile -Root $repo -RelativePath 'Editor/Foo.cs' -Content "class Foo { }`n"
+        Write-FixtureFile -Root $repo -RelativePath 'docs/guide.md' -Content "guide`n"
+        & git -C $repo add -A 2>&1 | Out-Null
+        & git -C $repo commit -q -m 'add fixtures' 2>&1 | Out-Null
+        Remove-Item -LiteralPath (Join-Path $repo 'Editor/Foo.cs')
+        Remove-Item -LiteralPath (Join-Path $repo 'docs/guide.md')
+        $output = Invoke-PlanOnly -Repo $repo
+        Assert-True ($output -match 'csharp: \r?\n') 'a deleted C# file must not be a format target'
+        Assert-True ($output -match 'markdown: \r?\n') 'a deleted Markdown file must not be a format target'
+        Assert-True ($output -match 'Packaging : True') 'a deleted Editor file must still plan packaging'
+    } finally {
+        Remove-TempRoot -Path $repo
+    }
+}
+
+Invoke-TestCase 'Plan_ExcludesCommittedDeletionsFromFormatGroups' {
+    $repo = New-PlanRepo
+    try {
+        Write-FixtureFile -Root $repo -RelativePath 'Editor/Foo.cs' -Content "class Foo { }`n"
+        Write-FixtureFile -Root $repo -RelativePath 'docs/guide.md' -Content "guide`n"
+        & git -C $repo add -A 2>&1 | Out-Null
+        & git -C $repo commit -q -m 'add fixtures' 2>&1 | Out-Null
+        Remove-Item -LiteralPath (Join-Path $repo 'Editor/Foo.cs')
+        Remove-Item -LiteralPath (Join-Path $repo 'docs/guide.md')
+        & git -C $repo add -A 2>&1 | Out-Null
+        & git -C $repo commit -q -m 'delete fixtures' 2>&1 | Out-Null
+        $output = Invoke-PlanOnly -Repo $repo -Base (& git -C $repo rev-parse HEAD~1)
+        Assert-True ($output -match 'csharp: \r?\n') 'a committed C# deletion must not be a format target'
+        Assert-True ($output -match 'markdown: \r?\n') 'a committed Markdown deletion must not be a format target'
+        Assert-True ($output -match 'Packaging : True') 'a committed Editor deletion must still plan packaging'
+    } finally {
+        Remove-TempRoot -Path $repo
+    }
+}
+
+Invoke-TestCase 'Plan_FormatsOnlyTheExistingSideOfARename' {
+    $repo = New-PlanRepo
+    try {
+        Write-FixtureFile -Root $repo -RelativePath 'docs/old.md' -Content "guide`n"
+        & git -C $repo add -A 2>&1 | Out-Null
+        & git -C $repo commit -q -m 'add doc' 2>&1 | Out-Null
+        & git -C $repo mv docs/old.md docs/new.md 2>&1 | Out-Null
+        $output = Invoke-PlanOnly -Repo $repo
+        Assert-True ($output -match 'markdown: docs/new\.md') 'the new path of a rename must be a format target'
+        Assert-True ($output -notmatch 'docs/old\.md') 'the old path of a rename must not be a format target'
+    } finally {
+        Remove-TempRoot -Path $repo
+    }
+}
+
 if ($script:TestFailureCount -gt 0) {
     Write-Host "fast-check self-tests: $($script:TestFailureCount) failed"
     exit 1