@cratis/pi 7.102.0 → 7.103.0

package/package/corpus/skills/directory-build-organization/SKILL.md

@@ -0,0 +1,205 @@
+---
+name: directory-build-organization
+description: 'Organizes shared MSBuild policy across Directory.Build.props, Directory.Build.targets, Directory.Build.rsp, and Directory.Packages.props: centralizing repeated properties, targets, and package versions, hierarchy and import structure, props-versus-targets placement, and folder or project exceptions. Use when two or more projects repeat MSBuild policy, or an existing Directory.Build hierarchy has an import, placement, or layering defect, even if only one project is affected. Not for a one-project repo without a Directory.Build file, property value or condition semantics, legacy-to-SDK migration, or non-MSBuild 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/directory-build-organization/SKILL.md; see NOTICE) -->
+
+# Organizing Build Infrastructure with Directory.Build Files
+
+Cratis rules in `.cratis/ai/rules/` (including `csharp.md`, `specs.csharp.md`, and `orleans.md`) and the `cratis-*` skills win where they differ.
+
+## Intent control
+
+- For "should we", "how should we organize", "recommend", "advise", or review
+  requests, inspect the actual project files and return a proposed layout only.
+  Do not create or edit files unless the user explicitly asks to apply, move,
+  centralize, or clean up the configuration.
+- Before summarizing, verify which project retains each project-specific
+  property, item, or target. Name the actual file; do not infer it from sibling
+  names.
+- Recommend a verification command only after discovering a real `.sln`,
+  `.slnx`, `.proj`, or project file at that path. If no repo-root entry point
+  exists, give commands for the discovered projects or state that the entry
+  point was not found.
+- Every advice response must explain that `Microsoft.Common.props` searches
+  upward from each project and automatically imports the nearest
+  `Directory.Build.props` early; project values can then override shared
+  defaults. Explain the equivalent late `Microsoft.Common.targets` import when
+  recommending `Directory.Build.targets`.
+
+## Directory.Build.props vs Directory.Build.targets
+
+Understanding which file to use is critical. They differ in **when** they are imported during evaluation:
+
+**Evaluation order:**
+
+```
+Microsoft.Common.props imports Directory.Build.props early
+→ project body and package/project imports evaluate
+→ Microsoft.Common.targets imports Directory.Build.targets late
+```
+
+| Use `.props` for | Use `.targets` for |
+|---|---|
+| Setting property defaults | Custom build targets |
+| Common item definitions | Late-bound property overrides |
+| Properties projects can override | Post-build steps |
+| Assembly/package metadata | Conditional logic on final values |
+| Analyzer PackageReferences | Targets that depend on SDK-defined properties |
+
+**Rule of thumb:** Properties and items go in `.props`. Custom targets and late-bound logic go in `.targets`.
+
+Because `.props` is imported before the project file, the project can override any value set there. Because `.targets` is imported after everything, it gets the final say—but projects cannot override `.targets` values.
+
+### ⚠️ Critical: TargetFramework Availability in .props vs .targets
+
+**Property conditions on `$(TargetFramework)` in `.props` files silently fail for single-targeting projects** — the property is empty during `.props` evaluation. Move TFM-conditional properties to `.targets` instead. ItemGroup and Target conditions are not affected.
+
+See [targetframework-props-pitfall.md](references/targetframework-props-pitfall.md) for the full explanation.
+
+## Directory.Build.props
+
+Good candidates: language settings, assembly/package metadata, build warnings, code analysis, common analyzers.
+
+```xml
+<Project>
+  <PropertyGroup>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
+    <Company>Contoso</Company>
+    <Authors>Contoso Engineering</Authors>
+  </PropertyGroup>
+</Project>
+```
+
+**Do NOT put here:** project-specific TFMs, project-specific PackageReferences, targets/build logic, or properties depending on SDK-defined values (not available during `.props` evaluation).
+
+## Directory.Build.targets
+
+Good candidates: custom build targets, late-bound property overrides (values depending on SDK properties), post-build validation.
+
+```xml
+<Project>
+  <Target Name="ValidateProjectSettings" BeforeTargets="Build">
+    <Error Text="All libraries must target netstandard2.0 or higher"
+           Condition="'$(OutputType)' == 'Library' AND '$(TargetFramework)' == 'net472'" />
+  </Target>
+
+  <PropertyGroup>
+    <!-- DocumentationFile depends on OutputPath, which is set by the SDK -->
+    <DocumentationFile Condition="'$(IsPackable)' == 'true'">$(OutputPath)$(AssemblyName).xml</DocumentationFile>
+  </PropertyGroup>
+</Project>
+```
+
+## Directory.Packages.props (Central Package Management)
+
+Central Package Management (CPM) provides a single source of truth for all NuGet package versions. See [https://learn.microsoft.com/en-us/nuget/consume-packages/central-package-management](https://learn.microsoft.com/en-us/nuget/consume-packages/central-package-management) for details.
+
+**Enable CPM in `Directory.Packages.props` at the repo root:**
+
+```xml
+<Project>
+  <PropertyGroup>
+    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageVersion Include="Microsoft.Extensions.Logging" Version="8.0.0" />
+    <PackageVersion Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageVersion Include="xunit" Version="2.9.0" />
+    <PackageVersion Include="xunit.runner.visualstudio" Version="2.8.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <!-- GlobalPackageReference applies to ALL projects — great for analyzers -->
+    <GlobalPackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.556" />
+    <GlobalPackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="8.0.0" />
+  </ItemGroup>
+</Project>
+```
+
+## Directory.Build.rsp
+
+Contains default MSBuild CLI arguments applied to all builds under the directory tree.
+
+**Example `Directory.Build.rsp`:**
+
+```
+/maxcpucount
+/nodeReuse:false
+/consoleLoggerParameters:Summary;ForceNoAlign
+/warnAsMessage:MSB3277
+```
+
+- Works with both `msbuild` and `dotnet` CLI in modern .NET versions
+- Great for enforcing consistent CI and local build flags
+- Each argument goes on its own line
+
+## Multi-level Directory.Build Files
+
+MSBuild only auto-imports the **first** `Directory.Build.props` (or `.targets`) it finds walking up from the project directory. To chain multiple levels, explicitly import the parent at the **top** of the inner file. See [multi-level-examples](references/multi-level-examples.md) for full file examples.
+
+```xml
+<Project>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.props', '$(MSBuildThisFileDirectory)../'))"
+         Condition="Exists('$([MSBuild]::GetPathOfFileAbove('Directory.Build.props', '$(MSBuildThisFileDirectory)../'))')" />
+
+  <!-- Inner-level overrides go here -->
+</Project>
+```
+
+**Example layout:**
+
+```
+repo/
+  Directory.Build.props          ← repo-wide (lang version, company info, analyzers)
+  Directory.Build.targets        ← repo-wide targets
+  Directory.Packages.props       ← central package versions
+  src/
+    Directory.Build.props        ← src-specific (imports repo-level, sets IsPackable=true)
+  test/
+    Directory.Build.props        ← test-specific (imports repo-level, sets IsPackable=false, adds test packages)
+```
+
+## Artifact Output Layout (.NET 8+)
+
+Set `<ArtifactsPath>$(MSBuildThisFileDirectory)artifacts</ArtifactsPath>` in `Directory.Build.props` to automatically produce project-name-separated `bin/`, `obj/`, and `publish/` directories under a single `artifacts/` folder, avoiding bin/obj clashes by default. See [common-patterns](references/common-patterns.md) for the directory layout and additional patterns (conditional settings by project type, post-pack validation).
+
+## Workflow: Organizing Build Infrastructure
+
+1. **Audit all `.csproj` files** — Catalog every `<PropertyGroup>`, `<ItemGroup>`, and custom `<Target>` across the solution. Note which settings repeat and which are project-specific.
+2. **Create root `Directory.Build.props`** — Move shared property defaults (LangVersion, Nullable, TreatWarningsAsErrors, metadata) here. These are imported before the project file so projects can override them.
+3. **Create root `Directory.Build.targets`** — Move custom build targets, post-build validation, and any properties that depend on SDK-defined values (e.g., `OutputPath`, `TargetFramework` for single-targeting projects) here. These are imported after the SDK so all properties are available.
+4. **Create `Directory.Packages.props`** — Enable Central Package Management (`ManagePackageVersionsCentrally`), list all `PackageVersion` entries, and remove `Version=` from `PackageReference` items in `.csproj` files.
+5. **Set up multi-level hierarchy** — Create inner `Directory.Build.props` files for `src/` and `test/` folders with distinct settings. Use `GetPathOfFileAbove` to chain to the parent.
+6. **Simplify `.csproj` files** — Remove all centralized properties, version attributes, and duplicated targets. Each project should only contain what is unique to it.
+7. **Validate** — Run restore/build against the discovered `.sln`, `.slnx`,
+   `.proj`, or project path, for example
+   `dotnet restore <entrypoint> && dotnet build <entrypoint>`. If no root
+   entrypoint exists, validate each discovered project explicitly instead of
+   claiming a repo-root build. Use
+   `dotnet msbuild <project> -pp:output.xml` to inspect the final merged view.
+
+## Troubleshooting
+
+| Problem | Cause | Fix |
+|---|---|---|
+| `Directory.Build.props` isn't picked up | File name casing wrong (exact match required on Linux/macOS) | Verify exact casing: `Directory.Build.props` (capital D, B) |
+| Properties from `.props` are ignored by projects | Project sets the same property after the import | Move the property to `Directory.Build.targets` to set it after the project |
+| Multi-level import doesn't work | Missing `GetPathOfFileAbove` import in inner file | Add the `<Import>` element at the top of the inner file (see Multi-level section) |
+| Properties using SDK values are empty in `.props` | SDK properties aren't defined yet during `.props` evaluation | Move to `.targets` which is imported after the SDK |
+| `Directory.Packages.props` not found | File not at repo root or not named exactly | Must be named `Directory.Packages.props` and at or above the project directory |
+| Property condition on `$(TargetFramework)` doesn't match in `.props` | `TargetFramework` isn't set yet for single-targeting projects during `.props` evaluation | Move property to `.targets`, or use ItemGroup/Target conditions instead (which evaluate late) |
+
+**Diagnosis:** Use the preprocessed project output to see all imports and final property values:
+
+```bash
+dotnet msbuild -pp:output.xml MyProject.csproj
+```
+
+This expands all imports inline so you can see exactly where each property is set and what the final evaluated value is.

package/package/corpus/skills/directory-build-organization/references/common-patterns.md

@@ -0,0 +1,56 @@
+# Common Directory.Build Patterns
+
+## Conditional Settings by Project Type
+
+Detect test projects by naming convention in `Directory.Build.props`:
+
+```xml
+<PropertyGroup Condition="$(MSBuildProjectName.EndsWith('.Tests')) OR $(MSBuildProjectName.EndsWith('.UnitTests'))">
+  <IsPackable>false</IsPackable>
+  <IsTestProject>true</IsTestProject>
+</PropertyGroup>
+```
+
+Use `Directory.Build.targets` for conditions on SDK-defined properties like `OutputType`:
+
+```xml
+<PropertyGroup Condition="'$(OutputType)' == 'Exe'">
+  <SelfContained>false</SelfContained>
+</PropertyGroup>
+
+<PropertyGroup Condition="'$(OutputType)' == 'Library' AND '$(IsTestProject)' != 'true'">
+  <GenerateDocumentationFile>true</GenerateDocumentationFile>
+</PropertyGroup>
+```
+
+## Post-Build Validation
+
+Validate that `Pack` produced the expected output:
+
+```xml
+<Target Name="ValidatePackageOutput" AfterTargets="Pack"
+        Condition="'$(IsPackable)' == 'true'">
+  <Error Text="Package was not created at $(PackageOutputPath)$(PackageId).$(PackageVersion).nupkg"
+         Condition="!Exists('$(PackageOutputPath)$(PackageId).$(PackageVersion).nupkg')" />
+</Target>
+```
+
+## Artifact Output Layout (.NET 8+)
+
+Setting `ArtifactsPath` in `Directory.Build.props` produces this structure:
+
+```
+artifacts/
+  bin/
+    MyLib/
+      debug/
+      release/
+    MyApp/
+      debug/
+      release/
+  obj/
+    MyLib/
+    MyApp/
+  publish/
+    MyApp/
+```

package/package/corpus/skills/directory-build-organization/references/multi-level-examples.md

@@ -0,0 +1,167 @@
+# Multi-level Directory.Build Examples
+
+## Contents
+
+- Repo-level `Directory.Build.props`
+- `src/Directory.Build.props`
+- `test/Directory.Build.props`
+- Before/After: Centralizing Duplicated Settings
+
+Full file examples for a typical multi-level repo layout.
+
+## Repo-level `Directory.Build.props`
+
+```xml
+<Project>
+
+  <PropertyGroup>
+    <Nullable>enable</Nullable>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+  </PropertyGroup>
+
+</Project>
+```
+
+## `src/Directory.Build.props`
+
+```xml
+<Project>
+
+  <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.props', '$(MSBuildThisFileDirectory)../'))"
+         Condition="Exists('$([MSBuild]::GetPathOfFileAbove('Directory.Build.props', '$(MSBuildThisFileDirectory)../'))')" />
+
+  <PropertyGroup>
+    <IsPackable>true</IsPackable>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+  </PropertyGroup>
+
+</Project>
+```
+
+## `test/Directory.Build.props`
+
+```xml
+<Project>
+
+  <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.props', '$(MSBuildThisFileDirectory)../'))"
+         Condition="Exists('$([MSBuild]::GetPathOfFileAbove('Directory.Build.props', '$(MSBuildThisFileDirectory)../'))')" />
+
+  <PropertyGroup>
+    <IsPackable>false</IsPackable>
+    <NoWarn>$(NoWarn);CS1591</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="NSubstitute" />
+  </ItemGroup>
+
+</Project>
+```
+
+## Before/After: Centralizing Duplicated Settings
+
+**Before — duplicated settings in every .csproj:**
+
+```xml
+<!-- src/LibA/LibA.csproj -->
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <Company>Contoso</Company>
+    <Authors>Contoso Engineering</Authors>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.556" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+  </ItemGroup>
+
+</Project>
+
+<!-- src/LibB/LibB.csproj — same boilerplate repeated -->
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <Company>Contoso</Company>
+    <Authors>Contoso Engineering</Authors>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.556" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.0" />
+  </ItemGroup>
+
+</Project>
+```
+
+**After — centralized with Directory.Build files:**
+
+```xml
+<!-- Directory.Build.props -->
+<Project>
+
+  <PropertyGroup>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <Company>Contoso</Company>
+    <Authors>Contoso Engineering</Authors>
+  </PropertyGroup>
+
+</Project>
+
+<!-- Directory.Packages.props -->
+<Project>
+
+  <PropertyGroup>
+    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageVersion Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageVersion Include="Microsoft.Extensions.Logging" Version="8.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <GlobalPackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.556" />
+  </ItemGroup>
+
+</Project>
+
+<!-- src/LibA/LibA.csproj — clean and minimal -->
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Newtonsoft.Json" />
+  </ItemGroup>
+
+</Project>
+
+<!-- src/LibB/LibB.csproj — clean and minimal -->
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging" />
+  </ItemGroup>
+
+</Project>
+```

package/package/corpus/skills/directory-build-organization/references/targetframework-props-pitfall.md

@@ -0,0 +1,54 @@
+# AP-21: Property Conditioned on TargetFramework in .props Files
+
+**Smell**: `<PropertyGroup Condition="'$(TargetFramework)' == '...'">` or `<Property Condition="'$(TargetFramework)' == '...'">` in `Directory.Build.props` or any `.props` file imported before the project body.
+
+**Why it's bad**: `$(TargetFramework)` is NOT reliably available in `Directory.Build.props` or any `.props` file imported before the project body. It is only set that early for multi-targeting projects, which receive `TargetFramework` as a global property from the outer build. Single-targeting projects (using singular `<TargetFramework>`) set it in the project body, which is evaluated *after* `.props`. This means property conditions on `$(TargetFramework)` in `.props` files silently fail for single-targeting projects — the condition never matches because the property is empty. This applies to both `<PropertyGroup Condition="...">` and individual `<Property Condition="...">` elements.
+
+For a detailed explanation of MSBuild's evaluation and execution phases, see [Build process overview](https://learn.microsoft.com/en-us/visualstudio/msbuild/build-process-overview).
+
+```xml
+<!-- BAD: In Directory.Build.props — TargetFramework may be empty here -->
+<PropertyGroup Condition="'$(TargetFramework)' == 'net8.0'">
+  <DefineConstants>$(DefineConstants);MY_FEATURE</DefineConstants>
+</PropertyGroup>
+
+<!-- ALSO BAD: Condition on the property itself has the same problem -->
+<PropertyGroup>
+  <DefineConstants Condition="'$(TargetFramework)' == 'net8.0'">$(DefineConstants);MY_FEATURE</DefineConstants>
+</PropertyGroup>
+
+<!-- GOOD: In Directory.Build.targets — TargetFramework is always available -->
+<PropertyGroup Condition="'$(TargetFramework)' == 'net8.0'">
+  <DefineConstants>$(DefineConstants);MY_FEATURE</DefineConstants>
+</PropertyGroup>
+
+<!-- ALSO GOOD: In the project file itself -->
+<!-- MyProject.csproj -->
+<PropertyGroup Condition="'$(TargetFramework)' == 'net8.0'">
+  <DefineConstants>$(DefineConstants);MY_FEATURE</DefineConstants>
+</PropertyGroup>
+```
+
+**⚠️ Item and Target conditions are NOT affected.** This restriction applies ONLY to property conditions (`<PropertyGroup Condition="...">` and `<Property Condition="...">`). Item conditions (`<ItemGroup Condition="...">`) and Target conditions in `.props` files are SAFE because items and targets evaluate after all properties (including those set in the project body) have been evaluated. This includes `PackageVersion` items in `Directory.Packages.props`, `PackageReference` items in `Directory.Build.props`, and any other item types.
+
+**Do NOT flag the following patterns — they are correct:**
+
+```xml
+<!-- OK in Directory.Build.props — ItemGroup conditions evaluate late -->
+<ItemGroup Condition="'$(TargetFramework)' == 'net472'">
+  <PackageReference Include="System.Memory" />
+</ItemGroup>
+
+<!-- OK in Directory.Packages.props — PackageVersion items evaluate late -->
+<ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
+  <PackageVersion Include="Microsoft.AspNetCore.Mvc.Testing" Version="8.0.11" />
+</ItemGroup>
+<ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
+  <PackageVersion Include="Microsoft.AspNetCore.Mvc.Testing" Version="9.0.0" />
+</ItemGroup>
+
+<!-- OK — Individual item conditions also evaluate late -->
+<ItemGroup>
+  <PackageReference Include="System.Memory" Condition="'$(TargetFramework)' == 'net472'" />
+</ItemGroup>
+```

package/package/corpus/skills/dotnet-aot-compat/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/dotnet-aot-compat/NOTICE

@@ -0,0 +1,18 @@
+dotnet-aot-compat
+Copyright (c) .NET Foundation and Contributors
+Licensed under the MIT License. See LICENSE.
+
+Upstream source: https://github.com/dotnet/skills/blob/a6bf43ab61967c30919334986515163ab24d7635/plugins/dotnet-upgrade/skills/dotnet-aot-compat/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 with the skill-specific safety, ownership or compatibility caveat.
+- 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.
+- Remove the invalid [JsonSerializerContext] attribute from the source-generated JSON example; the context is a partial class deriving from JsonSerializerContext.
+
+NOTICE: Add this attribution, change list, and any download/execution disclosure.