@danmoisan/drm-copilot-mcp 1.0.13 → 1.0.15

package/resources/codex-and-agents-customizations/.codex/hooks/enforce-epic-wave-barrier.ps1

@@ -0,0 +1,295 @@
+<#
+.SYNOPSIS
+    Denies covered child mutations before all epic dependencies are durably merged.
+
+.DESCRIPTION
+    For launcher-bound execution children, this PreToolUse gate resolves the exact feature and
+    epic checkpoint from the active session receipt before any local checkpoint exists. Native
+    compatibility paths use the local epic context. Mutation remains blocked until every
+    dependency is merged or worktree_removed.
+#>
+[CmdletBinding()]
+param()
+
+. (Join-Path $PSScriptRoot 'codex-epic-child-launch-attestation.ps1')
+
+$script:AllowedDependencyStatuses = @('merged', 'worktree_removed')
+
+function ConvertFrom-CodexWaveJson {
+    [CmdletBinding()]
+    param(
+        [AllowNull()][AllowEmptyString()][string] $Raw,
+        [Parameter(Mandatory)][string] $Name,
+        [switch] $Optional
+    )
+
+    if ([string]::IsNullOrWhiteSpace($Raw)) {
+        if ($Optional) {
+            return $null
+        }
+        throw "EPIC_WAVE_BARRIER_BLOCKED: $Name is empty."
+    }
+    try {
+        return $Raw | ConvertFrom-Json -ErrorAction Stop
+    } catch {
+        throw "EPIC_WAVE_BARRIER_BLOCKED: $Name is malformed JSON: $_"
+    }
+}
+
+function Get-CodexWaveFeatureKey {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param([Parameter(Mandatory)] $LocalCheckpoint)
+
+    foreach ($name in @('issue-num', 'issue_num', 'feature-folder', 'feature_folder')) {
+        if (@($LocalCheckpoint.PSObject.Properties.Name) -contains $name -and
+            -not [string]::IsNullOrWhiteSpace([string]$LocalCheckpoint.$name)) {
+            return (([string]$LocalCheckpoint.$name) -replace '\\', '/').TrimEnd('/').Split('/')[-1]
+        }
+    }
+    if (@($LocalCheckpoint.PSObject.Properties.Name) -contains 'epic_context' -and
+        $null -ne $LocalCheckpoint.epic_context) {
+        foreach ($name in @('issue_num', 'feature_folder', 'target_feature_folder')) {
+            if (@($LocalCheckpoint.epic_context.PSObject.Properties.Name) -contains $name -and
+                -not [string]::IsNullOrWhiteSpace([string]$LocalCheckpoint.epic_context.$name)) {
+                return (([string]$LocalCheckpoint.epic_context.$name) -replace '\\', '/').TrimEnd('/').Split('/')[-1]
+            }
+        }
+    }
+    return ''
+}
+
+function Find-CodexWaveFeature {
+    [CmdletBinding()]
+    param([AllowNull()] $Checkpoint, [Parameter(Mandatory)][string] $Key)
+
+    if ($null -eq $Checkpoint -or
+        @($Checkpoint.PSObject.Properties.Name) -notcontains 'features') {
+        return $null
+    }
+    foreach ($feature in @($Checkpoint.features)) {
+        if ($null -eq $feature) {
+            continue
+        }
+        $properties = @($feature.PSObject.Properties.Name)
+        if ($properties -contains 'issue_num' -and [string]$feature.issue_num -eq $Key) {
+            return $feature
+        }
+        if ($properties -contains 'feature_folder') {
+            $basename = (([string]$feature.feature_folder) -replace '\\', '/').TrimEnd('/').Split('/')[-1]
+            if ($basename -eq $Key) {
+                return $feature
+            }
+        }
+    }
+    return $null
+}
+
+function Find-CodexWaveLaunchFeature {
+    [CmdletBinding()]
+    param([AllowNull()] $Checkpoint, [Parameter(Mandatory)] $Receipt)
+
+    if ($null -eq $Checkpoint -or
+        @($Checkpoint.PSObject.Properties.Name) -notcontains 'features') {
+        return $null
+    }
+    $expectedFolder = (([string]$Receipt.feature_folder) -replace '\\', '/').TrimEnd('/')
+    foreach ($feature in @($Checkpoint.features)) {
+        if ($null -eq $feature) {
+            continue
+        }
+        $actualFolder = (([string]$feature.feature_folder) -replace '\\', '/').TrimEnd('/')
+        $issueMatches = ($feature.issue_num | ConvertTo-Json -Compress) -ceq
+        ($Receipt.issue_num | ConvertTo-Json -Compress)
+        if ($issueMatches -and $actualFolder -ceq $expectedFolder) {
+            return $feature
+        }
+    }
+    return $null
+}
+
+function Test-CodexWaveDependenciesReady {
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param([AllowNull()] $EpicCheckpoint, [AllowNull()] $Feature)
+
+    if ($null -eq $EpicCheckpoint -or $null -eq $Feature) {
+        return $false
+    }
+    if (@($Feature.PSObject.Properties.Name) -notcontains 'depends_on' -or
+        @($Feature.depends_on).Count -eq 0) {
+        return $true
+    }
+    foreach ($dependency in @($Feature.depends_on)) {
+        $record = Find-CodexWaveFeature -Checkpoint $EpicCheckpoint -Key ([string]$dependency)
+        if ($null -eq $record -or
+            @($record.PSObject.Properties.Name) -notcontains 'merge_status' -or
+            $script:AllowedDependencyStatuses -notcontains [string]$record.merge_status) {
+            return $false
+        }
+    }
+    return $true
+}
+
+function Test-CodexWaveMutation {
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param([Parameter(Mandatory)] $Payload)
+
+    $toolName = [string]$Payload.tool_name
+    if ($toolName -in @('apply_patch', 'Edit', 'Write')) {
+        return $true
+    }
+    if ($toolName -like 'mcp__*' -and $toolName -notlike 'mcp__drm-copilot__*') {
+        return $true
+    }
+    if ($toolName -like 'mcp__drm-copilot__*') {
+        return $toolName -notmatch '__(?:collect_|validate_|resolve_)'
+    }
+    if ($toolName -in @('Bash', 'shell_command')) {
+        return $true
+    }
+    return $false
+}
+
+function Get-CodexWaveDenyDecision {
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param([Parameter(Mandatory)][string] $FeatureKey, [Parameter(Mandatory)][string] $Reason)
+
+    return [ordered]@{
+        hookSpecificOutput = [ordered]@{
+            hookEventName            = 'PreToolUse'
+            permissionDecision       = 'deny'
+            permissionDecisionReason = "EPIC_WAVE_BARRIER_BLOCKED: '$FeatureKey' $Reason"
+        }
+    }
+}
+
+function Invoke-CodexEpicWaveDecision {
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param(
+        [Parameter(Mandatory)][string] $PayloadRaw,
+        [AllowNull()][AllowEmptyString()][string] $LocalCheckpointRaw,
+        [AllowNull()][AllowEmptyString()][string] $EpicCheckpointRaw,
+        [AllowNull()][AllowEmptyString()][string] $LauncherReceiptRaw = '',
+        [AllowNull()] $LauncherEnvironment,
+        [AllowEmptyString()][string] $RepositoryRoot = '',
+        [datetimeoffset] $Now = [datetimeoffset]::UtcNow
+    )
+
+    $payload = ConvertFrom-CodexWaveJson -Raw $PayloadRaw -Name 'PreToolUse input'
+    if (-not (Test-CodexWaveMutation -Payload $payload)) {
+        return $null
+    }
+    $launchId = if ($null -eq $LauncherEnvironment) { '' } else {
+        [string]$LauncherEnvironment.launch_id
+    }
+    if (-not [string]::IsNullOrWhiteSpace($launchId)) {
+        $context = [string]$LauncherEnvironment.execution_context
+        if ($context -eq 'epic_preparation_child') {
+            return $null
+        }
+        if ($context -ne 'epic_execution_child') {
+            return Get-CodexWaveDenyDecision -FeatureKey $launchId -Reason 'has an invalid launcher execution context.'
+        }
+        $routingReceipt = [pscustomobject]@{ execution_context = $context }
+        $authorityValid = Test-CodexEpicChildRoutingLaunchAuthority -RoutingReceipt $routingReceipt `
+            -Payload $payload -RepositoryRoot $RepositoryRoot -LaunchEnvironment $LauncherEnvironment `
+            -LaunchReceiptRaw $LauncherReceiptRaw -Now $Now
+        if (-not $authorityValid) {
+            return Get-CodexWaveDenyDecision -FeatureKey $launchId -Reason 'has no valid session-bound launcher receipt.'
+        }
+        $launchReceipt = ConvertFrom-CodexWaveJson -Raw $LauncherReceiptRaw -Name 'launcher receipt'
+        $epicCheckpoint = ConvertFrom-CodexWaveJson -Raw $EpicCheckpointRaw -Name 'receipt-bound epic checkpoint'
+        $feature = Find-CodexWaveLaunchFeature -Checkpoint $epicCheckpoint -Receipt $launchReceipt
+        $featureKey = (([string]$launchReceipt.feature_folder) -replace '\\', '/').TrimEnd('/').Split('/')[-1]
+        if (Test-CodexWaveDependenciesReady -EpicCheckpoint $epicCheckpoint -Feature $feature) {
+            return $null
+        }
+        return Get-CodexWaveDenyDecision -FeatureKey $featureKey `
+            -Reason 'cannot mutate until every depends_on edge is merged or worktree_removed in the receipt-bound epic checkpoint.'
+    }
+    if ([string]::IsNullOrWhiteSpace($LocalCheckpointRaw)) {
+        return $null
+    }
+    $localCheckpoint = ConvertFrom-CodexWaveJson -Raw $LocalCheckpointRaw -Name 'child checkpoint'
+    if (@($localCheckpoint.PSObject.Properties.Name) -notcontains 'epic_mode' -or
+        $localCheckpoint.epic_mode -isnot [bool] -or
+        -not [bool]$localCheckpoint.epic_mode) {
+        return $null
+    }
+
+    $epicCheckpoint = ConvertFrom-CodexWaveJson -Raw $EpicCheckpointRaw -Name 'epic checkpoint'
+    $featureKey = Get-CodexWaveFeatureKey -LocalCheckpoint $localCheckpoint
+    $feature = if ($featureKey) {
+        Find-CodexWaveFeature -Checkpoint $epicCheckpoint -Key $featureKey
+    } else {
+        $null
+    }
+    if (Test-CodexWaveDependenciesReady -EpicCheckpoint $epicCheckpoint -Feature $feature) {
+        return $null
+    }
+
+    return Get-CodexWaveDenyDecision -FeatureKey $featureKey `
+        -Reason 'cannot mutate until every depends_on edge is merged or worktree_removed in the epic checkpoint.'
+}
+
+function Get-CodexPrimaryWorktreeRoot {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param([Parameter(Mandatory)][string] $RepositoryRoot)
+
+    $output = & git -C $RepositoryRoot worktree list --porcelain 2>$null
+    $first = @($output | Where-Object { $_ -like 'worktree *' } | Select-Object -First 1)
+    if ($first.Count -eq 0) {
+        return $RepositoryRoot
+    }
+    return ([string]$first[0]).Substring('worktree '.Length)
+}
+
+if ($MyInvocation.InvocationName -eq '.') {
+    return
+}
+
+try {
+    $payloadRaw = [Console]::In.ReadToEnd()
+    $repositoryRoot = Split-Path (Split-Path $PSScriptRoot -Parent) -Parent
+    $localPath = Join-Path $repositoryRoot 'artifacts/orchestration/orchestrator-state.json'
+    $localRaw = if (Test-Path -LiteralPath $localPath -PathType Leaf) {
+        Get-Content -Raw -LiteralPath $localPath
+    } else {
+        ''
+    }
+    $launcherEnvironment = Get-CodexEpicChildLaunchEnvironment
+    $launcherReceiptRaw = if (-not [string]::IsNullOrWhiteSpace($launcherEnvironment.receipt_path) -and
+        (Test-Path -LiteralPath $launcherEnvironment.receipt_path -PathType Leaf)) {
+        Get-Content -Raw -LiteralPath $launcherEnvironment.receipt_path
+    } else {
+        ''
+    }
+    $launcherReceipt = ConvertFrom-CodexWaveJson -Raw $launcherReceiptRaw -Name 'launcher receipt' -Optional
+    $primaryRoot = Get-CodexPrimaryWorktreeRoot -RepositoryRoot $repositoryRoot
+    $epicPath = if ($null -ne $launcherReceipt -and
+        [string]$launcherEnvironment.execution_context -eq 'epic_execution_child') {
+        [string]$launcherReceipt.checkpoint_path
+    } else {
+        Join-Path $primaryRoot 'artifacts/orchestration/epic-orchestrator-state.json'
+    }
+    $epicRaw = if (Test-Path -LiteralPath $epicPath -PathType Leaf) {
+        Get-Content -Raw -LiteralPath $epicPath
+    } else {
+        ''
+    }
+    $decision = Invoke-CodexEpicWaveDecision -PayloadRaw $payloadRaw -LocalCheckpointRaw $localRaw `
+        -EpicCheckpointRaw $epicRaw -LauncherReceiptRaw $launcherReceiptRaw `
+        -LauncherEnvironment $launcherEnvironment -RepositoryRoot $repositoryRoot
+    if ($null -ne $decision) {
+        $decision | ConvertTo-Json -Compress -Depth 5 | Write-Output
+    }
+    exit 0
+} catch {
+    [Console]::Error.WriteLine([string]$_)
+    exit 2
+}

package/resources/codex-and-agents-customizations/.codex/hooks/enforce-epic-worktree-removal-gate.ps1

@@ -0,0 +1,151 @@
+<#
+.SYNOPSIS
+    Denies git worktree removal until the matching epic feature is safely merged.
+#>
+[CmdletBinding()]
+param()
+
+$script:SafeWorktreeStatuses = @('merged', 'worktree_removed')
+
+function ConvertFrom-CodexWorktreeJson {
+    [CmdletBinding()]
+    param([AllowNull()][AllowEmptyString()][string] $Raw, [Parameter(Mandatory)][string] $Name, [switch] $Optional)
+
+    if ([string]::IsNullOrWhiteSpace($Raw)) {
+        if ($Optional) {
+            return $null
+        }
+        throw "EPIC_WORKTREE_REMOVAL_BLOCKED: $Name is empty."
+    }
+    try {
+        return $Raw | ConvertFrom-Json -ErrorAction Stop
+    } catch {
+        if ($Optional) {
+            return $null
+        }
+        throw "EPIC_WORKTREE_REMOVAL_BLOCKED: $Name is malformed JSON: $_"
+    }
+}
+
+function Get-CodexWorktreeRemovalPath {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param([Parameter(Mandatory)][AllowEmptyString()][string] $Command)
+
+    $pattern = '(?i)\bgit\s+worktree\s+remove(?:\s+--force)?\s+(?:"(?<double>[^"]+)"|''(?<single>[^'']+)''|(?<bare>\S+))'
+    if ($Command -notmatch $pattern) {
+        return ''
+    }
+    foreach ($name in @('double', 'single', 'bare')) {
+        if ($Matches[$name]) {
+            return [string]$Matches[$name]
+        }
+    }
+    return ''
+}
+
+function Get-NormalizedCodexWorktreePath {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param([Parameter(Mandatory)][string] $Path, [Parameter(Mandatory)][string] $WorkingDirectory)
+
+    $resolved = if ([System.IO.Path]::IsPathRooted($Path)) {
+        [System.IO.Path]::GetFullPath($Path)
+    } else {
+        [System.IO.Path]::GetFullPath((Join-Path $WorkingDirectory $Path))
+    }
+    return ($resolved -replace '\\', '/').TrimEnd('/')
+}
+
+function Find-CodexWorktreeFeature {
+    [CmdletBinding()]
+    param(
+        [AllowNull()] $Checkpoint,
+        [Parameter(Mandatory)][string] $TargetPath,
+        [Parameter(Mandatory)][string] $WorkingDirectory
+    )
+
+    if ($null -eq $Checkpoint -or
+        @($Checkpoint.PSObject.Properties.Name) -notcontains 'features') {
+        return $null
+    }
+    $normalizedTarget = Get-NormalizedCodexWorktreePath -Path $TargetPath -WorkingDirectory $WorkingDirectory
+    foreach ($feature in @($Checkpoint.features)) {
+        if ($null -eq $feature -or
+            @($feature.PSObject.Properties.Name) -notcontains 'worktree_path' -or
+            [string]::IsNullOrWhiteSpace([string]$feature.worktree_path)) {
+            continue
+        }
+        $normalizedFeature = Get-NormalizedCodexWorktreePath -Path ([string]$feature.worktree_path) -WorkingDirectory $WorkingDirectory
+        if ($normalizedFeature -eq $normalizedTarget) {
+            return $feature
+        }
+    }
+    return $null
+}
+
+function Invoke-CodexWorktreeRemovalDecision {
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param(
+        [Parameter(Mandatory)][string] $PayloadRaw,
+        [AllowNull()][AllowEmptyString()][string] $EpicCheckpointRaw
+    )
+
+    $payload = ConvertFrom-CodexWorktreeJson -Raw $PayloadRaw -Name 'PreToolUse input'
+    if ([string]$payload.tool_name -ne 'Bash') {
+        return $null
+    }
+    $command = [string]$payload.tool_input.command
+    if ($command -notmatch '(?i)\bgit\s+worktree\s+remove\b') {
+        return $null
+    }
+    $target = Get-CodexWorktreeRemovalPath -Command $command
+    $checkpoint = ConvertFrom-CodexWorktreeJson -Raw $EpicCheckpointRaw -Name 'epic checkpoint' -Optional
+    $workingDirectory = if ([string]::IsNullOrWhiteSpace([string]$payload.cwd)) {
+        (Get-Location).Path
+    } else {
+        [string]$payload.cwd
+    }
+    $feature = if ($target) {
+        Find-CodexWorktreeFeature -Checkpoint $checkpoint -TargetPath $target -WorkingDirectory $workingDirectory
+    } else {
+        $null
+    }
+    if ($null -ne $feature -and
+        @($feature.PSObject.Properties.Name) -contains 'merge_status' -and
+        $script:SafeWorktreeStatuses -contains [string]$feature.merge_status) {
+        return $null
+    }
+
+    return [ordered]@{
+        hookSpecificOutput = [ordered]@{
+            hookEventName            = 'PreToolUse'
+            permissionDecision       = 'deny'
+            permissionDecisionReason = "EPIC_WORKTREE_REMOVAL_BLOCKED: '$target' requires a matching epic feature with merge_status merged or worktree_removed."
+        }
+    }
+}
+
+if ($MyInvocation.InvocationName -eq '.') {
+    return
+}
+
+try {
+    $payloadRaw = [Console]::In.ReadToEnd()
+    $repositoryRoot = Split-Path (Split-Path $PSScriptRoot -Parent) -Parent
+    $checkpointPath = Join-Path $repositoryRoot 'artifacts/orchestration/epic-orchestrator-state.json'
+    $checkpointRaw = if (Test-Path -LiteralPath $checkpointPath -PathType Leaf) {
+        Get-Content -Raw -LiteralPath $checkpointPath
+    } else {
+        ''
+    }
+    $decision = Invoke-CodexWorktreeRemovalDecision -PayloadRaw $payloadRaw -EpicCheckpointRaw $checkpointRaw
+    if ($null -ne $decision) {
+        $decision | ConvertTo-Json -Compress -Depth 5 | Write-Output
+    }
+    exit 0
+} catch {
+    [Console]::Error.WriteLine([string]$_)
+    exit 2
+}

package/resources/codex-and-agents-customizations/.codex/hooks/enforce-evidence-locations.ps1

@@ -1,13 +1,11 @@
-# Converted hook
-# Review the generated hook behavior before enabling it.
 
 <#
 .SYNOPSIS
     Pre-tool-use hook that blocks writes to non-canonical evidence storage locations.
 
 .DESCRIPTION
-    This script is invoked by the Claude Code PreToolUse hook before any Write or Edit
-    operation. It reads the tool input from the CLAUDE_TOOL_INPUT environment variable
+    This script is invoked by the Codex PreToolUse hook before any Write or Edit
+    operation. It reads the tool input from the Codex tool_input environment variable
     (JSON with a 'file_path' field) and rejects the operation when the target path is
     a non-canonical evidence location.
 
@@ -20,17 +18,21 @@
       - artifacts/evidence/
       - artifacts/regression-testing/
       - artifacts/post-change/
+      - artifacts/research/
 
     All other paths pass through, including canonical evidence paths of the form
     <FEATURE>/evidence/<kind>/ and permitted artifacts/ sub-paths such as
-    artifacts/orchestration/, artifacts/research/, artifacts/pr_context,
-    artifacts/reviews/, artifacts/status/, artifacts/python/, artifacts/pester/,
-    and artifacts/csharp/.
-
-    If the file_path resolves to a forbidden prefix, the script writes a JSON response
-    to stdout with 'decision': 'block' and exits with code 0 so Claude Code surfaces
-    the reason. For allowed paths, 'decision': 'allow' is written to stdout and the
-    script exits 0. On hard failure (malformed JSON input), the script exits 1.
+    artifacts/orchestration/, artifacts/pr_context, artifacts/reviews/,
+    artifacts/status/, artifacts/python/, artifacts/pester/, and
+    artifacts/csharp/. Research output is no longer an artifacts/ sub-path; it
+    is written to the tracked roots docs/features/<feature>/research/
+    (feature-associated) or docs/research/ (one-off).
+
+    If the file_path resolves to a forbidden prefix, the script writes a PreToolUse JSON
+    response to stdout with hookSpecificOutput.permissionDecision = 'deny' and exits with
+    code 0 so Codex surfaces the reason. For allowed paths, a PreToolUse response
+    with permissionDecision = 'allow' is written to stdout and the script exits 0. On hard
+    failure (malformed JSON input), the script exits 2.
 
 .NOTES
     Compatible with PowerShell 7+.
@@ -44,7 +46,7 @@ function Test-EvidenceLocationForbidden {
     .SYNOPSIS
         Returns $true when the supplied file path targets a forbidden evidence sub-path.
     .PARAMETER FilePath
-        The raw file_path value from the Claude Code tool-input JSON.
+        The raw file_path value from the Codex tool-input JSON.
     #>
     [CmdletBinding()]
     [OutputType([bool])]
@@ -64,7 +66,8 @@ function Test-EvidenceLocationForbidden {
         'artifacts/coverage/',
         'artifacts/evidence/',
         'artifacts/regression-testing/',
-        'artifacts/post-change/'
+        'artifacts/post-change/',
+        'artifacts/research/'
     )
 
     # Match the prefix either at the start of the string or after any directory separator,
@@ -82,9 +85,9 @@ function Test-EvidenceLocationForbidden {
 function Get-EvidenceLocationBlockDecision {
     <#
     .SYNOPSIS
-        Constructs a block-decision ordered dictionary for the supplied forbidden path.
+        Constructs a deny-decision ordered dictionary for the supplied forbidden path.
     .PARAMETER FilePath
-        The file path that triggered the block.
+        The file path that triggered the deny decision.
     #>
     [CmdletBinding()]
     [OutputType([System.Collections.Specialized.OrderedDictionary])]
@@ -94,17 +97,20 @@ function Get-EvidenceLocationBlockDecision {
     )
 
     [ordered]@{
-        decision = 'block'
-        reason   = "EVIDENCE_LOCATION_BLOCKED: '$FilePath' is not a canonical evidence location. Use <FEATURE>/evidence/<kind>/ instead. See .agents/skills/evidence-and-timestamp-conventions/SKILL.md for the canonical scheme."
+        hookSpecificOutput = [ordered]@{
+            hookEventName            = 'PreToolUse'
+            permissionDecision       = 'deny'
+            permissionDecisionReason = "EVIDENCE_LOCATION_BLOCKED: '$FilePath' is not a canonical evidence location. Use <FEATURE>/evidence/<kind>/ instead. See .agents/skills/evidence-and-timestamp-conventions/SKILL.md for the canonical scheme."
+        }
     }
 }
 
 function Invoke-EvidenceLocationDecision {
     <#
     .SYNOPSIS
-        Parses the Claude Code tool-input JSON and returns an allow-or-block decision.
+        Parses the Codex tool-input JSON and returns an allow-or-block decision.
     .PARAMETER ToolInputRaw
-        The raw JSON string from $env:CLAUDE_TOOL_INPUT. An empty or null value
+        The raw JSON string from $env:Codex tool_input. An empty or null value
         results in an allow decision (non-file tool calls have no file_path).
     #>
     [CmdletBinding()]
@@ -114,40 +120,99 @@ function Invoke-EvidenceLocationDecision {
     )
 
     if (-not $ToolInputRaw) {
-        return [ordered]@{ decision = 'allow' }
+        return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
     }
 
     try {
         $toolInput = $ToolInputRaw | ConvertFrom-Json -ErrorAction Stop
     } catch {
         # Malformed JSON is a hard failure; caller exits 1 to surface the issue.
-        throw "enforce-evidence-locations hook received malformed JSON in CLAUDE_TOOL_INPUT: $_"
+        throw "enforce-evidence-locations hook received malformed JSON in Codex tool_input: $_"
     }
 
     $filePath = $toolInput.file_path
     if (-not $filePath) {
-        return [ordered]@{ decision = 'allow' }
+        return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
     }
 
     if (Test-EvidenceLocationForbidden -FilePath $filePath) {
         return Get-EvidenceLocationBlockDecision -FilePath $filePath
     }
 
-    return [ordered]@{ decision = 'allow' }
+    return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
 }
 
-# Guard allows dot-sourcing in tests without executing the entrypoint.
-if ($MyInvocation.InvocationName -eq '.') {
-    return
+function ConvertFrom-CodexEvidenceLocationPayload {
+    [CmdletBinding()]
+    param([Parameter(Mandatory)][string] $PayloadRaw)
+
+    if ([string]::IsNullOrWhiteSpace($PayloadRaw)) {
+        throw 'enforce-evidence-locations hook input is empty.'
+    }
+    try {
+        $payload = $PayloadRaw | ConvertFrom-Json -ErrorAction Stop
+    } catch {
+        throw "enforce-evidence-locations hook input is malformed JSON: $_"
+    }
+    if ($payload.PSObject.Properties.Name -notcontains 'tool_input' -or $null -eq $payload.tool_input) {
+        throw 'enforce-evidence-locations hook input is missing tool_input.'
+    }
+    if ([string]$payload.hook_event_name -ne 'PreToolUse' -or [string]$payload.tool_name -ne 'apply_patch') {
+        throw 'enforce-evidence-locations requires a PreToolUse apply_patch payload.'
+    }
+    return $payload
+}
+
+function Get-CodexEvidenceLocationPath {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param([Parameter(Mandatory)] $Payload)
+
+    if ($Payload.tool_input.PSObject.Properties.Name -contains 'file_path') {
+        return [string]$Payload.tool_input.file_path
+    }
+    $command = [string]$Payload.tool_input.command
+    if ([string]::IsNullOrWhiteSpace($command)) {
+        throw 'enforce-evidence-locations cannot map tool_input to a file edit.'
+    }
+    [string[]] $paths = @(
+        [regex]::Matches($command, '(?m)^\*\*\* (?:(?:Add|Update|Delete) File|Move to):\s*(?<path>.+?)\s*$') |
+            ForEach-Object { ([string]$_.Groups['path'].Value).Trim() }
+    )
+    $paths = @($paths | Select-Object -Unique)
+    if ($paths.Count -eq 0) {
+        throw 'enforce-evidence-locations received an unrecognized apply_patch command.'
+    }
+    foreach ($path in $paths) {
+        Write-Output ([string]$path)
+    }
 }
 
-try {
-    $decision = Invoke-EvidenceLocationDecision -ToolInputRaw $env:CLAUDE_TOOL_INPUT
-} catch {
-    Write-Error $_
-    exit 1
+function Invoke-EvidenceLocationEntryPoint {
+    [CmdletBinding()]
+    [OutputType([int])]
+    param([Parameter(Mandatory)][string] $PayloadRaw)
+
+    try {
+        $payload = ConvertFrom-CodexEvidenceLocationPayload -PayloadRaw $PayloadRaw
+        foreach ($path in @(Get-CodexEvidenceLocationPath -Payload $payload)) {
+            $toolInputRaw = @{ file_path = $path } | ConvertTo-Json -Compress
+            $decision = Invoke-EvidenceLocationDecision -ToolInputRaw $toolInputRaw
+            if ($decision.hookSpecificOutput.permissionDecision -eq 'deny') {
+                [Console]::Out.WriteLine(($decision | ConvertTo-Json -Compress -Depth 5))
+                return 0
+            }
+        }
+        return 0
+    } catch {
+        [Console]::Error.WriteLine([string]$_)
+        return 2
+    }
 }
 
-$decision | ConvertTo-Json -Compress | Write-Output
+# Guard allows dot-sourcing in tests without executing the entrypoint.
+if ($MyInvocation.InvocationName -eq '.') {
+    return
+}
 
-exit 0
+exit (Invoke-EvidenceLocationEntryPoint -PayloadRaw ([Console]::In.ReadToEnd()))