@danmoisan/drm-copilot-mcp 1.1.17 → 1.1.19

package/resources/claude-customizations/.claude/lib/orchestrator-state/OrchestratorStateRemediationAccounting.psm1

@@ -0,0 +1,337 @@
+<#
+.SYNOPSIS
+    Portable remediation-loop review-outcome and accounting checks (R5-R11).
+
+.DESCRIPTION
+    Destination-runtime PowerShell port of the issue #484 invariants the
+    authoritative Python validator applies to a checkpoint's remediation_loop:
+    the review-outcome rules R8a, R8b, R9a-R9d, and R10, and the accounting
+    rules R5, R6, R7a, R7b, and R11, matching the error-string templates in
+    `scripts/dev_tools/_orchestrator_state_remediation_loop.py` and the rules
+    document `.claude/rules/orchestrator-state.md`.
+
+    The receipts module calls the exported entry point after its unchanged
+    per-cycle checks, passing the cycle list or $null when cycles is absent or
+    not a list, so the new checks also run for a loop with review outcomes and
+    no cycles.
+
+    Every comparison against the verdict and class vocabulary is case-sensitive
+    (-ccontains, -cnotcontains, -ceq). An integer is a JSON number deserialized
+    as [int] or [long]; a boolean is never an integer. Values interpolated into
+    a message ({v}) render through ConvertTo-PythonDisplayText so the text
+    matches Python's str().
+
+    Every function is pure: it reads no file, starts no process, and never
+    mutates its input. Each check returns a string array, empty when valid.
+    CONVENTION: this module fails fast at module scope and imports its siblings with -ErrorAction Stop.
+#>
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Stop'
+
+# Import the shared checkpoint-value primitives, resolved relative to this
+# module's directory so the import travels with the pushed-down pack.
+Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'OrchestratorStateCheckpointValue.psm1') -Force -ErrorAction Stop
+
+# Loop and cycle keys read by the accounting rules.
+$script:REVIEW_OUTCOMES_KEY = 'review_outcomes'
+$script:COMPLETED_ATTEMPTS_KEY = 'completed_attempts'
+$script:CANDIDATE_APPLIED_KEY = 'candidate_applied'
+$script:OPENED_BY_REVIEW_KEY = 'opened_by_review'
+$script:COMPLETED_EXECUTION_STATUS = 'complete'
+
+# Review verdicts and remediability classes in spec table order, and the two
+# derived class partitions. Pinned to the Python constants of the same names.
+$script:REVIEW_VERDICTS = @('PASS', 'REMEDIATION_REQUIRED', 'HALT_NON_REMEDIABLE', 'AWAITING_CI')
+$script:REMEDIABILITY_CLASSES = @('autonomous', 'external_dependency', 'policy_hold', 'awaiting_ci', 'human_decision_required')
+$script:NON_REMEDIABLE_CLASSES = @('external_dependency', 'policy_hold', 'awaiting_ci', 'human_decision_required')
+$script:HALT_CLASSES = @('external_dependency', 'policy_hold', 'human_decision_required')
+$script:REMEDIABLE_CLASS = 'autonomous'
+$script:REMEDIATION_REQUIRED_VERDICT = 'REMEDIATION_REQUIRED'
+
+
+function Test-RemediationStrictInteger {
+    <#
+    .SYNOPSIS
+        Report whether a deserialized JSON value is an integer and not a boolean.
+    .DESCRIPTION
+        Private predicate mirroring Python's isinstance(value, int) and not
+        isinstance(value, bool). ConvertFrom-Json materializes a JSON integer as
+        [int] or [long] and a JSON boolean as [bool].
+    .PARAMETER Value
+        The deserialized JSON value to classify. May be $null.
+    .OUTPUTS
+        System.Boolean - $true only for an [int] or [long] value.
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [object] $Value
+    )
+
+    return (($Value -is [int]) -or ($Value -is [long])) -and -not ($Value -is [bool])
+}
+
+function Get-RemediationReviewVerdict {
+    <#
+    .SYNOPSIS
+        Derive a review verdict from its findings' remediability classes.
+    .DESCRIPTION
+        Private helper mirroring derive_review_verdict. Evaluates, in order: no
+        classes yields PASS; any autonomous class yields REMEDIATION_REQUIRED;
+        any member of HALT_CLASSES yields HALT_NON_REMEDIABLE; otherwise
+        AWAITING_CI. A member outside REMEDIABILITY_CLASSES (compared
+        case-sensitively) raises a terminating error whose message begins
+        'invalid remediability: '.
+    .PARAMETER Remediability
+        The remediability class of every blocking finding; may be empty and may
+        repeat a class.
+    .OUTPUTS
+        System.String - one of the four review verdicts.
+    #>
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyCollection()]
+        [string[]] $Remediability
+    )
+
+    foreach ($value in $Remediability) {
+        if ($script:REMEDIABILITY_CLASSES -cnotcontains $value) {
+            throw "invalid remediability: $value"
+        }
+    }
+
+    if ($Remediability.Count -eq 0) { return 'PASS' }
+    if ($Remediability -ccontains $script:REMEDIABLE_CLASS) { return 'REMEDIATION_REQUIRED' }
+    foreach ($value in $Remediability) {
+        if ($script:HALT_CLASSES -ccontains $value) { return 'HALT_NON_REMEDIABLE' }
+    }
+    return 'AWAITING_CI'
+}
+
+function Get-RemediationReviewOutcomeError {
+    <#
+    .SYNOPSIS
+        Return one review outcome's errors (R9a-R9d, then R10).
+    .DESCRIPTION
+        Private helper mirroring _validate_review_outcome. Checks the verdict
+        (string check before membership), the findings list, and each finding's
+        remediability (string check before membership); R10 runs only when none
+        of those checks produced an error for the outcome.
+    .PARAMETER Index
+        The outcome's zero-based position, used for error context.
+    .PARAMETER Outcome
+        The deserialized outcome object.
+    .OUTPUTS
+        System.String[] - zero or more error strings.
+    #>
+    [CmdletBinding()]
+    [OutputType([string[]])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [int] $Index,
+
+        [Parameter(Mandatory = $true)]
+        [psobject] $Outcome
+    )
+
+    $errors = [System.Collections.Generic.List[string]]::new()
+    $prefix = "Checkpoint remediation review outcome #$Index"
+
+    $verdict = (Get-CheckpointObjectMember -Owner $Outcome -Name 'verdict').Value
+    if (-not ($verdict -is [string]) -or ($script:REVIEW_VERDICTS -cnotcontains [string]$verdict)) {
+        $rendered = ConvertTo-PythonDisplayText -Value $verdict
+        $errors.Add("$prefix verdict must be one of PASS, REMEDIATION_REQUIRED, HALT_NON_REMEDIABLE, AWAITING_CI; got: $rendered")
+    }
+
+    $classes = [System.Collections.Generic.List[string]]::new()
+    $findings = (Get-CheckpointObjectMember -Owner $Outcome -Name 'findings').Value
+    if (-not (Test-CheckpointListValue -Value $findings)) {
+        $errors.Add("$prefix findings must be a list.")
+    } else {
+        $findingIndex = 0
+        foreach ($finding in @($findings)) {
+            if (-not (Test-CheckpointObjectValue -Value $finding)) {
+                $errors.Add("$prefix finding #$findingIndex must be an object.")
+            } else {
+                $remediability = (Get-CheckpointObjectMember -Owner $finding -Name 'remediability').Value
+                if (-not ($remediability -is [string]) -or ($script:REMEDIABILITY_CLASSES -cnotcontains [string]$remediability)) {
+                    $rendered = ConvertTo-PythonDisplayText -Value $remediability
+                    $errors.Add("$prefix finding #$findingIndex remediability must be one of autonomous, external_dependency, policy_hold, awaiting_ci, human_decision_required; got: $rendered")
+                } else {
+                    $classes.Add([string]$remediability)
+                }
+            }
+            $findingIndex++
+        }
+    }
+
+    # R10 compares only a well-formed outcome; any shape error above suppresses it.
+    if ($errors.Count -eq 0) {
+        $expected = Get-RemediationReviewVerdict -Remediability $classes.ToArray()
+        if (-not ([string]$verdict -ceq $expected)) {
+            $errors.Add("$prefix verdict $verdict does not match its findings (expected $expected).")
+        }
+    }
+
+    return $errors.ToArray()
+}
+
+function Get-RemediationReviewOutcomeListError {
+    <#
+    .SYNOPSIS
+        Return the review-outcome errors (R8a, R8b, then each outcome).
+    .DESCRIPTION
+        Private helper mirroring _validate_review_outcomes. An absent
+        review_outcomes key yields no errors; a present non-list value yields R8a
+        alone; otherwise each non-object outcome yields R8b and is skipped.
+    .PARAMETER RemediationLoop
+        The deserialized remediation_loop object.
+    .OUTPUTS
+        System.String[] - zero or more error strings.
+    #>
+    [CmdletBinding()]
+    [OutputType([string[]])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [psobject] $RemediationLoop
+    )
+
+    $errors = [System.Collections.Generic.List[string]]::new()
+    $member = Get-CheckpointObjectMember -Owner $RemediationLoop -Name $script:REVIEW_OUTCOMES_KEY
+    if (-not $member.Present) { return $errors.ToArray() }
+    if (-not (Test-CheckpointListValue -Value $member.Value)) {
+        $errors.Add('Checkpoint remediation_loop review_outcomes must be a list.')
+        return $errors.ToArray()
+    }
+
+    $index = 0
+    foreach ($outcome in @($member.Value)) {
+        if (-not (Test-CheckpointObjectValue -Value $outcome)) {
+            $errors.Add("Checkpoint remediation review outcome #$index must be an object.")
+        } else {
+            $errors.AddRange([string[]]@(Get-RemediationReviewOutcomeError -Index $index -Outcome $outcome))
+        }
+        $index++
+    }
+
+    return $errors.ToArray()
+}
+
+function Test-RemediationOpenedByReview {
+    <#
+    .SYNOPSIS
+        Report whether an index names a REMEDIATION_REQUIRED outcome object.
+    .DESCRIPTION
+        Private predicate for R11: the value must be an integer (not a boolean)
+        from 0 to one less than the outcome count of a list review_outcomes, and
+        the indexed entry must be an object whose verdict is exactly
+        REMEDIATION_REQUIRED. A negative index is out of range.
+    .PARAMETER OpenedByReview
+        The raw opened_by_review value. May be $null.
+    .PARAMETER Outcomes
+        The raw review_outcomes value. May be $null.
+    .OUTPUTS
+        System.Boolean - $true only when the reference is valid.
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [object] $OpenedByReview,
+
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [object] $Outcomes
+    )
+
+    if (-not (Test-RemediationStrictInteger -Value $OpenedByReview)) { return $false }
+    if (-not (Test-CheckpointListValue -Value $Outcomes)) { return $false }
+    $outcomeList = @($Outcomes)
+    if ($OpenedByReview -lt 0 -or $OpenedByReview -ge $outcomeList.Count) { return $false }
+    $target = $outcomeList[[int]$OpenedByReview]
+    if (-not (Test-CheckpointObjectValue -Value $target)) { return $false }
+    $verdict = (Get-CheckpointObjectMember -Owner $target -Name 'verdict').Value
+    return ($verdict -is [string]) -and ([string]$verdict -ceq $script:REMEDIATION_REQUIRED_VERDICT)
+}
+
+function Get-OrchestratorStateRemediationAccountingError {
+    <#
+    .SYNOPSIS
+        Return the remediation_loop review-outcome and accounting errors (R5-R11).
+    .DESCRIPTION
+        Public entry mirroring the issue #484 tail of _validate_remediation_loop.
+        Returns, in order: the review-outcome errors (R8a; otherwise per outcome
+        R8b, R9a, R9b, R9c or R9d per finding, then R10); then, for each object
+        cycle in order, R5, R6, and R11; then R7a, otherwise R7b. With none of the
+        new keys present it returns nothing.
+    .PARAMETER RemediationLoop
+        The deserialized remediation_loop object.
+    .PARAMETER Cycle
+        The loop's cycles list, or $null when cycles is absent or not a list.
+    .OUTPUTS
+        System.String[] - zero or more error strings.
+    #>
+    [CmdletBinding()]
+    [OutputType([string[]])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [psobject] $RemediationLoop,
+
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [AllowEmptyCollection()]
+        [object] $Cycle
+    )
+
+    $errors = [System.Collections.Generic.List[string]]::new()
+    $errors.AddRange([string[]]@(Get-RemediationReviewOutcomeListError -RemediationLoop $RemediationLoop))
+
+    $outcomes = (Get-CheckpointObjectMember -Owner $RemediationLoop -Name $script:REVIEW_OUTCOMES_KEY).Value
+    $appliedCount = 0
+    $cycleItems = @()
+    if ($null -ne $Cycle) { $cycleItems = @($Cycle) }
+    $index = 0
+    foreach ($item in $cycleItems) {
+        if (Test-CheckpointObjectValue -Value $item) {
+            $prefix = "Checkpoint remediation cycle #$index"
+            $applied = Get-CheckpointObjectMember -Owner $item -Name $script:CANDIDATE_APPLIED_KEY
+            if ($applied.Present) {
+                if (-not ($applied.Value -is [bool])) {
+                    $errors.Add("$prefix candidate_applied must be a boolean.")
+                } elseif ($applied.Value) {
+                    $appliedCount++
+                    $executionStatus = (Get-CheckpointObjectMember -Owner $item -Name 'execution_status').Value
+                    if (-not ($executionStatus -is [string]) -or -not ([string]$executionStatus -ceq $script:COMPLETED_EXECUTION_STATUS)) {
+                        $errors.Add("$prefix candidate_applied is true but execution_status is not 'complete'.")
+                    }
+                }
+            }
+            $opened = Get-CheckpointObjectMember -Owner $item -Name $script:OPENED_BY_REVIEW_KEY
+            if ($opened.Present -and -not (Test-RemediationOpenedByReview -OpenedByReview $opened.Value -Outcomes $outcomes)) {
+                $errors.Add("$prefix opened_by_review must reference a review outcome whose verdict is REMEDIATION_REQUIRED.")
+            }
+        }
+        $index++
+    }
+
+    $attempts = Get-CheckpointObjectMember -Owner $RemediationLoop -Name $script:COMPLETED_ATTEMPTS_KEY
+    if ($attempts.Present) {
+        if (-not (Test-RemediationStrictInteger -Value $attempts.Value) -or $attempts.Value -lt 0) {
+            $errors.Add('Checkpoint remediation_loop completed_attempts must be a non-negative integer.')
+        } elseif ($attempts.Value -ne $appliedCount) {
+            $errors.Add("Checkpoint remediation_loop completed_attempts is $($attempts.Value) but $appliedCount cycles have candidate_applied true.")
+        }
+    }
+
+    return $errors.ToArray()
+}
+
+# Only the entry point is exported; the verdict helper and the per-outcome and
+# per-reference checks stay private to this module.
+Export-ModuleMember -Function Get-OrchestratorStateRemediationAccountingError

