@danmoisan/drm-copilot-mcp 1.0.24 → 1.0.27

package/resources/claude-customizations/.claude/lib/bash/parallel-manifest-validate.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 # parallel-manifest-validate.sh: sourceable bash port of
 # scripts/dev_tools/parallel_manifest_contract.py. Validates a parallel-run
-# manifest document against invariants M1 through M7 and exposes the two
+# manifest document against invariants M1 through M8 and exposes the two
 # default-resolving accessors that every consumer uses instead of reading
 # `mode` and `max_concurrency` directly.
 #
@@ -9,7 +9,8 @@
 # frontmatter checks short-circuit with a single error; then run identity
 # (M2 parallel, M3 mode, M4 max_concurrency, M5 created_at) in schema field
 # order; then the M7 prohibited-key scan, deep results in document order
-# followed by the top-level results; then the M6 items collection.
+# followed by the top-level results; then the M6 items collection; then the
+# key-gated M8 expected_conflict_components assertion.
 #
 # Every error string begins with the literal prefix `Parallel manifest` and
 # ends with a period. The Python module remains the repository authority.
@@ -43,7 +44,7 @@ PM_DEFAULT_MAX_CONCURRENCY=4
 
 # Inclusive bounds on a present `max_concurrency` (invariant M4, A7).
 PM_MIN_CONCURRENCY=1
-PM_MAX_CONCURRENCY=8
+PM_MAX_CONCURRENCY=32
 
 # Keys the manifest rejects at any nesting level (invariant M7).
 PM_DEEP_PROHIBITED_KEYS="depends_on"
@@ -54,6 +55,11 @@ PM_TOP_LEVEL_PROHIBITED_KEYS="integration_branch"
 # Detail recorded when the parser refuses an out-of-subset construct.
 PM_SUBSET_DETAIL=""
 
