@cratis/pi 7.102.0 → 7.103.0

package/package/corpus/skills/analyzing-dotnet-performance/references/regex-patterns.md

@@ -0,0 +1,95 @@
+# Regex Patterns
+
+### Choose the Right Regex Engine Mode
+🟡 **DO** use `[GeneratedRegex]` for all static regex patterns, but never remove `NonBacktracking` if present | .NET 7+
+
+❌
+```csharp
+var r = new Regex(dynamicPattern, RegexOptions.Compiled);
+```
+✅
+```csharp
+[GeneratedRegex("pattern")]
+private static partial Regex MyRegex();
+
+var safe = new Regex(untrustedPattern, RegexOptions.NonBacktracking);
+
+var oneOff = new Regex("pattern");
+```
+
+**Impact: Source generator is always beneficial for static patterns. NonBacktracking prevents O(2^N) worst case — never remove it if present.**
+
+### Use IsMatch When You Only Need a Boolean Result
+🟡 **DO** use `IsMatch` instead of `Match(...).Success` | .NET 7+
+
+❌
+```csharp
+bool found = Regex.Match(input, pattern).Success;
+```
+✅
+```csharp
+bool found = Regex.IsMatch(input, pattern);
+```
+
+**Impact: Avoids Match object allocation; with NonBacktracking, ~3x faster by skipping capture computation.**
+
+### Use Regex.Count/EnumerateMatches Instead of Matches
+🟡 **DO** use `Count()` and `EnumerateMatches()` for allocation-free match processing | .NET 7+
+
+❌
+```csharp
+int count = 0;
+Match m = regex.Match(text);
+while (m.Success) { count++; m = m.NextMatch(); }
+```
+✅
+```csharp
+int count = regex.Count(text);
+
+foreach (ValueMatch m in Regex.EnumerateMatches(text, @"\b\w+\b"))
+{
+    ReadOnlySpan<char> word = text.AsSpan(m.Index, m.Length);
+}
+```
+
+**Impact: ~3x faster than Match/NextMatch with NonBacktracking. Zero allocations for both Count and EnumerateMatches.**
+
+### Use Span-Based Regex APIs for Allocation-Free Matching
+🟡 **DO** use `ReadOnlySpan<char>` overloads for regex matching on spans | .NET 7+
+
+❌
+```csharp
+string sub = largeBuffer.Substring(start, length);
+bool found = Regex.IsMatch(sub, pattern);
+```
+✅
+```csharp
+ReadOnlySpan<char> text = largeBuffer.AsSpan(start, length);
+foreach (ValueMatch m in Regex.EnumerateMatches(text, @"\b\w+\b"))
+{
+    ReadOnlySpan<char> word = text.Slice(m.Index, m.Length);
+}
+```
+
+**Impact: Eliminates string allocations when working with spans — particularly valuable in high-throughput parsing pipelines.**
+
+## Detection
+
+Scan recipes for regex anti-patterns. Run these and report exact counts.
+
+```bash
+# Compiled regex count (startup cost budget — compare ratio to GeneratedRegex)
+grep -rn --include='*.cs' 'RegexOptions.Compiled' --exclude-dir=bin --exclude-dir=obj . | wc -l
+
+# GeneratedRegex count (already optimized — verify the inverse)
+grep -rn --include='*.cs' 'GeneratedRegex' --exclude-dir=bin --exclude-dir=obj . | wc -l
+
+# Uncached new Regex() calls (construction cost per call)
+grep -rn --include='*.cs' 'new Regex(' --exclude-dir=bin --exclude-dir=obj . | wc -l
+```
+
+When `RegexOptions.Compiled` appears inside a class constructor or field initializer of an instantiated class (not a static singleton), count how many instances of that class are created at startup to determine total compiled regex budget. For example, if a `Rule` class compiles a regex in its constructor and 122 rules are registered, that is 122 compiled regexes at startup.
+
+### Patterns Requiring Manual Review
+
+- **`new Regex(` uncached**: Field assignment may span multiple lines — grep on one line is unreliable. Verify that matched instances are stored in `static readonly` fields or `[GeneratedRegex]`.

