@danmoisan/drm-copilot-mcp 1.1.17 → 1.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danmoisan/drm-copilot-mcp",
-  "version": "1.1.17",
+  "version": "1.1.18",
   "description": "Stdio MCP server exposing drm-copilot repo-automation tools.",
   "license": "MIT",
   "type": "commonjs",
@@ -38,11 +38,12 @@
     "prepack": "node prepack.cjs"
   },
   "overrides": {
-    "fast-uri": "^3.1.4",
+    "fast-uri": "^3.1.8",
     "hono": "^4.12.27",
     "ip-address": "^10.7.2",
     "qs": "^6.15.2",
-    "@hono/node-server": "^2.0.5"
+    "@hono/node-server": "^2.0.5",
+    "brace-expansion": "^5.0.12"
   },
   "devDependencies": {
     "esbuild": "^0.28.0"

package/resources/claude-customizations/.claude/agents/feature-review.md

@@ -9,6 +9,7 @@ tools:
   - "Bash(git diff *)"
   - "Bash(git log *)"
   - "Write(/docs/features/active/**)"
+  - "mcp__drm-copilot__validate_orchestration_artifacts"
 skills:
   - policy-compliance-order
   - acceptance-criteria-tracking
@@ -32,7 +33,12 @@ When the active review scope is a selected version folder such as `docs/features
 1. `docs/features/active/<feature-or-selected-version>/policy-audit.<timestamp>.md` — policy compliance audit with PASS/PARTIAL/FAIL verdicts and evidence
 2. `docs/features/active/<feature-or-selected-version>/code-review.<timestamp>.md` — code quality review covering best practices
 3. `docs/features/active/<feature-or-selected-version>/feature-audit.<timestamp>.md` — acceptance criteria verification relative to baseline
-4. If remediation is needed: `docs/features/active/<feature-or-selected-version>/remediation-inputs.<timestamp>.md` with explicit remediation-required findings and artifact paths
+4. For every review with at least one blocking finding, including halt (`HALT_NON_REMEDIABLE`) and wait (`AWAITING_CI`) verdicts: `docs/features/active/<feature-or-selected-version>/remediation-inputs.<timestamp>.md` with explicit remediation-required findings and artifact paths. The file carries these line formats:
+   - one line `Review-Verdict: <VERDICT>`, where the verdict is `PASS`, `REMEDIATION_REQUIRED`, `HALT_NON_REMEDIABLE`, or `AWAITING_CI`,
+   - inside each blocking finding block, one line `Remediability: <class>`, where the class is `autonomous`, `external_dependency`, `policy_hold`, `awaiting_ci`, or `human_decision_required` (`autonomous` when the line is absent),
+   - inside each blocking finding block, one line `Remediability-Evidence: <text>` stating why the class applies.
+
+   These lines, including the evidence text, never contain the substrings the orchestrator counts when it counts blocking findings, so their presence does not change the blocking count. The verdict follows from the classes: no blocking finding is `PASS`; any `autonomous` finding is `REMEDIATION_REQUIRED`; otherwise any `external_dependency`, `policy_hold`, or `human_decision_required` finding is `HALT_NON_REMEDIABLE`; otherwise `AWAITING_CI`.
 
 Timestamp format: `yyyy-MM-ddTHH-mm` (ISO-8601).
 
@@ -44,6 +50,9 @@ Report the required artifact paths in the final response using these tokens:
 - `code-review-path: docs/features/active/<feature-or-selected-version>/code-review.<timestamp>.md`
 - `feature-audit-path: docs/features/active/<feature-or-selected-version>/feature-audit.<timestamp>.md`
 - When remediation inputs are produced: `remediation-inputs-path: docs/features/active/<feature-or-selected-version>/remediation-inputs.<timestamp>.md`
+- Optional: `review-status: <VERDICT>` with the same verdict as the remediation inputs (`PASS` when none were produced). The orchestrator treats the remediation inputs as authoritative and this token as a cross-check.
+
+Validate each review artifact immediately after writing it with `mcp__drm-copilot__validate_orchestration_artifacts`, passing `artifact_path` set to that artifact: use `artifact_type: "policy-audit"` for `policy-audit.<timestamp>.md`, `artifact_type: "code-review"` for `code-review.<timestamp>.md`, and `artifact_type: "feature-audit"` for `feature-audit.<timestamp>.md`. When the validator reports a failure, fix the artifact in the same review and validate it again. Report an artifact path only after its validation passes.
 
 ## Context Sources
 

package/resources/claude-customizations/.claude/agents/orchestrator.md

@@ -96,7 +96,9 @@ PR creation and PR body edits must be delegated to `Agent(pr-author)`. The orche
 
 When the orchestrator runs the remediation loop, it records a top-level `remediation_loop` object in `artifacts/orchestration/orchestrator-state.json`:
 
-- `current_cycle` — integer index of the active cycle.
+- `current_cycle` — integer index of the active cycle's record in `cycles[]`; a record position, not an attempt count.
+- `completed_attempts` — non-negative integer equal to the number of cycles whose `candidate_applied` is `true`. This is the shared attempt count for local, CI-failure, merge-conflict, and parallel-drift cycles; the guard halts after three completed attempts.
+- `review_outcomes[]` — one entry per review, including `PASS`, appended in order. Each entry is an object with `verdict` (one of `PASS`, `REMEDIATION_REQUIRED`, `HALT_NON_REMEDIABLE`, `AWAITING_CI`) and `findings[]`, the review's blocking findings only, each an object with `remediability` (one of `autonomous`, `external_dependency`, `policy_hold`, `awaiting_ci`, `human_decision_required`). An optional `inputs_path` names the `remediation-inputs` file.
 - `cycles[]` — an ordered array of cycle records. Each cycle is an object with:
   - `entry_timestamp` — ISO-8601 timestamp when the cycle was entered.
   - `inputs_path` — path to the `remediation-inputs.<entry-ts>.md` that opened the cycle.
@@ -106,14 +108,25 @@ When the orchestrator runs the remediation loop, it records a top-level `remedia
   - `audit_paths` — the reaudit artifact paths produced at cycle exit (`code-review`, `feature-audit`, `policy-audit`).
   - `blocking_count` — the total number of blocking findings across the reaudit artifacts.
   - `exit_condition_met` — boolean; `true` only when the cycle's exit gate is satisfied.
+  - `candidate_applied` — boolean; `true` only for a completed attempt (execution `complete` and a non-empty pre-reaudit commit). A cycle without a candidate records `false` and consumes no attempt number.
+  - `opened_by_review` — zero-based index of the `review_outcomes[]` entry that opened the cycle.
+
+These four fields are recorded by producers. Verdicts follow from the classes of a review's blocking findings: none is `PASS`; any `autonomous` is `REMEDIATION_REQUIRED`; otherwise any `external_dependency`, `policy_hold`, or `human_decision_required` is `HALT_NON_REMEDIABLE`; otherwise `AWAITING_CI`. A `HALT_NON_REMEDIABLE` or `AWAITING_CI` review opens no cycle.
 
 Malformed-cycle rules:
 
 - `plan_path` must be a non-empty string.
 - `execution_status` may be in `{in_progress, complete, failed}` only when `preflight.final_status == 'clear'`; any other preflight status with one of those execution statuses is malformed (execution recorded before preflight cleared).
 - `exit_condition_met == true` requires `blocking_count == 0`; a non-zero `blocking_count` with `exit_condition_met == true` is malformed.
+- R5: `candidate_applied`, when present, must be a boolean.
+- R6: `candidate_applied == true` requires `execution_status == "complete"`.
+- R7: `completed_attempts`, when present, must be a non-negative integer equal to the number of object cycles whose `candidate_applied` is `true`.
+- R8: `review_outcomes`, when present, must be a list, and each entry must be an object.
+- R9: each outcome's `verdict` must be one of the four verdicts, its `findings` must be a list, and each finding must be an object whose `remediability` is one of the five classes (case-sensitive).
+- R10: each well-formed outcome's `verdict` must equal the verdict derived from its findings' classes.
+- R11: `opened_by_review`, when present, must be a non-negative integer that indexes an object entry of `review_outcomes` whose `verdict` is `REMEDIATION_REQUIRED`.
 
-Cycle-aware `next_step` uses the form `remediation.cycle_N.{plan,preflight,execute,reaudit,exit_check}`, where `N` is the cycle index and the sub-step names the current position in the loop.
+Cycle-aware `next_step` uses the form `remediation.cycle_N.{plan,preflight,execute,reaudit,exit_check}`, where `N` is `completed_attempts + 1` (the active cycle number) and the sub-step names the current position in the loop; `current_cycle` remains a record position in `cycles[]`.
 
 ### CI Monitoring and Post-PR Remediation
 
@@ -149,7 +162,7 @@ A new finding discovered during execution triggers a NEW cycle with a follow-up
 
 ### Exit Gate
 
-`blocking_count` is the total of FAIL and blocking-PARTIAL findings across the three reaudit artifacts (`code-review`, `feature-audit`, `policy-audit`). Only `blocking_count == 0` sets `exit_condition_met = true`. A non-zero `blocking_count` leaves the gate unmet and opens the next cycle.
+`blocking_count` is the total of FAIL and blocking-PARTIAL findings across the three reaudit artifacts (`code-review`, `feature-audit`, `policy-audit`). Only `blocking_count == 0` sets `exit_condition_met = true`. The exit gate counts only `autonomous` blocking findings when deciding whether to open the next cycle: a non-zero count of `autonomous` blocking findings leaves the gate unmet and opens the next cycle, while remaining blocking findings that are all non-remediable halt (`HALT_NON_REMEDIABLE`) or wait (`AWAITING_CI`) instead of opening a cycle.
 
 ### Citations
 

package/resources/claude-customizations/.claude/agents/parallel-orchestrator.md

@@ -275,6 +275,12 @@ In `closed` mode, do not report completion until:
    `artifact_type: "parallel-orchestrator-state"`).
 4. Acceptance criteria in the AC source files of each item have been checked off by that item's own
    run, per the `acceptance-criteria-tracking` skill.
