@danmoisan/drm-copilot-mcp 1.1.10 → 1.1.12

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

@@ -0,0 +1,347 @@
+<#
+.SYNOPSIS
+    Call-target derivation for target-worktree resolution (issue #669).
+
+.DESCRIPTION
+    Reads target signals from a tool-call payload (a feature-folder path, a file
+    path, and a branch name) and derives the worktree the call pertains to as one
+    of four states: SessionRoot, OtherWorktree, NoTarget, or Ambiguous.
+
+    The presence of a signal, not the success of resolving it, separates NoTarget
+    from Ambiguous. Signals that resolve to different worktree roots are
+    Ambiguous. The precedence order FeatureFolderPath, FilePath, Branch only
+    selects which agreeing signal is reported; no run state is ever read to break
+    a disagreement.
+
+.NOTES
+    Compatible with PowerShell 7+. Pure given its sibling WorktreeResolution.psm1,
+    which owns every filesystem read. No subprocess, no network, no clock read, and
+    no environment read. Mirrored byte-identically under
+    extensions/drm-copilot/resources/claude-customizations/.
+    CONVENTION: this module fails fast at module scope and imports its siblings with -ErrorAction Stop.
+#>
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Stop'
+
+Import-Module (Join-Path $PSScriptRoot 'WorktreeResolution.psm1') -ErrorAction Stop
+
+# The four states of a derived target. The set is closed so a caller writes exactly
+# one branch per state; a fifth value would silently fall through every caller.
+$script:StatusSessionRoot = 'SessionRoot'
+$script:StatusOtherWorktree = 'OtherWorktree'
+$script:StatusNoTarget = 'NoTarget'
+$script:StatusAmbiguous = 'Ambiguous'
+
+# The signal kinds a result may report. SessionRoot names no payload signal; it is
+# reserved for a caller that resolves against the session root deliberately.
+$script:SignalFeatureFolderPath = 'FeatureFolderPath'
+$script:SignalFilePath = 'FilePath'
+$script:SignalBranch = 'Branch'
+$script:SignalSessionRoot = 'SessionRoot'
+
+# The prose label used for each payload signal in a Detail clause.
+$script:SignalLabel = @{
+    FeatureFolderPath = 'feature folder token'
+    FilePath          = 'file path'
+    Branch            = 'branch'
+}
+
+# A feature-folder token: an optional prefix ending in a separator, then
+# docs/features/active/<folder>. The prefix is kept rather than discarded, because
+# an absolute prefix is the only unambiguous placement of the token.
+$script:FeatureFolderPattern = '(?<![^\s"''`(])(?:[^\s"''`]*?[\\/])?docs[\\/]+features[\\/]+active[\\/]+[A-Za-z0-9][A-Za-z0-9._-]*'
+
+# An absolute file path with an extension. Only the absolute form is read from free
+# text, because a relative file path names a file present in every worktree.
+$script:FilePathPattern = '(?<![^\s"''`(])(?:[A-Za-z]:[\\/]|/)[^\s"''`]*[\\/][^\s"''`\\/]+\.[A-Za-z0-9]+'
+
+# A branch named by a --head or --branch option, or by a "branch:" label. Narrow on
+# purpose: a bare word is never read as a branch.
+$script:BranchPattern = '(?i)(?:(?<![\w-])--(?:head|branch)(?:=|\s+)|\bbranch:\s*)(?<name>[A-Za-z0-9][A-Za-z0-9._/-]*)'
+
+# A drive-rooted or slash-rooted normalised path.
+$script:AbsolutePathPattern = '^([A-Za-z]:(/|$)|/)'
+
+function New-WorktreeResolutionTargetResult {
+    <#
+    .SYNOPSIS
+        Build a target result object. The single constructor of that shape.
+    .DESCRIPTION
+        Enforces the field invariants: SessionRoot and Detail are always non-empty,
+        Candidates is always an array, WorktreeRoot is populated only for the two
+        resolved states, Signal and SignalValue are null for NoTarget, and
+        ReasonCode is the ambiguity code when Status is Ambiguous and the no-target
+        code when Status is NoTarget (issue #687); it is null for the two resolved
+        states.
+    .PARAMETER Status
+        One of SessionRoot, OtherWorktree, NoTarget, or Ambiguous.
+    .PARAMETER SessionRoot
+        The worktree root the invoking process runs in.
+    .PARAMETER WorktreeRoot
+        The resolved target root; required for the two resolved states.
+    .PARAMETER Signal
+        The signal kind that produced or failed to produce the target.
+    .PARAMETER SignalValue
+        The raw token the signal was read from.
+    .PARAMETER Candidate
+        The distinct candidate worktree roots considered.
+    .PARAMETER Detail
+        A prose clause safe to append to a gate's deny reason.
+    #>
+    [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseShouldProcessForStateChangingFunctions', '', Justification = 'Pure in-memory factory that changes no system state; the exported name is fixed by the issue #669 contract.')]
+    [CmdletBinding()]
+    [OutputType([pscustomobject])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [ValidateSet('SessionRoot', 'OtherWorktree', 'NoTarget', 'Ambiguous')]
+        [string] $Status,
+        [Parameter(Mandatory = $true)]
+        [ValidatePattern('\S')]
+        [string] $SessionRoot,
+        [string] $WorktreeRoot,
+        [ValidateSet('', 'FeatureFolderPath', 'FilePath', 'Branch', 'SessionRoot')]
+        [string] $Signal,
+        [string] $SignalValue,
+        [AllowEmptyCollection()]
+        [string[]] $Candidate = @(),
+        [Parameter(Mandatory = $true)]
+        [ValidatePattern('\S')]
+        [string] $Detail
+    )
+
+    $isResolved = $Status -in @($script:StatusSessionRoot, $script:StatusOtherWorktree)
+    $root = ConvertTo-WorktreeResolutionNormalizedPath -Path $WorktreeRoot
+    if ($isResolved -and $null -eq $root) {
+        throw "A target result with Status '$Status' requires a WorktreeRoot."
+    }
+    $hasSignal = ($Status -ne $script:StatusNoTarget) -and -not [string]::IsNullOrEmpty($Signal)
+    $kept = if ($Status -eq $script:StatusNoTarget) { @() } else { $Candidate }
+    $candidates = [string[]] @($kept | Where-Object { -not [string]::IsNullOrWhiteSpace($_) })
+    return [pscustomobject]@{
+        Status       = $Status
+        WorktreeRoot = if ($isResolved) { $root } else { $null }
+        SessionRoot  = ConvertTo-WorktreeResolutionNormalizedPath -Path $SessionRoot
+        Signal       = if ($hasSignal) { $Signal } else { $null }
+        SignalValue  = if ($hasSignal) { $SignalValue } else { $null }
+        Candidates   = $candidates
+        ReasonCode   = switch ($Status) {
+            $script:StatusAmbiguous { Get-WorktreeResolutionAmbiguityReasonCode; break }
+            $script:StatusNoTarget { Get-WorktreeResolutionNoTargetReasonCode; break }
+            default { $null }
+        }
+        Detail       = $Detail
+    }
+}
+
+function Find-WorktreeResolutionFeatureFolderSignal {
+    <#
+    .SYNOPSIS
+        Return the first feature-folder token in a text, with any absolute prefix preserved, or $null.
+    .DESCRIPTION
+        The match does not start at the literal docs segment: a drive or worktree
+        prefix written before it stays part of the token, so the token can be
+        placed in exactly one worktree. The token ends at the feature-folder name.
+    .PARAMETER Text
+        The prompt or payload text to scan.
+    #>
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [AllowEmptyString()]
+        [string] $Text
+    )
+
+    $match = [regex]::Match([string] $Text, $script:FeatureFolderPattern)
+    if (-not $match.Success) {
+        return $null
+    }
+    return $match.Value.TrimEnd('.')
+}
+
+function Find-WorktreeResolutionBranchSignal {
+    <#
+    .SYNOPSIS
+        Return the first branch named by --head, --branch, or a "branch:" label, or $null.
+    .PARAMETER Text
+        The prompt or payload text to scan.
+    #>
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [AllowEmptyString()]
+        [string] $Text
+    )
+
+    $match = [regex]::Match([string] $Text, $script:BranchPattern)
+    if (-not $match.Success) {
+        return $null
+    }
+    return $match.Groups['name'].Value.TrimEnd('.', '/')
+}
+
+function Find-WorktreeResolutionFilePathSignal {
+    <#
+    .SYNOPSIS
+        Return the first absolute file path (with an extension) in a text, or $null.
+    .PARAMETER Text
+        The prompt or payload text to scan.
+    #>
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [AllowEmptyString()]
+        [string] $Text
+    )
+
+    $match = [regex]::Match([string] $Text, $script:FilePathPattern)
+    if (-not $match.Success) {
+        return $null
+    }
+    return $match.Value
+}
+
+function Get-WorktreeResolutionSignalCandidate {
+    # The distinct worktree roots one present signal resolves to. An absolute path
+    # is placed by the upward walk; a relative path is looked up in every worktree
+    # reachable from the session root; a branch is matched against each HEAD.
+    [OutputType([string[]])]
+    param([hashtable] $Signal, [string] $SessionRoot)
+
+    if ($Signal.Kind -eq $script:SignalBranch) {
+        $byBranch = Get-WorktreeResolutionWorktreeRoot -SessionRoot $SessionRoot -Branch $Signal.Value
+        return , [string[]] @($byBranch)
+    }
+    $normalized = ConvertTo-WorktreeResolutionNormalizedPath -Path $Signal.Value
+    if ($normalized -match $script:AbsolutePathPattern) {
+        $placed = ConvertTo-WorktreeResolutionRepoRelativePath -Path $normalized
+        if (-not $placed.IsNormalized) {
+            return , [string[]] @()
+        }
+        return , [string[]] @($placed.WorktreeRoot)
+    }
+    $byPath = Get-WorktreeResolutionWorktreeRoot -SessionRoot $SessionRoot -RepoRelativePath $normalized
+    return , [string[]] @($byPath)
+}
+
+function Resolve-WorktreeCallTarget {
+    <#
+    .SYNOPSIS
+        Derive the worktree a tool call pertains to, as one of four states.
+    .DESCRIPTION
+        Always returns a target result object. A call naming no signal is NoTarget.
+        A present signal that places in no worktree or in several, or two present
+        signals that place in different worktrees, is Ambiguous. Otherwise the one
+        agreed root is SessionRoot when it is the session root and OtherWorktree
+        when it is not. Signals are reported in the precedence FeatureFolderPath,
+        FilePath, Branch, which never suppresses a disagreement.
+    .PARAMETER Text
+        Optional prompt or payload text scanned for all three signal kinds.
+    .PARAMETER Branch
+        Optional explicit branch; takes the place of a branch read from Text.
+    .PARAMETER FilePath
+        Optional explicit file path, relative or absolute; takes the place of a
+        file path read from Text.
+    .PARAMETER SessionRoot
+        Optional. Defaults to the worktree containing the current location.
+    #>
+    [CmdletBinding()]
+    [OutputType([pscustomobject])]
+    param(
+        [AllowNull()]
+        [AllowEmptyString()]
+        [string] $Text,
+        [string] $Branch,
+        [string] $FilePath,
+        [string] $SessionRoot
+    )
+
+    $session = ConvertTo-WorktreeResolutionNormalizedPath -Path $SessionRoot
+    if ($null -eq $session) {
+        $current = (Get-Location).ProviderPath
+        $session = Find-WorktreeResolutionRoot -Path $current
+        if ($null -eq $session) {
+            $session = ConvertTo-WorktreeResolutionNormalizedPath -Path $current
+        }
+    }
+
+    $filePathValue = if ([string]::IsNullOrWhiteSpace($FilePath)) { Find-WorktreeResolutionFilePathSignal -Text $Text } else { $FilePath.Trim() }
+    $branchValue = if ([string]::IsNullOrWhiteSpace($Branch)) { Find-WorktreeResolutionBranchSignal -Text $Text } else { $Branch.Trim() }
+    $present = @(
+        @{ Kind = $script:SignalFeatureFolderPath; Value = (Find-WorktreeResolutionFeatureFolderSignal -Text $Text) }
+        @{ Kind = $script:SignalFilePath; Value = $filePathValue }
+        @{ Kind = $script:SignalBranch; Value = $branchValue }
+    ) | Where-Object { -not [string]::IsNullOrWhiteSpace($_.Value) }
+    $present = @($present)
+    if ($present.Count -eq 0) {
+        return (New-WorktreeResolutionTargetResult -Status $script:StatusNoTarget -SessionRoot $session -Detail "the call names no feature folder, file path, or branch, so it has no target and the session root '$session' applies")
+    }
+
+    $agreed = [System.Collections.Generic.List[string]]::new()
+    foreach ($signal in $present) {
+        $label = $script:SignalLabel[$signal.Kind]
+        $candidates = Get-WorktreeResolutionSignalCandidate -Signal $signal -SessionRoot $session
+        if ($candidates.Count -ne 1) {
+            $detail = "$label '$($signal.Value)' matched $($candidates.Count) candidate worktrees; supply an absolute path inside exactly one worktree to disambiguate"
+            return (New-WorktreeResolutionTargetResult -Status $script:StatusAmbiguous -SessionRoot $session -Signal $signal.Kind -SignalValue $signal.Value -Candidate $candidates -Detail $detail)
+        }
+        if (-not ($agreed -contains $candidates[0])) {
+            $agreed.Add($candidates[0])
+        }
+    }
+
+    $reported = $present[0]
+    $reportedLabel = $script:SignalLabel[$reported.Kind]
+    if ($agreed.Count -gt 1) {
+        $detail = "the call's signals resolve to $($agreed.Count) different worktrees ($($agreed -join ', ')); precedence does not choose between disagreeing signals"
+        return (New-WorktreeResolutionTargetResult -Status $script:StatusAmbiguous -SessionRoot $session -Signal $reported.Kind -SignalValue $reported.Value -Candidate $agreed.ToArray() -Detail $detail)
+    }
+    $root = $agreed[0]
+    $status = if ($root -eq $session) { $script:StatusSessionRoot } else { $script:StatusOtherWorktree }
+    $detail = "$reportedLabel '$($reported.Value)' resolves to worktree '$root'"
+    return (New-WorktreeResolutionTargetResult -Status $status -SessionRoot $session -WorktreeRoot $root -Signal $reported.Kind -SignalValue $reported.Value -Candidate @($root) -Detail $detail)
+}
+
+function Join-WorktreeResolutionPath {
+    <#
+    .SYNOPSIS
+        Compose an absolute forward-slash path from a worktree root and a repo-relative path.
+    .PARAMETER WorktreeRoot
+        The absolute worktree root, in either separator style.
+    .PARAMETER RepoRelativePath
+        The path below the root, in either separator style.
+    #>
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [string] $WorktreeRoot,
+        [Parameter(Mandatory = $true)]
+        [string] $RepoRelativePath
+    )
+
+    $root = ConvertTo-WorktreeResolutionNormalizedPath -Path $WorktreeRoot
+    if ($root -notmatch $script:AbsolutePathPattern) {
+        throw "WorktreeRoot must be an absolute path: '$WorktreeRoot'."
+    }
+    $relative = ConvertTo-WorktreeResolutionNormalizedPath -Path $RepoRelativePath
+    if ($null -eq $relative) {
+        return $root
+    }
+    $separator = if ($root.EndsWith('/')) { '' } else { '/' }
+    return $root + $separator + $relative.TrimStart('/')
+}
+
+Export-ModuleMember -Function `
+    New-WorktreeResolutionTargetResult, `
+    Find-WorktreeResolutionFeatureFolderSignal, `
+    Find-WorktreeResolutionBranchSignal, `
+    Find-WorktreeResolutionFilePathSignal, `
+    Resolve-WorktreeCallTarget, `
+    Join-WorktreeResolutionPath