package/package/corpus/skills/analyzing-dotnet-performance/references/structural-patterns.md

@@ -0,0 +1,38 @@
+# Structural Patterns
+
+Patterns detected by the **absence** of a keyword or interface. These require codebase-wide counting scans, not single-file matching.
+
+### Seal Classes for Devirtualization
+🟡 **DO** seal all leaf classes (those not subclassed) | .NET Core 3.0+
+
+Sealing lets the JIT devirtualize/inline virtual calls and use pointer comparison for type checks. Every non-abstract, non-static class that is not subclassed should be sealed. **Cratis qualification:** Never seal public types of a published framework/library package: doing so is a breaking change, and Cratis framework repositories treat public API changes as semver.
+
+**Detection:** This is an absence pattern — scan for classes that are NOT sealed.
+
+```bash
+# Count unsealed (non-abstract, non-static) classes
+grep -rn --include='*.cs' -E '^\s*((public|internal|private|protected|file)\s+)?(partial\s+)?class ' --exclude-dir=bin --exclude-dir=obj . | grep -v 'sealed' | grep -v 'abstract' | grep -v 'static' | wc -l
+
+# Count already-sealed classes (verify the inverse)
+grep -rn --include='*.cs' 'sealed class' --exclude-dir=bin --exclude-dir=obj . | wc -l
+```
+
+**Exclusions:** Do not seal classes that are subclassed elsewhere in the codebase. Identifying base classes requires manual review — grep for `: ClassName` patterns and cross-reference, but expect false positives from interface implementations and generic constraints.
+
+❌
+```csharp
+internal class MyHandler : Base
+{ public override int Run() => 42; }
+```
+✅
+```csharp
+internal sealed class MyHandler : Base
+{ public override int Run() => 42; }
+```
+
+**Impact: Virtual calls up to 500x faster; type checks ~25x faster. Severity scales with count.**
+
+**Scale-based severity:**
+- 1-10 unsealed leaf classes → ℹ️ Info
+- 11-50 unsealed leaf classes → 🟡 Moderate
+- 50+ unsealed leaf classes → 🟡 Moderate (elevated priority)

package/package/corpus/skills/binlog-generation/LICENSE

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) .NET Foundation and Contributors
+
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package/corpus/skills/binlog-generation/NOTICE

@@ -0,0 +1,22 @@
+Generate Binary Logs
+Copyright (c) .NET Foundation and Contributors
+Licensed under the MIT License. See LICENSE.
+
+Upstream source: https://github.com/dotnet/skills/blob/a6bf43ab61967c30919334986515163ab24d7635/plugins/dotnet-msbuild/skills/binlog-generation/SKILL.md
+
+Changes made by Cratis:
+
+LICENSE:
+- Copy upstream MIT license and copyright verbatim.
+
+SKILL.md:
+- Remove the SDK version from the description; the 17.12 floor stays in the body.
+- Normalize frontmatter serialization, add MIT license where absent; preserve name and description.
+- Correct the binlog {} placeholder SDK/MSBuild minimum in description and body.
+- Add marked modification/source comment and applicability/Cratis precedence line with the skill-specific safety, ownership or compatibility caveat.
+- Render unimported binlog-failure-analysis routing reference as plain topic text.
+- Render unimported build-perf-diagnostics routing reference as plain topic text.
+- Correct the binlog {} placeholder SDK/MSBuild minimum.
+- Rewrite the description to the Cratis shape (what it does, Use when, Not for) and drop references to skills that are not part of this corpus.
+
+NOTICE: Add this attribution, change list, and any download/execution disclosure.

package/package/corpus/skills/binlog-generation/SKILL.md

