@cratis/pi 7.102.0 → 7.103.0

package/package/corpus/skills/coverage-analysis/scripts/CoverageData.ps1

@@ -0,0 +1,272 @@
+# Shared, report-identity-scoped Cobertura normalization. This does not attest
+# that a report was collected from the current checkout.
+
+function New-CoverageMap {
+    return [System.Collections.Generic.Dictionary[string, object]]::new([StringComparer]::Ordinal)
+}
+
+function Add-CoverageDiagnostic($Diagnostics, [string]$Code, [string]$Message, [string]$Path) {
+    $Diagnostics.Add([pscustomobject]@{ code = $Code; severity = 'warning'; message = $Message; path = $Path })
+}
+
+function Read-CoverageInteger([string]$Text, [string]$Name, [long]$Minimum = 0) {
+    $value = 0L
+    if (-not [long]::TryParse($Text, [Globalization.NumberStyles]::Integer,
+            [Globalization.CultureInfo]::InvariantCulture, [ref]$value) -or $value -lt $Minimum) {
+        throw [FormatException]::new("Invalid $Name value '$Text'.")
+    }
+    return $value
+}
+
+function Add-CoverageLine($Map, $Node, [string]$Key, [string]$ReportId) {
+    $number = Read-CoverageInteger $Node.GetAttribute('number') 'line number' 1
+    $hits = Read-CoverageInteger $Node.GetAttribute('hits') 'line hits'
+    $lineKey = "$Key`n$number"
+    if (-not $Map.ContainsKey($lineKey)) {
+        $Map[$lineKey] = @{
+            Covered = $false
+            NonBranch = $false
+            ConflictingBranches = $false
+            Branches = [System.Collections.Generic.List[object]]::new()
+            Observations = [System.Collections.Generic.HashSet[string]]::new([StringComparer]::Ordinal)
+        }
+    }
+    $entry = $Map[$lineKey]
+    $entry.Covered = $entry.Covered -or $hits -gt 0
+    if (-not $entry.Observations.Add($ReportId)) { return }
+    $branch = $Node.GetAttribute('branch')
+    if ($branch -and $branch -notin @('true', 'false')) {
+        throw [FormatException]::new("Invalid branch flag '$branch'.")
+    }
+    if ($branch -ne 'true') {
+        $entry.NonBranch = $true
+        if ($entry.Branches.Count) { $entry.ConflictingBranches = $true }
+        return
+    }
+    if ($entry.NonBranch) { $entry.ConflictingBranches = $true }
+    $raw = $Node.GetAttribute('condition-coverage')
+    if ($raw -notmatch '^\s*[\d.]+%\s*\((\d+)/(\d+)\)\s*$') {
+        $entry.Branches.Add(@{ Total = $null; Covered = $null; Conditions = $null })
+        return
+    }
+    $covered = Read-CoverageInteger $Matches[1] 'covered branches'
+    $total = Read-CoverageInteger $Matches[2] 'total branches' 1
+    if ($covered -gt $total) { throw [FormatException]::new('Covered branches exceed total branches.') }
+
+    # Cobertura jump conditions describe two outcomes, not which outcome a
+    # 50% observation took. Keep that ambiguity even when condition ids match.
+    $conditions = New-CoverageMap
+    $nodes = @($Node.SelectNodes('conditions/condition'))
+    $conditionSum = 0
+    $usable = $nodes.Count -gt 0 -and $total -eq 2 * $nodes.Count
+    foreach ($condition in $nodes) {
+        $id = $condition.GetAttribute('number')
+        $coverage = $condition.GetAttribute('coverage')
+        if ($condition.GetAttribute('type') -ne 'jump' -or -not $id -or
+            $conditions.ContainsKey($id) -or $coverage -notmatch '^(0|50|100)(?:\.0+)?%$') {
+            $usable = $false
+            continue
+        }
+        $count = [int]$Matches[1] / 50
+        $conditions[$id] = $count
+        $conditionSum += $count
+    }
+    if (-not $usable -or $conditionSum -ne $covered) { $conditions = $null }
+    $entry.Branches.Add(@{ Total = $total; Covered = $covered; Conditions = $conditions })
+}
+
+function Get-CoverageMeasure($Lines) {
+    $coveredLines = @($Lines.Values | Where-Object Covered).Count
+    $linePercent = if ($Lines.Count) { [math]::Round(100.0 * $coveredLines / $Lines.Count, 1) } else { $null }
+    $lower = 0L
+    $upper = 0L
+    $total = 0L
+    $unknown = $Lines.Count -eq 0
+    foreach ($line in $Lines.Values) {
+        $observations = @($line.Branches)
+        if (-not $observations.Count) { continue }
+        if ($line.ConflictingBranches -or @($observations | Where-Object { $null -eq $_.Total }).Count) {
+            $unknown = $true
+            continue
+        }
+        $totals = @($observations | ForEach-Object { $_.Total } | Sort-Object -Unique)
+        if ($totals.Count -ne 1 -or $null -eq $totals[0]) { $unknown = $true; continue }
+        $capacity = $totals[0]
+        $total += $capacity
+        $useConditions = $true
+        $conditionIds = $null
+        foreach ($observation in $observations) {
+            if ($null -eq $observation.Conditions) { $useConditions = $false; break }
+            $ids = @($observation.Conditions.Keys | Sort-Object -CaseSensitive)
+            $identity = ConvertTo-Json -InputObject $ids -Compress
+            if ($null -ne $conditionIds -and $conditionIds -cne $identity) { $useConditions = $false; break }
+            $conditionIds = $identity
+        }
+        if ($useConditions) {
+            foreach ($id in $observations[0].Conditions.Keys) {
+                $counts = @($observations | ForEach-Object { $_.Conditions[$id] })
+                $lower += ($counts | Measure-Object -Maximum).Maximum
+                $upper += [math]::Min(2, ($counts | Measure-Object -Sum).Sum)
+            }
+        } else {
+            $counts = @($observations | ForEach-Object { $_.Covered })
+            $lower += ($counts | Measure-Object -Maximum).Maximum
+            $upper += [math]::Min($capacity, ($counts | Measure-Object -Sum).Sum)
+        }
+    }
+    $branchStatus = if ($unknown) { 'unknown' } elseif (-not $total) { 'not-applicable' } elseif ($lower -eq $upper) { 'exact' } else { 'bounded' }
+    return [pscustomobject]@{
+        TotalLines = $Lines.Count
+        CoveredLines = $coveredLines
+        LineCoverage = $linePercent
+        LineCoverageStatus = $(if ($Lines.Count) { 'exact' } else { 'unknown' })
+        TotalBranches = $(if ($unknown) { $null } else { $total })
+        CoveredBranches = $(if ($branchStatus -in @('exact', 'not-applicable')) { [long]$lower } else { $null })
+        BranchCoverage = $(if ($branchStatus -eq 'exact') { [math]::Round(100.0 * $lower / $total, 1) } else { $null })
+        BranchCoverageStatus = $branchStatus
+        CoveredBranchesLower = $(if (-not $unknown) { [long]$lower } else { $null })
+        CoveredBranchesUpper = $(if (-not $unknown) { [long]$upper } else { $null })
+        BranchCoverageLower = $(if (-not $unknown -and $total) { [math]::Round(100.0 * $lower / $total, 1) } else { $null })
+        BranchCoverageUpper = $(if (-not $unknown -and $total) { [math]::Round(100.0 * $upper / $total, 1) } else { $null })
+    }
+}
+
+function Get-CoverageData([string[]]$Paths) {
+    if (-not $Paths.Count) { throw [ArgumentException]::new('At least one Cobertura report is required.') }
+    $methods = New-CoverageMap
+    $classLines = New-CoverageMap
+    $methodLines = New-CoverageMap
+    $inputs = [System.Collections.Generic.List[object]]::new()
+    $reports = [System.Collections.Generic.List[object]]::new()
+    $diagnostics = [System.Collections.Generic.List[object]]::new()
+    $seen = [System.Collections.Generic.HashSet[string]]::new([StringComparer]::Ordinal)
+    $allClassesHaveLines = $true
+    foreach ($path in ($Paths | Sort-Object -Unique -CaseSensitive)) {
+        $resolved = (Get-Item -LiteralPath $path -ErrorAction Stop).FullName
+        $bytes = [IO.File]::ReadAllBytes($resolved)
+        $hash = [Convert]::ToHexString([Security.Cryptography.SHA256]::HashData($bytes)).ToLowerInvariant()
+        $inputs.Add([pscustomobject]@{ path = $resolved; sha256 = $hash })
+        if (-not $seen.Add($hash)) { continue }
+        $xml = [xml]::new()
+        $xml.XmlResolver = $null
+        $stream = [IO.MemoryStream]::new($bytes, $false)
+        try { $xml.Load($stream) } finally { $stream.Dispose() }
+        if ($xml.DocumentElement.Name -ne 'coverage') { throw [FormatException]::new("Not a Cobertura report: $path") }
+        $coverageRoot = $xml.DocumentElement
+        $report = @{ line = $null; branch = $null }
+        foreach ($metric in @('line', 'branch')) {
+            $prefix = if ($metric -eq 'line') { 'lines' } else { 'branches' }
+            $valid = $coverageRoot.GetAttribute("$prefix-valid")
+            $covered = $coverageRoot.GetAttribute("$prefix-covered")
+            if ($valid -or $covered) {
+                $denominator = Read-CoverageInteger $valid "$prefix-valid"
+                $numerator = Read-CoverageInteger $covered "$prefix-covered"
+                if ($numerator -gt $denominator) { throw [FormatException]::new("$prefix-covered exceeds $prefix-valid.") }
+                $report[$metric] = @{ Total = $denominator; Covered = $numerator }
+            }
+        }
+        $reports.Add($report)
+        $reportMethods = [System.Collections.Generic.HashSet[string]]::new([StringComparer]::Ordinal)
+        foreach ($class in $xml.SelectNodes('/coverage/packages/package/classes/class')) {
+            $filename = $class.GetAttribute('filename').Replace('\', '/')
+            $className = $class.GetAttribute('name')
+            $module = $class.ParentNode.ParentNode.GetAttribute('name')
+            if (-not $filename -or -not $className) { throw [FormatException]::new('Class name and filename are required.') }
+            $sourceKey = ConvertTo-Json -InputObject @($module, $filename) -Compress
+            $classNodes = @($class.SelectNodes('lines/line'))
+            if (-not $classNodes.Count) { $allClassesHaveLines = $false }
+            foreach ($line in $classNodes) { Add-CoverageLine $classLines $line $sourceKey $hash }
+            foreach ($method in $class.SelectNodes('methods/method')) {
+                $name = $method.GetAttribute('name')
+                if (-not $name) { throw [FormatException]::new('Method name is required.') }
+                $signature = $method.GetAttribute('signature')
+                $key = ConvertTo-Json -InputObject @($module, $filename, $className, $name, $signature) -Compress
+                if (-not $reportMethods.Add($key)) {
+                    throw [FormatException]::new("Duplicate method identity for $className.$name; signatures or source mapping are ambiguous.")
+                }
+                if (-not $methods.ContainsKey($key)) {
+                    $methods[$key] = @{
+                        Module = $module; Class = $className; Method = $name; Signature = $signature; File = $filename
+                        Lines = (New-CoverageMap)
+                        Complexities = [System.Collections.Generic.HashSet[long]]::new()
+                    }
+                }
+                $entry = $methods[$key]
+                $complexity = $method.GetAttribute('complexity')
+                if ($complexity) { [void]$entry.Complexities.Add((Read-CoverageInteger $complexity 'complexity' 1)) }
+                foreach ($line in $method.SelectNodes('lines/line')) {
+                    Add-CoverageLine $entry.Lines $line '' $hash
+                    Add-CoverageLine $methodLines $line $sourceKey $hash
+                }
+            }
+        }
+    }
+    $result = [System.Collections.Generic.List[object]]::new()
+    foreach ($entry in $methods.Values) {
+        $measure = Get-CoverageMeasure $entry.Lines
+        $complexity = if ($entry.Complexities.Count -eq 1) { @($entry.Complexities)[0] } else { $null }
+        $item = [ordered]@{
+            Class = $entry.Class; Method = $entry.Method; Signature = $entry.Signature; File = $entry.File
+            Module = $entry.Module; Complexity = $complexity
+            ComplexityStatus = $(if ($null -ne $complexity) { 'exact' } else { 'unknown' })
+        }
+        foreach ($property in $measure.PSObject.Properties) { $item[$property.Name] = $property.Value }
+        $item.UncoveredLines = $measure.TotalLines - $measure.CoveredLines
+        if ($null -eq $complexity) {
+            Add-CoverageDiagnostic $diagnostics 'COMPLEXITY_UNKNOWN' "Missing or conflicting complexity for $($entry.Class).$($entry.Method)." $entry.File
+        }
+        if ($measure.LineCoverageStatus -eq 'unknown') {
+            Add-CoverageDiagnostic $diagnostics 'METHOD_LINES_UNKNOWN' "No executable-line evidence for $($entry.Class).$($entry.Method)." $entry.File
+        }
+        if ($measure.BranchCoverageStatus -in @('unknown', 'bounded')) {
+            Add-CoverageDiagnostic $diagnostics 'BRANCH_UNION_UNCERTAIN' "Branch outcomes cannot be uniquely merged for $($entry.Class).$($entry.Method)." $entry.File
+        }
+        $result.Add([pscustomobject]$item)
+    }
+    $aggregate = Get-CoverageMeasure $classLines
+    $aggregateScope = 'class-lines'
+    if (-not $allClassesHaveLines -or -not $classLines.Count) {
+        $aggregateScope = if ($reports.Count -eq 1) { 'report' } else { 'method-lines-only' }
+        $aggregate = [pscustomobject]@{ LineCoverage = $null; LineCoverageStatus = 'unknown'; BranchCoverage = $null; BranchCoverageStatus = 'unknown' }
+        if ($reports.Count -eq 1) {
+            foreach ($metric in @('line', 'branch')) {
+                $counter = $reports[0][$metric]
+                $name = if ($metric -eq 'line') { 'LineCoverage' } else { 'BranchCoverage' }
+                if ($null -ne $counter) {
+                    $aggregate.$name = if ($counter.Total) { [math]::Round(100.0 * $counter.Covered / $counter.Total, 1) } else { $null }
+                    $aggregate."${name}Status" = if ($counter.Total) { 'exact' } else { 'not-applicable' }
+                }
+            }
+        }
+    }
+    if (-not $result.Count) {
+        Add-CoverageDiagnostic $diagnostics 'METHODS_UNAVAILABLE' 'The report has no method-level coverage evidence.' ''
+    }
+    return [pscustomobject]@{
+        Methods = @($result | Sort-Object -CaseSensitive Module, File, Class, Method, Signature)
+        Inputs = @($inputs)
+        Diagnostics = $diagnostics
+        Summary = [ordered]@{
+            overall_line_coverage = $aggregate.LineCoverage
+            overall_line_coverage_status = $aggregate.LineCoverageStatus
+            overall_branch_coverage = $aggregate.BranchCoverage
+            overall_branch_coverage_status = $aggregate.BranchCoverageStatus
+            coverage_scope = $aggregateScope
+            method_line_coverage = (Get-CoverageMeasure $methodLines).LineCoverage
+            total_methods = $result.Count
+        }
+    }
+}
+
+function Write-CoverageJson([string]$Tool, [string]$Status, $Scope, $Inputs, $Diagnostics, $Data) {
+    [ordered]@{
+        schema_version = '1'; tool = $Tool; tool_version = '1.0'; status = $Status
+        scope = $Scope; inputs = @($Inputs); diagnostics = @($Diagnostics); data = $Data
+    } | ConvertTo-Json -Depth 30
+}
+
+function Write-CoverageDiagnostics($Diagnostics) {
+    foreach ($diagnostic in $Diagnostics) {
+        [Console]::Error.WriteLine("$($diagnostic.code): $($diagnostic.message)")
+    }
+}

package/package/corpus/skills/coverage-analysis/scripts/Extract-MethodCoverage.ps1

@@ -0,0 +1,65 @@
+<#
+.SYNOPSIS
+Extract Cobertura method coverage without inventing missing measurements.
+.DESCRIPTION
+Legacy output is a JSON array; diagnostics and summaries go to stderr.
+Use -OutputFormat json-v1 for provenance, null/unknown metrics and branch bounds.
+Merging is scoped to reported module/file/class/signature identities, not an
+attestation of source revision. Duplicate report bytes are idempotent.
+Exit codes: 0 complete, 2 invalid input, 3 incomplete/unrepresentable evidence.
+#>
+param(
+    [Parameter(Mandatory=$true)][string[]]$CoberturaPath,
+    [ValidateRange(0,100)][int]$CoverageThreshold = 80,
+    [ValidateRange(0,100)][int]$BranchThreshold = 70,
+    [ValidateSet('uncovered', 'below-threshold', 'all')][string]$Filter = 'all',
+    [ValidateSet('legacy', 'json-v1')][string]$OutputFormat = 'legacy'
+)
+
+try {
+    . "$PSScriptRoot\CoverageData.ps1"
+} catch {
+    $diagnostic = @{ code = 'DEPENDENCY_UNAVAILABLE'; severity = 'error'; message = $_.Exception.Message; path = "$PSScriptRoot\CoverageData.ps1" }
+    [Console]::Error.WriteLine("$($diagnostic.code): $($diagnostic.message)")
+    if ($OutputFormat -eq 'json-v1') {
+        @{
+            schema_version = '1'; tool = 'Extract-MethodCoverage'; tool_version = '1.0'; status = 'error'
+            scope = @{}; inputs = @(); diagnostics = @($diagnostic); data = @{}
+        } | ConvertTo-Json -Depth 5
+    }
+    exit 2
+}
+$scope = @{ identity = 'reported-module-file-class-signature'; source_revision = $null; filter = $Filter }
+try {
+    $coverage = Get-CoverageData $CoberturaPath
+} catch {
+    $diagnostics = @([pscustomobject]@{ code = 'INVALID_INPUT'; severity = 'error'; message = $_.Exception.Message })
+    Write-CoverageDiagnostics $diagnostics
+    if ($OutputFormat -eq 'json-v1') { Write-CoverageJson 'Extract-MethodCoverage' 'error' $scope @() $diagnostics @{} }
+    exit 2
+}
+$partial = -not $coverage.Methods.Count -or @($coverage.Methods | Where-Object {
+    $_.LineCoverageStatus -eq 'unknown' -or $_.BranchCoverageStatus -in @('unknown', 'bounded') -or $_.ComplexityStatus -eq 'unknown'
+}).Count -gt 0
+$methods = @($coverage.Methods | Where-Object {
+    if ($Filter -eq 'all') { return $true }
+    if ($_.LineCoverageStatus -eq 'unknown' -or $_.BranchCoverageStatus -in @('unknown', 'bounded')) { return $true }
+    if ($Filter -eq 'uncovered') { return $_.LineCoverage -eq 0 }
+    return (100.0 * $_.CoveredLines / $_.TotalLines) -lt $CoverageThreshold -or
+        ($_.TotalBranches -gt 0 -and (100.0 * $_.CoveredBranches / $_.TotalBranches) -lt $BranchThreshold)
+} | Sort-Object -Property @{Expression='UncoveredLines';Descending=$true}, @{Expression='LineCoverage';Descending=$false}, Class, Method, File, Signature)
+Write-CoverageDiagnostics $coverage.Diagnostics
+if ($OutputFormat -eq 'json-v1') {
+    Write-CoverageJson 'Extract-MethodCoverage' $(if ($partial) { 'partial' } else { 'complete' }) $scope $coverage.Inputs $coverage.Diagnostics @{
+        methods = $methods; summary = $coverage.Summary
+    }
+} elseif (-not $partial) {
+    $legacy = @($methods | Select-Object Class, Method, Signature, File, Complexity, LineCoverage,
+        @{Name='BranchCoverage';Expression={if ($_.BranchCoverageStatus -eq 'not-applicable') { 0 } else { $_.BranchCoverage }}},
+        CoveredLines, TotalLines, UncoveredLines, CoveredBranches, TotalBranches)
+    ConvertTo-Json -InputObject $legacy -Depth 5
+    [Console]::Error.WriteLine("METHODS_FILTERED:$($methods.Count)")
+    [Console]::Error.WriteLine("UNCOVERED_METHODS:$(@($methods | Where-Object { $_.LineCoverageStatus -eq 'exact' -and $_.LineCoverage -eq 0 }).Count)")
+}
+if ($partial) { exit 3 }
+exit 0

package/package/corpus/skills/csharp-refactoring/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/csharp-refactoring/NOTICE

@@ -0,0 +1,22 @@
+C# Refactoring (behavior-preserving)
+Copyright (c) .NET Foundation and Contributors
+Licensed under the MIT License. See LICENSE.
+
+Upstream source: https://github.com/dotnet/skills/blob/a6bf43ab61967c30919334986515163ab24d7635/plugins/dotnet/skills/csharp-refactoring/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.
+- Add the requested Cratis persisted-event, proxy, Orleans identity and framework-public-API contract section.
+- 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 references to the dotnet-upgrade skill; point to the repository's own upgrade workflow.
+
+references/operation-catalog.md:
+- Replace the upstream issue reference with a plain statement of the behavior.
+
+NOTICE: Add this attribution, change list, and any download/execution disclosure.

package/package/corpus/skills/csharp-refactoring/SKILL.md

@@ -0,0 +1,175 @@
+---
+name: csharp-refactoring
+description: 'Safely refactors C#/.NET code without changing behavior: rename, move, extract, inline, merge, consolidate, deduplicate, split, or modernize, including partial or generated declarations, public APIs, serialization and reflection names, friend assemblies, conditional compilation, and multi-targeted projects. Use when a request asks for a refactor, or calls a feature, bug fix, upgrade, or public nullability change a refactor and the behavior-changing part must be separated or declined. Not for ordinary feature or bug fixes, standalone framework or package upgrades, adding tests, or formatting-only work.'
+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/skills/csharp-refactoring/SKILL.md; see NOTICE) -->
+
+# C# Refactoring (behavior-preserving)
+
+Cratis rules in `.cratis/ai/rules/` (including `csharp.md`, `specs.csharp.md`, and `orleans.md`) and the `cratis-*` skills win where they differ.
+
+A refactor changes **structure**, never observable **behavior**. Do the edit with binding-aware tools,
+then confirm behavior held with a build + the relevant tests. Keep the effort proportional to the change:
+a one-line local rename does not need the ceremony a public multi-targeted change does.
+
+## Mandatory gate: classify before validation or editing
+
+Read only enough repository context to classify **each requested operation**. Do this before restoring,
+building, or making an edit. Classification precedence is:
+
+- If the request explicitly asks for at least one separable behavior-preserving operation, complete
+  that structural work and defer only the behavior-changing or contract-changing operations. Do not
+  invent or infer structural work to avoid the stop response.
+- If the structural and behavior-changing parts cannot be separated, use the whole-request stop
+  response and state why they are inseparable.
+- Otherwise, use the whole-request stop response only when **every** requested operation is outside
+  behavior-preserving refactoring.
+
+For a whole request that is outside behavior-preserving refactoring:
+
+1. State: `Not a behavior-preserving refactor: <specific reason>.`
+2. State: `No files changed.`
+3. State: `Next workflow: <workflow>.` Then stop. Do not add manual implementation steps, alternatives,
+   an offer to proceed without the workflow, or a follow-up question — even when that workflow is unavailable.
+
+| Requested as a "refactor" | Classification and action |
+|---|---|
+| Framework or NuGet version change | **Upgrade.** Do not edit or validate the upgrade here; hand off to the repository's upgrade workflow. |
+| New capability, flag, endpoint, tier, or behavior | **Feature.** Do not implement it here; hand off to the repository's feature workflow. |
+| Threshold, rate, output, or bug-result change | **Behavior change.** Defer it and hand off to the repository's bug-fix or behavior-change workflow; still complete any clearly separable structural operation. |
+| Tighten or loosen a shipped/public nullable annotation | **Source-contract change.** Leave the declaration and API record unchanged; hand off to the repository's API-contract workflow. |
+
+For a mixed request, never stop after classification. Perform the separable structural operation,
+explicitly defer the behavior/contract change, and never state `No files changed.` after completing
+structural work. Never modify tests to make an unauthorized behavior change appear preserved.
+
+## Work only in the current workspace
+
+Use the current agent workspace as the boundary. If it is a Git checkout, resolve its repository root
+(`git rev-parse --show-toplevel`) and stay inside it. If Git metadata is absent, treat the current working
+directory and its subdirectories as the boundary, and use a solution or project named in the request
+inside it; Git is not a prerequisite for a refactor. Resolve prompt-provided relative paths inside that
+boundary.
+
+Search and edit only that workspace. Never use filesystem-wide search or select a similarly named clone,
+another worktree, build output, or unrelated temporary directory because a file also exists there. If a
+named path is absent, stop and report the mismatch instead of guessing another workspace. If a tool rejects
+an in-workspace path for a mechanical reason such as path form or unsupported tool root, retry through
+another in-workspace mechanism. If the rejection is a permission or policy denial, report it instead of
+working around it. Never search outside the boundary.
+
+## Rename / move by bindings, not text
+
+The #1 way a "rename" silently corrupts code is editing textual matches (comments, strings, unrelated
+overloads) instead of real **bindings**. Find every binding reference first, then edit semantically. Use
+the strongest tool available: an IDE/Roslyn workspace refactoring, then the C# LSP the
+[`dotnet` plugin declares](https://github.com/dotnet/skills/blob/main/plugins/dotnet/lsp.json)
+(`findReferences`, `goToDefinition`, `incomingCalls`, `rename` code action), then analyzer code-fixes /
+Roslynator, then compiler-validated edits (edit the true bindings, rebuild, let the compiler flag misses).
+Plain find/replace only when scope is provably tiny and every hit is verified. Include **every** `partial`
+declaration, and edit the generator input, never generated (`*.g.cs`) output.
+
+For the operation → Roslyn-provider mapping and representative PRs, see
+[references/operation-catalog.md](references/operation-catalog.md).
+
+## Consolidate toward the existing source of truth
+
+When de-duplicating, preserve the ownership direction stated by the code or request. If `B` duplicates
+an implementation already owned by `A`, keep `A` canonical and make `B` delegate to it; do not invert
+the dependency merely because either direction compiles. Preserve public compatibility wrappers when
+the duplicate surface is shipped, and migrate only in-repo callers that are safe to move.
+
+## Decisions that change the edit
+
+Use the first matching row instead of applying the requested operation mechanically:
+
+| Situation | Do | Never |
+|---|---|---|
+| Inline an internal, unshipped pass-through wrapper | Migrate every binding reference to the target, remove the wrapper, then compile to catch misses. | Keep dead indirection "for compatibility" when no compatibility boundary exists. |
+| Inline or remove a shipped/public wrapper | Migrate ordinary in-repo callers, but retain an `[Obsolete]` forwarding entry point unless the request explicitly authorizes a breaking change. | Delete a shipped API merely because all current source callers were migrated. |
+| Rename a member reached by a string, reflection, DI, or configuration | Rename binding-based callers; preserve the observed external name with a forwarding shim or metadata, and exercise the old-name path. | Rewrite an external/configured name just to make the new source name consistent. |
+| Extract duplicated logic whose callers pass different values | Extract the algorithm and pass each caller's existing inputs through unchanged. | Collapse distinct inputs, evaluation order, rounding, or side effects into one caller's version. |
+| Rename code compiled under `#if` or multiple TFMs | Update every source branch and validate each target framework explicitly. | Treat a green default-target build as evidence for unbuilt branches. |
+| Merge near-identical types | Parameterize only the values that differ, migrate every construction site, and preserve each old value exactly. If the old types are internal/unshipped and the request says to merge into one type, delete their declarations. | Retain unnecessary aliases, static holders, factories, or wrapper types that leave the requested merge incomplete; introduce a new hierarchy or behavior. |
+
+## Preserve contracts beyond C# call sites
+
+Compilation proves binding compatibility, not every external contract. Before renaming or moving a
+type/member, check whether its name or metadata is observed by serialization, reflection, dependency
+injection, configuration binding, source generators, P/Invoke, or `dynamic`.
+
+| Boundary | Required decision |
+|---|---|
+| Serialized/configuration name | Preserve the external name with the repository's existing mechanism (for example, `JsonPropertyName`) while migrating C# callers; run a focused round-trip or payload test. |
+| Public nullable annotation | The mandatory classification gate applies: leave it unchanged and hand off as a source-contract change. |
+| Uncovered reflection or runtime lookup | Do not guess that a compile-clean rename is safe. Preserve the observed name or stop and report the unverified runtime boundary. |
+
+## Verify proportionally
+
+Confirm behavior is preserved after the edit — scaled to blast radius, not a fixed ceremony:
+
+- **Local / private** (method-local or `private` member, one file, single target framework, no public
+  surface, no `partial`/generated/`#if`): skip a separate baseline unless the tree is already suspect.
+  Make the edit, then run the narrowest build and relevant tests once. Let the compiler catch missed
+  references.
+- **Cross-boundary** (public/shipped symbol, multi-targeted project, `#if`/platform branches, or
+  `partial`/generated code): establish a baseline, then run an explicit build and the relevant tests for
+  **each** target framework after the edit (a test command's implicit build is not separate build evidence;
+  a green default build can hide a break on another TFM), and run the hazards check below.
+
+Use the repo's own build/test workflow when it documents one (`README`/`CONTRIBUTING`, `build.*`, `eng/`,
+`global.json`, `.github/workflows`); its instructions win over any generic command.
+
+### Typical workflow (one operation)
+1. Choose one named refactoring operation and keep the step focused on that operation only.
+2. Find true binding references (`findReferences`/`goToDefinition`/rename) and include all `partial` declarations.
+3. Establish a baseline first only for a cross-boundary change or a tree not already known green.
+4. Apply the change via the most semantics-aware tool available; avoid blind find/replace when possible.
+5. Rebuild and run the relevant tests. If the gate goes red, report the failure and repair or reassess only
+  your edit; never discard unrelated worktree changes.
+
+Otherwise:
+```bash
+dotnet build   # 0 errors
+dotnet test    # stays green; same pass count as before
+```
+
+One operation per step; never mix a refactor and a behavior change in the same step. On red, stop and report the failure; repair only your edit without discarding unrelated worktree changes.
+
+## Final response contract
+
+Keep the handoff concise and evidence-based:
+
+- **Refactor:** name the structural operation and the symbols/files changed.
+- **Preserved:** name the behavior or compatibility boundary and the mechanism that preserved it.
+- **Validation:** report the exact commands and observed result; never claim success after a failed restore,
+  build, target framework, or test run.
+- **Deferred:** for a mixed request, name the behavior/contract change intentionally left undone and its
+  correct next workflow. Omit this line when nothing was deferred.
+
+## Cross-boundary hazards (only when it touches a boundary)
+
+If — and only if — the change touches a **public** symbol, a **multi-targeted** project, or
+`partial`/generated code, some breaks won't show up as a failing test. Search the repo for the surface
+that governs the symbol (don't assume): the public-API gate (`PublicAPI.Shipped/Unshipped.txt` for
+PublicApiAnalyzers, and/or `ApiCompat`/`<EnablePackageValidation>` — not interchangeable),
+`<TargetFrameworks>`/`#if` branches, and `InternalsVisibleTo`. Moving a public type to another assembly
+needs `[TypeForwardedTo]` in the original assembly; a move within one assembly does not. A public
+*rename* needs an `[Obsolete]` shim, not a forwarder. For a provably local/private change, skip these
+checks.
+
+## Stop an in-scope refactor when
+
+- The baseline is already red (you can't prove you preserved behavior).
+- The requested structural change would alter a public/shipped API and no compatibility shim or forwarder
+  can preserve it. Report the boundary. Use the gate's handoff format when no structural work was completed;
+  after separable work, put the incompatible operation on the `Deferred:` line instead. Do not ask to make
+  the breaking change.
+- Equivalence depends on runtime behavior tests don't cover (reflection, DI, serialization, `dynamic`,
+  P/Invoke) — report the unverified boundary instead of claiming behavior was preserved.
+
+## Contracts the compiler cannot see in Cratis code
+
+Preserve `[EventType]` identifiers and type names of persisted events, generated TypeScript proxies of Arc commands/queries, `[Alias]`/serializer ids in Orleans, and public API of framework packages (semver).

