@danmoisan/drm-copilot-mcp 1.0.13 → 1.0.15

package/resources/codex-and-agents-customizations/.codex/hooks/codex-authority-store.ps1

@@ -0,0 +1,182 @@
+<#
+.SYNOPSIS
+    Resolves the non-workspace authority store used by Codex provenance hooks.
+
+.DESCRIPTION
+    Epic-entry receipts and routed-subagent attestations must not be writable by
+    workspace-scoped agents. These helpers derive a repository- and session-bound
+    directory under CODEX_HOME and exact receipt/attestation paths within it.
+#>
+[CmdletBinding()]
+param()
+
+function Get-CodexAuthoritySha256 {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param([Parameter(Mandatory)][AllowEmptyString()][string] $Text)
+
+    $bytes = [System.Text.Encoding]::UTF8.GetBytes($Text)
+    return [Convert]::ToHexString(
+        [System.Security.Cryptography.SHA256]::HashData($bytes)
+    ).ToLowerInvariant()
+}
+
+function Get-CodexCanonicalAuthorityPath {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param([Parameter(Mandatory)][string] $Path)
+
+    $fullPath = [System.IO.Path]::GetFullPath($Path).TrimEnd(
+        [System.IO.Path]::DirectorySeparatorChar,
+        [System.IO.Path]::AltDirectorySeparatorChar
+    )
+    if ($IsWindows) {
+        return $fullPath.ToLowerInvariant()
+    }
+    return $fullPath
+}
+
+function Get-CodexAuthorityRepositoryKey {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param([Parameter(Mandatory)][string] $RepositoryRoot)
+
+    return Get-CodexAuthoritySha256 -Text (
+        Get-CodexCanonicalAuthorityPath -Path $RepositoryRoot
+    )
+}
+
+function Get-CodexResolvedAuthorityPath {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param([Parameter(Mandatory)][string] $Path)
+
+    $candidate = [System.IO.Path]::GetFullPath($Path)
+    $suffix = [System.Collections.Generic.Stack[string]]::new()
+    while (-not (Test-Path -LiteralPath $candidate)) {
+        $leaf = Split-Path $candidate -Leaf
+        if ([string]::IsNullOrWhiteSpace($leaf)) {
+            break
+        }
+        $suffix.Push($leaf)
+        $candidate = Split-Path $candidate -Parent
+    }
+    if (-not (Test-Path -LiteralPath $candidate)) {
+        return Get-CodexCanonicalAuthorityPath -Path $Path
+    }
+    $item = Get-Item -Force -LiteralPath $candidate
+    $resolved = if ($null -ne $item.LinkTarget) {
+        $target = [string]$item.LinkTarget
+        if (-not [System.IO.Path]::IsPathFullyQualified($target)) {
+            $target = Join-Path (Split-Path $candidate -Parent) $target
+        }
+        [System.IO.Path]::GetFullPath($target)
+    } else {
+        [string](Resolve-Path -LiteralPath $candidate).ProviderPath
+    }
+    while ($suffix.Count -gt 0) {
+        $resolved = Join-Path $resolved $suffix.Pop()
+    }
+    return Get-CodexCanonicalAuthorityPath -Path $resolved
+}
+
+function Assert-CodexAuthorityOutsideRepository {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory)][string] $AuthorityPath,
+        [Parameter(Mandatory)][string] $RepositoryRoot
+    )
+
+    $authority = Get-CodexResolvedAuthorityPath -Path $AuthorityPath
+    $repository = Get-CodexResolvedAuthorityPath -Path $RepositoryRoot
+    $prefix = $repository + [System.IO.Path]::DirectorySeparatorChar
+    $comparison = if ($IsWindows) {
+        [System.StringComparison]::OrdinalIgnoreCase
+    } else {
+        [System.StringComparison]::Ordinal
+    }
+    if ($authority.Equals($repository, $comparison) -or $authority.StartsWith($prefix, $comparison)) {
+        throw 'EPIC_INVOCATION_ORIGIN_BLOCKED: the Codex authority store must be outside the repository workspace.'
+    }
+}
+
+function Get-CodexAuthorityHome {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param()
+
+    if (-not [string]::IsNullOrWhiteSpace($env:CODEX_HOME)) {
+        return [System.IO.Path]::GetFullPath($env:CODEX_HOME)
+    }
+    $profileRoot = [Environment]::GetFolderPath(
+        [Environment+SpecialFolder]::UserProfile
+    )
+    if ([string]::IsNullOrWhiteSpace($profileRoot)) {
+        throw 'EPIC_INVOCATION_ORIGIN_BLOCKED: CODEX_HOME and the user profile are unavailable.'
+    }
+    return Join-Path $profileRoot '.codex'
+}
+
+function ConvertTo-CodexAuthorityPathSegment {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param([Parameter(Mandatory)][string] $Value)
+
+    if ([string]::IsNullOrWhiteSpace($Value)) {
+        throw 'EPIC_INVOCATION_ORIGIN_BLOCKED: authority path identity is empty.'
+    }
+    return $Value -replace '[^A-Za-z0-9._-]', '_'
+}
+
+function Get-CodexAuthorityStateRoot {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter(Mandatory)][string] $RepositoryRoot,
+        [Parameter(Mandatory)][string] $SessionId
+    )
+
+    $repositoryKey = Get-CodexAuthorityRepositoryKey -RepositoryRoot $RepositoryRoot
+    $safeSession = ConvertTo-CodexAuthorityPathSegment -Value $SessionId
+    $stateRoot = Join-Path (
+        Join-Path (Join-Path (Get-CodexAuthorityHome) 'authority/epic-entry') $repositoryKey
+    ) $safeSession
+    Assert-CodexAuthorityOutsideRepository -AuthorityPath $stateRoot -RepositoryRoot $RepositoryRoot
+    return $stateRoot
+}
+
+function Get-CodexAuthorityReceiptPath {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter(Mandatory)][string] $RepositoryRoot,
+        [Parameter(Mandatory)][string] $SessionId,
+        [Parameter(Mandatory)][string] $TurnId
+    )
+
+    $stateRoot = Get-CodexAuthorityStateRoot `
+        -RepositoryRoot $RepositoryRoot `
+        -SessionId $SessionId
+    $safeTurn = ConvertTo-CodexAuthorityPathSegment -Value $TurnId
+    return Join-Path $stateRoot "epic-root-invocation.$safeTurn.json"
+}
+
+function Get-CodexAuthorityAttestationPath {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter(Mandatory)][string] $RepositoryRoot,
+        [Parameter(Mandatory)][string] $SessionId,
+        [Parameter(Mandatory)][string] $AttestationKey
+    )
+
+    $stateRoot = Get-CodexAuthorityStateRoot `
+        -RepositoryRoot $RepositoryRoot `
+        -SessionId $SessionId
+    $safeKey = ConvertTo-CodexAuthorityPathSegment -Value $AttestationKey
+    return Join-Path $stateRoot "codex-routing-attestation.$safeKey.json"
+}
+
+if ($MyInvocation.InvocationName -ne '.') {
+    throw 'codex-authority-store.ps1 is a helper and must be dot-sourced.'
+}

