@danmoisan/drm-copilot-mcp 1.1.10 → 1.1.12

package/resources/claude-customizations/.claude/hooks/enforce-orchestration-preimplementation-gate-helpers.ps1

@@ -27,15 +27,34 @@ $script:OrchestrationBookkeepingTrees = @(
     'artifacts/orchestration/'
 )
 
-# Characters that make a command line statically unresolvable: shell interpolation and
-# redirection (D4 row 12). Tested across the whole line rather than per operand, because a
-# redirection anywhere in the line moves content the operand list cannot describe.
-$script:UnresolvableCommandCharacters = [char[]]@('$', '`', '>', '<')
+# Characters that make a command line statically unresolvable (D4 row 12, as narrowed by
+# issue #663). Interpolation characters are unresolvable in every quote state, because a
+# double-quoted span still expands them. Redirection characters are unresolvable only
+# outside a quoted span: inside single or double quotes the shell treats `<` and `>` as
+# literal text, so a quoted Co-Authored-By trailer is not a redirection.
+$script:InterpolationCommandCharacters = [char[]]@('$', '`')
+$script:RedirectionCommandCharacters = [char[]]@('>', '<')
 
 # Wildcards that make an operand a glob (D4 row 15). Only the literal prefix before the
 # first of these is prefix-tested.
 $script:PathspecWildcardCharacters = [char[]]@('*', '?', '[')
 
+# The single repository selector modelled between the command name and the subcommand: D4
+# row 14 as narrowed by issue #671, the Lexical Absolute-Canonical Selector (LACS) rule in
+# docs/features/active/2026-09-13-preimplementation-gate-worktree-selector-671/spec.md.
+# Compared case-sensitively; no other relocating spelling is modelled.
+$script:OrchestrationSelectorOptionName = '-C'
+
+# Accepted widening (issue #671): a selector naming a nested subdirectory of a worktree
+# passes L1 through L8 lexically yet relocates what a relative operand denotes, so
+# `docs/features/active/X` under `-C <root>/tests/fixtures/resolve_execute_plan_prompt`
+# stages `tests/fixtures/resolve_execute_plan_prompt/docs/features/active/X`. Measured
+# exposure in this repository is seven Markdown test fixtures under the
+# resolve_execute_plan_prompt fixture tree, all of which the gate's file_path leg already
+# classifies as non-implementation. This module stays pure string logic; the epic's F1
+# resolution module composes upstream to close the escape later without a schema change,
+# the same posture D4 row 16 takes toward issue #516.
+
 function Split-OrchestrationCommandLine {
     <#
     .SYNOPSIS
@@ -88,6 +107,59 @@ function Split-OrchestrationCommandLine {
     }
 }
 
