@danmoisan/drm-copilot-mcp 1.1.11 → 1.1.14

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

@@ -209,6 +209,8 @@ All nine enums of the parallel surface are owned by the schema-and-validator fea
 
 The wave-4 features — F6 (mutation protocol), F7 (enforcement hooks), and F8 (drift detection) — CONSUME these member sets and NEVER extend them. A wave-4 feature that needs a new member must amend this rule file and the validators at spec review, not add the member at implementation time. This constraint exists because the wave-4 features are prepared concurrently and would otherwise add fields to the same files at the same time.
 
+Integration-cost scheduling (issue #722) adds no `conflict_edges[].reason` member; the four members above are unchanged. The scheduling data travels in tolerated-not-validated fields: an edge may carry the extra fields `hard`, `cost`, and `benefit`, and the planner and orchestrator checkpoints may carry a `tolerated_overlaps` list. No validator reads these fields, and the Python validators and the TypeScript validator port accept them with zero errors.
+
 ## F7 Seam
 
 The retrospective cohort-ordering invariant `PARALLEL_COHORT_BARRIER_VIOLATION` (design section 9, Layer 2) is F7's explicitly assigned addition to the orchestrator validator. It is NOT implemented here. The entry point of `scripts/dev_tools/validate_parallel_orchestrator_state.py` contains a clearly delimited, appendable helper-invocation block, marked with explicit begin and end comments that name F7 and the invariant token, so that F7's edit is one appended helper call with no reflow of existing code. The TypeScript core `extensions/drm-copilot/src/lib/validate/parallel-orchestrator-state-core.ts` carries the matching comment-delimited seam. Existing helper calls sit outside the block.
@@ -241,6 +243,11 @@ plan-side extraction so V1 and V2 stay self-consistent against a radius derived
 The key is optional and fail-closed: a truth table that omits it excludes nothing and reproduces
 pre-change behaviour exactly.
 
+The Copilot instructions file `.github/copilot-instructions.md` is a mandate read as well (issue
+#722): the policy reading order begins with it, so a plan that cites copilot-instructions.md is
+reporting that it read the tone and communication policy. Both committed copies of
+`config/blast-radius.json` list it in `mandate_reads`.
+
 Three constraints bound the mandate-read exclusion:
 
 1. **The planner remains obliged to enumerate a genuine write explicitly.** An exclusion describes
@@ -391,6 +398,144 @@ weakens the relation below the path level: two items editing the same file still
 A candidate module belongs in the map when it names a subsystem an item could plausibly not touch.
 A candidate that matches the majority of work items belongs nowhere.
 
+### Integration-cost scheduling (issue #722)
+
+Detection and scheduling are separate steps. The detection relation (`conflicts` in Python,
+`Test-BlastRadiusConflict` in PowerShell) is unchanged and still answers one question: do two radii
+contend? Scheduling decides whether a detected contention must serialize the two items. The entry
+points are `schedule_conflict_edges` in `scripts/dev_tools/_blast_radius_scheduling.py` and
+Get-BlastRadiusConflictEdge in `.claude/lib/blast-radius/BlastRadiusScheduling.psm1`; both return
+the edges and the tolerated overlaps of a set of items. Planners call the entry point instead of
+applying the detection relation to every pair by hand.
+
+This is an operator-directed configured policy change (issue #722, 2026-09-27), not ad hoc
+narrowing. The only sanctioned mechanisms for relaxing contention are the configured
+`conflict_tolerance` key and configured write-intent extraction. Planners still never hand-narrow a
+radius: editing a declared radius to suppress an edge remains prohibited.
+
+**Configuration.** `config/blast-radius.json` carries an optional `conflict_tolerance` object with
+tolerance_percent (integer, at least 0), `weights` (same_file, possible_overlap, append_only, and
+module, each an integer of at least 1), `band_durations` (C1 through C4, each an integer of at least
+1), `default_band` (one of C1 through C4), and append_only_paths (a list of exact entries and `**`
+globs). The reader fails fast with an error naming the key for any other shape; booleans are
+rejected wherever an integer is required. An absent key means strict scheduling, identical to
+tolerance_percent 0.
+
+**Edge rule.** For each unordered pair of items:
+
+1. Run the unchanged detection relation. No conflict means no edge and no tolerated overlap.
+2. **Hard classes.** A reason list containing `shared_surface_overlap` or `contract_dependency`
+   makes the pair an edge at every tolerance.
+3. **Cost** (integer, computed only for a detected conflict). Re-enumerate the overlapping entry
+   pairs with the same mergeable-path exclusion and the same entry-overlap primitive the relation
+   uses, then sum the append_only weight for a concrete overlapping path that matches an
+   append_only_paths entry, the same_file weight for two equal concrete entries, the
+   possible_overlap weight for a glob or directory-prefix overlap, and the module weight times the
+   number of shared modules. The append_only_paths check runs before the same_file check (append-only
+   precedence), so an append-only file stays low cost even when both items name it. Mergeable paths
+   contribute 0 because they are excluded before enumeration.
+4. **Benefit** (integer, pairwise). The smaller of the two items' band durations; a missing band uses
+   `default_band`. Running the pair concurrently saves at most one cohort step of the shorter item.
+5. **Rule.** The pair is an edge if and only if it conflicts and either it is hard or
+   `cost * 100 > benefit * tolerance_percent`.
+6. **Recorded reason.** The first member of the relation's reason list in canonical kind order.
+
+**Strict-identity proof.** Every weight and every band duration is validated as an integer of at
+least 1. A detected conflict that is not hard therefore has a cost of at least 1, so at
+tolerance_percent 0 the inequality `cost * 100 > 0` always holds and the edge set equals the
+detected-conflict set exactly; cohort coloring of that set is identical to strict scheduling. At
+every tolerance an edge requires a conflict, so every edge implies a conflict and the edge set is
+always a subset of the detected-conflict set. Raising tolerance_percent never adds an edge, and the
+decision for (a, b) equals the decision for (b, a).
+
+**Soft-overlap handling.** A detected, non-hard pair within tolerance is a tolerated overlap, not an
+edge. The planner records it in a tolerated_overlaps list on the planner checkpoint (and the
+orchestrator carries it), each entry holding `a`, `b`, `reasons`, `cost`, and `benefit`. Tolerated
+pairs run in the same or adjacent cohorts without a barrier. The later-merging item of a tolerated
+pair merges `origin/main` under the existing per-item merge-conflict handling and re-passes CI before
+it merges.
+
+**Drift behaviour.** When an item's observed radius replaces its declared radius, drift detection
+evaluates each in-flight peer pair through the same edge rule, using the items' complexity bands from
+the checkpoint (`default_band` when absent), through the helper module
+`scripts/dev_tools/_parallel_drift_scheduling.py`. A pair is newly conflicting only when the rule
+yields an edge and the pair is not already a recorded edge. A tolerated pair whose observed overlap
+stays within tolerance halts neither item; one whose observed overlap exceeds tolerance, or becomes
+hard, is reported. An unevaluable peer radius still counts as an edge (fail closed). At
+tolerance_percent 0 the drift output equals strict drift output.
+
+### Write-intent extraction (issue #722)
+
+The extractor harvests every inline-code token of a plan and spec, so a path an item only reads,
+mentions as a glob, or quotes inside a command becomes a radius path and can create a false edge.
+Write-intent extraction keeps only tokens that state a write. It is the second sanctioned mechanism,
+beside `conflict_tolerance`, for relaxing contention; like it, it is an operator-directed configured
+policy change, and planners still never hand-narrow a radius.
+
+**Configuration.** `config/blast-radius.json` carries two optional keys. `write_intent_extraction`
+is a boolean; when it is true, rules W1 through W6 below apply. `path_roots` is a list of non-empty
+first path segments that enables rule W4. Both readers fail fast with an error naming the key for any
+other shape. An absent or false `write_intent_extraction` reproduces pre-change extraction exactly
+(fail closed), and an empty or absent `path_roots` disables W4. The self-hosted copy sets
+`path_roots` to this repository's tracked top-level directories. The implementations are
+`scripts/dev_tools/_blast_radius_write_intent.py` and
+`.claude/lib/blast-radius/BlastRadiusWriteIntent.psm1`.
+
+**Rules.** Each rule is a pure, statically decidable function of the text and the truth table.
+
+- **W1 glob mention.** Drop any harvested token containing a wildcard character. The feature-folder
+  glob is added after filtering and is never dropped.
+- **W2 command span.** Drop every token of an inline span whose whitespace split yields more than
+  one word.
+- **W3 read task.** Drop the tokens of a task attribution window (a task line plus the following
+  non-task lines up to the next ATX heading, as defined in `.claude/rules/plan-acceptance-gates.md`)
+  whose title's first word, after an optional bold label, is in the read-verb set (Read, Verify,
+  Confirm, Inspect, Review, Baseline) and whose title contains no member of the write-verb set (Fix,
+  Write, Update, Edit, Add, Create, Delete, Remove, Rename, Author, Append, Replace). A write verb
+  anywhere in the title overrides the read verb.
+- **W4 root anchoring.** Drop a concrete token whose first segment, after stripping a leading `./`,
+  is not in `path_roots` and is not a configured root surface.
+- **W5 spec paths.** The spec contributes contracts only, not paths. Contract harvesting from the
+  spec applies W1 and W2.
+- **W6 placeholder stem.** Drop a concrete token whose final-component stem is in the placeholder
+  set (the single ASCII letters, and foo, bar, baz, example, sample, placeholder), compared
+  case-insensitively.
+
+The read-verb, write-verb, and placeholder-stem sets are code constants pinned equal across Python
+and PowerShell by a parity test. Shared surfaces are still resolved from the surviving concrete
+paths, so a shared surface cited only in a read task, a command span, or the spec produces no hard
+edge, while a shared surface an item writes in a write task survives and stays hard.
+
+**One extractor for derivation and validation.** W1, W4, and W6 are token-level and also apply when
+`normalize_declared_radius` and Get-NormalizedDeclaredRadius re-filter a recorded radius; an entry
+that starts with `docs/features/`, ends with `/**`, and carries no other wildcard (the feature-folder
+glob) is always kept. W2, W3, and W5 need line context and apply only to derivation and to the
+plan-side extraction of validation. `derive_blast_radius` and `validate_blast_radius` (and their
+PowerShell ports) select the same extractor from the same flag, so a derived radius still passes V1
+and V2 against its own plan in both modes.
+
+#### Known false negatives
+
+Write-intent extraction can drop a genuine write in these cases:
+
+1. a genuine write stated only as a glob (W1);
+2. a genuine write stated only inside a command span (W2);
+3. a write named only in spec prose (W5);
+4. a read-verb task that also writes without a write verb in its title (W3);
+5. a new top-level directory not yet in `path_roots` (W4);
+6. a genuine file whose stem is in the placeholder set (W6).
+
+Three mitigations bound these cases:
+
+1. **The planner remains obliged to enumerate a genuine write explicitly.** When an item's plan will
+   write a path that one of the rules drops, the planner appends that exact path to the declared
+   radius after normalization, as for the mandate-read exclusion.
+2. **Execution-time escaped-path detection.** `detect_escaped_paths` compares the declared radius
+   against the paths a diff actually touched, so a dropped write is caught against observed evidence
+   rather than against prose.
+3. **The fail-closed absent key.** A truth table without `write_intent_extraction`, or with it set
+   to false, reproduces pre-change extraction exactly, so an operator can disable the rules at once.
+
 ### The published truth table is not a copy of this one (issue #500)
 
 The push-down publishes a second truth table into a destination workspace at
@@ -430,8 +575,11 @@ 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`, `mandate_reads`, and `mergeable_paths`
-are byte-equal across the two copies.
+the self-hosted file. Only `version`, `over_breadth_fraction`, `mandate_reads`, `mergeable_paths`,
+`conflict_tolerance`, and `write_intent_extraction` are byte-equal across the two copies.
+`path_roots` is a Class 2 key: its self-hosted value is this repository's tracked top-level
+directory list, and its bundled value is an empty list, because the bundle cannot know a
+destination's top-level directories and an empty list disables root anchoring there.
 
 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

package/resources/claude-customizations/.claude/rules/plan-acceptance-gates.md

@@ -85,7 +85,7 @@ The window size is fixed at four adjacent non-blank lines. Blank lines are remov
 
 ### The shared measurement behind G7, G8, G8b, and G9
 
-The four severities below were fixed by one corpus measurement recorded in `docs/features/active/2026-08-23-plan-acceptance-gates-miss-unobservable-and-ambient-state-gates-519/evidence/qa-gates/corpus-measurement.2026-08-24T00-00.md`. The pre-declared decision rule was written and committed **before** the driver existed and before any count was taken, so the ordering is verifiable from git history rather than only asserted in prose. Its form matches the G5 precedent: the shipped severity is Blocking if and only if the total finding count for that rule is greater than zero **and** the recorded false-positive count for that rule is zero; otherwise Warning.
+The four severities below were fixed by one corpus measurement recorded in `docs/features/completed/2026-08-23-plan-acceptance-gates-miss-unobservable-and-ambient-state-gates-519/evidence/qa-gates/corpus-measurement.2026-08-24T00-00.md`. The pre-declared decision rule was written and committed **before** the driver existed and before any count was taken, so the ordering is verifiable from git history rather than only asserted in prose. Its form matches the G5 precedent: the shipped severity is Blocking if and only if the total finding count for that rule is greater than zero **and** the recorded false-positive count for that rule is zero; otherwise Warning.
 
 The false-positive definition the rule consumes is likewise pre-declared: a finding is a false positive when the acceptance condition it reports is in fact falsifiable — when the plan states an observation sufficient to distinguish a passing run from a failing one, by a mechanism the rule's predicate does not recognise. A finding is a true positive when the acceptance condition it reports genuinely cannot fail, or can only be satisfied vacuously.
 
@@ -108,7 +108,7 @@ G7's finding count of 466 satisfies the first conjunct, so the rule was not deci
 
 Both classes are addressable by a later feature — Class 1 by adding a check-flag exclusion to the `prettier-write` entry, Class 2 by admitting a tree-observation span as an alternative to a marker — but neither was changed here, because narrowing a predicate after reading its measurement would invalidate the measurement that decided its severity. A later feature that narrows either class must re-take the measurement the same way.
 
-Counts, and every one of the 22 false positives named by plan path, task identifier, and offending span: `docs/features/active/2026-08-23-plan-acceptance-gates-miss-unobservable-and-ambient-state-gates-519/evidence/qa-gates/corpus-measurement.2026-08-24T00-00.md`.
+Counts, and every one of the 22 false positives named by plan path, task identifier, and offending span: `docs/features/completed/2026-08-23-plan-acceptance-gates-miss-unobservable-and-ambient-state-gates-519/evidence/qa-gates/corpus-measurement.2026-08-24T00-00.md`.
 
 ### G8 — ships as a Warning because the measurement recorded 7 false positives
 
@@ -118,7 +118,7 @@ G8's finding count of 82 satisfies the first conjunct. It fails the second: 7 fi
 
 **Class 2, one finding — the unmerged-path filter.** `--diff-filter=U` selects conflicted paths during a merge or rebase. In that state the worktree-against-index comparison is the correct one and does not become vacuous on commit, because the conflict is precisely what is not yet committed.
 
-Counts, and every one of the 7 false positives named by plan path, task identifier, and offending span: `docs/features/active/2026-08-23-plan-acceptance-gates-miss-unobservable-and-ambient-state-gates-519/evidence/qa-gates/corpus-measurement.2026-08-24T00-00.md`.
+Counts, and every one of the 7 false positives named by plan path, task identifier, and offending span: `docs/features/completed/2026-08-23-plan-acceptance-gates-miss-unobservable-and-ambient-state-gates-519/evidence/qa-gates/corpus-measurement.2026-08-24T00-00.md`.
 
 ### G8b — ships as a Warning unconditionally, by the pre-declared rule
 
@@ -126,7 +126,7 @@ G8b is exempt from the two-conjunct rule and **cannot reach the Blocking channel
 
 The reason is that G8b carries the highest false-positive surface of the set, and a false-positive count taken over one corpus does not bound the false-positive surface of a predicate. Promoting a rule on the strength of a clean run over one corpus would convert an accident of that corpus into a gate. The 19 findings were nonetheless examined individually and all 19 were retained as true positives, across three sub-classes: a placeholder ref operand, which resolves to a real ref at run time and still cannot make the diff see an untracked path; an artifact-field label inside the span, which is cosmetic and leaves the underlying acceptance condition as the finding describes it; and a pathspec written without the `--` separator, where the predicate reads the pathspec as a ref operand. That last sub-class is a true positive for G8b and is simultaneously recorded in the measurement as a **G8 false negative**: the same span should also have been reported by G8, and was not.
 
-Counts, the zero false-positive record, and the three sub-classes with their plan paths and offending spans: `docs/features/active/2026-08-23-plan-acceptance-gates-miss-unobservable-and-ambient-state-gates-519/evidence/qa-gates/corpus-measurement.2026-08-24T00-00.md`.
+Counts, the zero false-positive record, and the three sub-classes with their plan paths and offending spans: `docs/features/completed/2026-08-23-plan-acceptance-gates-miss-unobservable-and-ambient-state-gates-519/evidence/qa-gates/corpus-measurement.2026-08-24T00-00.md`.
 
 ### G9 — ships as a Warning because the measurement recorded 4 false positives
 
@@ -134,7 +134,7 @@ G9's finding count of 8 satisfies the first conjunct. It fails the second: 4 of
 
 The remaining 4 findings are true positives, and each is the exact defect the rule was written for: the acceptance condition demands a numeric coverage percentage, the command supplies no terminal reporter, the project `addopts` supplies only an LCOV reporter, and the number the acceptance demands is therefore never printed.
 
-Counts, and every one of the 4 false positives named by plan path, task identifier, offending span, and the reason its acceptance condition is falsifiable: `docs/features/active/2026-08-23-plan-acceptance-gates-miss-unobservable-and-ambient-state-gates-519/evidence/qa-gates/corpus-measurement.2026-08-24T00-00.md`.
+Counts, and every one of the 4 false positives named by plan path, task identifier, offending span, and the reason its acceptance condition is falsifiable: `docs/features/completed/2026-08-23-plan-acceptance-gates-miss-unobservable-and-ambient-state-gates-519/evidence/qa-gates/corpus-measurement.2026-08-24T00-00.md`.
 
 ## The Write-Mode Register
 

package/resources/claude-customizations/.claude/skills/cleanup-merged-worktrees/SKILL.md

@@ -178,6 +178,12 @@ The script emits pipe-delimited, `LC_ALL=C`-ordered records, one per line:
    defer to that skill for it rather than restating any value from it here. For `<N>`,
    use the GitHub issue number the run executes under when the run has one. When the run
    has none, `<N>` is an arbitrary run-scoped identifier chosen by the pr-author agent.
+   The delegation prompt MUST carry a `branch: <name>` label naming the consolidation branch,
+   and the canonical issue number line when the run has an issue number.
+   `enforce-model-routing-receipt.ps1` identifies the item from those two lines and denies a
+   gated delegation it cannot identify. A cleanup run with no issue number is therefore
+   identified by the branch label alone, which is why the label is required and the issue line
+   is not.
    It is not a pull-request number, and the only requirement on it is that the body-file
    path, the receipt's `number` field, and the body bytes all agree. This skill never
    authors or creates the PR itself.
@@ -519,6 +525,12 @@ and is prohibited by this skill, which is the term the residual rests on.
   only a distinct, individually confirmed manual action outside that automated path for
   `NOT_MERGED`/`HAS_UNIQUE_RESIDUALS` — never a change to the classification ladder
   itself, and never for `PROTECTED_CURRENT`.
+- Never delete the base branch `main` and never remove a worktree checked out on it.
+  `compute_protected` protects `main` by name in every checkout topology, so it
+  classifies `PROTECTED_CURRENT` even when no protected worktree has it checked out, and
+  `delete_candidate` refuses a deletion request for it with
+  `ACTION|delete|main|BLOCKED-PROTECTED-BASE` before any re-verification, worktree
+  removal, or branch deletion runs.
 - Never use commit-message text matching as a classification input, and never
   auto-resolve cherry-pick conflicts.
 - Never delete an origin branch, or run plain filesystem removal on an orphaned