+   A CI-dependent criterion, whose verification requires the result of CI on the pull-request head,
+   is checked off and pushed by the item's own run after its S9 success and before its DONE, and
+   that run re-runs S9 so its reported `ci_gate.head_sha` is the final head. Before `gh pr merge`,
+   confirm that the `headRefOid` value equals that reported `ci_gate.head_sha` and that the item
+   reported no pending CI-dependent criteria. You never commit acceptance-criteria check-offs from
+   the coordinator root.
 
 In `open` mode there is no automatic completion. The run is a standing queue and terminates only
 via `/parallel-close`, which is owned by F6 and is not specified here or shipped by this feature. Do

package/resources/claude-customizations/.claude/lib/bash/parallel-lane-assertion.sh

@@ -82,8 +82,10 @@ pla_parse_edges() {
 	PLA_EDGES=()
 	local -a tokens=()
 	# read -ra rather than an unquoted expansion, so a token carrying a glob
-	# character is never subjected to pathname expansion.
-	read -ra tokens <<<"$text"
+	# character is never subjected to pathname expansion. Newline, CR, VT, and FF
+	# become spaces first: read consumes one newline-terminated record and splits
+	# it on IFS only, so the Python str.split() whitespace set would otherwise differ.
+	read -ra tokens <<<"${text//[$'\n\r\v\f']/ }"
 	for token in "${tokens[@]}"; do
 		# Partition on the FIRST colon, matching str.partition: a token with two
 		# colons yields a second endpoint that still carries one, which the lexis

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

@@ -93,17 +93,10 @@ $script:STEP_SPECIFIC_EXTRA_STATUS = @{
     step9_status = @('passed', 'failed_remediation_required', 'blocked_ci_loop_limit')
 }
 
-# The allowed blocked_reason vocabulary. Pinned to VALID_BLOCKED_REASONS in the
-# primary validator.
-$script:VALID_BLOCKED_REASONS = @(
-    'none',
-    'spawn_agent_unavailable',
-    'delegation_launch_failed',
-    'delegate_no_receipt',
-    'delegate_contract_incomplete',
-    'validator_failed',
-    'user_requested_stop'
-)
+# blocked_reason vocabulary; mirrors scripts/dev_tools/_orchestrator_state_blocked_reason.py.
+$script:MECHANICAL_BLOCKED_REASONS = @('spawn_agent_unavailable', 'delegation_launch_failed', 'delegate_no_receipt', 'delegate_contract_incomplete', 'validator_failed', 'user_requested_stop')
+$script:NON_MECHANICAL_BLOCKED_REASONS = @('premise_falsified', 'external_dependency', 'policy_hold', 'awaiting_ci', 'human_decision_required')
+$script:VALID_BLOCKED_REASONS = @('none') + $script:MECHANICAL_BLOCKED_REASONS + $script:NON_MECHANICAL_BLOCKED_REASONS
 
 # The upstream steps that must not be pending/blocked before the first PR creation
 # of a branch. Pinned to PR_CREATION_READY_STEP_KEYS in
@@ -290,7 +283,7 @@ function Get-OrchestratorStateBasePresenceError {
     # A present, non-null blocked_reason must be a member of the allowed vocabulary.
     $blocked = Get-OrchestratorStateField -State $State -Name 'blocked_reason'
     if ($blocked.Present -and $null -ne $blocked.Value -and
-        ($script:VALID_BLOCKED_REASONS -notcontains [string]$blocked.Value)) {
+        ($script:VALID_BLOCKED_REASONS -cnotcontains [string]$blocked.Value)) {
         $errors.Add("Checkpoint has invalid blocked_reason: $($blocked.Value)")
     }
 
@@ -333,7 +326,7 @@ function Get-OrchestratorStatePrCreationReadinessError {
     # blocked_reason must read as clear: absent, null, or the literal 'none'. Any
     # other recorded reason means the branch is not ready for PR creation.
     $blocked = Get-OrchestratorStateField -State $State -Name 'blocked_reason'
-    if ($blocked.Present -and $null -ne $blocked.Value -and ([string]$blocked.Value -ne 'none')) {
+    if ($blocked.Present -and $null -ne $blocked.Value -and ([string]$blocked.Value -cne 'none')) {
         $errors.Add('Checkpoint PR-creation readiness validation failed: blocked_reason is not `none`.')
     }
 

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

@@ -0,0 +1,375 @@
+<#
+.SYNOPSIS
+    Issue-adoption record validation and receipt waivers (inventory row C6.15).
+
+.DESCRIPTION
+    Destination-runtime PowerShell port of `resolve_issue_adoption` in
+    `scripts/dev_tools/_orchestrator_state_issue_adoption.py`. The optional
+    checkpoint object `issue_adoption` records that the orchestration adopted a
+    GitHub issue that existed before orchestration started. A valid record
+    waives the successful-receipt requirement for `potential_to_issue` and,
+    optionally, for the checkpoint's promotion-entry tool.
+
+    Invariants:
+      - When the `issue_adoption` member is absent, no error is produced and no
+        tool is waived, so existing checkpoints validate exactly as before.
+      - Errors accumulate in the fixed rule order of the feature specification.
+      - Fail-closed: WaivedTools is empty whenever Errors is non-empty.
+      - Every string comparison is ordinal and case-sensitive.
+      - Messages interpolate only non-blank `waived_tools` entries and the route id.
+
+    Every function is pure: it reads no file, starts no process, and never mutates
+    its input.
+    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
+
+$script:ISSUE_ADOPTION_KEY = 'issue_adoption'
+$script:POTENTIAL_TO_ISSUE_TOOL = 'potential_to_issue'
+$script:FEATURE_PROMOTION_ENTRY_TOOL = 'new_potential_entry'
+$script:BUG_PROMOTION_ENTRY_TOOL = 'new_potential_bug_entry'
+$script:ORIGIN_VALUES = [string[]]@('transferred', 'filed_before_orchestration', 'epic_decomposition')
+$script:VERIFIED_VIA_VALUES = [string[]]@('gh_issue_view', 'gh_api_get', 'github_mcp_issue_read')
+
+# The closed set of tools an adoption record may waive: the issue-creation tool
+# and the two promotion-type-specific promotion-entry tools.
+$script:WAIVABLE_TOOLS = [string[]]@($script:POTENTIAL_TO_ISSUE_TOOL, $script:FEATURE_PROMOTION_ENTRY_TOOL, $script:BUG_PROMOTION_ENTRY_TOOL)
+$script:PROMOTION_ENTRY_TOOLS = [string[]]@($script:FEATURE_PROMOTION_ENTRY_TOOL, $script:BUG_PROMOTION_ENTRY_TOOL)
+$script:POTENTIAL_RECORD_PREFIX = 'docs/features/potential/'
+$script:POTENTIAL_RECORD_SUFFIX = '.md'
+$script:ISSUE_NUM_PATTERN = '\A[1-9][0-9]*\z'
+
+$script:ERROR_NOT_OBJECT = 'Checkpoint issue_adoption must be an object when present.'
+$script:ERROR_ISSUE_NUM_FORMAT = 'Checkpoint issue_adoption.issue_num must be a string of decimal digits without a leading zero.'
+$script:ERROR_ISSUE_NUM_MISMATCH = 'Checkpoint issue_adoption.issue_num must equal the checkpoint issue-num.'
+$script:ERROR_ISSUE_URL = 'Checkpoint issue_adoption.issue_url must end with /issues/ followed by issue_num.'
+$script:ERROR_ORIGIN = 'Checkpoint issue_adoption.origin must be one of transferred, filed_before_orchestration, epic_decomposition.'
+$script:ERROR_VERIFIED_VIA = 'Checkpoint issue_adoption.verified_via must be one of gh_issue_view, gh_api_get, github_mcp_issue_read.'
+$script:ERROR_VERIFIED_AT = 'Checkpoint issue_adoption.verified_at must be present.'
+$script:ERROR_EVIDENCE = 'Checkpoint issue_adoption.evidence must be a non-empty string.'
+$script:ERROR_WAIVED_TOOLS_SHAPE = 'Checkpoint issue_adoption.waived_tools must be a non-empty list of tool names.'
+$script:ERROR_WAIVED_TOOLS_INCLUDE = 'Checkpoint issue_adoption.waived_tools must include potential_to_issue.'
+
+
+function Test-AdoptionNonBlankString {
+    <#
+    .SYNOPSIS
+        Report whether a value is a string with non-whitespace content.
+    .PARAMETER Value
+        The deserialized JSON value to inspect. May be $null.
+    .OUTPUTS
+        System.Boolean
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [object] $Value
+    )
+
+    return (($Value -is [string]) -and -not [string]::IsNullOrWhiteSpace([string]$Value))
+}
+
+function Get-AdoptionIssueIdentityError {
+    <#
+    .SYNOPSIS
+        Validate issue_num and issue_url (rules 2 and 3).
+    .PARAMETER Adoption
+        The issue_adoption object.
+    .PARAMETER State
+        The parsed checkpoint object, read for its hyphenated issue-num key.
+    .OUTPUTS
+        System.String[] - zero or more error strings.
+    #>
+    [CmdletBinding()]
+    [OutputType([string[]])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [psobject] $Adoption,
+
+        [Parameter(Mandatory = $true)]
+        [psobject] $State
+    )
+
+    $errors = [System.Collections.Generic.List[string]]::new()
+    $rawIssueNum = (Get-CheckpointObjectMember -Owner $Adoption -Name 'issue_num').Value
+    $issueNum = $null
+    if (($rawIssueNum -is [string]) -and ([string]$rawIssueNum -cmatch $script:ISSUE_NUM_PATTERN)) {
+        $issueNum = [string]$rawIssueNum
+    }
+
+    if ($null -ceq $issueNum) {
+        $errors.Add($script:ERROR_ISSUE_NUM_FORMAT)
+    }
+    else {
+        # The equality check applies only when the checkpoint records its own
+        # issue number as a string; other shapes are validated elsewhere.
+        $checkpointIssueNum = (Get-CheckpointObjectMember -Owner $State -Name 'issue-num').Value
+        if (($checkpointIssueNum -is [string]) -and -not [string]::Equals([string]$checkpointIssueNum, $issueNum, [System.StringComparison]::Ordinal)) {
+            $errors.Add($script:ERROR_ISSUE_NUM_MISMATCH)
+        }
+    }
+
+    $issueUrl = (Get-CheckpointObjectMember -Owner $Adoption -Name 'issue_url').Value
+    $urlIsValid = ($null -cne $issueNum) -and ($issueUrl -is [string]) -and ([string]$issueUrl).EndsWith("/issues/$issueNum", [System.StringComparison]::Ordinal)
+    if (-not $urlIsValid) {
+        $errors.Add($script:ERROR_ISSUE_URL)
+    }
+    return $errors.ToArray()
+}
+
+function Get-AdoptionProvenanceError {
+    <#
+    .SYNOPSIS
+        Validate origin, verified_via, verified_at, and evidence (rules 4 to 7).
+    .PARAMETER Adoption
+        The issue_adoption object.
+    .OUTPUTS
+        System.String[] - zero or more error strings.
+    #>
+    [CmdletBinding()]
+    [OutputType([string[]])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [psobject] $Adoption
+    )
+
+    $errors = [System.Collections.Generic.List[string]]::new()
+
+    $origin = (Get-CheckpointObjectMember -Owner $Adoption -Name 'origin').Value
+    if (-not (($origin -is [string]) -and ($script:ORIGIN_VALUES -ccontains [string]$origin))) {
+        $errors.Add($script:ERROR_ORIGIN)
+    }
+
+    $verifiedVia = (Get-CheckpointObjectMember -Owner $Adoption -Name 'verified_via').Value
+    if (-not (($verifiedVia -is [string]) -and ($script:VERIFIED_VIA_VALUES -ccontains [string]$verifiedVia))) {
+        $errors.Add($script:ERROR_VERIFIED_VIA)
+    }
+
+    # Presence-only: any non-null value other than a blank string passes,
+    # including a System.DateTime produced by ConvertFrom-Json.
+    $verifiedAt = (Get-CheckpointObjectMember -Owner $Adoption -Name 'verified_at').Value
+    if (($null -ceq $verifiedAt) -or (($verifiedAt -is [string]) -and [string]::IsNullOrWhiteSpace([string]$verifiedAt))) {
+        $errors.Add($script:ERROR_VERIFIED_AT)
+    }
+
+    if (-not (Test-AdoptionNonBlankString -Value (Get-CheckpointObjectMember -Owner $Adoption -Name 'evidence').Value)) {
+        $errors.Add($script:ERROR_EVIDENCE)
+    }
+    return $errors.ToArray()
+}
+
+function Get-AdoptionWaivedToolList {
+    <#
+    .SYNOPSIS
+        Return the waived tools when they form a non-empty list of non-blank strings.
+    .PARAMETER Value
+        The deserialized waived_tools value. May be $null.
+    .OUTPUTS
+        System.Collections.Hashtable with keys Ok (bool) and Value (string[]).
+    #>
+    [CmdletBinding()]
+    [OutputType([hashtable])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [object] $Value
+    )
+
+    if (-not (Test-CheckpointListValue -Value $Value)) {
+        return @{ Ok = $false; Value = [string[]]@() }
+    }
+    $items = @($Value)
+    if ($items.Count -ceq 0) {
+        return @{ Ok = $false; Value = [string[]]@() }
+    }
+    foreach ($item in $items) {
+        if (-not (Test-AdoptionNonBlankString -Value $item)) {
+            return @{ Ok = $false; Value = [string[]]@() }
+        }
+    }
+    return @{ Ok = $true; Value = [string[]]$items }
+}
+
+function Get-AdoptionWaivedToolError {
+    <#
+    .SYNOPSIS
+        Validate each waived tool entry and the mandatory issue-creation waiver (rule 8).
+    .PARAMETER WaivedTool
+        The well-formed waived tool list, in checkpoint order.
+    .PARAMETER RouteId
+        The selected route id, interpolated into route errors.
+    .PARAMETER RequiredMcpTool
+        The route's required MCP tools after promotion-type resolution.
+    .PARAMETER SuccessfulTool
+        Tools that hold a successful MCP receipt.
+    .OUTPUTS
+        System.String[] - zero or more error strings.
+    #>
+    [CmdletBinding()]
+    [OutputType([string[]])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [string[]] $WaivedTool,
+
+        [Parameter(Mandatory = $true)]
+        [string] $RouteId,
+
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyCollection()]
+        [string[]] $RequiredMcpTool,
+
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyCollection()]
+        [string[]] $SuccessfulTool
+    )
+
+    $errors = [System.Collections.Generic.List[string]]::new()
+    $seen = [System.Collections.Generic.HashSet[string]]::new([System.StringComparer]::Ordinal)
+    foreach ($tool in $WaivedTool) {
+        # Each entry receives only the first rule it violates, in rule order.
+        if ($seen.Contains($tool)) {
+            $errors.Add("Checkpoint issue_adoption.waived_tools lists a tool more than once: $tool.")
+        }
+        elseif ($script:WAIVABLE_TOOLS -cnotcontains $tool) {
+            $errors.Add("Checkpoint issue_adoption.waived_tools names a tool that cannot be waived: $tool.")
+        }
+        elseif ($RequiredMcpTool -cnotcontains $tool) {
+            $errors.Add("Checkpoint issue_adoption.waived_tools names a tool that is not required by route ${RouteId}: $tool.")
+        }
+        elseif ($SuccessfulTool -ccontains $tool) {
+            $errors.Add("Checkpoint issue_adoption.waived_tools names a tool that has a successful MCP receipt: $tool.")
+        }
+        [void]$seen.Add($tool)
+    }
+
+    if (-not $seen.Contains($script:POTENTIAL_TO_ISSUE_TOOL)) {
+        $errors.Add($script:ERROR_WAIVED_TOOLS_INCLUDE)
+    }
+    return $errors.ToArray()
+}
+
+function Get-AdoptionPotentialRecordError {
+    <#
+    .SYNOPSIS
+        Require a potential record when a promotion-entry tool is waived (rule 9).
+    .PARAMETER WaivedTool
+        The well-formed waived tool list, in checkpoint order.
+    .PARAMETER PotentialRecord
+        The deserialized potential_record value. May be $null.
+    .OUTPUTS
+        System.String[] - zero or more error strings.
+    #>
+    [CmdletBinding()]
+    [OutputType([string[]])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [string[]] $WaivedTool,
+
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [object] $PotentialRecord
+    )
+
+    $recordIsValid = $false
+    if ($PotentialRecord -is [string]) {
+        $record = [string]$PotentialRecord
+        $recordIsValid = $record.StartsWith($script:POTENTIAL_RECORD_PREFIX, [System.StringComparison]::Ordinal) -and $record.EndsWith($script:POTENTIAL_RECORD_SUFFIX, [System.StringComparison]::Ordinal)
+    }
+    if ($recordIsValid) { return [string[]]@() }
+
+    $errors = [System.Collections.Generic.List[string]]::new()
+    $reported = [System.Collections.Generic.HashSet[string]]::new([System.StringComparer]::Ordinal)
+    foreach ($tool in $WaivedTool) {
+        if (($script:PROMOTION_ENTRY_TOOLS -ccontains $tool) -and -not $reported.Contains($tool)) {
+            $errors.Add("Checkpoint issue_adoption.potential_record must name a markdown file under docs/features/potential/ when waiving $tool.")
+            [void]$reported.Add($tool)
+        }
+    }
+    return $errors.ToArray()
+}
+
+function Get-OrchestratorStateIssueAdoptionResult {
+    <#
+    .SYNOPSIS
+        Validate the checkpoint's issue_adoption record and resolve its waivers.
+    .DESCRIPTION
+        Public entry mirroring resolve_issue_adoption. Absent key: no errors and
+        no waivers. A present value that is not an object (null included) yields
+        only the not-an-object error. Otherwise rules 2 to 9 accumulate errors in
+        order, and the waived-tool set is populated only when no error was found.
+    .PARAMETER State
+        The parsed checkpoint object.
+    .PARAMETER RouteId
+        The selected route id, interpolated into route errors.
+    .PARAMETER RequiredMcpTool
+        The route's required MCP tools after promotion-type resolution.
+    .PARAMETER SuccessfulTool
+        Tools that hold a successful MCP receipt in the checkpoint.
+    .OUTPUTS
+        System.Collections.Hashtable with keys Errors (string[]) and WaivedTools (string[]).
+    #>
+    [CmdletBinding()]
+    [OutputType([hashtable])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [psobject] $State,
+
+        [Parameter(Mandatory = $true)]
+        [string] $RouteId,
+
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyCollection()]
+        [string[]] $RequiredMcpTool,
+
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyCollection()]
+        [string[]] $SuccessfulTool
+    )
+
+    $member = Get-CheckpointObjectMember -Owner $State -Name $script:ISSUE_ADOPTION_KEY
+    if (-not $member.Present) {
+        return @{ Errors = [string[]]@(); WaivedTools = [string[]]@() }
+    }
+
+    $adoption = $member.Value
+    if (-not (Test-CheckpointObjectValue -Value $adoption)) {
+        return @{ Errors = [string[]]@($script:ERROR_NOT_OBJECT); WaivedTools = [string[]]@() }
+    }
+
+    $errors = [System.Collections.Generic.List[string]]::new()
+    $errors.AddRange([string[]]@(Get-AdoptionIssueIdentityError -Adoption $adoption -State $State))
+    $errors.AddRange([string[]]@(Get-AdoptionProvenanceError -Adoption $adoption))
+
+    $waived = Get-AdoptionWaivedToolList -Value (Get-CheckpointObjectMember -Owner $adoption -Name 'waived_tools').Value
+    if (-not $waived.Ok) {
+        # A malformed list stops rule 8 and skips rule 9 entirely.
+        $errors.Add($script:ERROR_WAIVED_TOOLS_SHAPE)
+        return @{ Errors = $errors.ToArray(); WaivedTools = [string[]]@() }
+    }
+
+    $errors.AddRange([string[]]@(Get-AdoptionWaivedToolError -WaivedTool $waived.Value -RouteId $RouteId -RequiredMcpTool $RequiredMcpTool -SuccessfulTool $SuccessfulTool))
+    $potentialRecord = (Get-CheckpointObjectMember -Owner $adoption -Name 'potential_record').Value
+    $errors.AddRange([string[]]@(Get-AdoptionPotentialRecordError -WaivedTool $waived.Value -PotentialRecord $potentialRecord))
+
+    if ($errors.Count -gt 0) {
+        return @{ Errors = $errors.ToArray(); WaivedTools = [string[]]@() }
+    }
+
+    # The waived-tool set is the distinct entries in first-occurrence order.
+    $distinct = [System.Collections.Generic.List[string]]::new()
+    foreach ($tool in $waived.Value) {
+        if (-not $distinct.Contains($tool)) { $distinct.Add($tool) }
+    }
+    return @{ Errors = [string[]]@(); WaivedTools = $distinct.ToArray() }
+}
+
+# Only the family entry point is exported; the rule helpers stay private.
+Export-ModuleMember -Function Get-OrchestratorStateIssueAdoptionResult

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

