@danmoisan/drm-copilot-mcp 1.1.22 → 1.1.24

package/resources/claude-customizations/.claude/lib/blast-radius/BlastRadiusCombination.psm1

@@ -0,0 +1,228 @@
+<#
+.SYNOPSIS
+    Planning-time issue combination over the scheduling pair data (issue #1013).
+
+.DESCRIPTION
+    Destination-runtime PowerShell mirror of
+    scripts/dev_tools/_blast_radius_combination.py (spec D-5). Finds the pairs
+    of work items whose integration cost is high enough that delivering them as
+    one item costs less than merging them, and groups them into combinations.
+
+    Rules:
+      1. Disabled when conflict_tolerance is absent or tolerance_percent is 0.
+      2. Get-BlastRadiusPairDecision supplies each conflicting pair's reasons,
+         cost (including the D-7 contract term), and benefit; edges and
+         tolerated pairs are both evaluated.
+      3. A pair is a candidate when its full reasons contain
+         contract_dependency or it has a same-file overlap: an overlapping entry
+         pair, after the mergeable exclusion, of two equal concrete entries that
+         do not match append_only_paths.
+      4. A candidate qualifies when
+         cost * 100 >= benefit * combination_threshold_percent.
+      5. Qualifying pairs are grouped into connected components (union-find);
+         each becomes one combination with ascending members, primary equal to
+         the smallest member, pairs sorted by (a, b), and estimated_savings equal
+         to the sum of its pair costs.
+
+    Parity notes for maintainers:
+      - The Python module is the reference implementation; the committed
+        combination fixtures bind the two runtimes together.
+      - Every function is pure: no filesystem, subprocess, network, or clock
+        access, and no input is mutated.
+    CONVENTION: this module fails fast at module scope and imports its siblings with -ErrorAction Stop.
+#>
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Stop'
+
+Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'BlastRadiusGlob.psm1') -Force -ErrorAction Stop
+Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'BlastRadiusConflict.psm1') -Force -ErrorAction Stop
+Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'BlastRadiusValidation.psm1') -Force -ErrorAction Stop
+Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'BlastRadiusScheduling.psm1') -Force -ErrorAction Stop
+
+# The threshold is a percentage of the pair benefit.
+$script:Percent = 100
+$script:ContractDependency = 'contract_dependency'
+
+# Port of has_same_file_overlap: two equal, non-mergeable, non-append-only
+# concrete entries among the overlapping pairs the relation enumerates.
+function Test-SameFileOverlap {
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [object] $RadiusA,
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [object] $RadiusB,
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [object] $Config,
+        [Parameter(Mandatory = $true)]
+        [hashtable] $Tolerance
+    )
+
+    $left = ConvertTo-NormalizedBlastRadius -Radius $RadiusA
+    $right = ConvertTo-NormalizedBlastRadius -Radius $RadiusB
+    $mergeable = [string[]]@(Get-ConfigMergeablePath -Config $Config)
+    $pathsA = @(Get-NonMergeablePathEntry -Entry ([string[]]@($left['paths'])) -MergeablePath $mergeable)
+    $pathsB = @(Get-NonMergeablePathEntry -Entry ([string[]]@($right['paths'])) -MergeablePath $mergeable)
+    $appendOnly = [string[]]@($Tolerance['append_only_paths'])
+    foreach ($pair in @(Get-OverlappingPathPair -PathA $pathsA -PathB $pathsB)) {
+        $entry = [string]$pair['EntryA']
+        $isEqual = [string]::Equals($entry, [string]$pair['EntryB'], [System.StringComparison]::Ordinal)
+        if ($isEqual -and -not (Test-GlobEntry -Entry $entry) -and -not (Test-MergeablePath -Entry $entry -MergeablePath $appendOnly)) {
+            return $true
+        }
+    }
+    return $false
+}
+
+# Validate item keys (distinct integers) and return records sorted by key.
+function Get-CombinationOrderedItem {
+    [CmdletBinding()]
+    [OutputType([System.Object[]])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyCollection()]
+        [object[]] $Item
+    )
+
+    $seen = [System.Collections.Generic.HashSet[long]]::new()
+    $record = foreach ($entry in $Item) {
+        $key = [long]$entry['key']
+        if (-not $seen.Add($key)) {
+            throw "combination item keys must be distinct: $key."
+        }
+        $band = if ($entry.Contains('band')) { $entry['band'] } else { $null }
+        @{ key = $key; radius = $entry['radius']; band = $band }
+    }
+    return @(@($record) | Where-Object { $null -ne $_ } | Sort-Object -Property { $_['key'] })
+}
+
+# Return the union-find root of Key, registering Key as its own root when new.
+# Parent is the component's working map, owned by Get-CombinationComponent.
+function Get-UnionFindRoot {
+    [CmdletBinding()]
+    [OutputType([long])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [hashtable] $Parent,
+        [Parameter(Mandatory = $true)]
+        [long] $Key
+    )
+
+    if (-not $Parent.ContainsKey($Key)) { $Parent[$Key] = $Key }
+    $root = $Key
+    while ($Parent[$root] -ne $root) { $root = $Parent[$root] }
+    return $root
+}
+
+# Group qualifying pairs into connected components with union-find.
+function Get-CombinationComponent {
+    [CmdletBinding()]
+    [OutputType([System.Object[]])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyCollection()]
+        [object[]] $Pair
+    )
+
+    $parent = @{}
+    foreach ($entry in $Pair) {
+        $rootA = Get-UnionFindRoot -Parent $parent -Key $entry['a']
+        $rootB = Get-UnionFindRoot -Parent $parent -Key $entry['b']
+        if ($rootA -ne $rootB) {
+            $parent[[System.Math]::Max($rootA, $rootB)] = [System.Math]::Min($rootA, $rootB)
+        }
+    }
+
+    $grouped = @{}
+    foreach ($entry in $Pair) {
+        $root = Get-UnionFindRoot -Parent $parent -Key $entry['a']
+        if (-not $grouped.ContainsKey($root)) { $grouped[$root] = [System.Collections.Generic.List[object]]::new() }
+        $grouped[$root].Add($entry)
+    }
+    $combination = foreach ($root in @($grouped.Keys | Sort-Object)) {
+        $component = @($grouped[$root].ToArray() | Sort-Object -Property { $_['a'] }, { $_['b'] })
+        [long[]]$member = @($component | ForEach-Object { $_['a']; $_['b'] } | Sort-Object -Unique)
+        [long]$savings = 0
+        foreach ($entry in $component) { $savings += $entry['cost'] }
+        [ordered]@{ members = $member; primary = $member[0]; pairs = $component; estimated_savings = $savings }
+    }
+    return @($combination)
+}
+
+function Get-BlastRadiusCombination {
+    <#
+    .SYNOPSIS
+        Find the qualifying pairs of a set of items and group them.
+
+    .DESCRIPTION
+        Port of find_combinations. Visits every unordered pair once in ascending
+        key order and applies D-5 rules 1 to 5.
+
+    .PARAMETER Item
+        The run's items: records carrying key (an integer issue number), radius,
+        and an optional band.
+
+    .PARAMETER Config
+        Parsed truth table.
+
+    .PARAMETER Relation
+        The detection relation passed to every pair decision; pass
+        ${function:Test-BlastRadiusConflict}.
+
+    .OUTPUTS
+        System.Collections.Hashtable. Keys pairs (ordered records a, b, cost,
+        benefit, sorted by (a, b)) and combinations (ordered records members,
+        primary, pairs, estimated_savings, sorted by primary). Both are empty
+        when combination is disabled.
+    #>
+    [CmdletBinding()]
+    [OutputType([hashtable])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyCollection()]
+        [object[]] $Item,
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [object] $Config,
+        [scriptblock] $Relation
+    )
+
+    if ($null -eq $Relation) {
+        throw '-Relation is required: pass ${function:Test-BlastRadiusConflict} from the facade module BlastRadius.psm1.'
+    }
+    $tolerance = Get-ConfigConflictTolerance -Config $Config
+    $ordered = @(Get-CombinationOrderedItem -Item $Item)
+    # The absent key reads as the strict tolerance, whose percent is 0.
+    if ([long]$tolerance['tolerance_percent'] -eq 0) {
+        return @{ pairs = @(); combinations = @() }
+    }
+
+    $threshold = [long]$tolerance['combination_threshold_percent']
+    $qualifying = [System.Collections.Generic.List[object]]::new()
+    for ($first = 0; $first -lt $ordered.Count; $first++) {
+        for ($second = $first + 1; $second -lt $ordered.Count; $second++) {
+            $a = $ordered[$first]
+            $b = $ordered[$second]
+            $decision = Get-BlastRadiusPairDecision -RadiusA $a['radius'] -RadiusB $b['radius'] -Config $Config -BandA $a['band'] -BandB $b['band'] -Relation $Relation
+            if (-not $decision['conflict']) { continue }
+            # The full reasons are read, because contract_dependency is never first.
+            $isCandidate = @($decision['reasons']) -ccontains $script:ContractDependency
+            if (-not $isCandidate) {
+                $isCandidate = Test-SameFileOverlap -RadiusA $a['radius'] -RadiusB $b['radius'] -Config $Config -Tolerance $tolerance
+            }
+            if ($isCandidate -and ($decision['cost'] * $script:Percent -ge $decision['benefit'] * $threshold)) {
+                $qualifying.Add([ordered]@{ a = $a['key']; b = $b['key']; cost = [long]$decision['cost']; benefit = [long]$decision['benefit'] })
+            }
+        }
+    }
+
+    $pair = @($qualifying.ToArray())
+    return @{ pairs = $pair; combinations = @(Get-CombinationComponent -Pair $pair) }
+}
+
+Export-ModuleMember -Function Get-BlastRadiusCombination

