@danmoisan/drm-copilot-mcp 1.1.15 → 1.1.17

package/resources/claude-customizations/.claude/lib/bash/abandon-parallel-item.sh

@@ -0,0 +1,176 @@
+#!/usr/bin/env bash
+# abandon-parallel-item.sh: bundled destination-runtime port of
+# scripts/dev_tools/parallel_mutation_abandon_cli.py (issue #763). It executes the
+# abandon disposition of /parallel-remove -- close the item's pull request, then
+# remove its worktree -- with nothing but bash, gh, and git on PATH: no Python, no
+# Poetry, no repository checkout.
+#
+# Usage:
+#   bash .claude/lib/bash/abandon-parallel-item.sh --item <key> --disposition abandon --confirm-abandon --pr <pr-number> --worktree <worktree-path>
+#
+# The PreToolUse hook .claude/hooks/enforce-parallel-abandon-gate.ps1 matches the
+# command text of that invocation: a command carrying the disposition token
+# without the confirmation marker is denied before it runs. The option tokens are
+# declared once each below, and tests/scripts/dev_tools/test_parallel_abandon_token_seam.py
+# binds them to the Python reference and to the hook.
+#
+# Exit codes:
+#   0  success; both side effects ran and nothing was written to stdout
+#   1  a side effect failed; the first failure is reported and nothing after it runs
+#   2  refusal (a disposition other than abandon, or no confirmation marker) or a
+#      usage error; both are reported before any side effect
+#
+# Declared divergences from the Python reference, all within "usage errors exit 2":
+#   - argparse usage text is not reproduced; only exit code 2 is matched, with one
+#     stderr line prefixed "PARALLEL_ABANDON_ERROR: usage error:".
+#   - option abbreviations are rejected (argparse accepts a unique prefix).
+#   - --item and --pr accept only canonical decimal integers (0 or [1-9][0-9]*).
+#   - -h and --help are unknown options.
+#   - an option value beginning with -- is treated as a missing value.
+# Repeated options keep the last value and the joined --name=value form is
+# accepted, as argparse does.
+set -euo pipefail
+
+# The option tokens and messages the abandon surface is built from. The first
+# three lines are read by the seam test and by tests/shell/parallel_abandon.bats.
+readonly ABANDON_DISPOSITION_OPTION='--disposition'
+readonly ABANDON_DISPOSITION_VALUE='abandon'
+readonly ABANDON_CONFIRM_OPTION='--confirm-abandon'
+readonly ABANDON_ITEM_OPTION='--item'
+readonly ABANDON_PR_OPTION='--pr'
+readonly ABANDON_WORKTREE_OPTION='--worktree'
+readonly ABANDON_VALID_DISPOSITIONS='detach abandon'
+readonly ABANDON_ERROR_PREFIX='PARALLEL_ABANDON_ERROR:'
+
+abandon_usage_error() {
+	# Report a usage error on stderr and exit 2 before any side effect.
+	#
+	# Args: $1 = the detail naming the offending argument.
+	printf '%s usage error: %s\n' "$ABANDON_ERROR_PREFIX" "$1" >&2
+	exit 2
+}
+
+abandon_require_integer() {
+	# Require a canonical decimal integer, as the reference's type=int requires
+	# an integer; leading zeros, signs, and blanks are usage errors here.
+	#
+	# Args: $1 = the value, $2 = the option it was given for.
+	if [[ ! $1 =~ ^(0|[1-9][0-9]*)$ ]]; then
+		abandon_usage_error "$2 requires a canonical decimal integer; got '$1'"
+	fi
+}
+
+abandon_require_disposition() {
+	# Require a member of the disposition vocabulary, as the reference's
+	# argparse choices do. Membership is not the abandon refusal: a valid
+	# disposition other than abandon is refused later with its own message.
+	#
+	# Args: $1 = the disposition value.
+	local candidate
+	# Scan the space-separated vocabulary for an exact match.
+	for candidate in $ABANDON_VALID_DISPOSITIONS; do
+		if [ "$candidate" = "$1" ]; then
+			return 0
+		fi
+	done
+	abandon_usage_error "$ABANDON_DISPOSITION_OPTION must be one of: $ABANDON_VALID_DISPOSITIONS; got '$1'"
+}
+
+abandon_side_effect_failed() {
+	# Report a failed side effect and exit 1, so nothing after it runs.
+	#
+	# Args: $1 = the exit code (-1 when the executable is not on PATH), then the
+	# command vector, which is rendered joined by single spaces.
+	local code="$1"
+	shift
+	printf '%s abandon side effect failed with exit code %s: %s\n' "$ABANDON_ERROR_PREFIX" "$code" "$*" >&2
+	exit 1
+}
+
+abandon_run_side_effect() {
+	# Run one side-effect command resolved through PATH. A non-zero exit is
+	# captured rather than aborting under set -e, so it can be reported.
+	#
+	# Args: the command vector, executable name first.
+	local executable status=0
+	if ! executable="$(command -v -- "$1")"; then
+		abandon_side_effect_failed -1 "$@"
+	fi
+	"$executable" "${@:2}" || status=$?
+	if [ "$status" -ne 0 ]; then
+		abandon_side_effect_failed "$status" "$@"
+	fi
+}
+
+item=''
+disposition=''
+pr=''
+worktree=''
+confirmed=0
+have_item=0
+have_disposition=0
+have_pr=0
+have_worktree=0
+
+# Parse the argument vector. The bare confirmation flag sets the marker; each of
+# the four valued options takes its value joined (--name=value) or as the next
+# argument; anything else -- an unknown option, an abbreviation, a value on the
+# confirmation flag, or a positional argument -- is a usage error.
+while [ "$#" -gt 0 ]; do
+	argument="$1"
+	shift
+	if [ "$argument" = "$ABANDON_CONFIRM_OPTION" ]; then
+		confirmed=1
+		continue
+	fi
+	name="${argument%%=*}"
+	case "$name" in
+	"$ABANDON_ITEM_OPTION" | "$ABANDON_DISPOSITION_OPTION" | "$ABANDON_PR_OPTION" | "$ABANDON_WORKTREE_OPTION") ;;
+	*) abandon_usage_error "unrecognized argument: $argument" ;;
+	esac
+	# Take the joined value when present, otherwise the next argument; an absent
+	# value is represented by the option prefix so one check rejects both forms.
+	if [ "$name" != "$argument" ]; then
+		value="${argument#*=}"
+	elif [ "$#" -gt 0 ]; then
+		value="$1"
+		shift
+	else
+		value='--'
+	fi
+	if [[ $value == --* ]]; then
+		abandon_usage_error "$name requires a value"
+	fi
+	# Store the value on its option; a repeated option keeps the last value.
+	case "$name" in
+	"$ABANDON_ITEM_OPTION") item="$value" have_item=1 ;;
+	"$ABANDON_DISPOSITION_OPTION") disposition="$value" have_disposition=1 ;;
+	"$ABANDON_PR_OPTION") pr="$value" have_pr=1 ;;
+	*) worktree="$value" have_worktree=1 ;;
+	esac
+done
+
+# Every valued option is required, as in the reference parser.
+if [ "$have_item" -eq 0 ] || [ "$have_disposition" -eq 0 ] || [ "$have_pr" -eq 0 ] || [ "$have_worktree" -eq 0 ]; then
+	abandon_usage_error "the options $ABANDON_ITEM_OPTION, $ABANDON_DISPOSITION_OPTION, $ABANDON_PR_OPTION, and $ABANDON_WORKTREE_OPTION are required"
+fi
+abandon_require_integer "$item" "$ABANDON_ITEM_OPTION"
+abandon_require_integer "$pr" "$ABANDON_PR_OPTION"
+abandon_require_disposition "$disposition"
+
+# The two refusals come before any side effect: this entry point exists only to
+# execute the confirmed abandon path, so any other request does nothing.
+if [ "$disposition" != "$ABANDON_DISPOSITION_VALUE" ]; then
+	printf "%s this CLI executes the '%s' disposition only; got '%s'.\n" "$ABANDON_ERROR_PREFIX" "$ABANDON_DISPOSITION_VALUE" "$disposition" >&2
+	exit 2
+fi
+if [ "$confirmed" -ne 1 ]; then
+	printf '%s refusing to abandon item %s without the explicit %s confirmation marker; no side effect was performed.\n' "$ABANDON_ERROR_PREFIX" "$item" "$ABANDON_CONFIRM_OPTION" >&2
+	exit 2
+fi
+
+# Close the pull request before removing the worktree: removing the worktree
+# first would leave an open pull request whose checkout is gone.
+abandon_run_side_effect gh pr close "$pr"
+abandon_run_side_effect git worktree remove "$worktree"
+exit 0

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