+# Issue numbers already claimed by an earlier expected_conflict_components
+# entry (invariant M8). Threaded across components so cross-component duplicate
+# membership is decided in one pass; reset by pm_validate_text.
+PM_CLAIMED=""
+
 pm_parse_manifest() {
 	# Parse manifest text into the shared node table (invariant M1).
 	#
@@ -128,6 +134,108 @@ pm_validate_identity() {
 	fi
 }
 
+pm_declared_issue_nums() {
+	# Echo the space-separated issue_num values the items collection declares.
+	#
+	# Supplies the resolution target for invariant M8 without re-running the M6
+	# item validation: a malformed entry is reported once by M6 and simply
+	# contributes no resolvable key here.
+	local declared="" count index entry_path issue_type issue_value
+	[[ $(yp_type_of "items") == seq ]] || return 0
+	count=$(yp_count_of "items")
+	# Accept only entries whose primary key is already well formed; admitting a
+	# malformed one would produce a second, confusing M8 error for one defect.
+	for ((index = 0; index < count; index++)); do
+		entry_path="items[${index}]"
+		[[ $(yp_type_of "$entry_path") == map ]] || continue
+		issue_type=$(yp_type_of "${entry_path}.issue_num")
+		issue_value=$(yp_value_of "${entry_path}.issue_num")
+		pc_is_positive_integer "$issue_type" "$issue_value" || continue
+		declared="$declared $issue_value"
+	done
+	printf '%s' "$declared"
+}
+
+pm_validate_component_members() {
+	# Validate one component's members list against invariant M8.
+	#
+	# Args: $1 = node path of the members list, $2 = component-scoped context
+	# prefix, $3 = space-separated declared issue_num values. Appends every
+	# accepted key to PM_CLAIMED so the caller's running set enforces the
+	# no-duplicate-membership rule across components.
+	local path="$1" ctx="$2" declared="$3"
+	local members_type count=0 index slot entry_path member_type member_value
+	members_type=$(yp_type_of "$path")
+	if [[ $members_type == seq ]]; then
+		count=$(yp_count_of "$path")
+	fi
+	# A missing key, a scalar, and an empty list are one violation: the
+	# component asserts no membership and therefore carries no information.
+	if [[ $members_type != seq ]] || ((count == 0)); then
+		pc_error_add "$ctx members must be a non-empty list of positive integers."
+		return 0
+	fi
+
+	# Three successive gates per member; the first failure ends that member's
+	# checks, because an unusable value cannot be resolved and an unresolved key
+	# cannot meaningfully duplicate another.
+	for ((index = 0; index < count; index++)); do
+		entry_path="${path}[${index}]"
+		slot="$ctx members[${index}]"
+		member_type=$(yp_type_of "$entry_path")
+		member_value=$(yp_value_of "$entry_path")
+		if ! pc_is_positive_integer "$member_type" "$member_value"; then
+			pc_error_add "$slot must be a positive integer; found: $(pi_repr_at "$entry_path")."
+			continue
+		fi
+		if ! pc_contains_word "$declared" "$member_value"; then
+			pc_error_add "$slot does not resolve to an items[] issue_num; found: $member_value."
+			continue
+		fi
+		if pc_contains_word "$PM_CLAIMED" "$member_value"; then
+			pc_error_add "$slot repeats issue_num $member_value, already claimed by an earlier component."
+			continue
+		fi
+		PM_CLAIMED="$PM_CLAIMED $member_value"
+	done
+}
+
+pm_validate_expected_components() {
+	# Validate the optional expected_conflict_components key (invariant M8).
+	#
+	# Key gated: absence is the overwhelmingly common shape and must cost the
+	# caller nothing, so the whole invariant is skipped rather than defaulted
+	# and a pre-M8 manifest's error list is unchanged.
+	local root="expected_conflict_components"
+	yp_has "$root" || return 0
+	if [[ $(yp_type_of "$root") != seq ]]; then
+		pc_error_add "$PM_CONTEXT $root must be a list."
+		return 0
+	fi
+
+	local declared total position comp_path ctx name_type name_value
+	declared=$(pm_declared_issue_nums)
+	total=$(yp_count_of "$root")
+	for ((position = 0; position < total; position++)); do
+		comp_path="${root}[${position}]"
+		ctx="$PM_CONTEXT ${root}[${position}]"
+		if [[ $(yp_type_of "$comp_path") != map ]]; then
+			pc_error_add "$ctx must be an object."
+			continue
+		fi
+		# Field order follows the documented authoring order: the optional
+		# diagnostic label first, then the required membership list.
+		if yp_has "${comp_path}.name"; then
+			name_type=$(yp_type_of "${comp_path}.name")
+			name_value=$(yp_value_of "${comp_path}.name")
+			if ! pc_is_non_empty_string "$name_type" "$name_value"; then
+				pc_error_add "$ctx name must be a non-empty string."
+			fi
+		fi
+		pm_validate_component_members "${comp_path}.members" "$ctx" "$declared"
+	done
+}
+
 pm_validate_text() {
 	# Validate a manifest document against invariants M1 to M7.
 	#
@@ -139,6 +247,7 @@ pm_validate_text() {
 	local text="$1" parse_status=0
 	pc_errors_reset
 	PM_SUBSET_DETAIL=""
+	PM_CLAIMED=""
 	pm_parse_manifest "$text" || parse_status=$?
 	# An out-of-subset refusal propagates so the caller can distinguish it from
 	# a validation verdict; an M1 failure returns the single-element error list
@@ -156,6 +265,9 @@ pm_validate_text() {
 	# The manifest carries `kind` on every item, unlike the orchestrator
 	# checkpoint, so the shared item validator is asked to require it (S1).
 	pi_validate_items "items" "$PM_CONTEXT" 1
+	# M8 runs last because its membership check resolves against the same items
+	# collection the previous call validated.
+	pm_validate_expected_components
 	return 0
 }
 

package/resources/claude-customizations/.claude/lib/blast-radius/BlastRadius.psm1

@@ -54,6 +54,7 @@ Set-StrictMode -Version Latest
 Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'BlastRadiusExtraction.psm1') -Force
 Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'BlastRadiusGlob.psm1') -Force
 Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'BlastRadiusConfig.psm1') -Force
+Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'BlastRadiusNormalization.psm1') -Force
 Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'BlastRadiusValidation.psm1') -Force
 
 # Feature-folder handling. Every radius contains its own feature folder, and a
@@ -66,6 +67,11 @@ $script:FeatureFolderPrefix = 'docs/features/'
 $script:SourceDerived = 'derived'
 $script:SourceObserved = 'observed'
 
+# A contract identifier names something callable or referenceable, so it must
+# carry at least one ASCII letter (issue #489). Get-NormalizedDeclaredRadius
+# re-applies that rule to identifiers a pre-#489 extractor already recorded.
+$script:ContractLetterPattern = [regex]::new('[A-Za-z]')
+
 # Contention reason kinds, in the fixed order every result reports them. These
 # strings are contract literals consumed by the downstream parallel schema.
 $script:ConflictPathOverlap = 'path_overlap'