package/resources/claude-customizations/.claude/lib/blast-radius/BlastRadiusExtraction.psm1

@@ -459,6 +459,7 @@ Export-ModuleMember -Function `
     Test-PlaceholderMarker, `
     Test-MultipleFeatureFolderSpan, `
     Test-FileShapedComponent, `
+    Test-GenericContractToken, `
     Get-PathTokenKind, `
     Get-PathFromLine, `
     Get-PlanPaths

package/resources/claude-customizations/.claude/lib/blast-radius/BlastRadiusNormalization.psm1

@@ -120,10 +120,12 @@ function Get-ContractIdentifier {
         # Inside a qualifying section an inline-code token without a separator is
         # a contract identifier; a token with one is a path reference and is
         # recorded at the paths level instead. A token carrying no ASCII letter
-        # is notation, not an identifier, and is dropped (issue #489).
+        # is notation, not an identifier, and is dropped (issue #489), as is a
+        # default spreadsheet sheet-tab name such as Sheet1 (issue #1006).
         foreach ($token in @(Get-InlineCodeToken -Line $line)) {
             if ($token.IndexOf('/') -lt 0 -and
-                $script:ContractLetterPattern.IsMatch($token)) {
+                $script:ContractLetterPattern.IsMatch($token) -and
+                -not (Test-GenericContractToken -Token $token)) {
                 $identifier.Add($token)
             }
         }

package/resources/claude-customizations/.claude/lib/blast-radius/BlastRadiusScheduling.psm1

@@ -38,6 +38,7 @@ Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'BlastRadiusGlob.psm1')
 Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'BlastRadiusConfig.psm1') -Force -ErrorAction Stop
 Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'BlastRadiusConflict.psm1') -Force -ErrorAction Stop
 Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'BlastRadiusValidation.psm1') -Force -ErrorAction Stop
+Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'BlastRadiusAggregate.psm1') -Force -ErrorAction Stop
 
 # Truth-table key and the label every reader error carries.
 $script:ToleranceKey = 'conflict_tolerance'
@@ -46,9 +47,15 @@ $script:ToleranceLabel = 'config["conflict_tolerance"]'
 # Member names of the key and of its two nested maps. Each must be carried
 # exactly, so a misspelled name fails fast instead of reading as absent.
 $script:MemberName = @('tolerance_percent', 'weights', 'band_durations', 'default_band', 'append_only_paths')
-$script:WeightName = @('same_file', 'possible_overlap', 'append_only', 'module')
+$script:WeightName = @('same_file', 'possible_overlap', 'append_only', 'module', 'contract')
 $script:BandName = @('C1', 'C2', 'C3', 'C4')
 
+# The one optional member (issue #1013): the issue-combination threshold, read
+# as this default when absent. Pinned to COMBINATION_THRESHOLD_DEFAULT in the
+# Python reference by a Pester parity row.
+$script:CombinationThresholdName = 'combination_threshold_percent'
+$script:CombinationThresholdDefault = 400
+
 # Reason kinds that make a conflict an edge at every tolerance: a shared surface
 # or a contract dependency cannot be reconciled by a merge step.
 $script:HardReasonKind = @('shared_surface_overlap', 'contract_dependency')
@@ -140,15 +147,18 @@ function Get-ConfigConflictTolerance {
     .DESCRIPTION
         Port of config_conflict_tolerance. An absent or null key returns the
         strict semantics: tolerance 0, every weight 1, every band duration 1,
-        default_band C1, and no append-only paths.
+        default_band C1, no append-only paths, and the default combination
+        threshold. combination_threshold_percent is optional: when present it
+        must be an integer of at least 0, and when absent it reads as 400.
 
     .PARAMETER Config
         Parsed config/blast-radius.json.
 
     .OUTPUTS
         System.Collections.Hashtable. Keys tolerance_percent, weights,
-        band_durations, default_band, and append_only_paths. Every error message
-        names the conflict_tolerance key.
+        band_durations, default_band, append_only_paths, and
+        combination_threshold_percent. Every error message names the
+        conflict_tolerance key.
     #>
     [CmdletBinding()]
     [OutputType([hashtable])]
@@ -165,22 +175,32 @@ function Get-ConfigConflictTolerance {
         foreach ($entry in $script:WeightName) { $unit[$entry] = [long]1 }
         $band = @{}
         foreach ($entry in $script:BandName) { $band[$entry] = [long]1 }
-        return @{ tolerance_percent = [long]0; weights = $unit; band_durations = $band; default_band = $script:BandName[0]; append_only_paths = [string[]]@() }
+        return @{ tolerance_percent = [long]0; weights = $unit; band_durations = $band; default_band = $script:BandName[0]; append_only_paths = [string[]]@(); combination_threshold_percent = [long]$script:CombinationThresholdDefault }
     }
 
     $member = Get-RequiredMapping -Value $value -FieldName $script:ToleranceLabel
-    Assert-ExactMemberName -Mapping $member -Name $script:MemberName -FieldName $script:ToleranceLabel
+    # The optional member joins the exact name set only when it is present, so
+    # every other unknown name is still rejected.
+    $hasThreshold = $member.ContainsKey($script:CombinationThresholdName)
+    $names = if ($hasThreshold) { @($script:MemberName) + $script:CombinationThresholdName } else { $script:MemberName }
+    Assert-ExactMemberName -Mapping $member -Name $names -FieldName $script:ToleranceLabel
     $defaultBand = $member['default_band']
     if ($defaultBand -isnot [string] -or $script:BandName -cnotcontains $defaultBand) {
         throw "$script:ToleranceLabel[""default_band""] must be one of $($script:BandName -join ', ')."
     }
 
+    $threshold = [long]$script:CombinationThresholdDefault
+    if ($hasThreshold) {
+        $threshold = Get-RequiredInteger -Value $member[$script:CombinationThresholdName] -FieldName "$script:ToleranceLabel[""$script:CombinationThresholdName""]" -Minimum 0
+    }
+
     return @{
-        tolerance_percent = Get-RequiredInteger -Value $member['tolerance_percent'] -FieldName "$script:ToleranceLabel[""tolerance_percent""]" -Minimum 0
-        weights           = Get-RequiredIntegerMap -Value $member['weights'] -Name $script:WeightName -Member 'weights'
-        band_durations    = Get-RequiredIntegerMap -Value $member['band_durations'] -Name $script:BandName -Member 'band_durations'
-        default_band      = [string]$defaultBand
-        append_only_paths = [string[]]@(Get-RequiredStringList -Value $member['append_only_paths'] -FieldName "$script:ToleranceLabel[""append_only_paths""]")
+        tolerance_percent             = Get-RequiredInteger -Value $member['tolerance_percent'] -FieldName "$script:ToleranceLabel[""tolerance_percent""]" -Minimum 0
+        weights                       = Get-RequiredIntegerMap -Value $member['weights'] -Name $script:WeightName -Member 'weights'
+        band_durations                = Get-RequiredIntegerMap -Value $member['band_durations'] -Name $script:BandName -Member 'band_durations'
+        default_band                  = [string]$defaultBand
+        append_only_paths             = [string[]]@(Get-RequiredStringList -Value $member['append_only_paths'] -FieldName "$script:ToleranceLabel[""append_only_paths""]")
+        combination_threshold_percent = $threshold
     }
 }
 
@@ -221,7 +241,10 @@ function Get-BlastRadiusPairCost {
     .DESCRIPTION
         Port of pair_cost. Sums the weight of every overlapping path pair left
         after the mergeable exclusion, then adds the module weight times the
-        number of shared modules. Mergeable paths therefore contribute 0.
+        number of shared modules and the contract weight times the number of
+        distinct shared contract identifiers (the ordinal intersection the
+        relation reads for contract_dependency, each identifier counted once).
+        Mergeable paths therefore contribute 0.
 
     .PARAMETER RadiusA
         First radius record.
@@ -269,7 +292,10 @@ function Get-BlastRadiusPairCost {
         $cost += Get-PathPairWeight -EntryA $pair['EntryA'] -EntryB $pair['EntryB'] -Tolerance $Tolerance
     }
     $sharedModule = @(@($left['modules']) | Where-Object { @($right['modules']) -ccontains $_ })
-    return $cost + ([long]$Tolerance['weights']['module'] * $sharedModule.Count)
+    # Distinct shared contract identifiers, compared ordinally like the relation.
+    $sharedContract = [System.Collections.Generic.HashSet[string]]::new([string[]]@($left['contracts']), [StringComparer]::Ordinal)
+    $sharedContract.IntersectWith([string[]]@($right['contracts']))
+    return $cost + ([long]$Tolerance['weights']['module'] * $sharedModule.Count) + ([long]$Tolerance['weights']['contract'] * $sharedContract.Count)
 }
 
 function Get-BlastRadiusPairBenefit {
@@ -423,7 +449,9 @@ function Get-BlastRadiusConflictEdge {
         Port of schedule_conflict_edges. Visits every unordered pair once in
         ascending key order. A pair whose decision is an edge is recorded as an
         edge; a conflict within tolerance is recorded as a tolerated overlap; a
-        pair that does not conflict appears in neither list.
+        pair that does not conflict appears in neither list. The aggregate cap
+        of BlastRadiusAggregate.psm1 (issue #1013) then promotes tolerated
+        overlaps until every item is within its cap.
 
     .PARAMETER Item
         The run's items: records carrying key (an integer issue number), radius,
@@ -454,7 +482,7 @@ function Get-BlastRadiusConflictEdge {
     )
 
     if ($null -eq $Relation) { throw $script:RelationRequired }
-    [void](Get-ConfigConflictTolerance -Config $Config)
+    $tolerance = Get-ConfigConflictTolerance -Config $Config
     $ordered = @(Get-OrderedSchedulingItem -Item $Item)
 
     $edge = [System.Collections.Generic.List[object]]::new()
@@ -472,7 +500,26 @@ function Get-BlastRadiusConflictEdge {
         }
     }
 
-    return @{ edges = @($edge.ToArray()); tolerated_overlaps = @($tolerated.ToArray()) }
+    # Aggregate cap post-pass (issue #1013, D-2): promote each cap-selected
+    # tolerated overlap to a non-hard edge carrying its first reason, then
+    # re-sort both lists by (a, b). At tolerance 0 nothing is tolerated.
+    $band = @{}
+    foreach ($entry in $ordered) { $band[$entry['key']] = $entry['band'] }
+    $promoted = [System.Collections.Generic.HashSet[string]]::new()
+    foreach ($pair in @(Get-AggregateCappedPair -ToleratedOverlap @($tolerated.ToArray()) -Band $band -Tolerance $tolerance)) {
+        [void]$promoted.Add(('{0}-{1}' -f $pair['a'], $pair['b']))
+    }
+    $kept = [System.Collections.Generic.List[object]]::new()
+    foreach ($overlap in $tolerated) {
+        if ($promoted.Contains(('{0}-{1}' -f $overlap['a'], $overlap['b']))) {
+            $edge.Add([ordered]@{ a = $overlap['a']; b = $overlap['b']; reason = @($overlap['reasons'])[0]; hard = $false; cost = $overlap['cost']; benefit = $overlap['benefit'] })
+        } else {
+            $kept.Add($overlap)
+        }
+    }
+    $sortedEdge = @($edge.ToArray() | Sort-Object -Property { $_['a'] }, { $_['b'] })
+
+    return @{ edges = $sortedEdge; tolerated_overlaps = @($kept.ToArray()) }
 }
 
 Export-ModuleMember -Function `

