@danmoisan/drm-copilot-mcp 1.0.21 → 1.0.22

package/resources/claude-customizations/.claude/hooks/enforce-parallel-worktree-removal-gate.ps1

@@ -0,0 +1,244 @@
+<#
+.SYNOPSIS
+    Pre-tool-use hook that gates git worktree remove behind parallel checkpoint merge state.
+
+.DESCRIPTION
+    Invoked by the Claude Code PreToolUse hook on the "Bash" matcher before any Bash
+    command runs. Regex-matches git worktree remove against CLAUDE_TOOL_INPUT.command,
+    extracts the target worktree path argument, reads
+    artifacts/orchestration/parallel-orchestrator-state.json, and finds the items[] record
+    whose worktree_path matches. Allows removal only when that record's merge_status is
+    merged or worktree_removed. Denies with reason PARALLEL_WORKTREE_REMOVAL_BLOCKED when
+    the checkpoint is unreadable, no matching record exists, or merge_status is anything
+    else - fail-closed, following the enforce-epic-worktree-removal-gate.ps1 precedent of
+    treating an unreadable/no-match checkpoint as deny.
+
+    Adapted from enforce-epic-worktree-removal-gate.ps1. The command interception regexes
+    and the path normalization are unchanged; the checkpoint path, the read seam name, and
+    the record collection differ, because the parallel surface records per-item state in
+    items[] rather than features[]. A parallel run has no integration branch: each item
+    opens its own pull request against main, so a removed worktree is unrecoverable work
+    unless that item's own merge has been durably confirmed.
+
+.NOTES
+    Compatible with PowerShell 7+. No external module dependencies. Filesystem reads go
+    through an injectable wrapper function so tests can mock the boundary without writing
+    temporary files.
+#>
+[CmdletBinding()]
+param()
+
+$script:ParallelCheckpointPath = 'artifacts/orchestration/parallel-orchestrator-state.json'
+$script:AllowedMergeStatuses = @('merged', 'worktree_removed')
+
+function Get-ParallelWorktreeRemovalGateCheckpointContent {
+    <#
+    .SYNOPSIS
+        Read the raw JSON text of the parallel checkpoint. Tests mock this function
+        (read seam).
+    .OUTPUTS
+        System.String or $null
+    #>
+    [CmdletBinding()]
+    [OutputType([string])]
+    param()
+
+    if (-not (Test-Path -LiteralPath $script:ParallelCheckpointPath -PathType Leaf)) {
+        return $null
+    }
+    return (Get-Content -LiteralPath $script:ParallelCheckpointPath -Raw)
+}
+
+function Get-ParallelWorktreeRemovalCommandPath {
+    <#
+    .SYNOPSIS
+        Extract the target worktree path argument from a git worktree remove command.
+    .PARAMETER CommandText
+        The Bash command text under evaluation.
+    .OUTPUTS
+        System.String or $null
+    #>
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter(Mandatory)]
+        [string] $CommandText
+    )
+
+    if ($CommandText -match '(?i)\bgit\s+worktree\s+remove\s+(?<path>\S+)') {
+        return $Matches['path'].Trim('"''')
+    }
+    return $null
+}
+
+function Find-ParallelWorktreeItemRecord {
+    <#
+    .SYNOPSIS
+        Locate the items[] record whose worktree_path matches the target path.
+    .PARAMETER Checkpoint
+        Parsed parallel checkpoint, or $null when absent/unreadable.
+    .PARAMETER WorktreePath
+        The target worktree path extracted from the command text.
+    .OUTPUTS
+        System.Object or $null
+    #>
+    [CmdletBinding()]
+    param(
+        [AllowNull()]
+        $Checkpoint,
+
+        [AllowNull()]
+        [string] $WorktreePath
+    )
+
+    if ($null -eq $Checkpoint -or [string]::IsNullOrWhiteSpace($WorktreePath)) {
+        return $null
+    }
+    $checkpointProps = @($Checkpoint.PSObject.Properties.Name)
+    if ($checkpointProps -notcontains 'items') {
+        return $null
+    }
+
+    $normalizedTarget = ($WorktreePath -replace '\\', '/').TrimEnd('/')
+
+    # Scan every recorded item for a worktree_path that matches the removal target;
+    # path separators are normalized so Windows- and POSIX-style paths compare equal.
+    foreach ($item in @($Checkpoint.items)) {
+        $itemProps = @($item.PSObject.Properties.Name)
+        if ($itemProps -notcontains 'worktree_path') {
+            continue
+        }
+        $normalizedItemPath = (([string]$item.worktree_path) -replace '\\', '/').TrimEnd('/')
+        if ($normalizedItemPath -eq $normalizedTarget) {
+            return $item
+        }
+    }
+    return $null
+}
+
+function Test-ParallelWorktreeRemovalAllowed {
+    <#
+    .SYNOPSIS
+        Decision logic: allow only when the matching item record's merge_status is
+        merged or worktree_removed.
+    .PARAMETER ItemRecord
+        The matched items[] record, or $null when no match was found.
+    .OUTPUTS
+        System.Boolean
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [AllowNull()]
+        $ItemRecord
+    )
+
+    if ($null -eq $ItemRecord) {
+        return $false
+    }
+    $props = @($ItemRecord.PSObject.Properties.Name)
+    if ($props -notcontains 'merge_status') {
+        return $false
+    }
+    return $script:AllowedMergeStatuses -contains ([string]$ItemRecord.merge_status)
+}
+
+function Get-ParallelWorktreeGateAllowDecision {
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param()
+
+    return [ordered]@{
+        hookSpecificOutput = [ordered]@{
+            hookEventName      = 'PreToolUse'
+            permissionDecision = 'allow'
+        }
+    }
+}
+
+function Get-ParallelWorktreeGateBlockDecision {
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param(
+        [Parameter(Mandatory)]
+        [string] $Reason
+    )
+
+    return [ordered]@{
+        hookSpecificOutput = [ordered]@{
+            hookEventName            = 'PreToolUse'
+            permissionDecision       = 'deny'
+            permissionDecisionReason = $Reason
+        }
+    }
+}
+
+function Invoke-ParallelWorktreeRemovalGateDecision {
+    <#
+    .SYNOPSIS
+        Parses CLAUDE_TOOL_INPUT and returns an allow-or-block decision.
+    .PARAMETER ToolInputRaw
+        The raw JSON tool payload supplied by Claude Code.
+    .OUTPUTS
+        System.Collections.Specialized.OrderedDictionary
+    #>
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param(
+        [string] $ToolInputRaw
+    )
+
+    if (-not $ToolInputRaw) {
+        return Get-ParallelWorktreeGateAllowDecision
+    }
+
+    try {
+        $toolInput = $ToolInputRaw | ConvertFrom-Json -ErrorAction Stop
+    } catch {
+        throw "enforce-parallel-worktree-removal-gate hook received malformed JSON in CLAUDE_TOOL_INPUT: $_"
+    }
+
+    $commandText = $toolInput.command
+    if (-not $commandText) {
+        return Get-ParallelWorktreeGateAllowDecision
+    }
+
+    if ($commandText -notmatch '(?i)\bgit\s+worktree\s+remove\b') {
+        return Get-ParallelWorktreeGateAllowDecision
+    }
+
+    $worktreePath = Get-ParallelWorktreeRemovalCommandPath -CommandText $commandText
+
+    $checkpointRaw = Get-ParallelWorktreeRemovalGateCheckpointContent
+    $checkpoint = $null
+    if (-not [string]::IsNullOrWhiteSpace($checkpointRaw)) {
+        try {
+            $checkpoint = $checkpointRaw | ConvertFrom-Json -ErrorAction Stop
+        } catch {
+            $checkpoint = $null
+        }
+    }
+
+    $itemRecord = Find-ParallelWorktreeItemRecord -Checkpoint $checkpoint -WorktreePath $worktreePath
+    if (Test-ParallelWorktreeRemovalAllowed -ItemRecord $itemRecord) {
+        return Get-ParallelWorktreeGateAllowDecision
+    }
+
+    return Get-ParallelWorktreeGateBlockDecision -Reason "PARALLEL_WORKTREE_REMOVAL_BLOCKED: git worktree remove for '$worktreePath' requires a matching parallel checkpoint items[] record with merge_status in {merged, worktree_removed}. The checkpoint was unreadable, no matching record was found, or merge_status was not yet safe for removal."
+}
+
+# Guard allows dot-sourcing in tests without executing the entrypoint.
+if ($MyInvocation.InvocationName -eq '.') {
+    return
+}
+
+try {
+    $decision = Invoke-ParallelWorktreeRemovalGateDecision -ToolInputRaw $env:CLAUDE_TOOL_INPUT
+} catch {
+    Write-Error $_
+    exit 1
+}
+
+$decision | ConvertTo-Json -Compress -Depth 5 | Write-Output
+
+exit 0

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