package/resources/codex-and-agents-customizations/.codex/hooks/codex-epic-child-launch-attestation.ps1

@@ -0,0 +1,129 @@
+# Validate inherited external-launch authority for routed epic child subagents.
+
+$contractPath = Join-Path (Split-Path $PSScriptRoot -Parent) 'scripts/epic-child-launch-contract.ps1'
+if (Test-Path -LiteralPath $contractPath -PathType Leaf) {
+    . $contractPath
+}
+
+$script:CodexEpicChildContexts = @('epic_preparation_child', 'epic_execution_child')
+
+function Get-CodexEpicChildLaunchEnvironment {
+    [CmdletBinding()]
+    [OutputType([pscustomobject])]
+    param()
+
+    return [pscustomobject]@{
+        launch_id         = [string]$env:CODEX_EPIC_CHILD_LAUNCH_ID
+        receipt_path      = [string]$env:CODEX_EPIC_CHILD_LAUNCH_RECEIPT
+        spec_path         = [string]$env:CODEX_EPIC_CHILD_LAUNCH_SPEC
+        worktree_path     = [string]$env:CODEX_EPIC_CHILD_EXPECTED_WORKTREE
+        delegation_id     = [string]$env:CODEX_EPIC_CHILD_DELEGATION_ID
+        execution_context = [string]$env:CODEX_EPIC_CHILD_EXECUTION_CONTEXT
+        deployment_agent  = [string]$env:CODEX_EPIC_CHILD_AGENT
+        model             = [string]$env:CODEX_EPIC_CHILD_MODEL
+        reasoning_effort  = [string]$env:CODEX_EPIC_CHILD_REASONING_EFFORT
+        profile_sha256    = [string]$env:CODEX_EPIC_CHILD_PROFILE_SHA256
+    }
+}
+
+function Get-CodexEpicChildCanonicalPath {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param([Parameter(Mandatory)][string] $Path, [Parameter(Mandatory)][string] $BasePath)
+
+    $candidate = if ([System.IO.Path]::IsPathFullyQualified($Path)) {
+        $Path
+    } else {
+        Join-Path $BasePath $Path
+    }
+    return [System.IO.Path]::GetFullPath($candidate).TrimEnd(
+        [System.IO.Path]::DirectorySeparatorChar,
+        [System.IO.Path]::AltDirectorySeparatorChar
+    )
+}
+
+function Test-CodexEpicChildRoutingLaunchAuthority {
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [AllowNull()] $RoutingReceipt,
+        [Parameter(Mandatory)] $Payload,
+        [Parameter(Mandatory)][string] $RepositoryRoot,
+        [AllowNull()] $LaunchEnvironment,
+        [AllowNull()][AllowEmptyString()][string] $LaunchReceiptRaw,
+        [datetimeoffset] $Now = [datetimeoffset]::UtcNow
+    )
+
+    $context = if ($null -eq $RoutingReceipt) { '' } else {
+        [string]$RoutingReceipt.execution_context
+    }
+    if ($script:CodexEpicChildContexts -cnotcontains $context) {
+        return $true
+    }
+    $environment = if ($null -eq $LaunchEnvironment) {
+        Get-CodexEpicChildLaunchEnvironment
+    } else {
+        $LaunchEnvironment
+    }
+    try {
+        $receiptPath = Get-CodexEpicChildCanonicalPath -Path ([string]$environment.receipt_path) -BasePath $RepositoryRoot
+        $raw = if ($PSBoundParameters.ContainsKey('LaunchReceiptRaw')) {
+            $LaunchReceiptRaw
+        } else {
+            Get-Content -Raw -LiteralPath $receiptPath -ErrorAction Stop
+        }
+        $receipt = $raw | ConvertFrom-Json -Depth 32 -ErrorAction Stop
+        if ((Get-CodexChildActiveReceiptErrorList -Receipt $receipt -ExpectedSessionId ([string]$Payload.session_id) -Now $Now).Count -gt 0) {
+            return $false
+        }
+
+        $comparison = if ($IsWindows) {
+            [System.StringComparison]::OrdinalIgnoreCase
+        } else {
+            [System.StringComparison]::Ordinal
+        }
+        $worktree = Get-CodexEpicChildCanonicalPath -Path ([string]$receipt.worktree_path) -BasePath $RepositoryRoot
+        $trustedRoot = Get-CodexEpicChildCanonicalPath -Path ([string]$receipt.trusted_repository_root) -BasePath $RepositoryRoot
+        $launchRoot = Join-Path $trustedRoot 'artifacts/orchestration/epic-child-launches'
+        $specPath = Get-CodexEpicChildCanonicalPath -Path ([string]$receipt.spec_path) -BasePath $trustedRoot
+        $checkpointName = if ($context -ceq 'epic_preparation_child') {
+            'epic-planner-state.json'
+        } else {
+            'epic-orchestrator-state.json'
+        }
+        $expectedCheckpoint = Join-Path $trustedRoot "artifacts/orchestration/$checkpointName"
+        $pathPairs = @(
+            @($receiptPath, (Get-CodexEpicChildCanonicalPath -Path ([string]$receipt.receipt_path) -BasePath $trustedRoot)),
+            @((Get-CodexEpicChildCanonicalPath -Path ([string]$environment.spec_path) -BasePath $trustedRoot), $specPath),
+            @((Get-CodexEpicChildCanonicalPath -Path ([string]$environment.worktree_path) -BasePath $RepositoryRoot), $worktree)
+        )
+        foreach ($pair in $pathPairs) {
+            if (-not ([string]$pair[0]).Equals([string]$pair[1], $comparison)) {
+                return $false
+            }
+        }
+        $identityPairs = @(
+            @([string]$environment.launch_id, [string]$receipt.launch_id),
+            @([string]$environment.delegation_id, [string]$receipt.delegation_id),
+            @([string]$environment.execution_context, [string]$receipt.execution_context),
+            @([string]$environment.deployment_agent, [string]$receipt.deployment_agent),
+            @([string]$environment.model, [string]$receipt.model),
+            @([string]$environment.reasoning_effort, [string]$receipt.model_reasoning_effort),
+            @([string]$environment.profile_sha256, [string]$receipt.profile_sha256)
+        )
+        foreach ($pair in $identityPairs) {
+            if (-not ([string]$pair[0]).Equals([string]$pair[1], [System.StringComparison]::Ordinal)) {
+                return $false
+            }
+        }
+        $repository = Get-CodexEpicChildCanonicalPath -Path $RepositoryRoot -BasePath $RepositoryRoot
+        $checkpoint = Get-CodexEpicChildCanonicalPath -Path ([string]$receipt.checkpoint_path) -BasePath $trustedRoot
+        return $repository.Equals($worktree, $comparison) -and
+        $context -ceq [string]$receipt.execution_context -and
+        $checkpoint.Equals($expectedCheckpoint, $comparison) -and
+        $receiptPath.StartsWith($launchRoot + [System.IO.Path]::DirectorySeparatorChar, $comparison) -and
+        $specPath.StartsWith($launchRoot + [System.IO.Path]::DirectorySeparatorChar, $comparison)
+    } catch {
+        return $false
+    }
+}