package/resources/claude-customizations/.claude/lib/orchestrator-state/OrchestratorStateRoutingContract.psm1

@@ -5,7 +5,8 @@
 .DESCRIPTION
     Destination-runtime PowerShell port of `validate_routing_contract` in
     `scripts/dev_tools/_orchestrator_state_routing.py`, covering parity-inventory
-    rows C6.1 through C6.14:
+    rows C6.1 through C6.15. The C6.15 adoption waiver affects only receipt
+    presence (C6.9); the declared-list equality checks are unchanged:
 
       C6.1   routing matrix carries no routes object          (returns)
       C6.2   no route selected                                (returns)
@@ -21,6 +22,7 @@
       C6.12  lifecycle_operations must be a list when present
       C6.13  per non-object lifecycle operation
       C6.14  per lifecycle operation that did not use the MCP surface
+      C6.15  issue_adoption field and waiver rules (OrchestratorStateIssueAdoption.psm1)
 
     The routing matrix is read from `OrchestratorStateRoutingMatrix.psm1`, which
     implements deviation PD-1: the constants are pinned and no disk read occurs at
@@ -56,6 +58,7 @@ $ErrorActionPreference = 'Stop'
 # pushed-down pack regardless of the working directory.
 Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'OrchestratorStateCheckpointValue.psm1') -Force -ErrorAction Stop
 Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'OrchestratorStateRoutingMatrix.psm1') -Force -ErrorAction Stop
+Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'OrchestratorStateIssueAdoption.psm1') -Force -ErrorAction Stop
 
 # The promotion-entry MCP tools and the promotion type that triggers substitution.
 $script:FEATURE_PROMOTION_ENTRY_TOOL = 'new_potential_entry'
@@ -410,11 +413,16 @@ function Get-OrchestratorStateRoutingContractError {
     }
 
     $actualTools = @(Get-CheckpointAcknowledgedName -State $State -ArrayKey 'mcp_call_receipts' -NameKey 'tool' -FlagKey 'ok')
+    # C6.15: a valid issue_adoption record waives the receipt requirement for the
+    # tools it lists; any adoption error waives nothing.
+    $adoption = Get-OrchestratorStateIssueAdoptionResult -State $State -RouteId $routeId -RequiredMcpTool ([string[]]$requiredMcpTools) -SuccessfulTool ([string[]]$actualTools)
     foreach ($tool in $requiredMcpTools) {
+        if (@($adoption.WaivedTools) -ccontains $tool) { continue }
         if ($actualTools -cnotcontains $tool) {
             $errors.Add("Checkpoint missing successful MCP receipt: $tool.")
         }
     }
+    $errors.AddRange([string[]]@($adoption.Errors))
 
     # C6.10 to C6.14: the two empty-list fields and the lifecycle operations.
     foreach ($key in $script:COMPLETION_EMPTY_LIST_KEYS) {

package/resources/claude-customizations/.claude/lib/worktree-resolution/WorktreeItemResolution.psm1

@@ -21,7 +21,8 @@
     PowerShell 7+. Re-uses its siblings for enumeration, the marker test, the ascent,
     the branch reader, normalisation, the join, the result constructor, and both
     reason-code accessors, re-implementing none. Neither reason-code literal appears
-    here. Its only filesystem read is the checkpoint-text seam. Mirrored byte-identically.
+    here. Its only filesystem read is still the checkpoint-text seam, including for the
+    item-by-pull-request resolver added for issue #850. Mirrored byte-identically.
     CONVENTION: this module fails fast at module scope and imports its siblings with -ErrorAction Stop.
 #>
 
@@ -395,6 +396,81 @@ function Resolve-WorktreeItemTarget {
     return (Resolve-WorktreeItemTargetByIssue -Session $session -Issue $issues[0])
 }
 
+# Private: whether checkpoint text records a pull request number in pr_gate.pr_number or
+# in a standalone_merge_authorizations entry whose pr_number is a positive JSON integer.
+function Test-WorktreeItemCheckpointRecordsPr {
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [Parameter(Mandatory = $true)] [AllowNull()] [AllowEmptyString()] [string] $Text,
+        [Parameter(Mandatory = $true)] [long] $PrNumber
+    )
+
+    if ([string]::IsNullOrWhiteSpace($Text)) { return $false }
+    $payload = $null
+    try { $payload = $Text | ConvertFrom-Json } catch { return $false }
+    if ($null -eq $payload -or $payload -isnot [pscustomobject]) { return $false }
+    # Names are collected per property, because strict mode throws on .Name of an empty object.
+    $names = @($payload.PSObject.Properties | ForEach-Object { $_.Name })
+    if ($names -contains 'pr_gate' -and $payload.pr_gate -is [pscustomobject] -and @($payload.pr_gate.PSObject.Properties | ForEach-Object { $_.Name }) -contains 'pr_number') {
+        $recorded = [long] 0
+        if ([long]::TryParse([string] $payload.pr_gate.pr_number, [ref] $recorded) -and $recorded -eq $PrNumber) { return $true }
+    }
+    if ($names -notcontains 'standalone_merge_authorizations') { return $false }
+    foreach ($entry in @($payload.standalone_merge_authorizations)) {
+        if ($entry -isnot [pscustomobject] -or @($entry.PSObject.Properties | ForEach-Object { $_.Name }) -notcontains 'pr_number') { continue }
+        $value = $entry.pr_number
+        # Only a JSON integer counts; a string, fraction, zero, or negative never matches.
+        if (($value -is [int] -or $value -is [long]) -and $value -gt 0 -and [long] $value -eq $PrNumber) { return $true }
+    }
+    return $false
+}
+
+function Resolve-WorktreeItemTargetByPrNumber {
+    <#
+    .SYNOPSIS
+        Resolve the live worktree whose orchestrator checkpoint records a pull request number (issue #850).
+    .DESCRIPTION
+        Keeps each live root whose checkpoint records the number in pr_gate.pr_number or
+        in a standalone_merge_authorizations entry. Zero matches resolve NoTarget, one
+        resolves, and several are Ambiguous with no tie-break. A number of zero or less
+        is NoTarget. Reads only through the checkpoint-text seam.
+    .PARAMETER PrNumber
+        The pull request number the command names.
+    .PARAMETER SessionRoot
+        The calling process's path, used only to find the repository and label a result.
+        Defaults to the current location when blank.
+    #>
+    [CmdletBinding()]
+    [OutputType([pscustomobject])]
+    param(
+        [Parameter(Mandatory = $true)] [long] $PrNumber,
+        [Parameter(Mandatory = $true)] [AllowEmptyString()] [string] $SessionRoot
+    )
+
+    $session = if ([string]::IsNullOrWhiteSpace($SessionRoot)) { (Get-Location).ProviderPath } else { $SessionRoot }
+    $noTarget = "pull request {0} is recorded in pr_gate.pr_number or a standalone_merge_authorizations entry of no live worktree's orchestrator checkpoint" -f $PrNumber
+    if ($PrNumber -le 0) {
+        return (New-WorktreeResolutionTargetResult -Status 'NoTarget' -SessionRoot $session -Detail $noTarget)
+    }
+    # Assigned before it is wrapped, for the reason recorded in the branch resolver.
+    $liveRoots = Get-WorktreeItemLiveRoot -SessionRoot $session
+    $matched = [System.Collections.Generic.List[string]]::new()
+    foreach ($root in @($liveRoots)) {
+        $text = Get-WorktreeItemCheckpointText -Path (Get-WorktreeItemCheckpointPath -WorktreeRoot $root)
+        if (Test-WorktreeItemCheckpointRecordsPr -Text $text -PrNumber $PrNumber) { $matched.Add($root) }
+    }
+    if ($matched.Count -eq 0) {
+        return (New-WorktreeResolutionTargetResult -Status 'NoTarget' -SessionRoot $session -Detail $noTarget)
+    }
+    if ($matched.Count -eq 1) {
+        return (ConvertTo-WorktreeItemResolvedResult -WorktreeRoot $matched[0] -SessionRoot $session -Detail (
+                "pull request {0} resolves to the live worktree whose orchestrator checkpoint records it" -f $PrNumber))
+    }
+    return (New-WorktreeResolutionTargetResult -Status 'Ambiguous' -SessionRoot $session -Candidate $matched.ToArray() -Detail (
+            "pull request {0} is recorded in the orchestrator checkpoints of {1} live worktrees; move the stale checkpoint to artifacts/orchestration/handoff/ so that one worktree records it" -f $PrNumber, $matched.Count))
+}
+
 Export-ModuleMember -Function `
     Get-WorktreeItemCheckpointRelativePath, `
     Get-WorktreeItemCheckpointPath, `
@@ -404,4 +480,5 @@ Export-ModuleMember -Function `
     Get-WorktreeItemCheckpointIssue, `
     Get-WorktreeItemLiveRoot, `
     ConvertTo-WorktreeItemResolvedResult, `
-    Resolve-WorktreeItemTarget
+    Resolve-WorktreeItemTarget, `
+    Resolve-WorktreeItemTargetByPrNumber

package/resources/claude-customizations/.claude/lib/worktree-resolution/WorktreeRunResolution.psm1

@@ -340,7 +340,7 @@ function Resolve-WorktreeParallelTarget {
 }
 
 # Private: compare two worktree paths, insensitive to separator style and trailing
-# slashes, and case-insensitive only for drive-letter paths.
+# slashes, and case-insensitive for drive-letter and UNC (//) paths.
 function Test-WorktreeRunPathEqual {
     [CmdletBinding()]
     [OutputType([bool])]
@@ -352,8 +352,8 @@ function Test-WorktreeRunPathEqual {
     if ([string]::IsNullOrWhiteSpace($Left) -or [string]::IsNullOrWhiteSpace($Right)) { return $false }
     $a = ($Left.Trim() -replace '\\', '/').TrimEnd('/')
     $b = ($Right.Trim() -replace '\\', '/').TrimEnd('/')
-    $isDrivePath = ($a -match '^[A-Za-z]:') -or ($b -match '^[A-Za-z]:')
-    $comparison = if ($isDrivePath) { [System.StringComparison]::OrdinalIgnoreCase } else { [System.StringComparison]::Ordinal }
+    $isCaseInsensitivePath = ($a -match '^([A-Za-z]:|//)') -or ($b -match '^([A-Za-z]:|//)')
+    $comparison = if ($isCaseInsensitivePath) { [System.StringComparison]::OrdinalIgnoreCase } else { [System.StringComparison]::Ordinal }
     return [string]::Equals($a, $b, $comparison)
 }
 

package/resources/claude-customizations/.claude/rules/architecture-boundaries.md

@@ -2,7 +2,7 @@
 paths:
   - "**/*.ts"
   - "**/*.cs"
-description: Architecture boundary enforcement rules for the No-COM architecture.
+description: Architecture boundary enforcement rules for a host-neutral layered architecture.
 ---
 
 # Architecture Boundaries
@@ -14,7 +14,7 @@ Architecture boundary enforcement is a uniform gate across all tiers (T1–T4).
 - **TypeScript:** `dependency-cruiser`. Configuration file pattern: `.dependency-cruiser.cjs`.
 - **.NET (when the backend exists):** `NetArchTest.Rules`. Test project naming pattern: `*.ArchitectureTests`.
 
-## No-COM Architecture Rules (enforceable assertions)
+## Host-Neutral Architecture Rules (enforceable assertions)
 
 Production code in this repository must satisfy each of the following assertions. Each assertion is enforced by `dependency-cruiser` (TypeScript) or `NetArchTest.Rules` (.NET) where applicable; legacy import utilities, when added, must satisfy the same assertions.
 
@@ -37,9 +37,9 @@ Production code in this repository must satisfy each of the following assertions
 
 ## Layer Boundary Assertions (.NET, applies once the backend exists)
 
-- `TaskMaster.Domain` must have zero references to Outlook PIA, VSTO, or Office.js types.
-- `TaskMaster.Application` may depend on `TaskMaster.Domain` only.
-- Adapter projects may depend on `TaskMaster.Domain` and `TaskMaster.Application`; domain may not depend on adapters.
+- `<Product>.Domain` must have zero references to Outlook PIA, VSTO, or Office.js types.
+- `<Product>.Application` may depend on `<Product>.Domain` only.
+- Adapter projects may depend on `<Product>.Domain` and `<Product>.Application`; domain may not depend on adapters.
 
 ## Enforcement Outcome
 

package/resources/claude-customizations/.claude/rules/csharp.md

@@ -2,12 +2,12 @@
 paths:
   - "**/*.cs"
   - "**/*.csproj"
-description: C#-specific toolchain and coding standards (No-COM, xUnit).
+description: C#-specific toolchain and coding standards (xUnit).
 ---
 
 # C# Code Standards
 
-This rule file summarizes the C#-specific policies for this repository. It targets the No-COM .NET foundation: xUnit, NSubstitute, FluentAssertions, `dotnet build`, the analyzer stack, `TimeProvider`, and uniform coverage thresholds.
+This rule file summarizes the C#-specific policies for this repository. It targets a host-neutral .NET foundation: xUnit, NSubstitute, FluentAssertions, `dotnet build`, the analyzer stack, `TimeProvider`, and uniform coverage thresholds.
 
 ## Toolchain
 

package/resources/claude-customizations/.claude/rules/general-code-change.md

@@ -26,7 +26,7 @@ Apply these priorities in order when designing or changing code:
 
 ## Module Rigor Tiers
 
-Module rigor tiers (T1–T4) and the uniform-versus-tier-dependent gate matrix are defined in `.claude/rules/quality-tiers.md`. Every project must be classified in `quality-tiers.yml` at repo root.
+Module rigor tiers (T1–T4) and the uniform-versus-tier-dependent gate matrix are defined in `.claude/rules/quality-tiers.md` and apply only when `quality-tiers.yml` exists at the repository root; in that case every project must be classified in it. A repository without `quality-tiers.yml` has not adopted tiers, and the tier requirements do not apply.
 
 ## Mandatory Toolchain Loop
 

package/resources/claude-customizations/.claude/rules/general-unit-test.md

@@ -20,10 +20,11 @@ Every unit test must satisfy all five of these properties:
 
 ## Coverage Requirements
 
+- Threshold precedence: when the repository's root `CLAUDE.md` states line or branch coverage thresholds, those thresholds govern. The 85% line and 75% branch figures are defaults that apply only when the root `CLAUDE.md` states none. This precedence applies to every restatement of these figures in other rule files, agents, and skills. Each metric falls back independently: when the root `CLAUDE.md` states only a line threshold or only a branch threshold, the stated threshold governs that metric and the default governs the other.
 - **Line coverage must remain >= 85% across all tiers (T1–T4).**
 - **Branch coverage must remain >= 75% across all tiers (T1–T4) for languages whose coverage tooling measures branch coverage.** PowerShell (Pester) and bash (kcov) are the exceptions: neither tool measures branch coverage in any output format, so only the line threshold applies to them and there is no branch-coverage gate. This is a threshold exemption only; PowerShell and bash production files remain in the coverage denominator under the Coverage Exclusion Policy below.
 - Code changes or refactors must not reduce coverage for the lines that were changed.
-- Tier-specific lower coverage thresholds are not used in this repository. See `.claude/rules/quality-tiers.md` for the full tier system.
+- Tier-specific lower coverage thresholds are not used. See `.claude/rules/quality-tiers.md` for the full tier system, which applies only when `quality-tiers.yml` exists at the repository root.
 - Coverage is a supporting metric, not the sole quality gate. Untested critical behavior is not acceptable even if the overall percentage looks good.
 - Configure coverage tooling to exclude test files (e.g., `tests/`) so metrics reflect application code, not tests.
 - Type-only / interface-only modules with no executable behavior may be omitted from coverage measurement. Examples: Python `Protocol`-only modules consumed only under `TYPE_CHECKING`, TypeScript interface/type-only files, and C# interface-only files. Such modules legitimately report 0% executable coverage and may be excluded from measurement. This is a clarification only; it does not lower any coverage threshold.
@@ -86,7 +87,7 @@ Colocation — placing test files alongside production source files in `src/` or
 
 ## Test Categories
 
-The following test categories apply across the repository, with tier-dependent obligations per `.claude/rules/quality-tiers.md`:
+The following test categories apply across the repository, with tier-dependent obligations per `.claude/rules/quality-tiers.md`; those tier-dependent obligations apply only when `quality-tiers.yml` exists at the repository root:
 
 - **Unit tests** — required for all tiers (T1–T4). Cover single units of behavior in isolation.
 - **Property-based tests** — required for T1 and T2 modules: at least one property test per pure function. Use `fast-check` (TypeScript) or `hypothesis` (Python) where applicable.