@@ -0,0 +1,379 @@
+<#
+.SYNOPSIS
+    Blast-radius derivation and the fail-closed contention relation.
+
+.DESCRIPTION
+    Destination-runtime PowerShell facade for the blast-radius library, porting
+    scripts/dev_tools/compute_blast_radius.py (derive_blast_radius,
+    radius_from_observed_paths, _feature_folder_glob) and
+    scripts/dev_tools/_blast_radius_conflicts.py (conflicts,
+    _smallest_path_overlap, _smallest_common). It imports the extraction, glob,
+    truth-table, and validation modules that sit beside it and re-exports the
+    five functions the spec PowerShell surface fixes:
+
+      - Get-PlanPaths                     port of extract_plan_paths
+      - Get-BlastRadius                   port of derive_blast_radius
+      - Get-BlastRadiusFromObservedPaths  port of radius_from_observed_paths
+      - Test-BlastRadius                  port of validate_blast_radius
+      - Test-BlastRadiusConflict          port of conflicts
+
+    The Python modules remain the authoritative reference implementation. This
+    module is one half of a two-language mirror; it never imports validator
+    logic. Every function is pure: no filesystem, subprocess, network, or
+    wall-clock access, and no input is mutated. computed_at is caller supplied,
+    so the library never reads the clock.
+
+    Parity notes for maintainers:
+      - A radius is a hashtable whose key set is exactly paths, modules,
+        shared_surfaces, contracts, source, and computed_at. Hashtable key order
+        is not significant; the key set and the values are the contract.
+      - Every function in this library that mirrors a Python tuple return writes
+        its elements to the pipeline, following the repository's
+        Get-PoshQCFileList convention. Callers must wrap such a call in @(...) to
+        obtain an array, because a zero-element result writes nothing and a
+        one-element result writes a single object. Test-BlastRadius is the one
+        collection-returning function on this facade; Get-BlastRadius,
+        Get-BlastRadiusFromObservedPaths, and Test-BlastRadiusConflict each
+        return a single hashtable.
+      - source is restricted to derived, declared, and observed; anything else,
+        and any malformed input, throws.
+      - The contention relation fails closed: a glob pair that cannot be proven
+        disjoint counts as overlapping, because radius under-reporting is the
+        dominant risk of the parallel design.
+      - Reasons are reported in the fixed kind order path_overlap,
+        module_overlap, shared_surface_overlap, contract_dependency, and each
+        detail is order-normalized so the relation is observably symmetric in its
+        two arguments.
+      - Two empty radii, and an empty radius against a non-empty one, do not
+        conflict. Under-reporting via emptiness is V1's problem at plan time, not
+        the relation's.
+#>
+
+Set-StrictMode -Version Latest
+
+Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'BlastRadiusExtraction.psm1') -Force
+Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'BlastRadiusGlob.psm1') -Force
+Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'BlastRadiusConfig.psm1') -Force
+Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'BlastRadiusValidation.psm1') -Force
+
+# Feature-folder handling. Every radius contains its own feature folder, and a
+# caller may pass either a bare folder name or an already-qualified path.
+$script:FeatureFolderRoot = 'docs/features/active'
+$script:FeatureFolderPrefix = 'docs/features/'
+
+# The default confidence source for derivation, and the source a diff-derived
+# radius always records.
+$script:SourceDerived = 'derived'
+$script:SourceObserved = 'observed'
+
+# Contention reason kinds, in the fixed order every result reports them. These
+# strings are contract literals consumed by the downstream parallel schema.
+$script:ConflictPathOverlap = 'path_overlap'
+$script:ConflictModuleOverlap = 'module_overlap'
+$script:ConflictSharedSurfaceOverlap = 'shared_surface_overlap'
+$script:ConflictContractDependency = 'contract_dependency'
+
+# Separator used in an overlapping-pair detail string. The pair is ordered
+# ordinally before formatting so the detail is identical in both argument orders.
+$script:PairDetailSeparator = ' ~ '
+
+
+# Port of _feature_folder_glob. Accepting an already-qualified path avoids
+# producing a doubled docs/features/active/docs/features/active/... entry when a
+# caller passes the folder path it already holds.
+function Get-FeatureFolderGlob {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [string] $FeatureFolder
+    )
+
+    $trimmed = $FeatureFolder.Trim().Trim('/')
+    if ($trimmed.StartsWith($script:FeatureFolderPrefix, [System.StringComparison]::Ordinal)) {
+        return "$trimmed/**"
+    }
+
+    return "$script:FeatureFolderRoot/$trimmed/**"
+}
+
+function Get-BlastRadius {
+    <#
+    .SYNOPSIS
+        Derive a blast radius from an approved plan and its feature spec.
+
+    .DESCRIPTION
+        Port of derive_blast_radius. Plan task bodies are the primary signal, the
+        spec contributes the paths it cites in inline code, and the feature
+        folder is always present because every work item writes its own documents
+        and evidence. A plan and spec with no extractable paths still yield a
+        radius containing the feature-folder glob.
+
+    .PARAMETER PlanText
+        Approved atomic-plan document text; may be empty.
+
+    .PARAMETER SpecText
+        Feature spec.md document text; may be empty.
+
+    .PARAMETER FeatureFolder
+        Bare feature folder name, or a path that already starts with
+        docs/features/.
+
+    .PARAMETER Config
+        Parsed config/blast-radius.json.
+
+    .PARAMETER Source
+        Confidence source to record; derived by default and declared when a
+        planner adopts the result as authoritative.
+
+    .PARAMETER ComputedAt
+        Caller-supplied ISO-8601 timestamp. The library never reads the clock.
+
+    .OUTPUTS
+        System.Collections.Hashtable. The derived radius, carrying exactly the
+        keys paths, modules, shared_surfaces, contracts, source, and computed_at.
+    #>
+    [CmdletBinding()]
+    [OutputType([hashtable])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyString()]
+        [string] $PlanText,
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyString()]
+        [string] $SpecText,
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyString()]
+        [string] $FeatureFolder,
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [object] $Config,
+        [string] $Source = $script:SourceDerived,
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyString()]
+        [string] $ComputedAt
+    )
+
+    [void](Get-RequiredText -Value $PlanText -FieldName 'plan_text' -AllowEmpty)
+    [void](Get-RequiredText -Value $SpecText -FieldName 'spec_text' -AllowEmpty)
+
+    # Both extraction calls read the separator-free root-surface set from the
+    # same -Config value that resolves modules and shared surfaces below. Sharing
+    # one reader with Test-BlastRadius is what preserves the invariant that a
+    # derived radius always passes V1 and V2 against its own plan (issue #452).
+    $rootSurface = [string[]]@(Get-ConfigRootSurface -Config $Config)
+
+    $specLine = [string[]]@(ConvertTo-NormalizedLine -Text $SpecText)
+    $entry = [System.Collections.Generic.List[string]]::new()
+    $entry.AddRange([string[]]@(Get-PlanPaths -PlanText $PlanText -RootSurface $rootSurface))
+    $entry.AddRange([string[]]@(Get-PathFromLine -Line $specLine -RootSurface $rootSurface))
+    $entry.Add((Get-FeatureFolderGlob -FeatureFolder (
+                Get-RequiredText -Value $FeatureFolder -FieldName 'feature_folder')))
+
+    $paths = [string[]]@(Get-OrdinalSortedEntry -Entry $entry.ToArray())
+    $concrete = [string[]]@(Get-ConcreteEntry -Entry $paths)
+
+    return ConvertTo-NormalizedBlastRadius -Radius @{
+        paths           = $paths
+        modules         = @(Resolve-BlastRadiusModule -PathEntry $paths -Config $Config)
+        shared_surfaces = @(Resolve-BlastRadiusSharedSurface -ConcretePath $concrete -Config $Config)
+        contracts       = @(Get-ContractIdentifier -SpecText $SpecText)
+        source          = $Source
+        computed_at     = $ComputedAt
+    }
+}
+
+function Get-BlastRadiusFromObservedPaths {
+    <#
+    .SYNOPSIS
+        Build an observed-source radius from an already-collected path list.
+
+    .DESCRIPTION
+        Port of radius_from_observed_paths. Drift detection supplies the output
+        of a diff listing; the library performs no subprocess call of its own, so
+        the paths arrive as plain strings and are taken verbatim rather than
+        re-classified by the plan-text heuristic. contracts is empty because a
+        diff carries no interface-section text.
+
+    .PARAMETER ObservedPaths
+        Repository-relative paths from a diff, as a collection. A bare string is
+        rejected, matching the Python reference guard.
+
+    .PARAMETER Config
+        Parsed config/blast-radius.json.
+
+    .PARAMETER ComputedAt
+        Caller-supplied ISO-8601 timestamp. The library never reads the clock.
+
+    .OUTPUTS
+        System.Collections.Hashtable. A radius whose source is observed and whose
+        modules and shared surfaces are resolved by the derivation rules.
+    #>
+    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseSingularNouns', '', Justification = 'The exported name is fixed by the spec PowerShell surface contract for issue #447 and mirrors radius_from_observed_paths.')]
+    [CmdletBinding()]
+    [OutputType([hashtable])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [object] $ObservedPaths,
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [object] $Config,
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyString()]
+        [string] $ComputedAt
+    )
+
+    $paths = [string[]]@(Get-RequiredStringList -Value $ObservedPaths -FieldName 'observed_paths')
+    $concrete = [string[]]@(Get-ConcreteEntry -Entry $paths)
+
+    return ConvertTo-NormalizedBlastRadius -Radius @{
+        paths           = $paths
+        modules         = @(Resolve-BlastRadiusModule -PathEntry $paths -Config $Config)
+        shared_surfaces = @(Resolve-BlastRadiusSharedSurface -ConcretePath $concrete -Config $Config)
+        contracts       = @()
+        source          = $script:SourceObserved
+        computed_at     = $ComputedAt
+    }
+}
+
+# Port of _smallest_path_overlap. Each overlapping pair is ordered before it is
+# recorded, so the minimum is taken over a set that does not depend on argument
+# order; that is what makes the reported detail symmetric.
+function Get-SmallestPathOverlap {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyCollection()]
+        [AllowEmptyString()]
+        [string[]] $PathA,
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyCollection()]
+        [AllowEmptyString()]
+        [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)
+        }
+    }
+
+    return (Get-OrdinalSmallestEntry -Entry $detail.ToArray())
+}
+
+# Port of _smallest_common. Two empty collections share nothing, so the result is
+# $null and the level contributes no reason.
+function Get-SmallestCommonEntry {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyCollection()]
+        [AllowEmptyString()]
+        [string[]] $Left,
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyCollection()]
+        [AllowEmptyString()]
+        [string[]] $Right
+    )
+
+    $rightSet = [System.Collections.Generic.HashSet[string]]::new($Right, [StringComparer]::Ordinal)
+    $common = [System.Collections.Generic.List[string]]::new()
+    foreach ($entry in $Left) {
+        if ($rightSet.Contains($entry)) {
+            $common.Add($entry)
+        }
+    }
+
+    return (Get-OrdinalSmallestEntry -Entry $common.ToArray())
+}
+
+function Test-BlastRadiusConflict {
+    <#
+    .SYNOPSIS
+        Decide whether two radii contend, and report every triggered disjunct.
+
+    .DESCRIPTION
+        Port of conflicts. Evaluates the four disjuncts and returns the verdict
+        plus one reason per triggered level in the fixed kind order path_overlap,
+        module_overlap, shared_surface_overlap, contract_dependency. The three
+        set-intersection levels differ only in which collection they read, so one
+        pass over the level table keeps them in the required order without
+        repeating the intersection logic.
+
+    .PARAMETER RadiusA
+        First radius record.
+
+    .PARAMETER RadiusB
+        Second radius record.
+
+    .PARAMETER Config
+        Parsed config/blast-radius.json. The relation reads no key from it today;
+        it is validated and kept in the signature because the contract is frozen
+        for downstream consumers.
+
+    .OUTPUTS
+        System.Collections.Hashtable. Keys conflict (a boolean) and reasons (an
+        array of hashtables with keys kind and detail).
+    #>
+    [CmdletBinding()]
+    [OutputType([hashtable])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [object] $RadiusA,
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [object] $RadiusB,
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [object] $Config
+    )
+
+    [void](Get-RequiredMapping -Value $Config -FieldName 'config')
+    $left = ConvertTo-NormalizedBlastRadius -Radius $RadiusA
+    $right = ConvertTo-NormalizedBlastRadius -Radius $RadiusB
+
+    $reason = [System.Collections.Generic.List[hashtable]]::new()
+    $pathDetail = Get-SmallestPathOverlap -PathA ([string[]]@($left['paths'])) `
+        -PathB ([string[]]@($right['paths']))
+    if ($null -ne $pathDetail) {
+        $reason.Add(@{ kind = $script:ConflictPathOverlap; detail = $pathDetail })
+    }
+
+    $level = @(
+        @{ kind = $script:ConflictModuleOverlap; key = 'modules' },
+        @{ kind = $script:ConflictSharedSurfaceOverlap; key = 'shared_surfaces' },
+        @{ kind = $script:ConflictContractDependency; key = 'contracts' }
+    )
+    foreach ($entry in $level) {
+        $shared = Get-SmallestCommonEntry -Left ([string[]]@($left[$entry['key']])) `
+            -Right ([string[]]@($right[$entry['key']]))
+        if ($null -ne $shared) {
+            $reason.Add(@{ kind = $entry['kind']; detail = $shared })
+        }
+    }
+
+    return @{
+        conflict = ($reason.Count -gt 0)
+        reasons  = @($reason.ToArray())
+    }
+}
+
+Export-ModuleMember -Function `
+    Get-PlanPaths, `
+    Get-BlastRadius, `
+    Get-BlastRadiusFromObservedPaths, `
+    Test-BlastRadius, `
+    Test-BlastRadiusConflict