@@ -37,6 +37,7 @@ $ErrorActionPreference = 'Stop'
 # module's directory so the import travels with the pushed-down pack regardless
 # of the consumer repository's working directory.
 Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'OrchestratorStateCheckpointValue.psm1') -Force -ErrorAction Stop
+Import-Module (Join-Path -Path $PSScriptRoot -ChildPath 'OrchestratorStateRemediationAccounting.psm1') -Force -ErrorAction Stop
 
 # The eight keys every list-form delegation receipt must carry. Pinned to
 # REQUIRED_RECEIPT_KEYS in scripts/dev_tools/validate_orchestrator_state.py.
@@ -290,12 +291,15 @@ function Get-RemediationCycleError {
 function Get-OrchestratorStateRemediationLoopError {
     <#
     .SYNOPSIS
-        Return the remediation_loop errors (inventory rows U6.R1-U6.R4).
+        Return the remediation_loop errors (inventory rows U6.R1-U6.R4, R5-R11).
     .DESCRIPTION
         Public entry mirroring _validate_remediation_loop. A non-object
-        remediation_loop, or a cycles value that is not a list, carries no cycles
-        to validate and deliberately yields ZERO errors, matching the Python
-        tolerance rather than fabricating a structural error.
+        remediation_loop deliberately yields ZERO errors, matching the Python
+        tolerance rather than fabricating a structural error. When cycles is a
+        list each cycle is validated independently (U6.R1-U6.R4); the issue #484
+        review-outcome and accounting invariants R5-R11 then run through
+        Get-OrchestratorStateRemediationAccountingError with the cycle list, or
+        $null when cycles is absent or not a list.
     .PARAMETER Value
         The raw deserialized value of the checkpoint's remediation_loop key.
     .OUTPUTS
@@ -313,21 +317,24 @@ function Get-OrchestratorStateRemediationLoopError {
 
     if (-not (Test-CheckpointObjectValue -Value $Value)) { return $errors.ToArray() }
     $cycles = (Get-CheckpointObjectMember -Owner $Value -Name $script:REMEDIATION_CYCLES_KEY).Value
-    if (-not (Test-CheckpointListValue -Value $cycles)) { return $errors.ToArray() }
-
-    # Validate each cycle independently so a malformed entry does not mask the
-    # errors of the cycles that follow it.
-    $index = 0
-    foreach ($cycle in @($cycles)) {
-        if (-not (Test-CheckpointObjectValue -Value $cycle)) {
-            $errors.Add("Checkpoint remediation cycle #$index must be an object.")
+    $cycleList = $null
+    if (Test-CheckpointListValue -Value $cycles) {
+        $cycleList = $cycles
+        # Validate each cycle independently so a malformed entry does not mask the
+        # errors of the cycles that follow it.
+        $index = 0
+        foreach ($cycle in @($cycles)) {
+            if (-not (Test-CheckpointObjectValue -Value $cycle)) {
+                $errors.Add("Checkpoint remediation cycle #$index must be an object.")
+                $index++
+                continue
+            }
+            $errors.AddRange([string[]]@(Get-RemediationCycleError -Index $index -Cycle $cycle))
             $index++
-            continue
         }
-        $errors.AddRange([string[]]@(Get-RemediationCycleError -Index $index -Cycle $cycle))
-        $index++
     }
 
+    $errors.AddRange([string[]]@(Get-OrchestratorStateRemediationAccountingError -RemediationLoop $Value -Cycle $cycleList))
     return $errors.ToArray()
 }