Address Copilot review feedback on dynamo-build-tests and dynamo-run-tests

- Remove hardcoded tool paths; use <MSBuildPath> and <DotNetPath>
  placeholders resolved from memory file or vswhere/where dotnet
- Prefer MSBuild over dotnet build (repo standard); dotnet build
  --no-dependencies is now the fallback
- Clarify --no-dependencies failure case: rebuild production project
  then test project, both with --no-dependencies
- Fix VisualizationTests -> WpfVisualizationTests in both skills,
  with note about directory/project name mismatch
- Move OR filter example out of markdown table into a code block
  to avoid escaped pipe being copied literally
- Move "Finding test projects" into the dynamo-run-tests workflow
  as step 2, before "Ensure the DLL is current"
- Fix duplicate step 3 numbering in dynamo-run-tests

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jasonstratton

.agents/skills/dynamo-build-tests/SKILL.md

@@ -26,39 +26,40 @@ Confirmation that the build succeeded with 0 errors in the target project, or a
 
 ### 1. Resolve tool paths
 
-Check the `reference_build_tools.md` memory file for cached paths to `msbuild`, `dotnet`, and `vswhere`. If the memory file is missing or the cached path doesn't work, discover the path:
+Do not hardcode tool paths. Obtain `<MSBuildPath>` and `<DotNetPath>` from your environment before running any commands:
+
+- **Claude Code users**: read `reference_build_tools.md` from the personal memory file (`~/.claude/projects/<project>/memory/reference_build_tools.md` — not part of the repo). Update it if a path is stale.
+- **All users**: discover MSBuild via `vswhere`:
 
 ```bash
-# Find MSBuild via vswhere
 "/c/Program Files (x86)/Microsoft Visual Studio/Installer/vswhere.exe" -latest -requires Microsoft.Component.MSBuild -find "MSBuild\**\Bin\MSBuild.exe"
 ```
 
-Then update the memory file with the new path.
+Use the resolved paths as `<MSBuildPath>` and `<DotNetPath>` in the commands below.
 
 ### 2. Build the test project
 
-**Preferred: `dotnet build --no-dependencies`** (fast, avoids satellite assembly errors):
+**Preferred: MSBuild** (this repo builds with MSBuild; it handles all project types correctly):
 
 ```bash
-"/c/Program Files/dotnet/dotnet.exe" build test/<TestProject>/<TestProject>.csproj -c Release --no-restore --no-dependencies -v q
+"<MSBuildPath>" "test/<TestProject>/<TestProject>.csproj" "-p:Configuration=Release" "-v:q" "-nologo"
 ```
 
-This compiles only the specified project, relying on pre-built dependency DLLs already in the output folder. This avoids the `MSB4803` errors from `DynamoUnits` and `DesignScriptBuiltin` satellite assembly tasks.
+> **Important**: When calling MSBuild from bash, quote all flag arguments (e.g. `"-p:Configuration=Release"`) to prevent the shell from interpreting `/p:` as a path.
 
-**If `--no-dependencies` fails** (missing dependency DLLs), build the production project first:
+**Fallback: `dotnet build --no-dependencies`** if MSBuild is unavailable. This compiles only the specified project against pre-built dependency DLLs already in the output folder, avoiding `MSB4803` errors from satellite assembly tasks:
 
 ```bash
-"/c/Program Files/dotnet/dotnet.exe" build src/<ProductionProject>/<ProductionProject>.csproj -c Release --no-restore --no-dependencies -v q
+"<DotNetPath>" build test/<TestProject>/<TestProject>.csproj -c Release --no-restore --no-dependencies -v q
 ```
 
-**If `dotnet build` cannot work at all** (rare), fall back to MSBuild:
+**If `dotnet build --no-dependencies` fails** because dependency DLLs are missing from the output folder, they need to be built first. Rebuild the production project, then the test project — both with `--no-dependencies`:
 
 ```bash
-"/e/VS2026/MSBuild/Current/Bin/MSBuild.exe" "test/<TestProject>/<TestProject>.csproj" "-p:Configuration=Release" "-v:q" "-nologo"
+"<DotNetPath>" build src/<ProductionProject>/<ProductionProject>.csproj -c Release --no-restore --no-dependencies -v q
+"<DotNetPath>" build test/<TestProject>/<TestProject>.csproj -c Release --no-restore --no-dependencies -v q
 ```
 
-> **Important**: When calling MSBuild from bash, quote all flag arguments (e.g. `"-p:Configuration=Release"`) to prevent the shell from interpreting `/p:` as a path.
-
 ### 3. Verify success
 
 Check the build output for `0 Error(s)` in the target project. Filter out known pre-existing errors from unrelated projects:
@@ -67,16 +68,15 @@ Check the build output for `0 Error(s)` in the target project. Filter out known
 
 These are infrastructure issues, not code errors.
 
-## Common test projects
+## Finding test projects
+
+Discover available test projects from the repo:
+
+```bash
+find test -name "*.csproj" | sort
+```
 
-| Test project | What it covers |
-|---|---|
-| `DynamoCoreTests` | Core engine, graph model, scheduler |
-| `DynamoCoreWpfTests` | WPF UI tests (part 1) |
-| `DynamoCoreWpf2Tests` | WPF UI tests (part 2) |
-| `DynamoCoreWpf3Tests` | WPF UI tests (part 3) — includes note pin/unpin, Python customization |
-| `ViewExtensionLibraryTests` | View extension tests |
-| `VisualizationTests` | Rendering and visualization tests |
+> **Exception**: The visualization test assembly is `WpfVisualizationTests`, but its directory is `test/VisualizationTests/` — directory and project name differ. All other projects follow the `test/<Name>/<Name>.csproj` pattern.
 
 Test DLLs are output to `bin/AnyCPU/Release/<TestProject>.dll`.
 