package/resources/claude-customizations/.claude/lib/blast-radius/BlastRadiusTokenShape.psm1

@@ -55,6 +55,12 @@
         from the Python source and pins them equal. A non-ASCII extension is
         rejected before lower-casing (issue #903); ToLowerInvariant then matches
         Python's str.lower on ASCII input, and known-name membership is ordinal.
+      - Test-GenericContractToken (issue #1006) ports is_generic_contract_token.
+        Its stem array equals GENERIC_CONTRACT_STEMS; a Pester parity test reads
+        the Python constant from the source and pins $script:GenericContractStem
+        equal to it. A token is first checked ordinally to be ASCII, because a
+        .NET case-insensitive match folds the Kelvin sign and the long s to
+        ASCII letters while Python re.ASCII does not (the issue #903 precedent).
     CONVENTION: this module fails fast at module scope and imports its siblings with -ErrorAction Stop.
 #>
 
@@ -114,6 +120,20 @@ $script:KnownFileName = [System.Collections.Generic.HashSet[string]]::new(
     ),
     [StringComparer]::Ordinal)
 
+# Default spreadsheet sheet-tab stems (issue #1006). A spreadsheet application
+# names a new worksheet or chart sheet with one of these stems followed by a
+# number, so a spec that mentions Sheet1 names a worksheet, not a contract. The
+# array is closed and is pinned equal to GENERIC_CONTRACT_STEMS in the Python
+# reference by a Pester parity test, so edit both files together. The pattern is
+# anchored with \A and \z to match Python's re.fullmatch, and the ASCII pattern
+# is applied first with -cmatch so the comparison is ordinal.
+$script:GenericContractStem = [string[]]@('Sheet', 'Chart')
+$script:GenericContractPattern = [regex]::new(
+    '\A(?:' + ($script:GenericContractStem -join '|') + ')[0-9]+\z',
+    [System.Text.RegularExpressions.RegexOptions]::IgnoreCase -bor
+    [System.Text.RegularExpressions.RegexOptions]::CultureInvariant)
+$script:AsciiOnlyPattern = '\A[\x00-\x7F]*\z'
+
 function Test-PlaceholderMarker {
     <#
     .SYNOPSIS
@@ -263,7 +283,42 @@ function Test-FileShapedComponent {
     return $script:FileExtensionPattern.IsMatch($extension.ToLowerInvariant())
 }
 
+function Test-GenericContractToken {
+    <#
+    .SYNOPSIS
+        Report whether a contract token is a default sheet-tab name (issue #1006).
+
+    .DESCRIPTION
+        Port of is_generic_contract_token. Two unrelated work items whose specs
+        both named the worksheet Sheet1 in an interface section were given a
+        hard contract_dependency edge, because the contract harvest accepts any
+        separator-free token carrying a letter. A default sheet-tab name
+        identifies no exported symbol, schema, or CLI identifier, so every
+        contract-filtering site rejects it with this predicate.
+
+    .PARAMETER Token
+        One candidate contract identifier. The empty string is accepted and
+        reports false.
+
+    .OUTPUTS
+        System.Boolean. True only when the token is ASCII and fully matches a
+        stem of $script:GenericContractStem followed by one or more ASCII
+        digits, compared case-insensitively; otherwise false.
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyString()]
+        [string] $Token
+    )
+
+    if ($Token -cnotmatch $script:AsciiOnlyPattern) { return $false }
+    return $script:GenericContractPattern.IsMatch($Token)
+}
+
 Export-ModuleMember -Function `
     Test-PlaceholderMarker, `
     Test-MultipleFeatureFolderSpan, `
-    Test-FileShapedComponent
+    Test-FileShapedComponent, `
+    Test-GenericContractToken

package/resources/claude-customizations/.claude/lib/blast-radius/BlastRadiusWriteIntent.psm1

@@ -343,9 +343,12 @@ function Get-WriteIntentSpecContract {
             continue
         }
 
+        # A default spreadsheet sheet-tab name such as Sheet1 is not a contract
+        # (issue #1006).
         foreach ($token in @(Get-SingleWordToken -Line $line)) {
             if ($token.IndexOf('/') -lt 0 -and $token.IndexOf('*') -lt 0 -and
-                $token.IndexOf('?') -lt 0 -and $script:ContractLetterPattern.IsMatch($token)) {
+                $token.IndexOf('?') -lt 0 -and $script:ContractLetterPattern.IsMatch($token) -and
+                -not (Test-GenericContractToken -Token $token)) {
                 $identifier.Add($token)
             }
         }

package/resources/claude-customizations/.claude/lib/cleanup-manifest/CleanupWorktreeManifest.psm1

@@ -24,8 +24,8 @@
     throwing.
 
 .NOTES
-    Compatible with PowerShell 7+. No external module dependencies, no subprocess,
-    and no network. The single filesystem read and the single wall-clock read each
+    Compatible with PowerShell 7+. Imports only the in-repository sibling
+    WorktreeRunRecordPath.psm1 (issue #995); no subprocess and no network. The single filesystem read and the single wall-clock read each
     sit behind an injectable seam so tests drive them without writing a temporary
     file. Mirrored byte-identically under
     extensions/drm-copilot/resources/claude-customizations/.
@@ -35,6 +35,9 @@
 Set-StrictMode -Version Latest
 $ErrorActionPreference = 'Stop'
 
+# The shared recorded-path matcher (issue #995), used by the checkpoint-coverage test.
+Import-Module (Join-Path $PSScriptRoot '../worktree-resolution/WorktreeRunRecordPath.psm1') -ErrorAction Stop
+
 # Repo-relative location of the sanctioned-removal manifest. Kept as a script-scope
 # constant so the read seam is the only function that names the path.
 $script:CleanupWorktreeManifestPath = 'artifacts/orchestration/cleanup-worktrees-manifest.json'
@@ -355,6 +358,14 @@ function Test-CleanupManifestCheckpointCoversPath {
         the gate's existing deny. Reusing the gates' merge_status predicate here
         would reopen the one path by which the manifest could widen what the gates
         protect.
+
+        Case rule: a record covers the target when the shared matcher holds on the
+        inputs as given, or holds on the same inputs lower-cased with the invariant
+        culture. This keeps the exclusion at parity with
+        Find-CleanupWorktreeManifestRemovalRecord, which ignores case for every path,
+        so a record that differs from the target only by case still blocks the
+        manifest branch. The shared matcher itself stays ordinal for single-slash
+        POSIX paths because the gates' allow lookups must remain fail-closed.
     .PARAMETER Checkpoint
         Parsed checkpoint object, or $null when absent or unreadable.
     .PARAMETER RecordArrayName
@@ -362,6 +373,10 @@ function Test-CleanupManifestCheckpointCoversPath {
         for the parallel checkpoint.
     .PARAMETER WorktreePath
         The removal target extracted from the command text.
+    .PARAMETER BaseRoot
+        Optional. The roots a relative recorded worktree_path is joined to: the main
+        checkout root and the root that holds the checkpoint (issue #995). With none, a
+        relative record covers nothing and a rooted record compares as before.
     .OUTPUTS
         System.Boolean
     #>
@@ -377,7 +392,11 @@ function Test-CleanupManifestCheckpointCoversPath {
 
         [AllowNull()]
         [AllowEmptyString()]
-        [string] $WorktreePath
+        [string] $WorktreePath,
+
+        [AllowNull()]
+        [AllowEmptyCollection()]
+        [string[]] $BaseRoot = @()
     )
 
     if ($null -eq $Checkpoint -or [string]::IsNullOrWhiteSpace($WorktreePath)) {
@@ -388,8 +407,10 @@ function Test-CleanupManifestCheckpointCoversPath {
         return $false
     }
 
-    $normalizedTarget = ConvertTo-CleanupWorktreeManifestNormalizedPath -Path $WorktreePath
+    $lowerBaseRoot = [string[]] @(@($BaseRoot) | Where-Object { -not [string]::IsNullOrWhiteSpace($_) } | ForEach-Object { $_.ToLowerInvariant() })
 
+    # Every record is compared through the shared matcher, so a relative record covers
+    # the absolute target it names under a base root, and an unsafe one covers nothing.
     foreach ($record in @($Checkpoint.PSObject.Properties[$RecordArrayName].Value)) {
         if ($null -eq $record) {
             continue
@@ -398,8 +419,14 @@ function Test-CleanupManifestCheckpointCoversPath {
         if ($recordProperties -notcontains 'worktree_path') {
             continue
         }
-        $normalizedRecordPath = ConvertTo-CleanupWorktreeManifestNormalizedPath -Path ([string]$record.worktree_path)
-        if ($normalizedRecordPath -eq $normalizedTarget) {
+        $recordedPath = [string]$record.worktree_path
+        if (Test-WorktreeRunRecordedPathMatchesTarget -RecordedPath $recordedPath -TargetPath $WorktreePath -BaseRoot $BaseRoot) {
+            return $true
+        }
+        # Case-insensitive parity with Find-CleanupWorktreeManifestRemovalRecord: the same
+        # inputs lower-cased with the invariant culture, so the exclusion is never narrower
+        # than the manifest lookup it guards.
+        if (Test-WorktreeRunRecordedPathMatchesTarget -RecordedPath $recordedPath.ToLowerInvariant() -TargetPath $WorktreePath.ToLowerInvariant() -BaseRoot $lowerBaseRoot) {
             return $true
         }
     }

package/resources/claude-customizations/.claude/lib/codex-routing/CodexDeployment.psm1

@@ -75,7 +75,11 @@ $script:GENERATED_AGENT_FAMILIES = @(
     'python-typed-engineer',
     'powershell-typed-engineer',
     'csharp-typed-engineer',
-    'typescript-engineer'
+    'typescript-engineer',
+    'legacy-parity-analyst',
+    'runtime-characterization-analyst',
+    'requirements-reconciler',
+    'migration-coverage-reviewer'
 )
 $script:LOGICAL_AGENT_ALIASES = @{ 'feature-review' = 'feature-reviewer' }