package/resources/codex-and-agents-customizations/.codex/hooks/enforce-checkpoint-monotonic.ps1

@@ -1,10 +1,11 @@
+
 <#
 .SYNOPSIS
     Pre-tool-use hook that blocks Write operations on the orchestrator checkpoint
     file when completed_steps appear out of declared canonical order.
 
 .DESCRIPTION
-    Invoked by the Claude Code PreToolUse hook on Write or Edit operations. The
+    Invoked by the Codex PreToolUse hook on Write or Edit operations. The
     hook activates only when the target file_path is
     artifacts/orchestration/orchestrator-state.json.
 
@@ -27,9 +28,11 @@
 
     Entries that do not match any canonical prefix are treated as informational
     and ignored. If any pair (i, j) with i < j has a higher canonical index at
-    position i than at position j, the script blocks with a reason listing the
-    offending pair. A non-empty rollback_history array suppresses this check
-    because rollbacks legitimately reorder steps.
+    position i than at position j, the script denies via a PreToolUse JSON
+    response with hookSpecificOutput.permissionDecision='deny' and a reason
+    listing the offending pair. A non-empty rollback_history array suppresses
+    this check because rollbacks legitimately reorder steps. All allow paths
+    emit hookSpecificOutput.permissionDecision='allow'.
 
     Edit tool calls supply only old_string/new_string (a partial patch) and
     cannot be reliably validated without the full target file content, so they
