@danmoisan/drm-copilot-mcp 1.1.22 → 1.1.24

package/resources/claude-customizations/.claude/hooks/enforce-file-size-limit.ps1

@@ -0,0 +1,244 @@
+<#
+.SYNOPSIS
+    Pre-tool-use hook that blocks a Write or Edit leaving a covered file above 800 lines.
+
+.DESCRIPTION
+    This script is invoked by the Claude Code PreToolUse hook before any Write or Edit
+    operation. It enforces the hard tier of the tiered file-size policy: 500 lines is
+    guidance, 700 lines is advisory, and above 800 lines a split is enforced regardless
+    of logical separability. The policy functions live in the shared module
+    ../lib/file-size-policy/FileSizePolicy.psm1.
+
+    Decision order:
+      1. A dependency-load failure denies (fail closed).
+      2. An unreadable envelope denies.
+      3. A path that is not covered (outside the extension allowlist, under an excluded
+         directory, or outside the repository root) allows with no file read.
+      4. Write: the resulting size is the logical line count of content. The pre-write
+         file is read only when that size is above 800.
+         Edit: the pre-edit file is read through the ReadFileContent seam and the
+         old_string to new_string replacement is applied in memory. An unreadable or
+         missing file, or an edit that cannot be resolved, denies.
+      5. The baseline-free pre-edit-size ratchet decides: a result above 800 lines is
+         denied unless the file already existed and does not grow.
+
+    The hook does not read config/file-size-baseline.json, because it ships to
+    repositories that have no baseline; the repository's CI gate is the
+    baseline-aware check. The deny shape is hookSpecificOutput.permissionDecision =
+    'deny' with permissionDecisionReason, exit 0.
+
+.NOTES
+    Compatible with PowerShell 7+.
+    This script must not modify any state; it is a read-only validation gate.
+#>
+[CmdletBinding()]
+param()
+$script:HookDependencyGuardLoadFailed = $false; try { . (Join-Path $PSScriptRoot 'hook-dependency-guard.ps1') } catch { $script:HookDependencyGuardLoadFailed = $true }
+
+try { Import-Module (Join-Path $PSScriptRoot '../lib/hook-payload/HookPayload.psm1') -Force -ErrorAction Stop } catch { Add-HookDependencyFailure -Name 'HookPayload.psm1' -ErrorRecord $_ }
+try { Import-Module (Join-Path $PSScriptRoot '../lib/file-size-policy/FileSizePolicy.psm1') -Force -ErrorAction Stop } catch { Add-HookDependencyFailure -Name 'FileSizePolicy.psm1' -ErrorRecord $_ }
+
+function Get-FileSizeLimitBlockDecision {
+    <#
+    .SYNOPSIS
+        Constructs a deny-decision ordered dictionary carrying the supplied reason.
+    .PARAMETER Reason
+        The deny reason; it starts with FILE_SIZE_LIMIT_BLOCKED:.
+    #>
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param(
+        [Parameter(Mandatory)]
+        [string] $Reason
+    )
+
+    return [ordered]@{
+        hookSpecificOutput = [ordered]@{
+            hookEventName            = 'PreToolUse'
+            permissionDecision       = 'deny'
+            permissionDecisionReason = $Reason
+        }
+    }
+}
+
+function Get-FileSizeLimitAllowDecision {
+    <#
+    .SYNOPSIS
+        Constructs the allow-decision ordered dictionary.
+    #>
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param()
+
+    return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
+}
+
+function Get-FileSizeLimitReplaceAllFlag {
+    <#
+    .SYNOPSIS
+        Returns the boolean value of the replace_all property of an Edit tool input.
+    .DESCRIPTION
+        A boolean is returned as is; a string is true only when its trimmed value is
+        'true' (case-insensitive); every other value, and an absent property, is false.
+        No [bool] cast is used because [bool]'false' is $true in PowerShell.
+    .PARAMETER ToolInput
+        The tool_input object.
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [AllowNull()]
+        [object] $ToolInput
+    )
+
+    $value = Get-ClaudeHookEnvelopeValue -Envelope $ToolInput -Name 'replace_all'
+    if ($value -is [bool]) {
+        return $value
+    }
+    if ($value -is [string]) {
+        return ($value.Trim() -ieq 'true')
+    }
+    return $false
+}
+
+function Invoke-FileSizeLimitDecision {
+    <#
+    .SYNOPSIS
+        Parses the PreToolUse envelope and returns an allow-or-deny decision.
+    .PARAMETER ToolInputRaw
+        The raw JSON hook payload acquired by Read-ClaudeHookRawPayload.
+    .PARAMETER RepositoryRoot
+        The repository root used to resolve relative paths. Defaults to the current
+        location, which is the project root when Claude Code runs the hook.
+    .PARAMETER ReadFileContent
+        Seam that returns the text of a file, $null when the file does not exist, and
+        throws when it cannot be read. Tests supply in-memory content.
+    #>
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param(
+        [AllowNull()]
+        [AllowEmptyString()]
+        [string] $ToolInputRaw,
+
+        [string] $RepositoryRoot = (Get-Location).ProviderPath,
+
+        [scriptblock] $ReadFileContent = {
+            param([string] $Path)
+            if (-not (Test-Path -LiteralPath $Path -PathType Leaf)) { return $null }
+            return [System.IO.File]::ReadAllText($Path)
+        }
+    )
+    $dependencyDecision = Get-HookDependencyFailureDecision -HookEvent PreToolUse -ReasonPrefix 'FILE_SIZE_LIMIT_BLOCKED:'
+    if ($null -ne $dependencyDecision) { return $dependencyDecision }
+
+    $payload = Resolve-ClaudeHookToolInput -Raw $ToolInputRaw
+    if (-not $payload.IsValid) {
+        return Get-FileSizeLimitBlockDecision -Reason ('FILE_SIZE_LIMIT_BLOCKED: payload anomaly - ' +
+            (Get-ClaudeHookPayloadAnomalyReason -Anomaly $payload.Anomaly) +
+            '. The gate fails closed on an envelope it cannot read.')
+    }
+
+    $toolInput = $payload.Value
+    $filePath = Get-ClaudeHookToolInputString -ToolInput $toolInput -Name 'file_path'
+    $relativePath = ConvertTo-FileSizeRelativePath -Path $filePath -RepositoryRoot $RepositoryRoot
+    if (-not (Test-FileSizeCoveredPath -RelativePath $relativePath)) {
+        return Get-FileSizeLimitAllowDecision
+    }
+
+    $isRooted = ($filePath -match '^[\\/]') -or ($filePath -match '^[A-Za-z]:[\\/]')
+    $readPath = if ($isRooted) { $filePath } else { Join-Path $RepositoryRoot $relativePath }
+    $toolName = Get-ClaudeHookToolInputString -ToolInput $payload.Envelope -Name 'tool_name'
+    $isEdit = ($toolName -eq 'Edit')
+
+    $resultCount = 0
+    if (-not $isEdit) {
+        $resultCount = Get-FileSizeLogicalLineCount -Content (Get-ClaudeHookToolInputString -ToolInput $toolInput -Name 'content')
+        if ($resultCount -le (Get-FileSizePolicyLimit).HardLimit) {
+            return Get-FileSizeLimitAllowDecision
+        }
+    }
+
+    try {
+        $preEditContent = & $ReadFileContent $readPath
+    } catch {
+        return Get-FileSizeLimitBlockDecision -Reason "FILE_SIZE_LIMIT_BLOCKED: '$relativePath' could not be read to measure its size ($($_.Exception.Message)). The gate fails closed for a covered file."
+    }
+
+    $preEditCount = $null
+    if ($null -ne $preEditContent) {
+        $preEditCount = Get-FileSizeLogicalLineCount -Content ([string]$preEditContent)
+    }
+
+    if ($isEdit) {
+        if ($null -eq $preEditContent) {
+            return Get-FileSizeLimitBlockDecision -Reason "FILE_SIZE_LIMIT_BLOCKED: '$relativePath' does not exist, so the Edit cannot be measured. The gate fails closed for a covered file."
+        }
+        $edit = Resolve-FileSizeEditContent -Content ([string]$preEditContent) `
+            -OldString (Get-ClaudeHookToolInputString -ToolInput $toolInput -Name 'old_string') `
+            -NewString (Get-ClaudeHookToolInputString -ToolInput $toolInput -Name 'new_string') `
+            -ReplaceAll (Get-FileSizeLimitReplaceAllFlag -ToolInput $toolInput)
+        if ($null -ne $edit.Failure) {
+            return Get-FileSizeLimitBlockDecision -Reason "FILE_SIZE_LIMIT_BLOCKED: the Edit to '$relativePath' could not be resolved in memory ($($edit.Failure)). The gate fails closed for a covered file."
+        }
+        $resultCount = Get-FileSizeLogicalLineCount -Content $edit.Content
+    }
+
+    $decision = Get-FileSizeHookDecision -RelativePath $relativePath -ResultLineCount $resultCount -PreEditLineCount $preEditCount
+    if ($decision.Allowed) {
+        return Get-FileSizeLimitAllowDecision
+    }
+    return Get-FileSizeLimitBlockDecision -Reason $decision.Reason
+}
+
+function Invoke-FileSizeLimitEntryPoint {
+    <#
+    .SYNOPSIS
+        Runs the file-size decision and returns the process exit code.
+    .DESCRIPTION
+        Acquires the payload through the shared reader unless the caller supplies one,
+        writes the compact JSON decision to the output stream, and returns 0. It never
+        returns 1: exit 1 is non-blocking for PreToolUse, so every anomaly is already a
+        deny decision by the time control reaches here.
+    .PARAMETER ToolInputRaw
+        Optional pre-acquired payload text. When omitted the ReadPayload seam runs.
+    .PARAMETER ReadPayload
+        Seam for payload acquisition.
+    #>
+    [CmdletBinding()]
+    [OutputType([int])]
+    param(
+        [AllowNull()]
+        [AllowEmptyString()]
+        [string] $ToolInputRaw,
+
+        [scriptblock] $ReadPayload = { Read-ClaudeHookRawPayload }
+    )
+
+    if (-not $PSBoundParameters.ContainsKey('ToolInputRaw')) {
+        $ToolInputRaw = [string](& $ReadPayload)
+    }
+
+    $decision = Invoke-FileSizeLimitDecision -ToolInputRaw $ToolInputRaw
+
+    $decision | ConvertTo-Json -Compress -Depth 5 | Write-Output
+
+    return 0
+}
+
+# Guard allows dot-sourcing in tests without executing the entrypoint.
+if ($MyInvocation.InvocationName -eq '.') {
+    return
+}
+if ($script:HookDependencyGuardLoadFailed) { [Console]::Error.WriteLine('FILE_SIZE_LIMIT_BLOCKED: hook-dependency-guard.ps1 failed to load; the gate fails closed.'); exit 2 }
+$dependencyDecision = Get-HookDependencyFailureDecision -HookEvent PreToolUse -ReasonPrefix 'FILE_SIZE_LIMIT_BLOCKED:'
+if ($null -ne $dependencyDecision) { $dependencyDecision | ConvertTo-Json -Compress -Depth 5 | Write-Output; exit 0 }
+
+# The entry point returns its [int] exit code as the last pipeline element and the
+# decision JSON before it, so the decision is written explicitly here first.
+$entryPointResult = @(Invoke-FileSizeLimitEntryPoint)
+if ($entryPointResult.Count -gt 1) {
+    $entryPointResult[0..($entryPointResult.Count - 2)] | Write-Output
+}
+
+exit ([int]$entryPointResult[-1])

package/resources/claude-customizations/.claude/hooks/enforce-model-routing-receipt.ps1

@@ -40,6 +40,14 @@
     delegation prompt to a receipt-gated subagent type carries the canonical issue
     number line and a `branch:` label naming the item's branch.
 
+    Author-asserted autoclose line (issue #989): for subagent `pr-author` only, once the
+    per-feature receipt is confirmed, a checkpoint that records an `issue-num` and whose
+    `epic_mode` is not true requires the prompt line
+    `Author-asserted autoclose issues: #<issue-num>` at the start of a line. Its absence denies
+    with the AUTHOR_ASSERTED_AUTOCLOSE_MISSING sub-code (Get-ModelRoutingAuthorAssertedReason).
+    The epic-scope path is not subject to this rule. Only the JSON boolean true waives the line;
+    a string or number such as "true" or 1 does not (issue #1001).
+
 .NOTES
     Compatible with PowerShell 7+. Read-only presence-gating deterrent.
 #>
@@ -198,6 +206,44 @@ function Get-ModelRoutingTargetCheckpointResolution {
     }
 }
 
+function Get-ModelRoutingAuthorAssertedReason {
+    <#
+    .SYNOPSIS
+        Return the deny reason for a pr-author delegation that omits the author-asserted line, or $null.
+    .DESCRIPTION
+        Returns $null when the checkpoint records no usable issue-num, when it carries an
+        epic_mode property whose value is true (an epic child whose integration PR owns the
+        closing keyword), or when a prompt line starts with 'Author-asserted autoclose issues:'
+        and names '#<issue-num>' later on that line with no digit after the number. Property
+        presence is tested first because strict mode throws on a missing property. Only the
+        JSON boolean true waives the line: a string or number such as "true" or 1 does not
+        (issue #1001).
+    .PARAMETER Checkpoint
+        The resolved per-feature checkpoint object.
+    .PARAMETER PromptText
+        The delegation prompt.
+    .OUTPUTS
+        System.String or $null
+    #>
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter(Mandatory)][AllowNull()] $Checkpoint,
+        [Parameter(Mandatory)][AllowEmptyString()][string] $PromptText
+    )
+
+    $names = @($Checkpoint.PSObject.Properties.Name)
+    $issue = if ($names -contains 'issue-num') { ConvertTo-WorktreeItemIssueNumber -Value $Checkpoint.'issue-num' } else { $null }
+    if ($null -eq $issue -or ($names -contains 'epic_mode' -and ($Checkpoint.epic_mode -is [bool]) -and $Checkpoint.epic_mode)) {
+        return $null
+    }
+    $line = "Author-asserted autoclose issues: #$issue"
+    if ([regex]::IsMatch($PromptText, '(?m)^Author-asserted autoclose issues:[^\r\n]*#' + $issue + '(?!\d)')) {
+        return $null
+    }
+    return "MODEL_ROUTING_RECEIPT_BLOCKED: AUTHOR_ASSERTED_AUTOCLOSE_MISSING: the checkpoint records issue-num $issue, so the Agent(pr-author) delegation prompt must carry the line '$line' so the PR body emits '- Closes #$issue'. Add that line on its own line, or omit it only for an epic child (epic_mode true)."
+}
+
 function Invoke-ModelRoutingReceiptDecision {
     <#
     .SYNOPSIS
@@ -274,6 +320,11 @@ function Invoke-ModelRoutingReceiptDecision {
 
     $checkpoint = Get-ModelRoutingCheckpoint -CheckpointPath $resolution.CheckpointPath
     if (Test-ModelRoutingReceiptPresent -Checkpoint $checkpoint -Subagent $subagent) {
+        # Issue #989: the pr-author delegation names the item's issue as author-asserted.
+        $authorAssertedReason = if ($subagent -eq 'pr-author') { Get-ModelRoutingAuthorAssertedReason -Checkpoint $checkpoint -PromptText $prompt } else { $null }
+        if ($authorAssertedReason) {
+            return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'deny'; permissionDecisionReason = $authorAssertedReason } }
+        }
         return $allow
     }
 

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

@@ -3,7 +3,7 @@
     Epic-scope legs, checkpoint read seams, and target resolution of the preimplementation gate.
 
 .DESCRIPTION
-    Dot-sourced by enforce-orchestration-preimplementation-gate.ps1. Holds four groups of
+    Dot-sourced by enforce-orchestration-preimplementation-gate.ps1. Holds five groups of
     functions:
 
     - The import guards for the worktree-resolution modules (issue #690). A failed import
@@ -15,13 +15,20 @@
       read binds to the calling process's directory. Get-CheckpointContent and
       Get-OrchestrationModeDenyReason were relocated here from the gate file by issue #690
       to keep the gate inside the 500-line cap.
+    - The target-resolution building blocks of issue #1010: the worktree-list wrapper
+      Get-OrchestrationGateWorktreeList (the only listing seam), the recording invoker
+      Invoke-OrchestrationGateWorktreeList, which records a failed or empty listing in
+      $script:OrchestrationGateWorktreeListFailed, and the command-operand parser
+      Get-OrchestrationGateCommandOperandPath for git add and git commit.
     - The target resolution of issue #690. Resolve-OrchestrationGateTarget selects the
       worktree whose checkpoint governs the call from portable identity only: the
       integration_branch: value for an epic delegation, the parallel_slug: value for a
-      parallel delegation, the file_path or git -C operand for the path and command legs,
-      and the canonical issue-number line and branch: label for a single-feature
-      delegation. Read-OrchestrationGateCheckpoint reads the checkpoint beneath the
-      resolved root, or returns the deny for an unresolved target.
+      parallel delegation, and the canonical issue-number line and branch: label for a
+      single-feature delegation. The path and command legs resolve through
+      Resolve-HookTargetWorktree (issue #1010) from the file_path or from every git add
+      and git commit selector and absolute operand. Read-OrchestrationGateCheckpoint reads
+      the checkpoint beneath the resolved root, or returns the deny for an unresolved
+      target.
     - The epic-scope decision for the command and path legs (issue #663). A staging
       command or a Write/Edit call is epic scope when the effective worktree's HEAD equals
       the integration branch of the epic checkpoint that Resolve-EpicScopeCheckpoint
@@ -30,21 +37,24 @@
 
 .NOTES
     PowerShell 7+. Depends on functions the gate defines or dot-sources before any call:
-    Split-OrchestrationCommandLine and ConvertTo-OrchestrationCommandToken (helpers file),
     Get-OrchestrationDelegationCheckpointPath (modes file), the gate's allow and block
-    decision constructors, and, through the targets file this file dot-sources (issue #738),
-    Read-CommandLineSegment, Get-CommandLineGlobalOption, and Get-CommandLineInvocation
-    (loaded by the gate's dot-source of hook-command-invocation.ps1). Imports
-    WorktreeItemResolution.psm1 and WorktreeRunResolution.psm1 before
-    EpicScopeResolution.psm1, so the nested import inside EpicScopeResolution reuses the
-    same module instance. Mirrored byte-identically under
+    decision constructors, and Read-CommandLineSegment, Get-CommandLineGlobalOption, and
+    Get-CommandLineInvocation (loaded by the gate's dot-source of
+    hook-command-invocation.ps1), which the targets file this file dot-sources (issue #738)
+    and Get-OrchestrationGateCommandOperandPath call. Imports
+    WorktreeResolution.psm1 (the reason-code accessors), then WorktreeItemResolution.psm1
+    and WorktreeRunResolution.psm1 before EpicScopeResolution.psm1, so the nested import
+    inside EpicScopeResolution reuses the same module instance, and HookTargetWorktree.psm1
+    (Resolve-HookTargetWorktree, issue #1009) last. Mirrored byte-identically under
     extensions/drm-copilot/resources/claude-customizations/.
 #>
 
+try { Import-Module (Join-Path $PSScriptRoot '../lib/worktree-resolution/WorktreeResolution.psm1') -Force -ErrorAction Stop } catch { Add-HookDependencyFailure -Name 'WorktreeResolution.psm1' -ErrorRecord $_ }
 try { Import-Module (Join-Path $PSScriptRoot '../lib/worktree-resolution/WorktreeItemResolution.psm1') -Force -ErrorAction Stop } catch { Add-HookDependencyFailure -Name 'WorktreeItemResolution.psm1' -ErrorRecord $_ }
 try { Import-Module (Join-Path $PSScriptRoot '../lib/worktree-resolution/WorktreeRunResolution.psm1') -Force -ErrorAction Stop } catch { Add-HookDependencyFailure -Name 'WorktreeRunResolution.psm1' -ErrorRecord $_ }
 try { Import-Module (Join-Path $PSScriptRoot '../lib/worktree-resolution/EpicScopeResolution.psm1') -Force -ErrorAction Stop } catch { Add-HookDependencyFailure -Name 'EpicScopeResolution.psm1' -ErrorRecord $_ }
 try { Import-Module (Join-Path $PSScriptRoot '../lib/worktree-resolution/EpicScopeReadiness.psm1') -Force -ErrorAction Stop } catch { Add-HookDependencyFailure -Name 'EpicScopeReadiness.psm1' -ErrorRecord $_ }
+try { Import-Module (Join-Path $PSScriptRoot '../lib/worktree-resolution/HookTargetWorktree.psm1') -Force -ErrorAction Stop } catch { Add-HookDependencyFailure -Name 'HookTargetWorktree.psm1' -ErrorRecord $_ }
 # Per-segment target resolution for the epic-scope decision (issue #738).
 . (Join-Path $PSScriptRoot 'enforce-orchestration-preimplementation-gate-targets.ps1')
 
@@ -102,15 +112,137 @@ function Get-OrchestrationModeDenyReason {
         'require that checkpoint to satisfy every readiness predicate before implementation begins.')
 }
 
+function Get-OrchestrationGateWorktreeList {
+    <#
+    .SYNOPSIS
+        Returns the porcelain worktree listing for the session root (issue #1010 seam).
+    .DESCRIPTION
+        Runs the listing exactly as the default WorktreeListInvoker of
+        Resolve-HookTargetWorktree does and returns an empty string on a non-zero exit. It
+        is the only test seam for the listing.
+    .OUTPUTS
+        System.String
+    #>
+    [CmdletBinding()]
+    [OutputType([string])]
+    param([Parameter(Mandatory)][string] $SessionRoot)
+
+    $porcelain = & git -C $SessionRoot worktree list --porcelain 2>$null
+    if ($LASTEXITCODE -ne 0) { return '' }
+    return ($porcelain -join "`n")
+}
+
+function Invoke-OrchestrationGateWorktreeList {
+    <#
+    .SYNOPSIS
+        Recording WorktreeListInvoker: returns the listing and records a listing failure.
+    .DESCRIPTION
+        Sets $script:OrchestrationGateWorktreeListFailed when the wrapper throws (and then
+        rethrows) or when its text holds no worktree entry, so the gate denies instead of
+        accepting the resolver's session-root fallback (issue #1010, spec E1).
+    .OUTPUTS
+        System.String
+    #>
+    [CmdletBinding()]
+    [OutputType([string])]
+    param([Parameter(Mandatory)][string] $SessionRoot)
+
+    try {
+        $text = [string](Get-OrchestrationGateWorktreeList -SessionRoot $SessionRoot)
+    } catch {
+        $script:OrchestrationGateWorktreeListFailed = $true
+        throw
+    }
+    if (@(ConvertFrom-HookTargetWorktreePorcelain -Text $text).Count -eq 0) {
+        $script:OrchestrationGateWorktreeListFailed = $true
+    }
+    return $text
+}
+
+function Get-OrchestrationGateCommandOperandPath {
+    <#
+    .SYNOPSIS
+        Returns the worktree-selecting paths of every git add and git commit invocation.
+    .DESCRIPTION
+        Scans every Structural match of git add and git commit (every command segment and
+        wrapper payload). Each -C value in any git global-option position and each absolute
+        operand is returned, distinct and in first-seen order. Relative operands, a -C on a
+        git segment invoking neither add nor commit, and Indeterminate matches are ignored.
+        For a match whose record is not argument-injected, a subcommand-aware walk (issue
+        #1010, F2) also reads the tokens after the subcommand with a per-subcommand option
+        model, compared case-sensitively: a value option consumes the next token unless its
+        value is inline (--name=value) or attached (-mvalue); a standalone flag consumes
+        itself; '--' makes every later token an operand; a redirection and its target are
+        skipped; any other dash token, such as the cluster -am, stops the walk. Its literal
+        absolute tokens are returned, and a token the walk reads as an option value is not
+        returned as an operand.
+    .PARAMETER Command
+        The full command line.
+    .OUTPUTS
+        System.String[]
+    #>
+    [CmdletBinding()]
+    [OutputType([string[]])]
+    param([Parameter(Mandatory)][AllowEmptyString()][string] $Command)
+
+    $valueOptions = @{
+        commit = @('-m', '--message', '-F', '--file', '--author', '--date', '-C', '--reuse-message', '-c', '--reedit-message', '-t', '--template', '--fixup', '--squash', '--trailer', '--pathspec-from-file')
+        add    = @('--pathspec-from-file', '--chmod')
+    }
+    $flagOptions = @{
+        commit = @('-a', '--all', '--amend', '--no-edit', '--no-verify', '-n', '-s', '--signoff', '-q', '--quiet', '-v', '--verbose', '--allow-empty', '-o', '--only', '-i', '--include', '--pathspec-file-nul')
+        add    = @('-A', '--all', '-u', '--update', '-f', '--force', '-N', '--intent-to-add', '-n', '--dry-run', '-v', '--verbose', '--pathspec-file-nul')
+    }
+    $absolutePattern = '^([A-Za-z]:[\\/]|/)'
+    $paths = [System.Collections.Generic.List[string]]::new()
+    foreach ($subcommand in @('add', 'commit')) {
+        foreach ($match in @(Get-CommandLineInvocation -CommandText $Command -CommandWord 'git' -SubcommandPath @($subcommand))) {
+            if ($match.Status -ne 'Structural') { continue }
+            $walked = [System.Collections.Generic.List[string]]::new()
+            $optionValues = [System.Collections.Generic.List[string]]::new()
+            $tokens = if ($match.Segment.ArgumentInjected) { [string[]]@() } else { [string[]]@($match.Segment.Tokens) }
+            $afterSeparator = $false
+            for ($index = [int]$match.OperandIndex; $index -lt $tokens.Count; $index++) {
+                $token = $tokens[$index]
+                if (-not $afterSeparator -and $token -match '^(<|>|\d*>|&>)') {
+                    if ($token -match '^(\d*[<>]{1,2}&?|&>{1,2})$') { $index++ }
+                    continue
+                }
+                if ($afterSeparator -or -not $token.StartsWith('-')) { $walked.Add($token); continue }
+                if ($token -ceq '--') { $afterSeparator = $true; continue }
+                $name = if ($token.IndexOf('=') -gt 0) { $token.Substring(0, $token.IndexOf('=')) } else { $token }
+                if ($valueOptions[$subcommand] -ccontains $name) {
+                    if ($name -ceq $token -and $index + 1 -lt $tokens.Count) { $index++; $optionValues.Add($tokens[$index]) }
+                    continue
+                }
+                if ($token -match '^-[^-].' -and $valueOptions[$subcommand] -ccontains $token.Substring(0, 2)) { continue }
+                if ($flagOptions[$subcommand] -ccontains $token) { continue }
+                break
+            }
+            $candidates = @(@($match.GlobalOptions) | Where-Object { $_.Name -ceq '-C' -and $_.Value } | ForEach-Object { [string]$_.Value })
+            $candidates += @(@($match.Operands) | Where-Object { $_ -match $absolutePattern -and $optionValues -cnotcontains $_ })
+            $candidates += @($walked | Where-Object { $_ -match $absolutePattern -and (Test-CommandLineTokenLiteral -Token $_) })
+            foreach ($candidate in $candidates) {
+                if ($paths -notcontains $candidate) { $paths.Add($candidate) }
+            }
+        }
+    }
+    return [string[]]$paths.ToArray()
+}
+
 function Resolve-OrchestrationGateTarget {
     <#
     .SYNOPSIS
         Resolves the worktree whose checkpoint governs a gated call (issue #690 seam).
     .DESCRIPTION
         An epic delegation is keyed on integration_branch: (with epic_feature_folder: as a
-        cross-check), a parallel delegation on parallel_slug:, a path leg on its file_path
-        operand, a command leg on its git -C selector (none means the session root), and a
-        single-feature delegation on its canonical issue-number line and branch: label.
+        cross-check), a parallel delegation on parallel_slug:, and a single-feature
+        delegation on its canonical issue-number line and branch: label. The path and
+        command legs use Resolve-HookTargetWorktree (issue #1010): a path leg passes its
+        file_path, a command leg the Get-OrchestrationGateCommandOperandPath result, and the
+        recording invoker supplies the worktree listing. A failed or empty listing denies as
+        not derivable instead of falling back to the session root; an ambiguous result
+        denies as ambiguous; a null root denies as not derivable.
     .OUTPUTS
         System.Management.Automation.PSCustomObject (the worktree-resolution target result).
     #>
@@ -131,13 +263,29 @@ function Resolve-OrchestrationGateTarget {
         }
         return Resolve-WorktreeParallelTarget -ParallelSlug $signal.ParallelSlug -SessionRoot $sessionRoot
     }
-    if ($FilePath) {
-        return Resolve-WorktreeOperandTarget -Path $FilePath -SessionRoot $sessionRoot
+    if (-not $FilePath -and -not $Command) {
+        return Resolve-WorktreeItemTarget -Text $Prompt -SessionRoot $sessionRoot
+    }
+    $script:OrchestrationGateWorktreeListFailed = $false
+    $invoker = { param($SessionRoot) Invoke-OrchestrationGateWorktreeList -SessionRoot $SessionRoot }
+    $resolved = if ($FilePath) {
+        Resolve-HookTargetWorktree -SessionRoot $sessionRoot -FilePath @($FilePath) -WorktreeListInvoker $invoker
+    } else {
+        Resolve-HookTargetWorktree -SessionRoot $sessionRoot -CommandOperandPath @(Get-OrchestrationGateCommandOperandPath -Command $Command) -WorktreeListInvoker $invoker
+    }
+    $detail = "resolver source $($resolved.Source): $($resolved.Detail)"
+    if ($script:OrchestrationGateWorktreeListFailed) {
+        return [pscustomobject]@{ Status = 'NoTarget'; WorktreeRoot = $null; ReasonCode = (Get-WorktreeResolutionNoTargetReasonCode); Detail = "the worktree listing failed or named no worktree; $detail" }
     }
-    if ($Command) {
-        return Resolve-WorktreeOperandTarget -Path (Get-OrchestrationEpicScopeSelector -Command $Command) -SessionRoot $sessionRoot
+    if ($resolved.Ambiguous) {
+        return [pscustomobject]@{ Status = 'Ambiguous'; WorktreeRoot = $null; ReasonCode = (Get-WorktreeResolutionAmbiguityReasonCode); Detail = $detail }
     }
-    return Resolve-WorktreeItemTarget -Text $Prompt -SessionRoot $sessionRoot
+    if ([string]::IsNullOrEmpty([string]$resolved.WorktreeRoot)) {
+        return [pscustomobject]@{ Status = 'NoTarget'; WorktreeRoot = $null; ReasonCode = (Get-WorktreeResolutionNoTargetReasonCode); Detail = $detail }
+    }
+    $isSession = [string]::Equals([string]$resolved.WorktreeRoot, (ConvertTo-HookTargetWorktreeNormalizedPath -Path $sessionRoot), [System.StringComparison]::OrdinalIgnoreCase)
+    $status = if ($isSession) { 'SessionRoot' } else { 'OtherWorktree' }
+    return [pscustomobject]@{ Status = $status; WorktreeRoot = [string]$resolved.WorktreeRoot; ReasonCode = $null; Detail = $detail }
 }
 
 function Read-OrchestrationGateCheckpoint {
@@ -187,34 +335,6 @@ function Read-OrchestrationGateCheckpoint {
     }
 }
 
-function Get-OrchestrationEpicScopeSelector {
-    <#
-    .SYNOPSIS
-        Returns the value of a leading `git -C <value>` selector, or $null.
-    .DESCRIPTION
-        Pure. Reads only the first segment of the command line, split and tokenized with
-        the helpers-file parser so quoting is handled exactly as the staging exemption
-        handles it. An unbalanced command line has no decidable selector and returns $null.
-    .PARAMETER Command
-        The full command line.
-    .OUTPUTS
-        System.String
-    #>
-    [CmdletBinding()]
-    [OutputType([string])]
-    param([Parameter(Mandatory)][AllowEmptyString()][string] $Command)
-
-    $split = Split-OrchestrationCommandLine -CommandText $Command
-    if (-not $split.Balanced -or @($split.Segments).Count -eq 0) {
-        return $null
-    }
-    $token = @(ConvertTo-OrchestrationCommandToken -Segment ([string]@($split.Segments)[0]).Trim())
-    if ($token.Count -ge 3 -and $token[0] -ceq 'git' -and $token[1] -ceq '-C' -and $token[2]) {
-        return $token[2]
-    }
-    return $null
-}
-
 function Get-OrchestrationEpicScopeDecision {
     <#
     .SYNOPSIS

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

@@ -239,7 +239,7 @@ function Test-OrchestrationReady {
     }
     $lifecycleReady = $false
     if ($Payload.PSObject.Properties.Name -contains 'lifecycle_ready') {
-        $lifecycleReady = [bool]$Payload.lifecycle_ready
+        $lifecycleReady = ($Payload.lifecycle_ready -is [bool]) -and $Payload.lifecycle_ready
     }
 
     if (-not $issueNum -or -not $featureFolder -or -not $routeId -or -not $lifecycleReady) {