.agents/skills/dynamo-run-tests/SKILL.md

@@ -25,28 +25,45 @@ Pass/fail summary with counts. For failures: the failing test name, assertion me
 
 ## Workflow
 
-### 1. Ensure the DLL is current
+### 1. Resolve tool path
+
+Do not hardcode the `dotnet` path. Obtain `<DotNetPath>` from your environment:
+
+- **Claude Code users**: read `reference_build_tools.md` from the personal memory file (`~/.claude/projects/<project>/memory/reference_build_tools.md` — not part of the repo).
+- **All users**: run `where dotnet` (Windows) or `which dotnet` (bash) to locate it.
+
+### 2. Find the test project
+
+Discover available test projects:
+
+```bash
+find test -name "*.csproj" | sort
+```
+
+> **Exception**: The visualization test assembly is `WpfVisualizationTests`, but its directory is `test/VisualizationTests/` — directory and project name differ. All other projects follow the `test/<Name>/<Name>.csproj` pattern.
+
+### 3. Ensure the DLL is current
 
 If you edited test or production code since the last build, rebuild first using `dynamo-build-tests`. A stale DLL will either miss new tests ("discovered 0 of 0") or run old code.
 
-### 2. Run tests
+### 4. Run tests
 
-Use `dotnet test` with `--no-build` to skip recompilation (since you built in step 1):
+Use `dotnet test` with `--no-build` to skip recompilation (since you built in step 3):
 
 ```bash
 # Run specific test(s) by name substring
-"/c/Program Files/dotnet/dotnet.exe" test test/<TestProject>/<TestProject>.csproj -c Release --no-restore --no-build --filter "FullyQualifiedName~<TestNameSubstring>" -v n
+"<DotNetPath>" test test/<TestProject>/<TestProject>.csproj -c Release --no-restore --no-build --filter "FullyQualifiedName~<TestNameSubstring>" -v n
 
 # Run all tests in a test class
-"/c/Program Files/dotnet/dotnet.exe" test test/<TestProject>/<TestProject>.csproj -c Release --no-restore --no-build --filter "FullyQualifiedName~<ClassName>" -v n
+"<DotNetPath>" test test/<TestProject>/<TestProject>.csproj -c Release --no-restore --no-build --filter "FullyQualifiedName~<ClassName>" -v n
 
 # Run all tests in a project
-"/c/Program Files/dotnet/dotnet.exe" test test/<TestProject>/<TestProject>.csproj -c Release --no-restore --no-build -v n
+"<DotNetPath>" test test/<TestProject>/<TestProject>.csproj -c Release --no-restore --no-build -v n
 ```
 
 > **Important**: Always use `--no-restore --no-build` to avoid triggering the `MSB4803` satellite assembly errors from `DynamoUnits`/`DesignScriptBuiltin`. The DLL must already be built.
 
-### 3. Interpret results
+### 5. Interpret results
 
 **Successful output** ends with:
 ```
@@ -71,9 +88,14 @@ The `--filter` flag uses `dotnet test` filter expressions:
 |---|---|
 | Test name contains substring | `"FullyQualifiedName~UnpinGroupedNote"` |
 | Exact test name | `"FullyQualifiedName=DynamoCoreWpfTests.NoteViewTests.UnpinGroupedNote_NoteRemainsInGroup"` |
-| Multiple tests (OR) | `"FullyQualifiedName~TestA\|FullyQualifiedName~TestB"` |
 | All tests in a class | `"FullyQualifiedName~NoteViewTests"` |
 
+Multiple tests (OR) — use a literal `|` inside the quoted filter string:
+
+```bash
+--filter "FullyQualifiedName~TestA|FullyQualifiedName~TestB"
+```
+
 ### Verbosity levels
 
 | Flag | Shows |
@@ -82,22 +104,11 @@ The `--filter` flag uses `dotnet test` filter expressions:
 | `-v n` | Normal — test names and timing (recommended) |
 | `-v d` | Detailed — full output including stdout from tests |
 
-### Common test projects
-
-| Test project | What it covers |
-|---|---|
-| `DynamoCoreTests` | Core engine, graph model, scheduler |
-| `DynamoCoreWpfTests` | WPF UI tests (part 1) |
-| `DynamoCoreWpf2Tests` | WPF UI tests (part 2) |
-| `DynamoCoreWpf3Tests` | WPF UI tests (part 3) — note pin/unpin, Python customization |
-| `ViewExtensionLibraryTests` | View extension tests |
-| `VisualizationTests` | Rendering and visualization tests |
-
 ## Troubleshooting
 
 | Symptom | Cause | Fix |
 |---|---|---|
-| "discovered 0 of 0 NUnit test cases" | DLL is stale — new tests not compiled | Rebuild with `dynamo-build-tests` |
+| "discovered 0 of 0 NUnit test cases" | DLL is stale — new tests not compiled | Rebuild with `dynamo-build-tests` (step 3) |
 | `MSB4803` errors | `--no-build` was omitted or `dotnet test` triggered a rebuild | Add `--no-restore --no-build` flags |
 | Test passes but behavior is wrong | Production DLL is stale | Rebuild the production project too |
 | `No test matches the given testcase filter` | Filter typo or wrong project | Check spelling; try broader filter like class name |