@@ -195,7 +198,7 @@ function Test-IsCheckpointPath {
 function Invoke-CheckpointMonotonicDecision {
     <#
     .SYNOPSIS
-        Parses CLAUDE_TOOL_INPUT and returns an allow-or-block decision.
+        Parses Codex tool_input and returns an allow-or-block decision.
     #>
     [CmdletBinding()]
     [OutputType([System.Collections.Specialized.OrderedDictionary])]
@@ -204,44 +207,49 @@ function Invoke-CheckpointMonotonicDecision {
     )
 
     if (-not $ToolInputRaw) {
-        return [ordered]@{ decision = 'allow' }
+        return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
     }
 
     try {
         $toolInput = $ToolInputRaw | ConvertFrom-Json -ErrorAction Stop
     }
     catch {
-        throw "enforce-checkpoint-monotonic hook received malformed JSON in CLAUDE_TOOL_INPUT: $_"
+        throw "enforce-checkpoint-monotonic 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' } }
     }
 
     $normalized = $filePath -replace '\\', '/'
     if (-not (Test-IsCheckpointPath -NormalizedPath $normalized)) {
-        return [ordered]@{ decision = 'allow' }
+        return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
     }
 
-    # Write tool: validate the content payload. Edit tool: partial new_string is
-    # not reliable without the full target file content, so allow.
+    # The adapter supplies complete post-patch content for every recognized
+    # operation. Empty content therefore represents deletion and must fail
+    # closed for the canonical checkpoint.
     $content = $toolInput.content
     if (-not $content) {
-        return [ordered]@{ decision = 'allow' }
+        return [ordered]@{ hookSpecificOutput = [ordered]@{
+                hookEventName = 'PreToolUse'; permissionDecision = 'deny'
+                permissionDecisionReason = 'CHECKPOINT_ORDER_BLOCKED: the canonical checkpoint cannot be deleted or replaced with empty content.'
+            } }
     }
 
     try {
         $payload = ConvertFrom-CheckpointJson -Json $content
     }
     catch {
-        # The content itself is not valid JSON. Let downstream tools surface the
-        # error rather than blocking with a misleading reason here.
-        return [ordered]@{ decision = 'allow' }
+        return [ordered]@{ hookSpecificOutput = [ordered]@{
+                hookEventName = 'PreToolUse'; permissionDecision = 'deny'
+                permissionDecisionReason = 'CHECKPOINT_ORDER_BLOCKED: the canonical checkpoint must remain valid JSON.'
+            } }
     }
 
     if (-not $payload.PSObject.Properties.Name -contains 'completed_steps') {
-        return [ordered]@{ decision = 'allow' }
+        return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
     }
 
     $steps = @()
@@ -256,14 +264,17 @@ function Invoke-CheckpointMonotonicDecision {
         $rollbackHistory = $payload.rollback_history
     }
     if ($rollbackHistory -and @($rollbackHistory).Count -gt 0) {
-        return [ordered]@{ decision = 'allow' }
+        return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
     }
 
     $pair = if ($steps.Count -ge 2) { Get-OutOfOrderPair -CompletedSteps $steps } else { $null }
     if ($null -ne $pair) {
         return [ordered]@{
-            decision = 'block'
-            reason   = "CHECKPOINT_ORDER_BLOCKED: completed_steps lists '$($pair.EarlierEntry)' at position $($pair.EarlierPos) before '$($pair.LaterEntry)' at position $($pair.LaterPos), but the canonical orchestrator workflow requires the later step to follow the earlier one. Reorder completed_steps or, if a rollback occurred, record it in rollback_history."
+            hookSpecificOutput = [ordered]@{
+                hookEventName            = 'PreToolUse'
+                permissionDecision       = 'deny'
+                permissionDecisionReason = "CHECKPOINT_ORDER_BLOCKED: completed_steps lists '$($pair.EarlierEntry)' at position $($pair.EarlierPos) before '$($pair.LaterEntry)' at position $($pair.LaterPos), but the canonical orchestrator workflow requires the later step to follow the earlier one. Reorder completed_steps or, if a rollback occurred, record it in rollback_history."
+            }
         }
     }
 
@@ -277,27 +288,133 @@ function Invoke-CheckpointMonotonicDecision {
             $missing += 'S4_atomic_planning'
         }
         return [ordered]@{
-            decision = 'block'
-            reason   = "CHECKPOINT_ORDER_BLOCKED: completed_steps lists '$($missingPrerequisite.Step)' before required prerequisite step(s): $($missing -join ', '). Record promotion and planning completion before implementation, review, PR, CI, or DONE steps."
+            hookSpecificOutput = [ordered]@{
+                hookEventName            = 'PreToolUse'
+                permissionDecision       = 'deny'
+                permissionDecisionReason = "CHECKPOINT_ORDER_BLOCKED: completed_steps lists '$($missingPrerequisite.Step)' before required prerequisite step(s): $($missing -join ', '). Record promotion and planning completion before implementation, review, PR, CI, or DONE steps."
+            }
         }
     }
 
-    return [ordered]@{ decision = 'allow' }
+    return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
 }
 
 # Guard allows dot-sourcing in tests without executing the entrypoint.
