@danmoisan/drm-copilot-mcp 1.1.10 → 1.1.12

package/resources/codex-and-agents-customizations/.codex/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/codex-and-agents-customizations/.codex/hooks/enforce-orchestration-preimplementation-gate.ps1

@@ -20,6 +20,9 @@ param()
 # normative contract and which lacks headroom; leaving that file byte-untouched is the
 # proof the issue #539 exemption is behaviourally unchanged.
 . (Join-Path $PSScriptRoot 'enforce-orchestration-preimplementation-gate-modes.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'
@@ -151,9 +154,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

package/resources/codex-and-agents-customizations/.codex/hooks/enforce-promotion-mcp-only.ps1

@@ -29,6 +29,12 @@
 [CmdletBinding()]
 param()
 
+# Shared command-line parser (issue #545). Every forbidden-token scan and both `gh`
+# expressions below run against each segment's clause-ordered scan text, and the
+# structural matcher reaches the relocating `gh` spellings adjacency cannot.
+. (Join-Path $PSScriptRoot 'hook-command-scanner.ps1')
+. (Join-Path $PSScriptRoot 'hook-command-invocation.ps1')
+
 $script:PromotionMcpOnlyBlockedReason = 'PROMOTION_MCP_ONLY_BLOCKED: Direct Bash promotion-script execution is not allowed in agent sessions. Use the drm-copilot MCP promotion tools instead.'
 
 $script:PromotionMcpOnlyGhIssueBlockedReason = 'PROMOTION_MCP_ONLY_BLOCKED: Direct GitHub issue creation via `gh` bypasses the approved drm-copilot MCP promotion path (`mcp__drm-copilot__new_potential_entry` -> `mcp__drm-copilot__potential_to_issue` -> `mcp__drm-copilot__new_active_feature_folder`). Use those MCP tools instead.'
@@ -88,15 +94,34 @@ function Get-PromotionBypassReason {
         'new_active_feature_folder'
     )
 
-    foreach ($token in $forbiddenTokens) {
-        if ($CommandText.IndexOf($token, [System.StringComparison]::OrdinalIgnoreCase) -ge 0) {
-            return (Get-PromotionMcpOnlyBlockedReason)
+    # Issue #545: the scan text of a segment is its raw text only when the segment is
+    # wrapper-led, carries a live substitution, or could not be balanced; otherwise
+    # quoted spans and attached heredoc bodies are masked. A promotion tool name that
+    # appears only as a JSON receipt value is therefore a mention, not an invocation.
+    $segments = @(Read-CommandLineSegment -CommandText $CommandText)
+
+    foreach ($segment in $segments) {
+        foreach ($token in $forbiddenTokens) {
+            if ($segment.ScanText.IndexOf($token, [System.StringComparison]::OrdinalIgnoreCase) -ge 0) {
+                return (Get-PromotionMcpOnlyBlockedReason)
+            }
         }
     }
 
     # `gh issue create` and `gh issue new` are direct bypasses of the MCP
     # promotion path. Tolerate any flags after the subcommand.
-    if ($CommandText -match '(?i)\bgh\s+issue\s+(?:create|new)\b') {
+    foreach ($segment in $segments) {
+        if ($segment.ScanText -match '(?i)\bgh\s+issue\s+(?:create|new)\b') {
+            return (Get-PromotionMcpOnlyGhIssueBlockedReason)
+        }
+    }
+
+    # The adjacency-requiring expression above cannot see a relocating spelling, in
+    # which a `gh` global option such as --repo or -R sits between the command word
+    # and its subcommand (D10). The structural matcher absorbs those options and
+    # reads the subcommand path positionally, so both spellings classify.
+    if ((Test-CommandLineInvocation -CommandText $CommandText -CommandWord 'gh' -SubcommandPath @('issue', 'create')) -or
+        (Test-CommandLineInvocation -CommandText $CommandText -CommandWord 'gh' -SubcommandPath @('issue', 'new'))) {
         return (Get-PromotionMcpOnlyGhIssueBlockedReason)
     }
 
@@ -104,10 +129,12 @@ function Get-PromotionBypassReason {
     # explicit POST method is supplied. `gh api` defaults to GET, so we only
     # block when -X POST or --method POST is present, to avoid false positives
     # on issue read operations. Use a single regex with lookaheads against the
-    # whole command string.
+    # scan text of one segment.
     $ghApiIssuesPostPattern = '(?i)(?=.*\bgh\s+api\b)(?=.*repos/[^/\s]+/[^/\s]+/issues(?:\b|/[^/\s]*$))(?=.*(?:-X\s+POST|--method\s+POST))'
-    if ($CommandText -match $ghApiIssuesPostPattern) {
-        return (Get-PromotionMcpOnlyGhIssueBlockedReason)
+    foreach ($segment in $segments) {
+        if ($segment.ScanText -match $ghApiIssuesPostPattern) {
+            return (Get-PromotionMcpOnlyGhIssueBlockedReason)
+        }
     }
 
     return $null