@@ -0,0 +1,129 @@
+---
+name: binlog-generation
+description: 'Generates MSBuild binary logs (binlogs) by adding /bl:{} to dotnet build, test, pack, publish, or restore commands, capturing a full build trace for later investigation. Use when a build error or build-performance problem needs a binlog and none exists. The {} placeholder needs a recent MSBuild; PowerShell must quote the switch as ''-bl:{}''. Not for analyzing an existing binlog or measuring build performance (use the msbuild skill) or for non-MSBuild build systems such as npm, Maven, or CMake.'
+license: MIT
+---
+
+<!-- Modified by Cratis from dotnet's original (MIT): frontmatter, applicability, navigation and the changes listed in NOTICE. Upstream: https://github.com/dotnet/skills (plugins/dotnet-msbuild/skills/binlog-generation/SKILL.md; see NOTICE) -->
+
+# Generate Binary Logs
+
+Cratis rules in `.cratis/ai/rules/` (including `csharp.md`, `specs.csharp.md`, and `orleans.md`) and the `cratis-*` skills win where they differ. Binlogs embed project and imported file contents: keep them local and task-scoped.
+
+**Pass the `/bl` switch when running any MSBuild-based command.** This is a non-negotiable requirement for all .NET builds.
+
+## Commands That Require /bl
+
+You MUST add the `/bl:{}` flag to:
+- `dotnet build`
+- `dotnet test`
+- `dotnet pack`
+- `dotnet publish`
+- `dotnet restore`
+- `msbuild` or `msbuild.exe`
+- Any other command that invokes MSBuild
+
+## Preferred: Use `{}` for Automatic Unique Names
+
+> **Note:** The `{}` placeholder requires MSBuild 17.12+ / .NET 9.0.100 SDK or later.
+
+The `{}` placeholder in the binlog filename is replaced by MSBuild with a unique identifier, guaranteeing no two builds ever overwrite each other — without needing to track or check existing files.
+
+```bash
+# Every invocation produces a distinct file automatically
+dotnet build /bl:{}
+dotnet test /bl:{}
+dotnet build --configuration Release /bl:{}
+```
+
+**PowerShell requires quoting the complete switch:**
+
+```powershell
+# Keep the literal {} placeholder in one argument
+dotnet build '-bl:{}'
+dotnet test '-bl:{}'
+```
+
+## Why This Matters
+
+1. **Unique names prevent overwrites** - You can always go back and analyze previous builds
+2. **Failure analysis** - When a build fails, the binlog is already there for immediate analysis
+3. **Comparison** - You can compare builds before and after changes
+4. **No re-running builds** - You never need to re-run a failed build just to generate a binlog
+
+## Examples
+
+```bash
+# ✅ CORRECT - {} generates a unique name automatically (bash/cmd)
+dotnet build /bl:{}
+dotnet test /bl:{}
+
+# ✅ CORRECT - quote the complete PowerShell argument
+dotnet build '-bl:{}'
+dotnet test '-bl:{}'
+
+# ❌ WRONG - Missing /bl flag entirely
+dotnet build
+dotnet test
+
+# ❌ WRONG - No filename (overwrites the same msbuild.binlog every time)
+dotnet build /bl
+dotnet build /bl
+```
+
+## One build = one binlog
+
+Add `/bl:{}` to **every** MSBuild invocation separately — never reuse a name and
+never rely on bare `/bl`:
+
+- Building several configurations, projects, or retrying a failed build? Each
+  command still gets its own `/bl:{}` so the logs never overwrite each other.
+
+```bash
+dotnet build -c Debug   /bl:{}   # unique file
+dotnet build -c Release /bl:{}   # another unique file
+```
+
+## Verify the binlog exists
+
+After the build, confirm a `.binlog` was actually produced before moving on to
+analysis — a build that fails *before* MSBuild starts (e.g. a bad argument)
+writes no binlog:
+
+```bash
+ls -1 *.binlog       # bash
+dir /b *.binlog      # Windows cmd
+```
+
+```powershell
+Get-ChildItem *.binlog   # PowerShell
+```
+
+Note the resulting path so binlog failure analysis or build perf diagnostics
+can consume it.
+
+## When a Specific Filename Is Required
+
+If the binlog filename needs to be known upfront (e.g., for CI artifact upload), or if `{}` is not available in the installed MSBuild version, pick a name that won't collide with existing files:
+
+1. Check for existing `*.binlog` files in the directory
+2. Choose a name not already taken (e.g., by incrementing a counter from the highest existing number)
+
+```bash
+# Example: directory contains 3.binlog — use 4.binlog
+dotnet build /bl:4.binlog
+```
+
+## Cleaning the Repository
+
+When cleaning the repository with `git clean`, **always exclude binlog files** to preserve your build history:
+
+```bash
+# ✅ CORRECT - Exclude binlog files from cleaning
+git clean -fdx -e "*.binlog"
+
+# ❌ WRONG - This deletes binlog files (they're usually in .gitignore)
+git clean -fdx
+```
+
+This is especially important when iterating on build fixes - you need the binlogs to analyze what changed between builds.