@@ -190,6 +190,182 @@ function Get-NonMergeablePathEntry {
     return @(Get-OrdinalSortedEntry -Entry $survivor.ToArray())
 }
 
+function ConvertTo-PathOverlapRecord {
+    <#
+    .SYNOPSIS
+        Precompute the per-entry facts the pairwise overlap decision reads.
+
+    .DESCRIPTION
+        Called once per path collection by Get-OverlappingPathPair (issue #776),
+        so the advanced-function calls made here are linear in the collection
+        size rather than quadratic in the number of pairs.
+
+    .PARAMETER Entry
+        Radius path entries. An empty collection and empty strings are accepted.
+
+    .OUTPUTS
+        System.Object[]. One hashtable record per entry, in input order, with
+        keys Entry, IsGlob, Prefix (the literal prefix of a glob entry, $null for
+        a concrete entry), and Directory (the entry anchored with one trailing
+        separator).
+    #>
+    [CmdletBinding()]
+    [OutputType([System.Object[]])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyCollection()]
+        [AllowEmptyString()]
+        [string[]] $Entry
+    )
+
+    $record = [System.Collections.Generic.List[hashtable]]::new()
+    foreach ($single in $Entry) {
+        $isGlob = Test-GlobEntry -Entry $single
+        $prefix = if ($isGlob) { Get-LiteralPrefix -Entry $single } else { $null }
+        $record.Add(@{
+                Entry     = $single
+                IsGlob    = $isGlob
+                Prefix    = $prefix
+                Directory = $single.TrimEnd('/') + '/'
+            })
+    }
+
+    return @($record.ToArray())
+}
+
+# The one record-form overlap decision (issue #776); its four cases reproduce
+# Test-EntryOverlap exactly (parity guard: BlastRadiusConflict.PathOverlap.Tests.ps1).
+# A simple function because it runs per candidate pair (see Get-GlobRegex).
+function Test-PathOverlapRecordPair {
+    param([hashtable] $Left, [hashtable] $Right)
+
+    $ordinal = [System.StringComparison]::Ordinal
+    if (-not $Left.IsGlob -and -not $Right.IsGlob) {
+        # Two concrete entries: equality or either anchored directory prefix.
+        return ([string]::Equals($Left.Entry, $Right.Entry, $ordinal) -or
+            $Left.Entry.StartsWith($Right.Directory, $ordinal) -or
+            $Right.Entry.StartsWith($Left.Directory, $ordinal))
+    }
+    if ($Left.IsGlob -and -not $Right.IsGlob) {
+        # Glob and concrete: the two literal nest tests, then the pattern match.
+        return ($Left.Prefix.StartsWith($Right.Directory, $ordinal) -or
+            $Right.Directory.StartsWith($Left.Prefix, $ordinal) -or
+            (Test-GlobMatch -Pattern $Left.Entry -Candidate $Right.Entry))
+    }
+    if ($Right.IsGlob -and -not $Left.IsGlob) {
+        return ($Right.Prefix.StartsWith($Left.Directory, $ordinal) -or
+            $Left.Directory.StartsWith($Right.Prefix, $ordinal) -or
+            (Test-GlobMatch -Pattern $Right.Entry -Candidate $Left.Entry))
+    }
+    # Two globs: either literal prefix nests the other.
+    return ($Left.Prefix.StartsWith($Right.Prefix, $ordinal) -or
+        $Right.Prefix.StartsWith($Left.Prefix, $ordinal))
+}
+
+function Get-OverlappingPathPair {
+    <#
+    .SYNOPSIS
+        Return every overlapping path pair of two collections, in nested-loop order.
+
+    .DESCRIPTION
+        Yields exactly the pairs for which Test-EntryOverlap holds without
+        evaluating all |PathA| x |PathB| pairs (issue #776). Concrete pairs, almost
+        all pairs in practice, are found by dictionary lookup: equality against
+        the concrete entries of the other side, and anchored-directory
+        containment, because X.StartsWith(Y.TrimEnd('/') + '/') holds exactly
+        when X[k] is '/' and X.Substring(0, k) equals Y.TrimEnd('/') for some k
+        over the positions of '/' in X, so one lookup per separator position of X
+        decides it (probed in both directions). Every glob-involving pair is
+        decided by Test-PathOverlapRecordPair against the other collection.
+
+        Ordering contract: each pair is recorded once under the key
+        i * |PathB| + j and emitted in ascending key order, which is nested-loop
+        order (outer over PathA, inner over PathB, both in input order). Pairs are
+        never reordered by value; a repeated entry yields one pair per occurrence.
+
+    .PARAMETER PathA
+        First path collection. An empty collection and empty strings are accepted.
+
+    .PARAMETER PathB
+        Second path collection. An empty collection and empty strings are accepted.
+
+    .OUTPUTS
+        System.Object[]. One hashtable per overlapping pair with keys EntryA (from
+        PathA) and EntryB (from PathB); an empty array when nothing overlaps.
+    #>
+    [CmdletBinding()]
+    [OutputType([System.Object[]])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyCollection()]
+        [AllowEmptyString()]
+        [string[]] $PathA,
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyCollection()]
+        [AllowEmptyString()]
+        [string[]] $PathB
+    )
+
+    $recordA = @(ConvertTo-PathOverlapRecord -Entry $PathA)
+    $recordB = @(ConvertTo-PathOverlapRecord -Entry $PathB)
+    $countB = [long]$recordB.Count
+    $pairKey = [System.Collections.Generic.HashSet[long]]::new()
+    $hit = $null
+
+    # Concrete entries keyed verbatim (equality) and trimmed of trailing separators
+    # (containment); each key lists every index carrying it, one per occurrence.
+    $exactB, $trimmedB, $trimmedA = @(1..3 | ForEach-Object { [System.Collections.Generic.Dictionary[string, System.Collections.Generic.List[int]]]::new([StringComparer]::Ordinal) })
+    for ($j = 0; $j -lt $recordB.Count; $j++) {
+        if ($recordB[$j].IsGlob) { continue }
+        foreach ($target in @(@($exactB, $recordB[$j].Entry), @($trimmedB, $recordB[$j].Entry.TrimEnd('/')))) {
+            if (-not $target[0].ContainsKey($target[1])) { $target[0][$target[1]] = [System.Collections.Generic.List[int]]::new() }
+            $target[0][$target[1]].Add($j)
+        }
+    }
+
+    for ($i = 0; $i -lt $recordA.Count; $i++) {
+        $entry = $recordA[$i].Entry
+        if ($recordA[$i].IsGlob) {
+            # A PathA glob is decided against every PathB record.
+            for ($j = 0; $j -lt $recordB.Count; $j++) {
+                if (Test-PathOverlapRecordPair -Left $recordA[$i] -Right $recordB[$j]) { [void]$pairKey.Add($i * $countB + $j) }
+            }
+            continue
+        }
+        if (-not $trimmedA.ContainsKey($entry.TrimEnd('/'))) { $trimmedA[$entry.TrimEnd('/')] = [System.Collections.Generic.List[int]]::new() }
+        $trimmedA[$entry.TrimEnd('/')].Add($i)
+        # Equality, then containment at each separator (the PathB pass probes the reverse).
+        if ($exactB.TryGetValue($entry, [ref]$hit)) { foreach ($j in $hit) { [void]$pairKey.Add($i * $countB + $j) } }
+        for ($slash = $entry.IndexOf('/'); $slash -ge 0; $slash = $entry.IndexOf('/', $slash + 1)) {
+            if ($trimmedB.TryGetValue($entry.Substring(0, $slash), [ref]$hit)) { foreach ($j in $hit) { [void]$pairKey.Add($i * $countB + $j) } }
+        }
+    }
+
+    for ($j = 0; $j -lt $recordB.Count; $j++) {
+        $entry = $recordB[$j].Entry
+        if ($recordB[$j].IsGlob) {
+            # Against concrete PathA records only; glob pairs were decided above.
+            for ($i = 0; $i -lt $recordA.Count; $i++) {
+                if (-not $recordA[$i].IsGlob -and (Test-PathOverlapRecordPair -Left $recordA[$i] -Right $recordB[$j])) { [void]$pairKey.Add($i * $countB + $j) }
+            }
+            continue
+        }
+        for ($slash = $entry.IndexOf('/'); $slash -ge 0; $slash = $entry.IndexOf('/', $slash + 1)) {
+            if ($trimmedA.TryGetValue($entry.Substring(0, $slash), [ref]$hit)) { foreach ($i in $hit) { [void]$pairKey.Add($i * $countB + $j) } }
+        }
+    }
+
+    $sortedKey = [long[]]@($pairKey)
+    [System.Array]::Sort($sortedKey)
+    $pair = [System.Collections.Generic.List[hashtable]]::new()
+    foreach ($key in $sortedKey) {
+        $i = [int][System.Math]::Floor($key / $countB)
+        $pair.Add(@{ EntryA = $recordA[$i].Entry; EntryB = $recordB[[int]($key - $i * $countB)].Entry })
+    }
+
+    return @($pair.ToArray())
+}
+
 function Get-SmallestPathOverlap {
     <#
     .SYNOPSIS
@@ -222,22 +398,24 @@ function Get-SmallestPathOverlap {
         [string[]] $PathB
     )
 
-    $detail = [System.Collections.Generic.List[string]]::new()
-    foreach ($entryA in $PathA) {
-        foreach ($entryB in $PathB) {
-            if (-not (Test-EntryOverlap -EntryA $entryA -EntryB $entryB)) {
-                continue
-            }
-            $ordered = if ([string]::CompareOrdinal($entryA, $entryB) -le 0) {
-                @($entryA, $entryB)
-            } else {
-                @($entryB, $entryA)
-            }
-            $detail.Add($ordered -join $script:PairDetailSeparator)
+    # The overlapping pairs come from the shared enumeration, so the record-form
+    # decision exists once (issue #776). The minimum over the ordered details does
+    # not depend on the order in which the pairs are enumerated.
+    $smallest = $null
+    foreach ($pair in @(Get-OverlappingPathPair -PathA $PathA -PathB $PathB)) {
+        # Order the pair ordinally so the detail is identical in both argument
+        # orders, then keep it only when it is the new ordinal minimum.
+        $pairDetail = if ([string]::CompareOrdinal($pair['EntryA'], $pair['EntryB']) -le 0) {
+            $pair['EntryA'] + $script:PairDetailSeparator + $pair['EntryB']
+        } else {
+            $pair['EntryB'] + $script:PairDetailSeparator + $pair['EntryA']
+        }
+        if ($null -eq $smallest -or [string]::CompareOrdinal($pairDetail, $smallest) -lt 0) {
+            $smallest = $pairDetail
         }
     }
 
-    return (Get-OrdinalSmallestEntry -Entry $detail.ToArray())
+    return $smallest
 }
 
 function Get-SmallestCommonEntry {
@@ -287,4 +465,5 @@ Export-ModuleMember -Function `
     Test-MergeablePath, `
     Get-NonMergeablePathEntry, `
     Get-SmallestPathOverlap, `
-    Get-SmallestCommonEntry
+    Get-SmallestCommonEntry, `
+    Get-OverlappingPathPair

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

@@ -31,6 +31,9 @@
         newline in .NET.
       - Comparisons and ordering use [StringComparer]::Ordinal and
         [string]::CompareOrdinal so results do not vary with the current culture.
+      - Test-GlobMatch memoizes each translated pattern in a script-scoped,
+        ordinally keyed regex cache (issue #776). The translation is pure, so
+        the cache changes speed only; Python recompiles through re's own cache.
     CONVENTION: this module fails fast at module scope and imports its siblings with -ErrorAction Stop.
 #>
 
@@ -40,7 +43,12 @@ $ErrorActionPreference = 'Stop'
 # Wildcards that make a path entry a pattern rather than a file. The question
 # mark is included because the subsumption helper treats it as a pattern;
 # admitting it here keeps every comparison in the fail-closed direction.
-$script:GlobWildcard = @('*', '?')
+$script:GlobWildcardCharacter = [char[]]@('*', '?')
+
+# Compiled whole-string regex per glob pattern (issue #776). Keys compare
+# ordinally so patterns differing only by case stay distinct. The cache lives
+# per module instance and is bounded by the number of distinct patterns seen.
+$script:GlobRegexCache = [System.Collections.Generic.Dictionary[string, regex]]::new([StringComparer]::Ordinal)
 
 
 function Test-GlobEntry {
@@ -49,8 +57,8 @@ function Test-GlobEntry {
         Report whether a path entry is a wildcard pattern rather than a file.
 
     .DESCRIPTION
-        Port of is_glob_entry. Used both to classify radius path entries and, one
-        character at a time, by the literal-prefix helper.
+        Port of is_glob_entry. Used to classify radius path entries; a single
+        ordinal IndexOfAny scan over the wildcard set decides the answer.
 
     .PARAMETER Entry
         A paths entry from a radius or an extraction, or a single character.
@@ -66,13 +74,7 @@ function Test-GlobEntry {
         [string] $Entry
     )
 
-    foreach ($wildcard in $script:GlobWildcard) {
-        if ($Entry.IndexOf($wildcard, [System.StringComparison]::Ordinal) -ge 0) {
-            return $true
-        }
-    }
-
-    return $false
+    return $Entry.IndexOfAny($script:GlobWildcardCharacter) -ge 0
 }
 
 function Get-ConcreteEntry {
@@ -147,6 +149,23 @@ function ConvertTo-GlobRegexText {
     return $part.ToString()
 }
 
+# Return the cached anchored regex for a glob pattern, building it on a miss.
+# Declared as a simple function, without [CmdletBinding()], because it runs once
+# per Test-GlobMatch call and advanced-function parameter binding is the
+# per-call cost issue #776 removes from the pairwise overlap hot path.
+function Get-GlobRegex {
+    param([string] $Pattern)
+
+    $cached = $null
+    if ($script:GlobRegexCache.TryGetValue($Pattern, [ref]$cached)) {
+        return $cached
+    }
+
+    $compiled = [regex]::new('\A(?:' + (ConvertTo-GlobRegexText -Pattern $Pattern) + ')\z')
+    $script:GlobRegexCache[$Pattern] = $compiled
+    return $compiled
+}
+
 function Test-GlobMatch {
     <#
     .SYNOPSIS
@@ -176,8 +195,7 @@ function Test-GlobMatch {
         [string] $Candidate
     )
 
-    $regexText = '\A(?:' + (ConvertTo-GlobRegexText -Pattern $Pattern) + ')\z'
-    return [regex]::IsMatch($Candidate, $regexText)
+    return (Get-GlobRegex -Pattern $Pattern).IsMatch($Candidate)
 }
 
 function Test-PathSubsumed {
@@ -261,10 +279,9 @@ function Get-LiteralPrefix {
         [string] $Entry
     )
 
-    for ($index = 0; $index -lt $Entry.Length; $index++) {
-        if (Test-GlobEntry -Entry ([string]$Entry[$index])) {
-            return $Entry.Substring(0, $index)
-        }
+    $index = $Entry.IndexOfAny($script:GlobWildcardCharacter)
+    if ($index -ge 0) {
+        return $Entry.Substring(0, $index)
     }
 
     return $Entry
@@ -308,8 +325,12 @@ function Test-EntryOverlap {
         [string] $EntryB
     )
 
-    $aIsGlob = Test-GlobEntry -Entry $EntryA
-    $bIsGlob = Test-GlobEntry -Entry $EntryB
+    # One ordinal scan per entry yields both the glob flag and the literal prefix,
+    # so this hot path makes no advanced-function call for either (issue #776).
+    $indexA = $EntryA.IndexOfAny($script:GlobWildcardCharacter)
+    $indexB = $EntryB.IndexOfAny($script:GlobWildcardCharacter)
+    $aIsGlob = $indexA -ge 0
+    $bIsGlob = $indexB -ge 0
 
     if (-not $aIsGlob -and -not $bIsGlob) {
         # Anchoring each entry with a trailing separator before the prefix test is
@@ -326,23 +347,25 @@ function Test-EntryOverlap {
     # entry's directory prefix nest. The nest is tested in both directions because
     # the glob may be rooted above the directory (scripts/ above
     # scripts/dev_tools/) or below it, and either arrangement admits a common file.
+    # The two literal nest tests run before the pattern match: all three terms are
+    # pure, so the order of the OR changes cost only, never the verdict.
     if ($aIsGlob -and -not $bIsGlob) {
-        $prefixGlob = Get-LiteralPrefix -Entry $EntryA
+        $prefixGlob = $EntryA.Substring(0, $indexA)
         $directoryConcrete = $EntryB.TrimEnd('/') + '/'
-        return ((Test-GlobMatch -Pattern $EntryA -Candidate $EntryB) -or
-            $prefixGlob.StartsWith($directoryConcrete, [System.StringComparison]::Ordinal) -or
-            $directoryConcrete.StartsWith($prefixGlob, [System.StringComparison]::Ordinal))
+        return ($prefixGlob.StartsWith($directoryConcrete, [System.StringComparison]::Ordinal) -or
+            $directoryConcrete.StartsWith($prefixGlob, [System.StringComparison]::Ordinal) -or
+            (Test-GlobMatch -Pattern $EntryA -Candidate $EntryB))
     }
     if ($bIsGlob -and -not $aIsGlob) {
-        $prefixGlob = Get-LiteralPrefix -Entry $EntryB
+        $prefixGlob = $EntryB.Substring(0, $indexB)
         $directoryConcrete = $EntryA.TrimEnd('/') + '/'
-        return ((Test-GlobMatch -Pattern $EntryB -Candidate $EntryA) -or
-            $prefixGlob.StartsWith($directoryConcrete, [System.StringComparison]::Ordinal) -or
-            $directoryConcrete.StartsWith($prefixGlob, [System.StringComparison]::Ordinal))
+        return ($prefixGlob.StartsWith($directoryConcrete, [System.StringComparison]::Ordinal) -or
+            $directoryConcrete.StartsWith($prefixGlob, [System.StringComparison]::Ordinal) -or
+            (Test-GlobMatch -Pattern $EntryB -Candidate $EntryA))
     }
 
-    $prefixA = Get-LiteralPrefix -Entry $EntryA
-    $prefixB = Get-LiteralPrefix -Entry $EntryB
+    $prefixA = $EntryA.Substring(0, $indexA)
+    $prefixB = $EntryB.Substring(0, $indexB)
     return ($prefixA.StartsWith($prefixB, [System.StringComparison]::Ordinal) -or
         $prefixB.StartsWith($prefixA, [System.StringComparison]::Ordinal))
 }

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

@@ -261,15 +261,12 @@ function Get-BlastRadiusPairCost {
     $pathsA = @(Get-NonMergeablePathEntry -Entry ([string[]]@($left['paths'])) -MergeablePath $mergeable)
     $pathsB = @(Get-NonMergeablePathEntry -Entry ([string[]]@($right['paths'])) -MergeablePath $mergeable)
 
-    # Enumerate the overlapping pairs with the relation's own primitive, so the
-    # cost covers exactly the pairs the relation could report.
+    # Enumerate the overlapping pairs with the relation's own indexed enumeration
+    # (the Test-EntryOverlap pairs, issue #776), so the cost covers exactly the
+    # pairs the relation could report.
     [long]$cost = 0
-    foreach ($entryA in $pathsA) {
-        foreach ($entryB in $pathsB) {
-            if (Test-EntryOverlap -EntryA $entryA -EntryB $entryB) {
-                $cost += Get-PathPairWeight -EntryA $entryA -EntryB $entryB -Tolerance $Tolerance
-            }
-        }
+    foreach ($pair in @(Get-OverlappingPathPair -PathA $pathsA -PathB $pathsB)) {
+        $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)