@@ -167,10 +173,20 @@ function Get-BlastRadius {
     $entry = [System.Collections.Generic.List[string]]::new()
     $entry.AddRange([string[]]@(Get-PlanPaths -PlanText $PlanText -RootSurface $rootSurface))
     $entry.AddRange([string[]]@(Get-PathFromLine -Line $specLine -RootSurface $rootSurface))
-    $entry.Add((Get-FeatureFolderGlob -FeatureFolder (
+
+    # Read-by-mandate citations are dropped before the feature folder is added: a
+    # plan cites the policy rules because its author was told to read them, not
+    # because the change will write them (issue #489). Test-BlastRadius applies
+    # the same filter, which is what keeps the derived radius passing V1 and V2
+    # against its own plan. The feature-folder glob is added afterwards so it can
+    # never be excluded.
+    $surviving = [System.Collections.Generic.List[string]]::new()
+    $surviving.AddRange([string[]]@(Get-NonMandateReadEntry -Entry $entry.ToArray() `
+                -MandateRead ([string[]]@(Get-ConfigMandateRead -Config $Config))))
+    $surviving.Add((Get-FeatureFolderGlob -FeatureFolder (
                 Get-RequiredText -Value $FeatureFolder -FieldName 'feature_folder')))
 
-    $paths = [string[]]@(Get-OrdinalSortedEntry -Entry $entry.ToArray())
+    $paths = [string[]]@(Get-OrdinalSortedEntry -Entry $surviving.ToArray())
     $concrete = [string[]]@(Get-ConcreteEntry -Entry $paths)
 
     return ConvertTo-NormalizedBlastRadius -Radius @{
@@ -183,6 +199,92 @@ function Get-BlastRadius {
     }
 }
 
+function Get-NormalizedDeclaredRadius {
+    <#
+    .SYNOPSIS
+        Re-apply the current extraction rules to an already-recorded radius.
+
+    .DESCRIPTION
+        Port of normalize_declared_radius. A radius recorded by an older
+        extractor can carry entries the current rules reject: directory-shaped
+        tokens, cross-corpus documentation globs, read-by-mandate citations, and
+        letterless contract tokens. Re-deriving from the plan text is not always
+        possible, so this function re-filters the recorded radius in place of a
+        fresh derivation and re-resolves the levels that depend on the surviving
+        paths (issue #489). source and computed_at are preserved and the input is
+        never mutated.
+
+    .PARAMETER Radius
+        A derived or declared radius hashtable to re-filter.
+
+    .PARAMETER Config
+        Parsed config/blast-radius.json. The root-surface set, the mandate-read
+        list, the module map, and the shared-surface list are all read from this
+        one value.
+
+    .OUTPUTS
+        System.Collections.Hashtable. A new radius carrying the surviving paths,
+        contracts re-filtered by the ASCII-letter rule, and modules and shared
+        surfaces re-resolved from the surviving paths. Throws when the radius
+        source is observed: an observed radius records a diff listing rather than
+        a plan-text harvest, so the plan-text acceptance rules do not apply to it
+        and re-filtering one would silently discard genuine evidence.
+    #>
+    [CmdletBinding()]
+    [OutputType([hashtable])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [object] $Radius,
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [object] $Config
+    )
+
+    $normalized = ConvertTo-NormalizedBlastRadius -Radius $Radius
+
+    # Fail fast, before any other work, so the prohibition is unambiguous and no
+    # partially-filtered value can escape.
+    if ($normalized['source'] -eq $script:SourceObserved) {
+        throw ("Get-NormalizedDeclaredRadius rejects a radius whose source is " +
+            "'$($script:SourceObserved)': an observed radius records a diff listing, " +
+            'not a plan-text harvest, so the plan-text acceptance rules must not ' +
+            'be applied to it.')
+    }
+
+    $rootSurface = [string[]]@(Get-ConfigRootSurface -Config $Config)
+
+    # Re-run the classifier over each recorded entry. An entry the current rules
+    # reject is dropped; the mandate-read filter then removes the citations that
+    # are evidence of a read rather than of a write.
+    $accepted = [System.Collections.Generic.List[string]]::new()
+    foreach ($entry in @($normalized['paths'])) {
+        if ($null -ne (Get-PathTokenKind -Token $entry -RootSurface $rootSurface)) {
+            $accepted.Add([string]$entry)
+        }
+    }
+
+    $paths = [string[]]@(Get-NonMandateReadEntry -Entry $accepted.ToArray() `
+            -MandateRead ([string[]]@(Get-ConfigMandateRead -Config $Config)))
+    $concrete = [string[]]@(Get-ConcreteEntry -Entry $paths)
+
+    $contract = [System.Collections.Generic.List[string]]::new()
+    foreach ($identifier in @($normalized['contracts'])) {
+        if ($script:ContractLetterPattern.IsMatch([string]$identifier)) {
+            $contract.Add([string]$identifier)
+        }
+    }
+
+    return ConvertTo-NormalizedBlastRadius -Radius @{
+        paths           = $paths
+        modules         = @(Resolve-BlastRadiusModule -PathEntry $paths -Config $Config)
+        shared_surfaces = @(Resolve-BlastRadiusSharedSurface -ConcretePath $concrete -Config $Config)
+        contracts       = @($contract.ToArray())
+        source          = $normalized['source']
+        computed_at     = $normalized['computed_at']
+    }
+}
+
 function Get-BlastRadiusFromObservedPaths {
     <#
     .SYNOPSIS
@@ -374,6 +476,7 @@ function Test-BlastRadiusConflict {
 Export-ModuleMember -Function `
     Get-PlanPaths, `
     Get-BlastRadius, `
+    Get-NormalizedDeclaredRadius, `
     Get-BlastRadiusFromObservedPaths, `
     Test-BlastRadius, `
     Test-BlastRadiusConflict

package/resources/claude-customizations/.claude/lib/blast-radius/BlastRadiusConfig.psm1

@@ -39,6 +39,7 @@ Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'BlastRadiusGlob.psm1')
 $script:ConfigSharedSurfaceKey = 'shared_surfaces'
 $script:ConfigSharedSurfaceGlobKey = 'shared_surface_globs'
 $script:ConfigModuleKey = 'modules'
+$script:ConfigMandateReadKey = 'mandate_reads'
 $script:ConfigOverBreadthKey = 'over_breadth_fraction'
 
 # Numeric types a JSON or literal truth table may carry for the V3 threshold.
@@ -279,6 +280,36 @@ function Get-ConfigRootSurface {
     return @($rootSurface.ToArray())
 }
 
+function Get-ConfigMandateRead {
+    <#
+    .SYNOPSIS
+        Read the read-by-mandate exclusion list from the truth table.
+
+    .DESCRIPTION
+        Port of config_mandate_reads. Mandate reads are the paths every agent is
+        instructed to read before doing any work, so a citation of one of them is
+        evidence that the author obeyed the reading order rather than evidence
+        that the change will write the file (issue #489).
+
+    .PARAMETER Config
+        Parsed config/blast-radius.json. Only the mandate_reads key is read.
+
+    .OUTPUTS
+        System.Object[]. Entries sorted and deduplicated by the underlying
+        reader. A config with no mandate_reads key yields an empty array, which
+        excludes nothing and reproduces pre-change behavior.
+    #>
+    [CmdletBinding()]
+    [OutputType([System.Object[]])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [object] $Config
+    )
+
+    return @(Get-ConfigStringList -Config $Config -Key $script:ConfigMandateReadKey)
+}
+
 function Get-ConfigModuleEntry {
     <#
     .SYNOPSIS
@@ -374,57 +405,6 @@ function Get-ConfigOverBreadthFraction {
     return $fraction
 }
 
-function Resolve-BlastRadiusModule {
-    <#
-    .SYNOPSIS
-        Resolve path entries to the module names of the truth-table map.
-
-    .DESCRIPTION
-        Port of resolve_modules. A module joins the radius as soon as one of its
-        globs covers one entry, so the search stops at the first hit per module.
-        A path matching no glob resolves to no module.
-
-    .PARAMETER PathEntry
-        Concrete paths and globs of a radius. An empty collection is accepted.
-
-    .PARAMETER Config
-        Parsed config/blast-radius.json.
-
-    .OUTPUTS
-        System.Object[]. Matched module names, deduplicated and ordinally sorted.
-    #>
-    [CmdletBinding()]
-    [OutputType([System.Object[]])]
-    param(
-        [Parameter(Mandatory = $true)]
-        [AllowEmptyCollection()]
-        [AllowEmptyString()]
-        [string[]] $PathEntry,
-        [Parameter(Mandatory = $true)]
-        [AllowNull()]
-        [object] $Config
-    )
-
-    $matched = [System.Collections.Generic.List[string]]::new()
-    foreach ($pair in @(Get-ConfigModuleEntry -Config $Config)) {
-        foreach ($pattern in $pair['globs']) {
-            $hit = $false
-            foreach ($entry in $PathEntry) {
-                if (Test-GlobMatch -Pattern $pattern -Candidate $entry) {
-                    $matched.Add([string]$pair['name'])
-                    $hit = $true
-                    break
-                }
-            }
-            if ($hit) {
-                break
-            }
-        }
-    }
-
-    return @(Get-OrdinalSortedEntry -Entry $matched.ToArray())
-}
-
 function Resolve-BlastRadiusSharedSurface {
     <#
     .SYNOPSIS
@@ -485,7 +465,7 @@ Export-ModuleMember -Function `
     Get-RequiredMapping, `
     Get-ConfigStringList, `
     Get-ConfigRootSurface, `
+    Get-ConfigMandateRead, `
     Get-ConfigModuleEntry, `
     Get-ConfigOverBreadthFraction, `
-    Resolve-BlastRadiusModule, `
     Resolve-BlastRadiusSharedSurface