package/package/corpus/skills/check-bin-obj-clash/LICENSE

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) .NET Foundation and Contributors
+
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package/corpus/skills/check-bin-obj-clash/NOTICE

@@ -0,0 +1,27 @@
+Detecting OutputPath and IntermediateOutputPath Clashes
+Copyright (c) .NET Foundation and Contributors
+Licensed under the MIT License. See LICENSE.
+
+Upstream source: https://github.com/dotnet/skills/blob/a6bf43ab61967c30919334986515163ab24d7635/plugins/dotnet-msbuild/skills/check-bin-obj-clash/SKILL.md
+
+Changes made by Cratis:
+
+LICENSE:
+- Copy upstream MIT license and copyright verbatim.
+
+SKILL.md:
+- Normalize frontmatter serialization, add MIT license where absent; preserve name and description.
+- Add marked modification/source comment and applicability/Cratis precedence line.
+- Render unimported msbuild-antipatterns routing reference as plain topic text.
+- Replace the blanket BuildProjectReferences=false exclusion with an evidence-based metadata-only query qualification.
+- Qualify the structured workflow exclusion by actual targets and writes.
+- Qualify the text-replay exclusion by actual targets and writes.
+- Move the complete ## Common Causes and Fixes section verbatim into references/common-causes-and-fixes.md to fit the body limit; leave a direct pointer.
+- Rewrite the description to the Cratis shape (what it does, Use when, Not for) and drop references to skills that are not part of this corpus.
+- Point the antipatterns cross-references at the bundled msbuild skill reference.
+
+references/common-causes-and-fixes.md:
+- Contain the section moved verbatim from SKILL.md, with a reference H1 title.
+- Add or normalize the top Contents list from existing headings; preserve section content.
+
+NOTICE: Add this attribution, change list, and any download/execution disclosure.

package/package/corpus/skills/check-bin-obj-clash/SKILL.md