+function ConvertFrom-CodexCheckpointHookPayload {
+    [CmdletBinding()]
+    param([Parameter(Mandatory)][string] $PayloadRaw)
+
+    if ([string]::IsNullOrWhiteSpace($PayloadRaw)) {
+        throw 'enforce-checkpoint-monotonic hook input is empty.'
+    }
+    try {
+        $payload = $PayloadRaw | ConvertFrom-Json -ErrorAction Stop
+    } catch {
+        throw "enforce-checkpoint-monotonic hook input is malformed JSON: $_"
+    }
+    if ($payload.PSObject.Properties.Name -notcontains 'tool_input' -or $null -eq $payload.tool_input) {
+        throw 'enforce-checkpoint-monotonic hook input is missing tool_input.'
+    }
+    if ([string]$payload.hook_event_name -ne 'PreToolUse' -or [string]$payload.tool_name -ne 'apply_patch') {
+        throw 'enforce-checkpoint-monotonic requires a PreToolUse apply_patch payload.'
+    }
+    return $payload
+}
+
+function ConvertTo-CodexApplyPatchCheckpointInput {
+    [CmdletBinding()]
+    [OutputType([object[]])]
+    param([Parameter(Mandatory)] $Payload)
+
+    if ($Payload.tool_input.PSObject.Properties.Name -contains 'file_path') {
+        return , $Payload.tool_input
+    }
+    $command = [string]$Payload.tool_input.command
+    if ([string]::IsNullOrWhiteSpace($command)) {
+        throw 'enforce-checkpoint-monotonic cannot map tool_input to a file edit.'
+    }
+
+    $fileMatches = [regex]::Matches(
+        $command,
+        '(?ms)^\*\*\* (?<operation>Add|Update|Delete) File:\s*(?<path>.+?)\r?\n(?<body>.*?)(?=^\*\*\* (?:(?:Add|Update|Delete) File:|End Patch)\s*|\z)'
+    )
+    if ($fileMatches.Count -eq 0) {
+        throw 'enforce-checkpoint-monotonic received an unrecognized apply_patch command.'
+    }
+
+    $inputs = [System.Collections.Generic.List[object]]::new()
+    foreach ($match in $fileMatches) {
+        $sourcePath = ([string]$match.Groups['path'].Value).Trim()
+        $path = $sourcePath
+        $operation = [string]$match.Groups['operation'].Value
+        $body = ([string]$match.Groups['body'].Value) -replace '\r\n', "`n"
+        $moveMatch = [regex]::Match($body, '(?m)^\*\*\* Move to:\s*(?<path>.+?)\s*$')
+        if ($moveMatch.Success) {
+            $path = ([string]$moveMatch.Groups['path'].Value).Trim()
+        }
+        if ($operation -eq 'Delete') {
+            $content = ''
+        } elseif ($operation -eq 'Add') {
+            $content = (($body -split "`n") | ForEach-Object {
+                    if ($_.StartsWith('+') -and -not $_.StartsWith('+++')) {
+                        $_.Substring(1)
+                    }
+                }) -join "`n"
+        } else {
+            if (-not (Test-Path -LiteralPath $sourcePath -PathType Leaf)) {
+                throw "enforce-checkpoint-monotonic cannot read update source '$sourcePath'."
+            }
+            $content = (Get-Content -Raw -LiteralPath $sourcePath) -replace '\r\n', "`n"
+            $hunks = @([regex]::Split($body, '(?m)^@@[^\r\n]*\r?\n') | Where-Object { $_ -match '\S' })
+            foreach ($hunk in $hunks) {
+                $oldLines = [System.Collections.Generic.List[string]]::new()
+                $newLines = [System.Collections.Generic.List[string]]::new()
+                foreach ($line in ($hunk -split "`n")) {
+                    if ($line -match '^\*\*\* (?:Move to|End of File)') {
+                        continue
+                    }
+                    if ($line.StartsWith('+') -and -not $line.StartsWith('+++')) {
+                        $newLines.Add($line.Substring(1))
+                    } elseif ($line.StartsWith('-') -and -not $line.StartsWith('---')) {
+                        $oldLines.Add($line.Substring(1))
+                    } elseif ($line.StartsWith(' ')) {
+                        $oldLines.Add($line.Substring(1))
+                        $newLines.Add($line.Substring(1))
+                    } else {
+                        $oldLines.Add($line)
+                        $newLines.Add($line)
+                    }
+                }
+                $oldText = $oldLines -join "`n"
+                $newText = $newLines -join "`n"
+                $index = $content.IndexOf($oldText, [System.StringComparison]::Ordinal)
+                if ($index -lt 0) {
+                    throw "enforce-checkpoint-monotonic could not apply an in-memory patch hunk for '$path'."
+                }
+                $content = $content.Substring(0, $index) + $newText + $content.Substring($index + $oldText.Length)
+            }
+        }
+        $inputs.Add([pscustomobject]@{ file_path = $path; content = $content })
+    }
+    return $inputs.ToArray()
+}
+
 if ($MyInvocation.InvocationName -eq '.') {
     return
 }
 
 try {
-    $decision = Invoke-CheckpointMonotonicDecision -ToolInputRaw $env:CLAUDE_TOOL_INPUT
-}
-catch {
-    Write-Error $_
-    exit 1
+    $payload = ConvertFrom-CodexCheckpointHookPayload -PayloadRaw ([Console]::In.ReadToEnd())
+    foreach ($toolInput in @(ConvertTo-CodexApplyPatchCheckpointInput -Payload $payload)) {
+        $toolInputRaw = $toolInput | ConvertTo-Json -Compress -Depth 20
+        $decision = Invoke-CheckpointMonotonicDecision -ToolInputRaw $toolInputRaw
+        if ($decision.hookSpecificOutput.permissionDecision -eq 'deny') {
+            $decision | ConvertTo-Json -Compress -Depth 5 | Write-Output
+            exit 0
+        }
+    }
+    exit 0
+} catch {
+    [Console]::Error.WriteLine([string]$_)
+    exit 2
 }
-
-$decision | ConvertTo-Json -Compress | Write-Output
-
-exit 0