@danmoisan/drm-copilot-mcp 1.1.25 → 1.1.27

package/resources/claude-customizations/.claude/lib/parallel-admission/ParallelAdmissionPrecedence.psm1

@@ -0,0 +1,508 @@
+<#
+.SYNOPSIS
+    Pure precedence and scheduling-record functions for the parallel surface (issue #1047).
+
+.DESCRIPTION
+    Holds the operator precedence input of /parallel-plan and /parallel-add
+    (`--after`): validation of the precedence[] entries, their normalization into
+    separating conflict edges, the precedence lift over a cohort table, the
+    active-entry resolution and cohort-table check, and the durable scheduling
+    record with its edge-reuse rule.
+
+    A precedence entry {before, after} states that the `after` item must start
+    in a later cohort than the `before` item. It is a separating input, never a
+    `depends_on` key. Every function is pure: no filesystem, subprocess, network,
+    or clock access, and no input is mutated. Rejections throw a message that
+    starts with the rejection code (precedence_unknown_item, precedence_cycle).
+    CONVENTION: this module fails fast at module scope and imports its siblings with -ErrorAction Stop.
+#>
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Stop'
+
+function Get-ParallelPrecedenceMapValue {
+    <#
+    .SYNOPSIS
+        Return the value stored under Key in a dictionary, or null when the key or the map is absent.
+    #>
+    [CmdletBinding()]
+    [OutputType([object])]
+    param([AllowNull()][object] $Map, [string] $Key)
+
+    if ($Map -isnot [System.Collections.IDictionary]) { return $null }
+    if (-not $Map.Contains($Key)) { return $null }
+    return $Map[$Key]
+}
+
+function ConvertTo-ParallelPrecedenceKey {
+    <#
+    .SYNOPSIS
+        Convert an item key (integer or decimal-digit string) to Int64, or return null.
+    #>
+    [CmdletBinding()]
+    [OutputType([object], [long])]
+    param([AllowNull()][object] $Value)
+
+    if ($null -eq $Value -or $Value -is [bool]) { return $null }
+    $parsed = [long]0
+    if ($Value -is [string]) {
+        if ($Value -match '^[0-9]+$' -and [long]::TryParse($Value, [ref] $parsed)) { return $parsed }
+        return $null
+    }
+    if ($Value -is [int] -or $Value -is [long] -or $Value -is [int16] -or $Value -is [byte]) { return [long]$Value }
+    return $null
+}
+
+function Get-ParallelPrecedencePair {
+    <#
+    .SYNOPSIS
+        Read precedence entries into [before, after] Int64 pairs.
+
+    .DESCRIPTION
+        Each entry is a dictionary carrying `before` and `after`. An entry whose
+        key is missing or is not an integer throws precedence_unknown_item.
+    #>
+    [CmdletBinding()]
+    [OutputType([System.Object[]])]
+    param([AllowNull()][AllowEmptyCollection()][object[]] $Entry = @())
+
+    $pairs = [System.Collections.Generic.List[object]]::new()
+    foreach ($item in @($Entry)) {
+        if ($null -eq $item) { continue }
+        $before = ConvertTo-ParallelPrecedenceKey -Value (Get-ParallelPrecedenceMapValue -Map $item -Key 'before')
+        $after = ConvertTo-ParallelPrecedenceKey -Value (Get-ParallelPrecedenceMapValue -Map $item -Key 'after')
+        if ($null -eq $before -or $null -eq $after) {
+            throw "precedence_unknown_item: a precedence entry must carry integer before and after item keys."
+        }
+        $pairs.Add([long[]]@($before, $after))
+    }
+    return , $pairs.ToArray()
+}
+
+function Get-ParallelPrecedenceOrder {
+    <#
+    .SYNOPSIS
+        Return the item keys in topological precedence order, ties by ascending key.
+
+    .DESCRIPTION
+        Kahn's algorithm over the before -> after pairs. Keys left unvisited lie on
+        a cycle, which throws precedence_cycle naming them.
+    #>
+    [CmdletBinding()]
+    [OutputType([long[]], [System.Object[]])]
+    param([AllowEmptyCollection()][object[]] $Pair = @(), [AllowEmptyCollection()][long[]] $ItemKey = @())
+
+    $keys = [System.Collections.Generic.SortedSet[long]]::new()
+    foreach ($key in @($ItemKey)) { [void]$keys.Add($key) }
+    # The loop variable is not named $pair: variable names are case-insensitive, so it would overwrite $Pair.
+    foreach ($edge in @($Pair)) { [void]$keys.Add($edge[0]); [void]$keys.Add($edge[1]) }
+    $inDegree = @{}
+    $successor = @{}
+    foreach ($key in $keys) { $inDegree[$key] = 0; $successor[$key] = [System.Collections.Generic.SortedSet[long]]::new() }
+    foreach ($edge in @($Pair)) {
+        if ($successor[$edge[0]].Add($edge[1])) { $inDegree[$edge[1]]++ }
+    }
+    $ready = [System.Collections.Generic.SortedSet[long]]::new()
+    foreach ($key in $keys) { if ($inDegree[$key] -eq 0) { [void]$ready.Add($key) } }
+    $order = [System.Collections.Generic.List[long]]::new()
+    while ($ready.Count -gt 0) {
+        $next = $ready.Min
+        [void]$ready.Remove($next)
+        $order.Add($next)
+        foreach ($after in $successor[$next]) {
+            $inDegree[$after]--
+            if ($inDegree[$after] -eq 0) { [void]$ready.Add($after) }
+        }
+    }
+    if ($order.Count -lt $keys.Count) {
+        $cyclic = @($keys | Where-Object { $order -notcontains $_ })
+        throw "precedence_cycle: the precedence entries form a cycle among items $($cyclic -join ', ')."
+    }
+    return , $order.ToArray()
+}
+
+function Test-ParallelPrecedenceInput {
+    <#
+    .SYNOPSIS
+        Validate precedence entries against the run's item keys.
+
+    .DESCRIPTION
+        Throws precedence_unknown_item when an entry names a key that is not an
+        item, and precedence_cycle when an entry pairs an item with itself or the
+        entries form a cycle. Returns true when the entries are valid.
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param([AllowNull()][AllowEmptyCollection()][object[]] $Entry = @(), [AllowEmptyCollection()][long[]] $ItemKey = @())
+
+    $pairs = Get-ParallelPrecedencePair -Entry $Entry
+    foreach ($pair in $pairs) {
+        foreach ($key in $pair) {
+            if (@($ItemKey) -notcontains $key) { throw "precedence_unknown_item: precedence entry $($pair[0]):$($pair[1]) names item $key, which is not an item of the run." }
+        }
+        if ($pair[0] -eq $pair[1]) { throw "precedence_cycle: precedence entry $($pair[0]):$($pair[1]) pairs an item with itself." }
+    }
+    [void](Get-ParallelPrecedenceOrder -Pair $pairs -ItemKey $ItemKey)
+    return $true
+}
+
+function ConvertTo-ParallelPrecedenceEdge {
+    <#
+    .SYNOPSIS
+        Normalize precedence entries into separating `a:b` edges with a < b.
+
+    .DESCRIPTION
+        Each before/after pair becomes the undirected edge `min:max`, so the
+        cohort coloring always separates the pair. Duplicates are removed and the
+        edges are sorted by (a, b).
+    #>
+    [CmdletBinding()]
+    [OutputType([string[]], [System.Object[]])]
+    param([AllowNull()][AllowEmptyCollection()][object[]] $Entry = @())
+
+    $seen = [System.Collections.Generic.HashSet[string]]::new([System.StringComparer]::Ordinal)
+    $edges = [System.Collections.Generic.List[long[]]]::new()
+    foreach ($pair in (Get-ParallelPrecedencePair -Entry $Entry)) {
+        $a = [math]::Min($pair[0], $pair[1])
+        $b = [math]::Max($pair[0], $pair[1])
+        if ($a -eq $b -or -not $seen.Add("${a}:${b}")) { continue }
+        $edges.Add([long[]]@($a, $b))
+    }
+    $sorted = @($edges | Sort-Object -Property @{ Expression = { $_[0] } }, @{ Expression = { $_[1] } })
+    return , [string[]]@($sorted | ForEach-Object { "$($_[0]):$($_[1])" })
+}
+
+function Get-ParallelPrecedenceNeighbor {
+    <#
+    .SYNOPSIS
+        Build the undirected neighbor map of conflict edges plus precedence pairs.
+
+    .DESCRIPTION
+        Edge entries are `a:b` strings of integer keys; a malformed entry throws.
+    #>
+    [CmdletBinding()]
+    [OutputType([hashtable])]
+    param([AllowEmptyCollection()][string[]] $Edge = @(), [AllowEmptyCollection()][object[]] $Pair = @())
+
+    $neighbor = @{}
+    foreach ($text in @($Edge)) {
+        if ([string]::IsNullOrWhiteSpace($text)) { continue }
+        if ($text -notmatch '^\s*([0-9]+):([0-9]+)\s*$') { throw "Conflict edge '$text' is not of the form <a>:<b>." }
+        Add-ParallelPrecedenceNeighborLink -Neighbor $neighbor -Left ([long]$Matches[1]) -Right ([long]$Matches[2])
+    }
+    foreach ($edgePair in @($Pair)) { Add-ParallelPrecedenceNeighborLink -Neighbor $neighbor -Left $edgePair[0] -Right $edgePair[1] }
+    return $neighbor
+}
+
+function Add-ParallelPrecedenceNeighborLink {
+    <#
+    .SYNOPSIS
+        Record one undirected link in a neighbor map (key to HashSet of keys), in both directions.
+    #>
+    [CmdletBinding()]
+    [OutputType([void])]
+    param([hashtable] $Neighbor, [long] $Left, [long] $Right)
+
+    foreach ($side in @(@($Left, $Right), @($Right, $Left))) {
+        if (-not $Neighbor.ContainsKey($side[0])) { $Neighbor[$side[0]] = [System.Collections.Generic.HashSet[long]]::new() }
+        [void]$Neighbor[$side[0]].Add($side[1])
+    }
+}
+
+function Invoke-ParallelPrecedenceLift {
+    <#
+    .SYNOPSIS
+        Lift unstarted `after` items into later cohorts than their `before` items.
+
+    .DESCRIPTION
+        Visits the cohort items in topological precedence order (ties by ascending
+        key). An unpinned `after` item whose cohort index is not above every
+        `before` index moves to the smallest index at or above both
+        max(before index) + 1 and Floor that holds no conflict neighbor (conflict
+        edges plus precedence pairs, pinned neighbors included). Pinned items
+        never move and unstarted items only move upward, so every cohort stays an
+        independent set and a second application changes nothing. A pinned
+        `after` item that violates its precedence is left in place; the
+        cohort-table check reports it.
+
+    .PARAMETER Cohort
+        The cohort table: one array of item keys per cohort index.
+
+    .PARAMETER Edge
+        Conflict edges as `a:b` strings.
+
+    .PARAMETER Precedence
+        precedence[] entries carrying `before` and `after`.
+
+    .PARAMETER Pinned
+        Item keys that have started and therefore cannot move.
+
+    .PARAMETER Floor
+        The lowest cohort index a moved item may take.
+
+    .OUTPUTS
+        System.Object[] of Int64 arrays, one per cohort; trailing empty cohorts are dropped.
+    #>
+    [CmdletBinding()]
+    [OutputType([System.Object[]])]
+    param(
+        [AllowEmptyCollection()][object[]] $Cohort = @(),
+        [AllowEmptyCollection()][string[]] $Edge = @(),
+        [AllowNull()][AllowEmptyCollection()][object[]] $Precedence = @(),
+        [AllowEmptyCollection()][long[]] $Pinned = @(),
+        [int] $Floor = 0
+    )
+
+    $table = [System.Collections.Generic.List[System.Collections.Generic.SortedSet[long]]]::new()
+    $position = @{}
+    foreach ($members in @($Cohort)) {
+        $set = [System.Collections.Generic.SortedSet[long]]::new()
+        foreach ($member in @($members)) {
+            $key = ConvertTo-ParallelPrecedenceKey -Value $member
+            if ($null -eq $key) { throw "Cohort member '$member' is not an integer item key." }
+            if ($position.ContainsKey($key)) { throw "Item $key appears in more than one cohort." }
+            [void]$set.Add($key)
+            $position[$key] = $table.Count
+        }
+        $table.Add($set)
+    }
+    $itemKey = [long[]]@($position.Keys)
+    [void](Test-ParallelPrecedenceInput -Entry $Precedence -ItemKey $itemKey)
+    $pairs = Get-ParallelPrecedencePair -Entry $Precedence
+    $neighbor = Get-ParallelPrecedenceNeighbor -Edge $Edge -Pair $pairs
+
+    foreach ($key in (Get-ParallelPrecedenceOrder -Pair $pairs -ItemKey $itemKey)) {
+        $before = @($pairs | Where-Object { $_[1] -eq $key } | ForEach-Object { $_[0] })
+        if ($before.Count -eq 0 -or @($Pinned) -contains $key) { continue }
+        $need = (@($before | ForEach-Object { $position[$_] }) | Measure-Object -Maximum).Maximum + 1
+        if ($position[$key] -ge $need) { continue }
+        $target = [math]::Max([int]$need, $Floor)
+        while ($true) {
+            while ($table.Count -le $target) { $table.Add([System.Collections.Generic.SortedSet[long]]::new()) }
+            $blocked = $neighbor.ContainsKey($key) -and @($table[$target] | Where-Object { $neighbor[$key].Contains($_) }).Count -gt 0
+            if (-not $blocked) { break }
+            $target++
+        }
+        [void]$table[$position[$key]].Remove($key)
+        [void]$table[$target].Add($key)
+        $position[$key] = $target
+    }
+    while ($table.Count -gt 0 -and $table[$table.Count - 1].Count -eq 0) { $table.RemoveAt($table.Count - 1) }
+    $result = [System.Collections.Generic.List[object]]::new()
+    foreach ($set in $table) { $result.Add([long[]]@($set)) }
+    return , $result.ToArray()
+}
+
+# A predecessor in one of these merge states, or in state withdrawn, no longer
+# constrains its dependent (decision D6). A blocked predecessor still holds.
+$script:ReleasedMergeStatus = @('merged', 'worktree_removed')
+
+function Get-ParallelActivePrecedence {
+    <#
+    .SYNOPSIS
+        Resolve the precedence entries that still constrain scheduling.
+
+    .DESCRIPTION
+        Each entry's keys are mapped to the item that carries them: an item
+        carries its own issue_num and every key in its combined_issue_nums, so a
+        combined item inherits the union of its members' entries, and a pair
+        inside one combination is dropped. An entry is inactive when its `before`
+        item has merge_status merged or worktree_removed, or state withdrawn; a
+        blocked predecessor holds (D6). A key that resolves to no item throws
+        precedence_unknown_item. Duplicate entries collapse to one.
+
+    .OUTPUTS
+        System.Object[] of pscustomobject {before, after}, sorted by (before, after).
+    #>
+    [CmdletBinding()]
+    [OutputType([System.Object[]])]
+    param([AllowNull()][AllowEmptyCollection()][object[]] $Precedence = @(), [AllowNull()][AllowEmptyCollection()][object[]] $Item = @())
+
+    $owner = @{}
+    $record = @{}
+    foreach ($entry in @($Item)) {
+        $key = ConvertTo-ParallelPrecedenceKey -Value (Get-ParallelPrecedenceMapValue -Map $entry -Key 'issue_num')
+        if ($null -eq $key) { continue }
+        $record[$key] = $entry
+        $owner[$key] = $key
+        foreach ($member in @(Get-ParallelPrecedenceMapValue -Map $entry -Key 'combined_issue_nums')) {
+            $memberKey = ConvertTo-ParallelPrecedenceKey -Value $member
+            if ($null -ne $memberKey) { $owner[$memberKey] = $key }
+        }
+    }
+    $active = [System.Collections.Generic.SortedDictionary[string, object]]::new([System.StringComparer]::Ordinal)
+    foreach ($pair in (Get-ParallelPrecedencePair -Entry $Precedence)) {
+        foreach ($side in $pair) {
+            if (-not $owner.ContainsKey($side)) { throw "precedence_unknown_item: precedence entry $($pair[0]):$($pair[1]) names item $side, which is not an item of the run." }
+        }
+        $before = [long]$owner[$pair[0]]
+        $after = [long]$owner[$pair[1]]
+        if ($before -eq $after) { continue }
+        $predecessor = $record[$before]
+        $mergeStatus = Get-ParallelPrecedenceMapValue -Map $predecessor -Key 'merge_status'
+        $state = Get-ParallelPrecedenceMapValue -Map $predecessor -Key 'state'
+        if ($script:ReleasedMergeStatus -ccontains $mergeStatus -or $state -ceq 'withdrawn') { continue }
+        $active[('{0:D20}:{1:D20}' -f $before, $after)] = [pscustomobject]@{ before = $before; after = $after }
+    }
+    return , [object[]]@($active.Values)
+}
+
+function Test-ParallelPrecedenceCohortTable {
+    <#
+    .SYNOPSIS
+        Check a parallel checkpoint's current-generation cohort table against its active precedence entries.
+
+    .DESCRIPTION
+        For each active entry, the cohort index of the `after` item must be
+        strictly greater than the index of the `before` item within the cohorts
+        whose generation equals recolor_generation. An entry whose item is in no
+        current-generation cohort is not compared. An absent precedence key gives
+        a satisfied table.
+
+    .OUTPUTS
+        pscustomobject with Satisfied, Violation (strings), and Active (the active entries).
+    #>
+    [CmdletBinding()]
+    [OutputType([pscustomobject])]
+    param([AllowNull()][object] $Checkpoint)
+
+    if ($Checkpoint -isnot [System.Collections.IDictionary]) { throw 'The parallel checkpoint must be a JSON object.' }
+    $active = Get-ParallelActivePrecedence -Precedence @(Get-ParallelPrecedenceMapValue -Map $Checkpoint -Key 'precedence') -Item @(Get-ParallelPrecedenceMapValue -Map $Checkpoint -Key 'items')
+    $generation = Get-ParallelPrecedenceMapValue -Map $Checkpoint -Key 'recolor_generation'
+    $index = @{}
+    foreach ($cohort in @(Get-ParallelPrecedenceMapValue -Map $Checkpoint -Key 'cohorts')) {
+        if ((Get-ParallelPrecedenceMapValue -Map $cohort -Key 'generation') -ne $generation) { continue }
+        $cohortIndex = Get-ParallelPrecedenceMapValue -Map $cohort -Key 'index'
+        foreach ($member in @(Get-ParallelPrecedenceMapValue -Map $cohort -Key 'item_keys')) {
+            $memberKey = ConvertTo-ParallelPrecedenceKey -Value $member
+            if ($null -ne $memberKey) { $index[$memberKey] = [long]$cohortIndex }
+        }
+    }
+    $violation = [System.Collections.Generic.List[string]]::new()
+    foreach ($entry in $active) {
+        if (-not $index.ContainsKey($entry.before) -or -not $index.ContainsKey($entry.after)) { continue }
+        if ($index[$entry.after] -le $index[$entry.before]) {
+            $violation.Add("item $($entry.after) in cohort $($index[$entry.after]) must follow item $($entry.before) in cohort $($index[$entry.before])")
+        }
+    }
+    return [pscustomobject]@{ Satisfied = ($violation.Count -eq 0); Violation = [string[]]$violation.ToArray(); Active = $active }
+}
+
+function ConvertTo-ParallelSchedulingProjection {
+    <#
+    .SYNOPSIS
+        Project each dictionary onto the named keys in ordinal key order; a missing key becomes null.
+    #>
+    [CmdletBinding()]
+    [OutputType([System.Object[]])]
+    param([AllowNull()][AllowEmptyCollection()][object[]] $Value = @(), [string[]] $Key)
+
+    $sortedKey = [string[]]@($Key)
+    [Array]::Sort($sortedKey, [System.StringComparer]::Ordinal)
+    $projection = [System.Collections.Generic.List[object]]::new()
+    foreach ($entry in @($Value)) {
+        if ($entry -isnot [System.Collections.IDictionary]) { continue }
+        $row = [ordered]@{}
+        foreach ($name in $sortedKey) { $row[$name] = Get-ParallelPrecedenceMapValue -Map $entry -Key $name }
+        $projection.Add($row)
+    }
+    return , $projection.ToArray()
+}
+
+$script:RecordItemKey = @('issue_num', 'branch_name', 'plan_path', 'plan_hash', 'base_commit', 'preparation_status', 'complexity_band')
+
+function New-ParallelSchedulingRecord {
+    <#
+    .SYNOPSIS
+        Build the durable scheduling record docs/features/parallel/<slug>/parallel-scheduling.json.
+
+    .DESCRIPTION
+        The record carries exactly schema_version, parallel_slug, edges,
+        tolerated_overlaps, precedence, and items. Edges keep a, b, and reason;
+        tolerated overlaps keep a, b, reasons, cost, and benefit; precedence
+        entries keep before, after, source, and recorded_at; items keep
+        issue_num, branch_name, plan_path, plan_hash, base_commit,
+        preparation_status, and complexity_band. Keys are in ordinal order at
+        every level and lists are sorted by their keys, so the same input always
+        yields the same record. The function builds content only; the caller
+        writes and commits it.
+
+    .OUTPUTS
+        System.Collections.Specialized.OrderedDictionary.
+    #>
+    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseShouldProcessForStateChangingFunctions', '', Justification = 'Pure record constructor; no state is changed.')]
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param(
+        [string] $Slug,
+        [AllowNull()][AllowEmptyCollection()][object[]] $Edge = @(),
+        [AllowNull()][AllowEmptyCollection()][object[]] $ToleratedOverlap = @(),
+        [AllowNull()][AllowEmptyCollection()][object[]] $Precedence = @(),
+        [AllowNull()][AllowEmptyCollection()][object[]] $Item = @()
+    )
+
+    if ([string]::IsNullOrWhiteSpace($Slug)) { throw 'New-ParallelSchedulingRecord requires -Slug.' }
+    $byPair = @(@{ Expression = { [long]$_['a'] } }, @{ Expression = { [long]$_['b'] } })
+    # Each projection is parenthesized so the pipeline enumerates its rows rather than passing the array as one object.
+    $edges = @((ConvertTo-ParallelSchedulingProjection -Value $Edge -Key @('a', 'b', 'reason')) | Sort-Object -Property $byPair)
+    $tolerated = @((ConvertTo-ParallelSchedulingProjection -Value $ToleratedOverlap -Key @('a', 'b', 'reasons', 'cost', 'benefit')) | Sort-Object -Property $byPair)
+    $precedence = @((ConvertTo-ParallelSchedulingProjection -Value $Precedence -Key @('before', 'after', 'source', 'recorded_at')) |
+            Sort-Object -Property @{ Expression = { [long]$_['before'] } }, @{ Expression = { [long]$_['after'] } })
+    $items = @((ConvertTo-ParallelSchedulingProjection -Value $Item -Key $script:RecordItemKey) | Sort-Object -Property @{ Expression = { [long]$_['issue_num'] } })
+    $record = [ordered]@{}
+    $record['edges'] = [object[]]$edges
+    $record['items'] = [object[]]$items
+    $record['parallel_slug'] = $Slug
+    $record['precedence'] = [object[]]$precedence
+    $record['schema_version'] = [long]1
+    $record['tolerated_overlaps'] = [object[]]$tolerated
+    return $record
+}
+
+function Get-ParallelSchedulingRecordReuse {
+    <#
+    .SYNOPSIS
+        Decide whether a re-seed may reuse an item's recorded conflict edges.
+
+    .DESCRIPTION
+        Reuse applies only when the record lists the item and its recorded
+        plan_hash equals the current plan blob hash; the item's recorded edges
+        (those with the item at either end) are then returned. Otherwise the
+        result is a recompute marker with the reason unknown_item or
+        plan_hash_changed.
+
+    .OUTPUTS
+        pscustomobject with action (reuse or recompute), reason, and edges.
+    #>
+    [CmdletBinding()]
+    [OutputType([pscustomobject])]
+    param([AllowNull()][object] $Record, [long] $IssueNum, [AllowNull()][AllowEmptyString()][string] $CurrentPlanHash)
+
+    $recorded = @(@(Get-ParallelPrecedenceMapValue -Map $Record -Key 'items') | Where-Object {
+            (ConvertTo-ParallelPrecedenceKey -Value (Get-ParallelPrecedenceMapValue -Map $_ -Key 'issue_num')) -eq $IssueNum
+        })
+    if ($recorded.Count -eq 0) {
+        return [pscustomobject]@{ action = 'recompute'; reason = 'unknown_item'; edges = [object[]]@() }
+    }
+    $hash = Get-ParallelPrecedenceMapValue -Map $recorded[0] -Key 'plan_hash'
+    if ([string]::IsNullOrEmpty($CurrentPlanHash) -or [string]$hash -cne $CurrentPlanHash) {
+        return [pscustomobject]@{ action = 'recompute'; reason = 'plan_hash_changed'; edges = [object[]]@() }
+    }
+    $edges = @(@(Get-ParallelPrecedenceMapValue -Map $Record -Key 'edges') | Where-Object {
+            $_ -is [System.Collections.IDictionary] -and (
+                (ConvertTo-ParallelPrecedenceKey -Value $_['a']) -eq $IssueNum -or (ConvertTo-ParallelPrecedenceKey -Value $_['b']) -eq $IssueNum)
+        })
+    return [pscustomobject]@{ action = 'reuse'; reason = 'plan_hash_matches'; edges = [object[]]$edges }
+}
+
+Export-ModuleMember -Function `
+    ConvertTo-ParallelPrecedenceKey, `
+    Get-ParallelPrecedencePair, `
+    Get-ParallelPrecedenceOrder, `
+    Test-ParallelPrecedenceInput, `
+    ConvertTo-ParallelPrecedenceEdge, `
+    Invoke-ParallelPrecedenceLift, `
+    Get-ParallelActivePrecedence, `
+    Test-ParallelPrecedenceCohortTable, `
+    New-ParallelSchedulingRecord, `
+    Get-ParallelSchedulingRecordReuse

package/resources/claude-customizations/.claude/rules/csharp.md

@@ -2,19 +2,19 @@
 paths:
   - "**/*.cs"
   - "**/*.csproj"
-description: C#-specific toolchain and coding standards (xUnit).
+description: C#-specific toolchain and coding standards (MSTest).
 ---
 
 # C# Code Standards
 
-This rule file summarizes the C#-specific policies for this repository. It targets a host-neutral .NET foundation: xUnit, NSubstitute, FluentAssertions, `dotnet build`, the analyzer stack, `TimeProvider`, and uniform coverage thresholds.
+This rule file summarizes the C#-specific policies for this repository. It targets a host-neutral .NET foundation: MSTest, NSubstitute, FluentAssertions, `dotnet build`, the analyzer stack, `TimeProvider`, and uniform coverage thresholds.
 
 ## Toolchain
 
 1. **Formatting — CSharpier**: All C# source files must be formatted with CSharpier. Do not use `dotnet format`. Command: `dotnet tool restore` followed by `dotnet csharpier check .` (or `dotnet csharpier .` to auto-format).
 2. **Linting — .NET Analyzers**: C# code must pass Roslyn/.NET analyzer diagnostics. Analyzer enforcement is centralized in `Directory.Build.props` (`AnalysisLevel=latest-all`, `AnalysisMode=All`, `TreatWarningsAsErrors=true`). Command: `dotnet build` runs analyzers as part of the build.
 3. **Type Checking — Nullable Analysis**: Nullable reference types are enabled solution-wide via `Directory.Build.props` (`Nullable=enable`, `TreatWarningsAsErrors=true`). Command: `dotnet build` enforces nullable warnings as errors.
-4. **Testing — xUnit + NSubstitute + FluentAssertions**: Run tests with: `dotnet test --collect:"XPlat Code Coverage"`.
+4. **Testing — MSTest + NSubstitute + FluentAssertions**: Run tests with: `dotnet test --collect:"XPlat Code Coverage"`.
 
 Run the toolchain in order: format → lint → type-check → architecture → test. Restart from step 1 if any step fails or changes files.
 
@@ -31,11 +31,11 @@ Run the toolchain in order: format → lint → type-check → architecture →
 
 ## Testing Standards
 
-- Use **xUnit** as the test framework with `[Fact]` and `[Theory]` attributes.
-- Use **`[Theory]` + `[InlineData]`** for parameterized tests.
-- Use **`IClassFixture<T>`** to share expensive setup across tests within a class.
+- Use **MSTest** (`Microsoft.VisualStudio.TestTools.UnitTesting`) as the test framework with `[TestClass]` and `[TestMethod]` attributes, on the VSTest runner (the `MSTest` package with `Microsoft.NET.Test.Sdk` and `coverlet.collector`).
+- Use **`[TestMethod]` + `[DataRow]`** for parameterized tests.
+- Use **`[ClassInitialize]`** to share expensive setup across tests within a class.
 - Use **NSubstitute** for test doubles. Example: `var sut = Substitute.For<IService>(); sut.Get().Returns(value);`.
-- Prefer **FluentAssertions** for assertions; use xUnit `Assert` only when FluentAssertions is not practical.
+- Prefer **FluentAssertions** for assertions; use MSTest `Assert` only when FluentAssertions is not practical.
 - Follow Arrange–Act–Assert structure.
 - No external dependencies in unit tests.
 
@@ -53,7 +53,7 @@ Run the toolchain in order: format → lint → type-check → architecture →
 
 ### Golden Tests
 
-- **Verify.Xunit**: required for T1 classifier-output modules, tested against a versioned corpus.
+- **Verify.MSTest**: required for T1 classifier-output modules, tested against a versioned corpus.
 
 ## Analyzer Stack
 

package/resources/claude-customizations/.claude/rules/orchestrator-state.md

@@ -71,7 +71,7 @@ These invariants apply only when the checkpoint contains a top-level `remediatio
 
 1. **Non-empty `plan_path`.** Each cycle's `plan_path` must be a non-empty string. A missing value, a non-string value, or an empty/whitespace-only string is a malformed cycle.
 
-2. **Execution requires cleared preflight.** A cycle's `execution_status` may be in `{in_progress, complete, failed}` only when that cycle's `preflight.final_status` is exactly `'clear'`. Any other preflight status with one of those execution statuses is a malformed cycle (execution was recorded before preflight cleared).
+2. **Execution requires cleared preflight.** A cycle's `execution_status` may be in `{in_progress, complete, failed}` only when that cycle's `preflight.final_status` is exactly `'clear'`. Any other preflight status with one of those execution statuses is a malformed cycle (execution was recorded before preflight cleared). The invariant does not apply to a cycle whose `remediation_path` is exactly the string `light`, compared ordinally, because a light cycle runs no preflight; invariant 8 governs that cycle.
 
 3. **Exit gate requires zero blocking findings.** When a cycle's `exit_condition_met == true`, its `blocking_count` must be `0`. A non-zero `blocking_count` with `exit_condition_met == true` is a malformed cycle (the exit gate was marked satisfied while blocking findings remained).
 
@@ -83,6 +83,17 @@ These invariants apply only when the checkpoint contains a top-level `remediatio
 
 7. **`completed_attempts` counts completed attempts (R7).** When `remediation_loop.completed_attempts` is present, it must be a non-negative integer (not a boolean) equal to the number of object cycles whose `candidate_applied` is `true` (zero when `cycles` is absent or not a list), and any other value is a malformed loop.
 
+8. **Light remediation (issue #1097).** When a cycle object carries `remediation_path`, the rules below run in the accounting stage, after the R7 checks, per cycle in order, with byte-identical messages in `scripts/dev_tools/_orchestrator_state_light_cycle.py`, `extensions/drm-copilot/src/lib/validate/orchestrator-state-light-cycle.ts`, and `Get-RemediationLightCycleError` in `.claude/lib/orchestrator-state/OrchestratorStateRemediationAccounting.psm1`, pinned by the corpus `tests/fixtures/orchestrator_state_remediation_loop/`. A cycle without the key reaches none of them, so every existing checkpoint validates as before. `scope` on a finding is read only by these rules.
+   1. A value other than exactly `light` or `full`, null included: `Checkpoint remediation cycle #N remediation_path must be light or full.` Nothing further runs for the cycle, and nothing further runs for `full`.
+   2. A `preflight` key, whatever its value: `Checkpoint remediation cycle #N remediation_path is light but the cycle carries preflight.`
+   3. `opened_by_review` absent, or not naming a `REMEDIATION_REQUIRED` outcome by the R11 predicate: `Checkpoint remediation cycle #N remediation_path is light but opened_by_review does not name its opening review.` Rules 4 to 6 are then skipped.
+   4. More than 3 findings in that outcome (a non-list `findings` value counts as empty): `Checkpoint remediation cycle #N remediation_path is light but its opening review has M findings; the limit is 3.`
+   5. Per finding K whose `remediability` is not exactly `autonomous`, a non-object finding included: `Checkpoint remediation cycle #N remediation_path is light but finding #K is not autonomous.`
+   6. Per finding K whose `scope` is not exactly `contained`, absent included: `Checkpoint remediation cycle #N remediation_path is light but finding #K scope is not contained.`
+   7. The immediately prior list element is an object whose `remediation_path` is exactly `light`: `Checkpoint remediation cycle #N remediation_path is light but the prior cycle is light.`
+
+   Route (D9): the installed MCP validator applies invariant 8 only after the extension release that carries it is installed. Until then, a Claude run validates a light checkpoint through the repository-local Python CLI, and on Codex, whose completion boundary is the installed MCP validator, the light path is unavailable.
+
 ## Invariants (remediation_loop.review_outcomes)
 
 These invariants apply only when `remediation_loop` contains a `review_outcomes` key. The orchestrator appends one entry per review, including a `PASS` review, in the shape `{"verdict": <verdict>, "findings": [{"remediability": <class>}, ...]}`, where `findings` lists the review's blocking findings only. A halt or wait verdict records no remediation cycle.
@@ -264,7 +275,7 @@ A standalone run (neither an epic child nor a parallel item) merges its own pull
 3. The per-feature checkpoint has `epic_mode` absent, `null`, or JSON `false`; carries no `parallel_mode: true` and no non-blank `parallel_slug`; records `step9_status` exactly `passed` and `ci_gate.conclusion` exactly `success`; records `pr_gate.pr_number` as a JSON integer equal to the command number (an authorization record does not substitute); records `ci_gate.head_sha` as a lowercase 40 or 64 character object id; and, when `pr_gate.head_sha` is present and not `null`, records it equal to `ci_gate.head_sha`.
 4. The live pull-request head from one bounded `gh pr view` call equals `ci_gate.head_sha`, and a `--match-head-commit` value, when present, equals the live head.
 
-`parallel_mode`, `parallel_slug`, and `pr_merge` are tolerated, unvalidated top-level checkpoint keys: no validator reads them. A parallel child records `parallel_mode: true` and `parallel_slug` at kickoff, and a standalone run records `pr_merge: { merge_commit_sha, target_branch, merged_at }` only after its merge is confirmed.
+`parallel_mode`, `parallel_slug`, `pr_merge`, and `stage_timing` are tolerated, unvalidated top-level checkpoint keys: no validator reads them. A parallel child records `parallel_mode: true` and `parallel_slug` at kickoff, and a standalone run records `pr_merge: { merge_commit_sha, target_branch, merged_at }` only after its merge is confirmed. The orchestrator main session writes `stage_timing`, a list of `{ stage, attempt, started_at, ended_at }` entries (issue 1097) of wall-clock times in which `ended_at` is null while a stage is open, and commits the same list as `FEATURE/evidence/other/stage-timing.<timestamp>.json` before the merge. The merge stage is not captured. The writer protocol is in the orchestrate skill.
 
 Honest disclosure: the parallel exclusion is best-effort. The `Parallel mode: true` marker lives in the delegation prompt and is not present in a Bash `PreToolUse` payload, so a parallel child whose number and worktree path the parallel checkpoint has not yet recorded, and which omits the `parallel_mode` key, is not excluded by the hook. Like the authorization record above, the green-CI condition is a policy-level control, not a security control. A push after the live-head lookup can also change the head unless the command passes `--match-head-commit`, which the hook does not require.
 
@@ -317,6 +328,21 @@ A lifecycle record moved to `docs/features/potential/promoted/` satisfies the `p
 
 Fail-closed behavior: any adoption error waives nothing, so each missing receipt is still reported as `Checkpoint missing successful MCP receipt: <tool>.`. Adoption errors are placed after the receipt-loop errors and before the `local_execution_overrides` errors. Rule 10 and rule 11 errors follow the rule 9 errors in the adoption error list, so a checkpoint that waives `new_active_feature_folder` without a valid record reports the missing-receipt line for each unreceipted required tool first, in `required_mcp_tools` order, and the rule 10 or rule 11 error after them. The waiver affects only receipt presence: the declared `required_mcp_tools` equality check with the routing matrix is unchanged, so a checkpoint must still declare every route tool it waives.
 
+## Concurrent-Review Scope and Backward Compatibility
+
+These rules apply only when a checkpoint contains the top-level key `review_mode` with the exact string `concurrent`, compared ordinally. An absent key, `null`, `sequential`, a case variant, a number, and every other value mean sequential, and a checkpoint without the key validates exactly as before: no `gh` call, no new denial, and no readiness relaxation. The key is tolerated and is not a member of `REQUIRED_STATE_KEYS`. `.claude/skills/orchestrate/SKILL.md` (`## Concurrent Review and CI (review_mode)`) defines the run sequence.
+
+- **`head_sha`.** Each `remediation_loop.review_outcomes[]` entry of a concurrent run carries `head_sha`: the head the review ran against, a full lowercase object id of 40 or 64 characters. Plain validation does not read it.
+- **Last-entry semantics.** Only the final `review_outcomes[]` element counts, so an earlier `PASS` never satisfies a rule.
+- **Readiness.** Under the key, PR-creation readiness stops rejecting `step7_status` for the value `pending` only. `blocked`, and every other step, keep today's result. TypeScript has no readiness port.
+- **Completion.** Under the key, `require_complete` appends exactly one of these strings after the existing completion checks, byte-identical in `scripts/dev_tools/_orchestrator_state_concurrent_review.py`, `extensions/drm-copilot/src/lib/validate/orchestrator-state-concurrent-review.ts`, and `Get-OrchestratorStateCompletionConcurrentReviewError` in `.claude/lib/orchestrator-state/OrchestratorStateCompletionChecks.psm1`, and pinned by the corpus `tests/fixtures/orchestrator_state_concurrent_review/`. The second is reported only when the first does not apply. Validators do no git work.
+  - `Checkpoint completion validation failed: review_mode concurrent requires a last review_outcomes entry with verdict PASS.`
+  - `Checkpoint completion validation failed: review_mode concurrent requires head_sha on the last review_outcomes entry.`
+- **Merge guard.** `.claude/hooks/enforce-epic-merge-gate-review.ps1`, byte-identical at `.codex/hooks/`, runs before every allow branch of both merge gates. It denies with `REVIEW_GATE_NOT_PASSED`, `REVIEW_GATE_HEAD_STALE`, or `REVIEW_GATE_HEAD_UNRESOLVED`, each after the token `EPIC_MERGE_GATE_BLOCKED`. A later head is current only when the reviewed head is its ancestor and every path changed since then lies inside `feature-folder`, so a code change after the review, including a merge of `origin/main`, is stale. A merge must be one plain `gh pr merge` of one number as its own Bash call: under the key, text that could be a merge and cannot be bound to one pull request is denied with `REVIEW_GATE_HEAD_UNRESOLVED`, before any process and before the out-of-scope allow of both gates.
+- **Validator route (D9).** The TypeScript rule reaches the MCP surface only after an extension release. Until then, installed MCP accepts a checkpoint that the PowerShell stop hook and the Python CLI reject, so a concurrent checkpoint is checked through the Python CLI.
+
+Honest disclosure (D10): the guard is a policy-level control, not a security control. A writer in the same session can edit the checkpoint. A merge outside the Bash hook surface is not gated. A merge whose item target does not resolve (`NoTarget` or `Ambiguous`), or whose child checkpoint does not parse, sees no key, and the parallel skill step is then the only backstop. A push after the lookup can change the head unless the command passes `--match-head-commit`. The `CI full run` requirement of the join is skill-level, because a docs-only head passes `CI Required Gate`. The authorization path reads no CI result, so the required `CI Required Gate` context is the control there. A text scan cannot read every merge: a script file performing the merge cannot be read, and neither can encoded or run-time composed text, a `gh` alias or shell function from an earlier call, or an endpoint held in a variable. A merge through a tool other than Bash is not gated: the Claude PowerShell tool and `mcp__*` tools, because the gate is registered on the `Bash` matcher only, and the Codex `shell_command` tool, because the gate is registered under `^Bash$` and returns for any other tool name. An already-queued auto-merge fires with no command, and `gh pr merge <PR> --disable-auto` removes it. A direct push to the base branch is not a pull-request merge, and the gate does not read it. A number-less merge text sees only the session checkpoint, so a key in another worktree is not found. The extra checkpoint read of the shape rule is best-effort: a failed read sees no key and keeps the decision of a run without the key. The extra read covers at most the first 4 numbers of the text, so a key held only by an item named after them is not found. Under the key the rule is fail-closed, so prose containing `pr merge` is denied in any command, including `git commit -m` and `grep`. The trigger is wider than `pr merge`: prose such as `pr (#12)` or `pr $HOME` is denied the same way, and a plain merge followed by a line feed or `;` is denied, because a bound merge must be the whole text. This trade is accepted because only concurrent runs carry the key and a merge is issued in its own call.
+
 ## Enforcement
 
 - `scripts/dev_tools/validate_orchestrator_state.py` appends one error per violated invariant when a `remediation_loop` is present, using the existing validator message style (literal, checkpoint-context prefixed). The validator returns a list of error strings and does not mutate its input.