@@ -0,0 +1,127 @@
+---
+name: check-bin-obj-clash
+description: 'Detects MSBuild projects with conflicting OutputPath or IntermediateOutputPath and fixes the clash. Use when builds fail with ''Cannot create a file when that file already exists'' or ''The process cannot access the file because it is being used by another process'', fail intermittently but pass on retry, or overwrite outputs in multi-project or multi-targeting builds where bin/obj or project.assets.json collide. Not for OS-level file locking, single-project single-TFM builds, or non-MSBuild build systems.'
+license: MIT
+---
+
+<!-- Modified by Cratis from dotnet's original (MIT): frontmatter, applicability, navigation and the changes listed in NOTICE. Upstream: https://github.com/dotnet/skills (plugins/dotnet-msbuild/skills/check-bin-obj-clash/SKILL.md; see NOTICE) -->
+
+# Detecting OutputPath and IntermediateOutputPath Clashes
+
+Cratis rules in `.cratis/ai/rules/` (including `csharp.md`, `specs.csharp.md`, and `orleans.md`) and the `cratis-*` skills win where they differ.
+
+## Overview
+
+This skill helps identify when multiple MSBuild project evaluations share the same `OutputPath` or `IntermediateOutputPath`. This is a common source of build failures including:
+
+- File access conflicts during parallel builds
+- Missing or overwritten output files
+- Intermittent build failures
+- "File in use" errors
+- **NuGet restore errors like `Cannot create a file when that file already exists`** - this strongly indicates multiple projects share the same `IntermediateOutputPath` where `project.assets.json` is written
+
+Clashes can occur between:
+- **Different projects** sharing the same output directory
+- **Multi-targeting builds** (e.g., `TargetFrameworks=net8.0;net9.0`) where the path doesn't include the target framework
+- **Multiple solution builds** where the same project is built from different solutions in a single build
+
+**Cratis qualification:** `BuildProjectReferences=false` only suppresses building referenced projects; it does not prove that this project instance is read-only. Exclude an instance only when its actual targets and writes show a metadata-only query (for example, `GetTargetPath`).
+
+## When to Use This Skill
+
+**Invoke this skill immediately when you see:**
+- `Cannot create a file when that file already exists` during NuGet restore
+- `The process cannot access the file because it is being used by another process`
+- Intermittent build failures that succeed on retry
+- Missing output files or unexpected overwriting
+
+## Step 1: Generate a Binary Log
+
+Use the `binlog-generation` skill to generate a binary log with the correct naming convention.
+
+## Primary workflow — binlog MCP
+
+The MCP server exposes structured tools for inspecting a `.binlog` without
+parsing text logs. Call them directly instead of replaying the binlog to a text
+file. Call `tools/list` for the MCP first if you are unsure which tools are available.
+
+**Important constraints:**
+- The `.binlog` file is a **binary format** — do NOT try to `cat`, `head`, `strings`, or read it directly. Use only the MCP tools to query it.
+- **Synthesize findings as you go.** Do not spend all available time investigating — once you have enough evidence, present your conclusions.
+
+### Step 2: Get an overview and list projects
+
+Use the MCP overview and projects tools to understand the build and list all projects that participated.
+
+### Step 3: Check evaluations and global properties
+
+Use the MCP `evaluations` and `evaluation_global_properties` tools to find all evaluations per project. Look for:
+- Multiple evaluations for the same project (indicates multi-targeting or multiple build configurations)
+- Differing global properties between evaluations (`TargetFramework`, `Configuration`, `RuntimeIdentifier`, `SolutionFileName`, `PublishReadyToRun`, etc.)
+
+### Step 4: Get output paths for each evaluation
+
+Use the MCP properties tool to query `OutputPath`, `IntermediateOutputPath`, `BaseOutputPath`, and `BaseIntermediateOutputPath` for each project evaluation.
+
+### Step 5: Check for double writes
+
+Use the MCP double_writes tool if available — it directly detects files written by multiple project instances.
+
+### Step 6: Identify clashes
+
+Compare the `OutputPath` and `IntermediateOutputPath` values across all evaluations:
+1. **Normalize paths** - Convert to absolute paths and normalize separators
+2. **Group by path** - Find evaluations that share the same OutputPath or IntermediateOutputPath
+3. **Filter out non-build evaluations** - Exclude only instances proven by their targets and writes to be metadata-only queries; `BuildProjectReferences=false` alone is insufficient.
+4. **Report clashes** - Any group with more than one evaluation indicates a clash
+
+## Fallback workflow — text-log replay (when MCP is unavailable)
+
+Use this only when the MCP server cannot be started.
+
+Replay the binlog to a diagnostic text log, then grep for the same signals the MCP tools surface:
+
+```bash
+dotnet msbuild build.binlog -noconlog -fl "-flp:v=diag;logfile=full.log"
+```
+
+Then extract the clash signals:
+
+- **Projects & evaluations** — list evaluation starts and count them per project: `grep 'Evaluation started' full.log | grep -oiE '"[^"]+\.[a-z]+proj"' | sort | uniq -c`. Matching the full **quoted path** keeps same-named projects in different directories distinct (and tolerates spaces in paths); a path with a count ≥ 2 was evaluated more than once (multi-targeting or extra global properties). (`grep -c` alone only totals evaluations across the whole log, so it can't reveal per-project duplication.)
+- **Output paths** — `grep -iE 'OutputPath[[:space:]]*=|IntermediateOutputPath[[:space:]]*=|BaseOutputPath[[:space:]]*=|BaseIntermediateOutputPath[[:space:]]*=' full.log | sort -u`, or query a project directly: `dotnet msbuild MyProject.csproj -getProperty:OutputPath` (and `IntermediateOutputPath`, `BaseIntermediateOutputPath`).
+- **Distinguishing global properties** — `grep -iE 'TargetFramework|Configuration|Platform|RuntimeIdentifier|SolutionFileName|PublishReadyToRun' full.log`. See the [Global Properties to Check](references/common-causes-and-fixes.md#global-properties-to-check-when-comparing-evaluations) table for which affect the path and which just fork a redundant instance.
+- **Corroborating evidence (optional)** — `grep 'Target "CopyFilesToOutputDirectory"' full.log` plus `grep 'SkipUnchangedFiles' full.log` show a second instance writing (or skipping a masked write) to the same path; a long vs ~0 ms `CoreCompile` distinguishes the real build from a redundant instance.
+
+**Then identify clashes:** normalize paths to absolute, group evaluations by `OutputPath` and by `IntermediateOutputPath`, and exclude only instances proven by their targets and writes to be metadata-only queries, not merely marked `BuildProjectReferences=false` — plus, for `OutputPath` only, `MSBuildRestoreSessionId` restore evaluations. Any group with more than one remaining evaluation is a clash.
+
+Read references/common-causes-and-fixes.md when selecting the relevant diagnostic workflow.
+
+## Tips
+
+- The SDK default paths include `$(TargetFramework)` — clashes often occur when projects override these defaults; normalize relative paths to absolute before comparing.
+- **Cross-project `IntermediateOutputPath` clashes cannot be fixed with `AppendTargetFrameworkToOutputPath`** — files like `project.assets.json` are written directly to the intermediate path. For multi-targeting clashes *within the same project*, `AppendTargetFrameworkToOutputPath=true` is the correct fix.
+- Error messages that indicate a path clash: `Cannot create a file when that file already exists` (NuGet restore), `The process cannot access the file because it is being used by another process`, or intermittent failures that succeed on retry.
+
+### Global Properties to Check When Comparing Evaluations
+
+When multiple evaluations share an output path, compare these global properties to understand why:
+
+| Property | Affects OutputPath? | Notes |
+|----------|---------------------|-------|
+| `TargetFramework` | Yes | Different TFMs should have different paths. **Exception:** re-injecting a *single-targeting* project's own TFM (e.g. via `SetTargetFramework` with the same value) is path-neutral — it forks a redundant instance sharing the output path (see "`SetTargetFramework` re-injecting...") |
+| `RuntimeIdentifier` | Yes | Different RIDs should have different paths |
+| `Configuration` | Yes | Debug vs Release |
+| `Platform` | Yes | AnyCPU vs x64 etc. |
+| `SolutionFileName` | No | Identifies which solution built the project — different values indicate multi-solution clash |
+| `SolutionName` | No | Solution name without extension |
+| `SolutionPath` | No | Full path to the solution file |
+| `SolutionDir` | No | Directory containing the solution file |
+| `CurrentSolutionConfigurationContents` | No | XML with project entries — count of entries reveals which solution |
+| `BuildProjectReferences` | No | `false` = P2P query, not a real build - ignore these |
+| `MSBuildRestoreSessionId` | No | Present = restore phase evaluation |
+| `PublishReadyToRun` | No | Publish setting, doesn't change build output path but creates distinct project instances |
+| `_IsPublishing` | No | Publish flag; an `<MSBuild>` Build/Publish call with this set (in this project or another that consumes it) forks a publish instance sharing the build output path (see "Explicit `<MSBuild>` Build/Publish with extra global properties") |
+
+## Testing Fixes
+
+After making changes to fix path clashes, clean and rebuild to verify. See the `binlog-generation` skill's "Cleaning the Repository" section on how to clean the repository while preserving binlog files.