+function Test-OrchestrationCommandTextUnresolvable {
+    <#
+    .SYNOPSIS
+        Reports whether a command line carries a statically unresolvable character.
+    .DESCRIPTION
+        Realizes D4 row 12 as narrowed by issue #663. Quote state is tracked with the same
+        state machine as Split-OrchestrationCommandLine. An interpolation character (`$` or
+        backtick) answers true in any quote state; a redirection character (`<` or `>`)
+        answers true only outside a quoted span. Backslash escapes are not modelled, so a
+        backslash before any quote character, or anywhere inside a double-quoted span,
+        answers true: the shell may end the span where this scan does not (fail closed).
+    .PARAMETER CommandText
+        The full command line as the shell would receive it.
+    .OUTPUTS
+        System.Boolean
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param([Parameter(Mandatory)][AllowEmptyString()][string] $CommandText)
+
+    # An escaped quote moves a span boundary the scan cannot model (issue #663 remediation CR-1).
+    if ($CommandText.Contains('\"') -or $CommandText.Contains("\'")) {
+        return $true
+    }
+
+    $openQuote = [char]0
+
+    # Scan every character once, tracking whether it sits inside a quoted span so that
+    # redirection characters are judged only where the shell would honour them.
+    foreach ($character in $CommandText.ToCharArray()) {
+        if ($script:InterpolationCommandCharacters -contains $character) {
+            return $true
+        }
+
+        # Decide by quote state: inside a span only the closing quote matters, and any
+        # backslash inside a double-quoted span is an unmodelled escape; outside a span a
+        # quote opens one and a redirection character is unresolvable.
+        if ($openQuote -ne [char]0) {
+            if ($openQuote -eq '"' -and $character -eq '\') {
+                return $true
+            }
+            if ($character -eq $openQuote) {
+                $openQuote = [char]0
+            }
+        } elseif ($character -eq '"' -or $character -eq "'") {
+            $openQuote = $character
+        } elseif ($script:RedirectionCommandCharacters -contains $character) {
+            return $true
+        }
+    }
+    return $false
+}
+
 function ConvertTo-OrchestrationCommandToken {
     <#
     .SYNOPSIS
@@ -203,6 +275,67 @@ function Test-ExemptOrchestrationOperand {
     return $false
 }
 
+function Test-ExemptOrchestrationSelector {
+    <#
+    .SYNOPSIS
+        Tests the repository selector of one tokenized segment against LACS L1 through L8.
+    .DESCRIPTION
+        Realizes D4 row 14 as narrowed by issue #671 (the Lexical Absolute-Canonical Selector
+        rule in docs/features/active/2026-09-13-preimplementation-gate-worktree-selector-671/spec.md).
+        Returns true only when the segment reads `git -C <value> <subcommand> ...` and the
+        value is decidable from the command text alone: exactly one case-sensitive `-C`, at
+        index 1 (L1, L2); a value at index 2 and the subcommand at index 3 (L3); a
+        drive-lettered or rooted, non-UNC value after separator normalization (L4); no `.` or
+        `..` segment (L5); no wildcard (L6); no colon other than the drive colon (L7); and a
+        non-empty value (L8). Each rejection writes a diagnostic token through Write-Debug.
+        The tokens are not contractual and change no decision.
+        L3 checks only that a non-option token follows the value; the caller
+        Test-ExemptOrchestrationSegmentToken rejects any subcommand other than add or commit.
+    .OUTPUTS
+        System.Boolean
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param([Parameter(Mandatory)][AllowEmptyCollection()][AllowEmptyString()][string[]] $Token)
+
+    $selector = $script:OrchestrationSelectorOptionName
+    if ($Token.Count -lt 2 -or $Token[1] -cne $selector) {
+        Write-Debug 'PREIMPL_SELECTOR_UNMODELLED_OPTION: the token after the command name is not the -C selector.'
+        return $false
+    }
+    if (@($Token | Where-Object { $_ -ceq $selector }).Count -gt 1) {
+        Write-Debug 'PREIMPL_SELECTOR_REPEATED: the segment carries more than one -C selector.'
+        return $false
+    }
+    if ($Token.Count -lt 4 -or $Token[3].StartsWith('-')) {
+        Write-Debug 'PREIMPL_SELECTOR_MALFORMED: no subcommand immediately follows the selector value.'
+        return $false
+    }
+    $value = $Token[2]
+    if (-not $value) {
+        Write-Debug 'PREIMPL_SELECTOR_MALFORMED: the selector value is empty.'
+        return $false
+    }
+
+    $normalized = $value -replace '\\', '/'
+    $isDriveRooted = $normalized -match '^[A-Za-z]:/'
+    if ($normalized.StartsWith('//') -or -not ($isDriveRooted -or $normalized.StartsWith('/'))) {
+        Write-Debug 'PREIMPL_SELECTOR_NOT_ROOTED: the selector value is relative or UNC.'
+        return $false
+    }
+    $segments = $normalized -split '/'
+    if ($segments -contains '..' -or $segments -contains '.') {
+        Write-Debug 'PREIMPL_SELECTOR_TRAVERSAL: the selector value carries a dot segment.'
+        return $false
+    }
+    $afterDrive = if ($isDriveRooted) { $normalized.Substring(2) } else { $normalized }
+    if ($normalized.IndexOfAny($script:PathspecWildcardCharacters) -ge 0 -or $afterDrive.Contains(':')) {
+        Write-Debug 'PREIMPL_SELECTOR_NOT_LITERAL: the selector value carries a wildcard or a stray colon.'
+        return $false
+    }
+    return $true
+}
+
 function Test-ExemptOrchestrationSegmentToken {
     <#
     .SYNOPSIS
@@ -218,18 +351,27 @@ function Test-ExemptOrchestrationSegmentToken {
     #>
     [CmdletBinding()]
     [OutputType([bool])]
-    param([Parameter(Mandatory)][AllowEmptyCollection()][string[]] $Token)
+    param([Parameter(Mandatory)][AllowEmptyCollection()][AllowEmptyString()][string[]] $Token)
 
     if ($Token.Count -lt 2) {
         return $false
     }
 
-    # Row 14: the command name leads and the subcommand follows immediately. Anything in
-    # between - a relocating option or an env-style prefix - moves the pathspec base and is
-    # rejected here rather than modelled.
+    # Row 14, narrowed by issue #671: the command name leads and the subcommand follows it,
+    # either immediately or after one lexically absolute `-C <value>` selector (LACS L1-L8).
+    # Anything else in between - an unmodelled or unresolvable relocating option, or an
+    # env-style prefix - moves the pathspec base undecidably and is rejected here.
     if ($Token[0] -cne 'git') {
         return $false
     }
+    if ($Token[1] -cne 'add' -and $Token[1] -cne 'commit') {
+        if (-not (Test-ExemptOrchestrationSelector -Token $Token)) {
+            return $false
+        }
+        # Drop the accepted selector and its value so the subcommand is again at index 1
+        # and operand collection below starts at index 2 exactly as before.
+        $Token = @($Token[0]) + @($Token[3..($Token.Count - 1)])
+    }
     $subcommand = $Token[1]
     if ($subcommand -cne 'add' -and $subcommand -cne 'commit') {
         return $false
@@ -322,9 +464,9 @@ function Test-ExemptOrchestrationStagingCommand {
         return $false
     }
 
-    # Row 12: interpolation and redirection are not statically resolvable, so the operand
-    # list cannot be trusted to describe what the line actually touches.
-    if ($CommandText.IndexOfAny($script:UnresolvableCommandCharacters) -ge 0) {
+    # Row 12: interpolation anywhere, redirection outside quotes, and unmodelled backslash
+    # escapes are not statically resolvable, so the operand list cannot be trusted.
+    if (Test-OrchestrationCommandTextUnresolvable -CommandText $CommandText) {
         return $false
     }
 
@@ -339,11 +481,17 @@ function Test-ExemptOrchestrationStagingCommand {
         return $false
     }
 
-    foreach ($segment in $segments) {
-        $tokens = @(ConvertTo-OrchestrationCommandToken -Segment $segment)
-        if (-not (Test-ExemptOrchestrationSegmentToken -Token $tokens)) {
-            return $false
+    # Fail closed (issue #671): an error raised while classifying any segment is a parse
+    # ambiguity, so it answers false instead of letting the caller continue past it.
+    try {
+        foreach ($segment in $segments) {
+            $tokens = @(ConvertTo-OrchestrationCommandToken -Segment $segment)
+            if (-not (Test-ExemptOrchestrationSegmentToken -Token $tokens)) {
+                return $false
+            }
         }
+    } catch {
+        return $false
     }
     return $true
 }

package/resources/claude-customizations/.claude/hooks/enforce-orchestration-preimplementation-gate.ps1

@@ -19,6 +19,14 @@ Import-Module (Join-Path $PSScriptRoot '../lib/hook-payload/HookPayload.psm1') -
 # proof the issue #539 exemption is behaviourally unchanged.
 . (Join-Path $PSScriptRoot 'enforce-orchestration-preimplementation-gate-modes.ps1')
 
+# Epic-scope command and path legs (issue #663, decision D2), plus the two per-mode read
+# seams relocated from this file to keep it inside the 500-line cap.
+. (Join-Path $PSScriptRoot 'enforce-orchestration-preimplementation-gate-epic-scope.ps1')
+
+# Shared command-line parser (issue #545): per-segment scan text and structural matching.
+. (Join-Path $PSScriptRoot 'hook-command-scanner.ps1')
+. (Join-Path $PSScriptRoot 'hook-command-invocation.ps1')
+
 # The readiness checkpoint this gate reads and names in its block message.
 $script:CheckpointPath = 'artifacts/orchestration/orchestrator-state.json'
 
@@ -132,9 +140,11 @@ function Test-ImplementationCommand {
         '(^|\s)npx\s+(prettier|eslint|tsc|jest)\b',
         '(^|\s)pwsh\s+.*(Invoke-Pester|tests/scripts/)'
     )
+    $scanText = @(Read-CommandLineSegment -CommandText $normalizedCommand).ScanText
+    $isStaging = @('add', 'commit').Where({ Test-CommandLineInvocation -CommandText $normalizedCommand -CommandWord 'git' -SubcommandPath @($_) }).Count -gt 0
 
     for ($index = 0; $index -lt $implementationCommandPatterns.Count; $index++) {
-        if ($normalizedCommand -notmatch $implementationCommandPatterns[$index]) {
+        if (-not (($scanText | Where-Object { $_ -match $implementationCommandPatterns[$index] }) -or ($index -eq 0 -and $isStaging))) {
             continue
         }
         # Allow-side only (issue #539). Index 0 is the git staging trigger, whose pattern
@@ -255,33 +265,6 @@ function Get-CheckpointContent {
     return Get-Content -Raw -LiteralPath $script:CheckpointPath
 }
 
-# The two per-mode read seams (issue #554). Each takes its path from the fixed mode
-# table and never from a delegation's own text; an absent file returns an empty
-# string, which the readiness predicate then treats as a deny.
-function Get-EpicCheckpointContent {
-    [CmdletBinding()]
-    [OutputType([string])]
-    param()
-
-    $path = Get-OrchestrationDelegationCheckpointPath -Mode 'epic'
-    if (-not (Test-Path -LiteralPath $path)) {
-        return ''
-    }
-    return Get-Content -Raw -LiteralPath $path
-}
-
-function Get-ParallelCheckpointContent {
-    [CmdletBinding()]
-    [OutputType([string])]
-    param()
-
-    $path = Get-OrchestrationDelegationCheckpointPath -Mode 'parallel'
-    if (-not (Test-Path -LiteralPath $path)) {
-        return ''
-    }
-    return Get-Content -Raw -LiteralPath $path
-}
-
 function Get-OrchestrationPreimplementationGateAllowDecision {
     [CmdletBinding()]
     [OutputType([System.Collections.Specialized.OrderedDictionary])]
@@ -371,6 +354,7 @@ function Invoke-OrchestrationPreimplementationGateDecision {
     # default wording they have today.
     $mode = $script:OrchestrationDelegationDefaultMode
     $prompt = ''
+    $command = ''
     $filePath = Get-StringProperty -Value $toolInput -Name 'file_path'
     if ($filePath) {
         $normalized = ([string]$filePath) -replace '\\', '/'
@@ -400,6 +384,15 @@ function Invoke-OrchestrationPreimplementationGateDecision {
             Get-OrchestrationModeDenyReason -Mode $mode -Failure 'declared-checkpoint-path')
     }
 
+    # The command and path legs consult the epic checkpoint first (issue #663). A call that
+    # is not epic scope yields $null and continues to the unchanged single-feature path.
+    if ($filePath -or $command) {
+        $epicDecision = Get-OrchestrationEpicScopeDecision -Command $command -FilePath $filePath
+        if ($null -ne $epicDecision) {
+            return $epicDecision
+        }
+    }
+
     if ($mode -eq 'epic' -or $mode -eq 'parallel') {
         $isEpic = ($mode -eq 'epic')
         $injected = if ($isEpic) { 'EpicCheckpointRaw' } else { 'ParallelCheckpointRaw' }

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

@@ -44,6 +44,13 @@ $script:AbandonConfirmToken = '--confirm-abandon'
 # Literal prefix on the deny reason, so the reason code is greppable in transcripts.
 $script:AbandonBlockedReasonCode = 'PARALLEL_ABANDON_BLOCKED'
 
+# Shared command-line parser (issue #545). Dot-sourced BELOW the two token assignments
+# rather than above them, deliberately: the assignments keep their existing line numbers,
+# so the diff shows no change at either line. Both are still declared before any function
+# body runs, because the file executes top to bottom before any of its functions is called.
+. (Join-Path $PSScriptRoot 'hook-command-scanner.ps1')
+. (Join-Path $PSScriptRoot 'hook-command-invocation.ps1')
+
 function Get-ParallelAbandonGateToolInput {
     <#
     .SYNOPSIS
@@ -85,10 +92,77 @@ function Get-ParallelAbandonNormalizedCommand {
     return ($CommandText -replace '\s+', ' ').Trim()
 }
 
+function Test-ParallelAbandonSegmentDisposition {
+    <#
+    .SYNOPSIS
+        Report whether one segment's tokens request the abandon disposition.
+    .DESCRIPTION
+        The option name and its value are derived from $script:AbandonDispositionToken by
+        splitting it on whitespace, so this function restates neither literal and the seam
+        test's single-source-of-truth property is preserved. Both spellings the producer's
+        argparse registration accepts are recognized: the separated pair
+        '--disposition' 'abandon' as two adjacent tokens, and the equals-joined single token
+        '--disposition=abandon'.
+
+        Comparison is by whole-token equality, which is case-insensitive in PowerShell and
+        therefore preserves the OrdinalIgnoreCase behaviour of the containment test it
+        replaces. Because a quoted span is one token, a grep whose quoted search term is the
+        disposition token no longer requests an abandon.
+
+        A raw-scan leg runs after the token loop, on the segments the scanner itself scans
+        raw, so a disposition carried inside a wrapper's quoted argument is still recognized.
+    .PARAMETER Segment
+        One segment record produced by Read-CommandLineSegment.
+    .OUTPUTS
+        System.Boolean
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param([Parameter(Mandatory)][AllowNull()] $Segment)
+
+    $parts = @($script:AbandonDispositionToken -split '\s+' | Where-Object { $_ })
+    if ($parts.Count -lt 2) {
+        return $false
+    }
+    $optionName = $parts[0]
+    $optionValue = $parts[1]
+    $joined = $optionName + '=' + $optionValue
+
+    $token = @($Segment.Tokens)
+
+    for ($index = 0; $index -lt $token.Count; $index++) {
+        if ($token[$index] -eq $joined) {
+            return $true
+        }
+        if ($token[$index] -eq $optionName -and
+            $index + 1 -lt $token.Count -and
+            $token[$index + 1] -eq $optionValue) {
+            return $true
+        }
+    }
+
+    if (-not (Test-CommandLineSegmentRawScan -Segment $Segment)) {
+        return $false
+    }
+
+    # A wrapper's quoted argument is a nested command line and collapses into ONE token, so
+    # neither the adjacent pair nor the equals-joined token can form inside it. Both accepted
+    # spellings are reconstructed from the split constant rather than restated, so the
+    # single-source-of-truth seam test still finds each literal exactly once in this file.
+    $scanText = [string]$Segment.ScanText
+    $comparison = [System.StringComparison]::OrdinalIgnoreCase
+    return ($scanText.IndexOf($joined, $comparison) -ge 0 -or
+        $scanText.IndexOf(($optionName + ' ' + $optionValue), $comparison) -ge 0)
+}
+
 function Test-ParallelAbandonCommandInScope {
     <#
     .SYNOPSIS
         Report whether a command carries the abandon disposition token at all.
+    .DESCRIPTION
+        Evaluated per segment through the shared parser rather than as a containment test
+        over the whole command string. In scope when ANY segment requests the abandon
+        disposition in either accepted spelling.
     .PARAMETER NormalizedCommand
         The whitespace-normalized command text.
     .OUTPUTS
@@ -105,15 +179,25 @@ function Test-ParallelAbandonCommandInScope {
     if ([string]::IsNullOrWhiteSpace($NormalizedCommand)) {
         return $false
     }
-    return $NormalizedCommand.Contains(
-        $script:AbandonDispositionToken,
-        [System.StringComparison]::OrdinalIgnoreCase)
+
+    foreach ($segment in @(Read-CommandLineSegment -CommandText $NormalizedCommand)) {
+        if (Test-ParallelAbandonSegmentDisposition -Segment $segment) {
+            return $true
+        }
+    }
+
+    return $false
 }
 
 function Test-ParallelAbandonCommandConfirmed {
     <#
     .SYNOPSIS
         Report whether a command carries the confirmation marker.
+    .DESCRIPTION
+        Confirmed only when a SINGLE segment carries both the abandon disposition and the
+        confirmation marker. The confirmation is the caller's deliberate acknowledgement of
+        this abandon, so a marker echoed in an unrelated segment is not an acknowledgement
+        of the command that follows it.
     .PARAMETER NormalizedCommand
         The whitespace-normalized command text.
     .OUTPUTS
@@ -130,9 +214,22 @@ function Test-ParallelAbandonCommandConfirmed {
     if ([string]::IsNullOrWhiteSpace($NormalizedCommand)) {
         return $false
     }
-    return $NormalizedCommand.Contains(
-        $script:AbandonConfirmToken,
-        [System.StringComparison]::OrdinalIgnoreCase)
+
+    foreach ($segment in @(Read-CommandLineSegment -CommandText $NormalizedCommand)) {
+        $tokens = @($segment.Tokens)
+        if (-not (Test-ParallelAbandonSegmentDisposition -Segment $segment)) {
+            continue
+        }
+        if ($tokens -contains $script:AbandonConfirmToken) {
+            return $true
+        }
+        if ((Test-CommandLineSegmentRawScan -Segment $segment) -and
+            ([string]$segment.ScanText).IndexOf($script:AbandonConfirmToken, [System.StringComparison]::OrdinalIgnoreCase) -ge 0) {
+            return $true
+        }
+    }
+
+    return $false
 }
 
 function Get-ParallelAbandonGateAllowDecision {

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

@@ -30,8 +30,27 @@ param()
 
 
 Import-Module (Join-Path $PSScriptRoot '../lib/hook-payload/HookPayload.psm1') -Force
+# Sanctioned-removal manifest reader (issue #635), consumed by the manifest branch in
+# Invoke-ParallelWorktreeRemovalGateDecision. Same module the epic gate imports.
+Import-Module (Join-Path $PSScriptRoot '../lib/cleanup-manifest/CleanupWorktreeManifest.psm1') -Force
+# Shared command-line parser (issue #545), consumed by the scope filter in
+# Invoke-ParallelWorktreeRemovalGateDecision and by Get-ParallelWorktreeRemovalCommandPath.
+# Both call sites are byte-for-byte the calls the epic gate makes, so the duplicated
+# concern now has one implementation.
+. (Join-Path $PSScriptRoot 'hook-command-scanner.ps1')
+. (Join-Path $PSScriptRoot 'hook-command-invocation.ps1')
 $script:ParallelCheckpointPath = 'artifacts/orchestration/parallel-orchestrator-state.json'
 $script:AllowedMergeStatuses = @('merged', 'worktree_removed')
+# Epic checkpoint location (issue #688). An epic run records per-child state in
+# features[] and never writes the parallel checkpoint, so without this read every
+# merged epic child worktree reached the deny below even though
+# enforce-epic-worktree-removal-gate.ps1 authorized the same call. Both gates run on
+# the same Bash call, so that deny won and epic worktrees could never be removed.
+$script:EpicCheckpointPath = 'artifacts/orchestration/epic-orchestrator-state.json'
+# Sanctioned-removal manifest location. Recorded here beside the checkpoint path so
+# every hook-read document this gate consults is named in one place; the module owns
+# the read itself.
+$script:CleanupWorktreeManifestPath = 'artifacts/orchestration/cleanup-worktrees-manifest.json'
 
 function Get-ParallelWorktreeRemovalGateCheckpointContent {
     <#
@@ -51,10 +70,50 @@ function Get-ParallelWorktreeRemovalGateCheckpointContent {
     return (Get-Content -LiteralPath $script:ParallelCheckpointPath -Raw)
 }
 
+function Get-ParallelWorktreeRemovalGateEpicCheckpointContent {
+    <#
+    .SYNOPSIS
+        Read the raw JSON text of the epic checkpoint. Tests mock this function
+        (read seam, issue #688).
+    .DESCRIPTION
+        A separate seam from the parallel checkpoint reader so a test can drive the
+        two documents independently: the epic branch must be exercised with the
+        parallel checkpoint absent, present-but-not-covering, and covering.
+    .OUTPUTS
+        System.String or $null
+    #>
+    [CmdletBinding()]
+    [OutputType([string])]
+    param()
+
+    if (-not (Test-Path -LiteralPath $script:EpicCheckpointPath -PathType Leaf)) {
+        return $null
+    }
+    return (Get-Content -LiteralPath $script:EpicCheckpointPath -Raw)
+}
+
 function Get-ParallelWorktreeRemovalCommandPath {
     <#
     .SYNOPSIS
         Extract the target worktree path argument from a git worktree remove command.
+    .DESCRIPTION
+        The operand comes from the segment that structurally invokes git worktree remove,
+        so a 'cd <path> &&' segment chained before the removal contributes nothing and a
+        quoted mention of the phrase resolves to no operand at all. Quotes around the path
+        are already stripped by the tokenizer.
+
+        '--force' is a zero-argument flag, so it never contributes an operand and may be
+        written on either side of the target path. Its presence is read structurally through
+        Test-CommandLineFlag rather than by searching the raw text, so a '--force' spelling
+        that appears inside an unrelated quoted argument cannot change how the operand list
+        is read. When no operand resolves, a present '--force' is reported in its place, so
+        the checkpoint lookup fails closed on a value that matches no recorded worktree_path
+        - the same value the previous raw-text pattern returned for that input.
+
+        This body is identical to Get-EpicWorktreeRemovalCommandPath in
+        enforce-epic-worktree-removal-gate.ps1. The two gates fire on the same command and
+        now delegate the shared concern to one parser rather than to two patterns that had
+        already diverged from the Codex copy.
     .PARAMETER CommandText
         The Bash command text under evaluation.
     .OUTPUTS
@@ -67,8 +126,14 @@ function Get-ParallelWorktreeRemovalCommandPath {
         [string] $CommandText
     )
 
-    if ($CommandText -match '(?i)\bgit\s+worktree\s+remove\s+(?<path>\S+)') {
-        return $Matches['path'].Trim('"''')
+    $hasForce = Test-CommandLineFlag -CommandText $CommandText -CommandWord 'git' -SubcommandPath @('worktree', 'remove') -FlagName '--force'
+    $operands = @(Get-CommandLineOperand -CommandText $CommandText -CommandWord 'git' -SubcommandPath @('worktree', 'remove'))
+
+    if ($operands.Count -gt 0) {
+        return $operands[0]
+    }
+    if ($hasForce) {
+        return '--force'
     }
     return $null
 }
@@ -76,11 +141,16 @@ function Get-ParallelWorktreeRemovalCommandPath {
 function Find-ParallelWorktreeItemRecord {
     <#
     .SYNOPSIS
-        Locate the items[] record whose worktree_path matches the target path.
+        Locate the record whose worktree_path matches the target path.
     .PARAMETER Checkpoint
-        Parsed parallel checkpoint, or $null when absent/unreadable.
+        Parsed checkpoint, or $null when absent/unreadable.
     .PARAMETER WorktreePath
         The target worktree path extracted from the command text.
+    .PARAMETER RecordArrayName
+        Name of the record array to scan. Defaults to 'items', the parallel
+        checkpoint's array, so every existing caller is unchanged; the epic branch
+        added for issue #688 passes 'features'. Parameterized rather than duplicated
+        so both topologies share one path-normalization implementation.
     .OUTPUTS
         System.Object or $null
     #>
@@ -90,14 +160,17 @@ function Find-ParallelWorktreeItemRecord {
         $Checkpoint,
 
         [AllowNull()]
-        [string] $WorktreePath
+        [string] $WorktreePath,
+
+        [ValidateNotNullOrEmpty()]
+        [string] $RecordArrayName = 'items'
     )
 
     if ($null -eq $Checkpoint -or [string]::IsNullOrWhiteSpace($WorktreePath)) {
         return $null
     }
     $checkpointProps = @($Checkpoint.PSObject.Properties.Name)
-    if ($checkpointProps -notcontains 'items') {
+    if ($checkpointProps -notcontains $RecordArrayName) {
         return $null
     }
 
@@ -105,7 +178,7 @@ function Find-ParallelWorktreeItemRecord {
 
     # 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)) {
+    foreach ($item in @($Checkpoint.$RecordArrayName)) {
         $itemProps = @($item.PSObject.Properties.Name)
         if ($itemProps -notcontains 'worktree_path') {
             continue
@@ -203,7 +276,10 @@ function Invoke-ParallelWorktreeRemovalGateDecision {
         return Get-ParallelWorktreeGateAllowDecision
     }
 
-    if ($commandText -notmatch '(?i)\bgit\s+worktree\s+remove\b') {
+    # Scope filter. The test is structural, so a relocating spelling such as
+    # 'git -C <dir> worktree remove <path>' is now in scope and quoted prose that merely
+    # mentions the phrase is not (issue #545). This is the same call the epic gate makes.
+    if (-not (Test-CommandLineInvocation -CommandText $commandText -CommandWord 'git' -SubcommandPath @('worktree', 'remove'))) {
         return Get-ParallelWorktreeGateAllowDecision
     }
 
@@ -224,6 +300,46 @@ function Invoke-ParallelWorktreeRemovalGateDecision {
         return Get-ParallelWorktreeGateAllowDecision
     }
 
+    # Epic-authorization branch (issue #688). It runs after the parallel allow above and
+    # before the manifest branch below, so neither of those decisions changes. An epic run
+    # records per-child state in the epic checkpoint's features[] array and never writes the
+    # parallel checkpoint, so before this branch every merged epic child worktree fell
+    # through to the deny even though enforce-epic-worktree-removal-gate.ps1 authorized the
+    # same call from that same record. The merge_status predicate is the one already used
+    # for parallel items, so the two topologies cannot drift apart on what counts as safe.
+    #
+    # Fail-closed is preserved: an absent, unreadable, or malformed epic checkpoint parses to
+    # $null, which yields no record, which is not allowed.
+    $epicCheckpointRaw = Get-ParallelWorktreeRemovalGateEpicCheckpointContent
+    $epicCheckpoint = $null
+    if (-not [string]::IsNullOrWhiteSpace($epicCheckpointRaw)) {
+        try {
+            $epicCheckpoint = $epicCheckpointRaw | ConvertFrom-Json -ErrorAction Stop
+        } catch {
+            $epicCheckpoint = $null
+        }
+    }
+
+    $featureRecord = Find-ParallelWorktreeItemRecord -Checkpoint $epicCheckpoint -WorktreePath $worktreePath -RecordArrayName 'features'
+    if (Test-ParallelWorktreeRemovalAllowed -ItemRecord $featureRecord) {
+        return Get-ParallelWorktreeGateAllowDecision
+    }
+
+    # Sanctioned-removal manifest branch (issue #635). It runs last, so a
+    # checkpoint-authorized removal still allows at the same decision point it does
+    # today and no transcript attribution changes.
+    #
+    # The coverage test is a PRESENCE test, deliberately not an authorization test. A
+    # target this checkpoint records at all is excluded from this branch regardless of
+    # that record's merge_status, so a removal the checkpoint does not authorize still
+    # reaches the unchanged deny below. This gate defines only the parallel checkpoint
+    # seam and has no epic-checkpoint seam, so its exclusion covers the items array
+    # only; the epic gate covers the features array with its own exclusion.
+    if (-not (Test-CleanupManifestCheckpointCoversPath -Checkpoint $checkpoint -RecordArrayName 'items' -WorktreePath $worktreePath) -and
+        (Test-CleanupWorktreeManifestAuthorizesRemoval -WorktreePath $worktreePath)) {
+        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."
 }