package/resources/claude-customizations/.claude/rules/orchestrator-state.md

@@ -122,6 +122,30 @@ The rest of the completion gate is unchanged. An epic whose feature is not merge
 
 Enforcement is validator logic plus this prose, never an imported JSON Schema. The activation scope lives in `scripts/dev_tools/_epic_orchestrator_state_launch_binding.py`, and the TypeScript parity port at `extensions/drm-copilot/src/lib/validate/epic-orchestrator-state-launch-binding.ts` reproduces it with byte-identical error strings. No schema file is authored, imported, or read for it.
 
+## Standalone-Merge-Authorization Scope and Backward Compatibility
+
+These invariants apply only when a checkpoint contains a top-level `standalone_merge_authorizations` array. The key may appear in any of the three checkpoints the epic merge gate reads: `artifacts/orchestration/orchestrator-state.json`, `artifacts/orchestration/epic-orchestrator-state.json`, and `artifacts/orchestration/parallel-orchestrator-state.json`. A checkpoint with no such key (the existing checkpoint shape) is unaffected: it validates exactly as before and produces no new errors. The invariants are additive and key-gated. No JSON Schema file is authored, imported, or read for the block (see the Foreign Schema Warning above); the enforcing surface is the `PreToolUse` merge gate (issue #670).
+
+Each entry records one authorized standalone merge with the shape `{ pr_number, pr_url, issue_num, branch_name, authorized_by, authorized_at, session_id, basis, run_slug? }`. The gate consults the array only for a `gh pr merge --merge` command that names an explicit pull request number, and only after its per-feature, epic, and parallel allow conditions have all declined.
+
+Honest disclosure: the standalone-merge authorization record is a policy-level, auditable declaration and is
+not a cryptographic or security control.
+`authorized_by` is a declaration that the gate does not verify, because the runtime exposes no attested agent identity at Bash `PreToolUse` time. The record is not tamper-proof: any actor able to write `artifacts/orchestration/*.json` inside the authorizing session can write one. The `session_id` cross-check binds a record to the session that wrote it, so a stale record from a previous run or a record copied between runs authorizes nothing; it does not stop same-session forgery. This is a documented accepted trade, not an unexamined gap.
+
+## Invariants (standalone_merge_authorizations array)
+
+1. **PR-specific block.** The value of `standalone_merge_authorizations` must be a non-empty array whose every entry is an object with a `pr_number` that is a JSON integer greater than zero. Any other shape (a boolean or other blanket flag, a string, an object, an empty array, a non-object entry, or a `pr_number` that is absent, `null`, zero, negative, fractional, a string, or an array) is rejected with `STANDALONE_MERGE_AUTHORIZATION_NOT_PR_SPECIFIC`.
+2. **Binding by `pr_number`.** The gate selects the entry whose `pr_number` equals the pull request number extracted from the command. When records exist but none matches, the gate denies with `STANDALONE_MERGE_AUTHORIZATION_PR_MISMATCH`; when no checkpoint carries the key, it denies with `STANDALONE_MERGE_AUTHORIZATION_ABSENT`.
+3. **`pr_url`.** Non-empty, and it must end with `/pull/` followed by the entry's own `pr_number` and nothing else.
+4. **`issue_num`.** A JSON integer greater than zero.
+5. **`branch_name`.** A non-empty string. It is never compared against the live branch or the working directory.
+6. **`authorized_by`.** A non-empty string; presence only.
+7. **`authorized_at`.** A date-time string that parses with the invariant culture, assuming and adjusting to UTC. No clock is read.
+8. **`basis` and `run_slug`.** `basis` is at least 20 characters after trimming. `run_slug` is optional; when present it is a non-empty string.
+9. **`session_id`.** A non-empty string equal, by ordinal comparison, to the `session_id` of the live hook envelope. An envelope without a `session_id` fails closed.
+
+Field checks 3 through 9 run in the fixed order `pr_url`, `issue_num`, `branch_name`, `authorized_by`, `authorized_at`, `basis`, `run_slug`, `session_id`; the first failure wins and the gate denies with `STANDALONE_MERGE_AUTHORIZATION_MALFORMED` naming that field.
+
 ## Enforcement
 
 - `scripts/dev_tools/validate_orchestrator_state.py` appends one error per violated invariant when a `remediation_loop` is present, using the existing validator message style (literal, checkpoint-context prefixed). The validator returns a list of error strings and does not mutate its input.
@@ -130,3 +154,6 @@ Enforcement is validator logic plus this prose, never an imported JSON Schema. T
 - `scripts/dev_tools/validate_orchestrator_state.py` appends one error per violated `model_routing_receipts` invariant when a `model_routing_receipts` key is present, delegating to `scripts/dev_tools/_orchestrator_state_model_routing.py`, which recomputes the resolved model via `resolve_delegation_model`. The check does not import or read any schema file.
 - `scripts/dev_tools/validate_orchestrator_state.py` appends one error per violated `require_model_routing` invariant only when the caller passes `require_model_routing=True`, delegating to `scripts/dev_tools/_orchestrator_state_model_routing_gate.py`, which reuses the complexity and model-routing per-entry validators. When the flag is not passed the gate does not run, so existing calls are byte-identical.
 - The validator is consumed by the MCP tool `validate_orchestration_artifacts`; backward compatibility for existing step-based checkpoints is preserved.
+- The standalone-merge authorization invariants are enforced by the `PreToolUse` merge gate (`.claude/hooks/enforce-epic-merge-gate.ps1` with its dot-sourced helpers file, and `.codex/hooks/enforce-epic-merge-gate.ps1`) at merge time. The Python checkpoint validator
+  does not currently validate standalone_merge_authorizations
+  entries; adding that check is recorded as follow-up FU-3.

package/resources/claude-customizations/.claude/rules/parallel-orchestration.md

@@ -260,6 +260,61 @@ wildcard occupies or truncates the feature-folder segment, a contract token carr
 letter, and a token containing a placeholder or interpolation marker. `artifacts/` is not a known
 top-level segment, so a bare `artifacts/**` subtree claim no longer satisfies the shape rules.
 
+### Mechanically-mergeable path class (issue #643)
+
+Some contended paths are not a design collision. A `.csproj` item list, a `packages.config` package
+list, and an `app.config` binding-redirect list are additive registries: two items that each append a
+distinct entry produce a textual conflict that a deterministic union resolves without judgement.
+Serializing those items buys nothing.
+
+`config/blast-radius.json` carries an optional `mergeable_paths` list of exact entries and `**`
+globs. That list is the mechanically-mergeable path class. Its published default is the five-entry
+list `**/*.csproj`, `**/packages.config`, `**/app.config`, `**/*.vbproj`, `**/*.props`.
+
+A matching path **stays in the declared `paths`**. The exclusion is applied at exactly one place per
+runtime — inside `conflicts` (`scripts/dev_tools/_blast_radius_conflicts.py`) and inside
+`Test-BlastRadiusConflict` (`.claude/lib/blast-radius/BlastRadius.psm1`), on both radii's `paths`
+immediately before the smallest-path-overlap computation. Derivation, normalization,
+observed-radius construction, V1, V2, V3, and `detect_escaped_paths` are therefore unchanged: the
+class narrows one comparison and nothing else. The key is optional and fail-closed: a truth table
+that omits it excludes nothing and reproduces pre-change behaviour exactly.
+
+The matcher is local to this comparison and does not extend the glob engine. A declared path matches
+the class when, against some configured entry, any of the following holds: the two strings are
+ordinally equal; or the declared path is concrete (carries no wildcard) and the configured entry is
+a glob that contains it; or the declared path is concrete and, for a configured entry beginning with
+`**/`, the same two-step test succeeds against the entry with that prefix removed, which is what
+makes a root-level `Directory.Build.props` match `**/*.props`. A declared path that is itself a glob
+is mergeable only when it equals a configured entry verbatim, because a glob can expand over
+non-mergeable files. `_glob_to_regex_text` (`scripts/dev_tools/_blast_radius_glob.py`) and its
+PowerShell mirror `BlastRadiusGlob.psm1` are unchanged by this class; if either is ever changed, both
+it and this matcher must be re-examined together, since the containment step depends on the glob
+engine's semantics.
+
+Three constraints bound the mergeable-path class:
+
+1. **The planner remains obliged to enumerate a genuine write explicitly.** The class describes how a
+   contention is scored, not what an item may touch. An item that will write a `.csproj` still
+   declares that exact path in its radius.
+2. **The path stays in the declared radius, so the audits still see it.** Nothing is removed from any
+   stored record. Over-breadth, shared-surface, and manifest audits read the same `paths` they read
+   before; only the pairwise overlap set is narrowed.
+3. **`detect_escaped_paths` remains the backstop at execution time.** A mergeable classification is a
+   scheduling decision taken from declared text; `detect_escaped_paths` still compares the declared
+   radius against the paths a diff actually touched, so an item that wrote outside its radius is
+   caught against observed evidence regardless of this class.
+
+An item record of the parallel-orchestrator checkpoint MAY carry an optional
+`mergeable_conflicts_resolved` list recording the mergeable conflicts an item resolved mechanically.
+The field is additive and tolerated-not-validated: no validator in Python, TypeScript, or bash reads
+it, and it follows the `expected_conflict_components` diagnostic precedent — a record written for a
+human reader and for post-hoc audit, never a scheduling input. Each entry carries `path`,
+`resolved_at`, `merged_against`, `merge_commit_sha`, `entries_added_from_ours`,
+`entries_added_from_theirs`, and `version_resolutions`. Entry keys inside those three lists use
+`<ItemType>:<Include>` for MSBuild items, `package:<id>` for `packages.config` packages, and
+`bindingRedirect:<name>` for `app.config` binding redirects. Invariant 9 (the six `blast_radius`
+keys) and invariant 15 (the four edge reasons) are unchanged by this field.
+
 ### Placeholder-shape rejection (issue #502)
 
 The fourth shape is a token containing any member of the marker set
@@ -353,6 +408,15 @@ reading the file is not told something false, and because
 `tests/scripts/dev_tools/test_blast_radius_config.py` calls `load_module_globs` on it and that
 helper raises on an absent key. Nothing schedules on it.
 
+**The .NET manifest family is a structure signal, not a module source (issue #643).** `.csproj`,
+`.fsproj`, `.vbproj`, `.sln`, and `.slnx` are classified in
+`extensions/drm-copilot/src/lib/push-down/claude-blast-radius-derive-manifests.ts` as
+structure-observing manifests: each one marks a project root and suppresses the
+top-level-directory fallback, and none of them contributes a module. A .NET solution layout
+therefore derives exactly `{ "config": ["config/**"] }` from `PAYLOAD_MODULES` alone. The reason is
+the granularity criterion: a per-assembly module would fire for the majority of work items in that
+solution, so it discriminates nothing and belongs in neither the module map nor the surface list.
+
 **`PAYLOAD_MODULES` carries `config` only.** `claude-runtime` was removed from it by the same
 granularity criterion that removed it from this repository's own map. The criterion transfers
 without modification: every agent in the runtime is instructed to read the policy rules and process
@@ -366,8 +430,8 @@ non-vacuous input.
 subset, not a copy of the self-hosted sets.** They were authored narrow when the bundled copy was
 created and were never a copy that fell behind, so the correct gate is portable-set equality against
 a declared constant plus a subset relation against the self-hosted list — never byte-equality with
-the self-hosted file. Only `version`, `over_breadth_fraction`, and `mandate_reads` are byte-equal
-across the two copies.
+the self-hosted file. Only `version`, `over_breadth_fraction`, `mandate_reads`, and `mergeable_paths`
+are byte-equal across the two copies.
 
 The reason the two key groups take different relations is an asymmetry between surfaces and modules.
 An over-matching MODULE glob costs concurrency on every pair of items it touches, because a module