package/package/corpus/skills/csharp-refactoring/references/operation-catalog.md

@@ -0,0 +1,37 @@
+# C# refactoring operation catalog (detail)
+
+Load this when you need the full operation taxonomy or the Roslyn provider each maps to.
+The core SKILL.md keeps only the short operation list; this file is the depth.
+
+## Contents
+
+- Operation catalog (provider, recurrence, representative PR)
+- "Modernize" is defined by the repo's analyzer config
+
+## Operation catalog
+
+Canonical operations, aligned with Roslyn's own IDE refactoring providers
+(`src/Features/CSharp/Portable/CodeRefactorings`). The provider column is informational — a
+headless CLI agent usually cannot invoke these IDE code actions directly, so apply them via the fallback
+ladder in SKILL.md.
+
+| Operation | Roslyn provider / tool | Recurrence | Representative real PR |
+|-----------|------------------------|-----------:|------------------------|
+| **Rename** symbol / type / file | rename engine (`Renamer`) | high | _runtime_ "Rename `DISABLE_CROSSGEN`"; _sdk_ "Rename `dnup` to `dotnetup`" |
+| **Move** type / member / file | `MoveType`, `MoveStaticMembers` | high | _runtime_ "Move DSA tests into System.Security.Cryptography"; _sdk_ "Move SDK task unit test projects from src/ to test/" |
+| **Consolidate / de-duplicate** | analyzer-assisted | high | _runtime_ "Consolidate ComWrappers implementation across platforms" |
+| **Modernize / simplify** idioms | `UseExplicitOrImplicitType`, `UseRecursivePatterns`, `ConvertLocalFunctionToMethod`, `AddAwait` | high | _roslyn_ "Simplify lots of redundant code in code fix providers" |
+| **Split** large class / file / assembly | extract + move | medium | _roslyn_ "Split `FeatureSwitchManager`"; _runtime_ "Move RPC contracts to a separate assembly" |
+| **Extract** method / class / interface | `ExtractClass`, extract-method, extract-interface | medium | _runtime_ "Extract `ManifestBuilder` and `EventListener`" |
+| **Inline** method / local / constant | `InlineMethod`, `InlineTemporary` | lower | _runtime_ "Refactor `UInt128` division" |
+| **Pull up / push down** member | `PullMemberUp` | tail | move members between a type and its base/interface |
+| **Sync namespace** to folder | `SyncNamespace` | tail | align `namespace` with folder layout after a move |
+
+## "Modernize" is defined by the repo's analyzer config, not personal taste
+
+These repos drive idiom rules through `.editorconfig` + `EnforceOnBuild` (which enforces
+code-style analyzers during build). Apply the fixes the repo's own analyzers request
+(IDE00xx / CAxxxx) via `dotnet format` / code-fixes; don't impose a style it hasn't opted into, and don't
+blanket-suppress diagnostics to make an edit "pass." For _adopting_ nullable annotations specifically, see
+the repository's nullable migration workflow; enabling nullable across a project or changing public API
+annotations is a migration or contract change, not a canonical behavior-preserving refactoring operation.

package/package/corpus/skills/directory-build-organization/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/directory-build-organization/NOTICE

@@ -0,0 +1,21 @@
+Organizing Build Infrastructure with Directory.Build Files
+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/directory-build-organization/SKILL.md
+
+Changes made by Cratis:
+
+LICENSE:
+- Copy upstream MIT license and copyright verbatim.
+
+SKILL.md:
+- Lead the description trigger with an explicit "Use when" clause.
+- Normalize frontmatter serialization, add MIT license where absent; preserve name and description.
+- Add marked modification/source comment and applicability/Cratis precedence line.
+- 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.
+
+references/multi-level-examples.md:
+- Add or normalize the top Contents list from existing headings; preserve section content.
+
+NOTICE: Add this attribution, change list, and any download/execution disclosure.