@danmoisan/drm-copilot-mcp 1.1.25 → 1.1.27

package/resources/claude-customizations/.claude/hooks/hook-cleanup-context.ps1

@@ -0,0 +1,343 @@
+<#
+.SYNOPSIS
+    Pure cleanup-context predicates shared by the cleanup legs of the enforcement gates (issue #1026).
+
+.DESCRIPTION
+    The cleanup-merged-worktrees skill writes no per-feature, epic, or parallel checkpoint, so
+    the checkpoint-based gates cannot recognize its writes, commits, delegation, and pull
+    request. Its integrity record is the sanctioned-removal manifest. This file holds the pure
+    decisions the gates' cleanup legs share:
+
+      Test-CleanupManifestText              - the manifest header (tool, schema_version) and,
+                                              with -UtcNow, its freshness and run_id.
+      Test-CleanupConsolidationRelativePath - the allowlist: the repository-relative prefixes
+                                              docs/ and .claude/agent-memory/ (ordinal,
+                                              case-sensitive), plus the pr-author receipt
+                                              artifacts/pr_body_<digits>.receipt.json with
+                                              -AllowReceipt.
+      Find-CleanupConsolidationRecord       - the consolidation worktree, identified by its
+                                              porcelain branch, never by its path.
+      Test-CleanupScratchPath               - the scratch rule: an absolute path outside every
+                                              registered worktree and the session root, under a
+                                              temporary root.
+      Test-CleanupConsolidationBranchLabel  - the delegation label rule of the model-routing leg.
+
+    Every function fails closed: a malformed or ambiguous input answers $false or $null.
+
+    The literals below restate values owned elsewhere: the branch equals
+    CLEANUP_WT_CONSOLIDATION_BRANCH in
+    .claude/skills/cleanup-merged-worktrees/scripts/cleanup_worktrees_actions_lib.sh, and the
+    manifest tool, schema version, and freshness bound equal $script:ExpectedManifestTool,
+    $script:ExpectedManifestSchemaVersion, and $script:ManifestFreshnessBound in
+    .claude/lib/cleanup-manifest/CleanupWorktreeManifest.psm1. The Codex hooks cannot import
+    .claude/lib, so the values are restated here and pinned equal by
+    tests/scripts/claude-hooks/hook-cleanup-context.Parity.Tests.ps1. The names avoid the
+    removal gates' $script:CleanupWorktreeManifestPath.
+
+.NOTES
+    PowerShell 7+. Functions and literals only: no file, process, network, clock, or
+    environment access, no dot-source, and no import. Byte-identical at .claude/hooks,
+    .codex/hooks, and both bundle mirrors under extensions/drm-copilot/resources/.
+#>
+
+$script:CleanupContextBranch = 'documentationandmemories'
+$script:CleanupContextManifestRelativePath = 'artifacts/orchestration/cleanup-worktrees-manifest.json'
+$script:CleanupContextManifestTool = 'cleanup-merged-worktrees'
+$script:CleanupContextManifestSchemaVersion = 1
+$script:CleanupContextFreshnessHours = 24
+
+function Test-CleanupManifestText {
+    <#
+    .SYNOPSIS
+        Return $true when the text is a cleanup manifest with the expected header.
+    .DESCRIPTION
+        The text must parse as a JSON object whose tool is the string cleanup-merged-worktrees
+        (ordinal) and whose schema_version is the integer 1. When -UtcNow is supplied, the
+        manifest must also carry a generated_at that parses, is not after UtcNow, and lies
+        within the freshness bound, and a run_id that is a non-blank string. The generated_at
+        value is read exactly as CleanupWorktreeManifest.psm1 reads it, so the PR and
+        delegation legs agree with the removal gates on freshness.
+    .PARAMETER Raw
+        The manifest text, or $null when no manifest exists.
+    .PARAMETER UtcNow
+        The current UTC time from the caller's clock seam.
+    .OUTPUTS
+        System.Boolean
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [AllowNull()][AllowEmptyString()][string] $Raw,
+        [datetime] $UtcNow
+    )
+
+    if ([string]::IsNullOrWhiteSpace($Raw)) {
+        return $false
+    }
+    try {
+        $manifest = $Raw | ConvertFrom-Json -ErrorAction Stop
+    }
+    catch {
+        return $false
+    }
+    if ($manifest -isnot [System.Management.Automation.PSCustomObject]) {
+        return $false
+    }
+    $names = @($manifest.PSObject.Properties.Name)
+    if ($names -notcontains 'tool' -or $names -notcontains 'schema_version') {
+        return $false
+    }
+    if ($manifest.tool -isnot [string] -or $manifest.tool -cne $script:CleanupContextManifestTool) {
+        return $false
+    }
+    $schemaVersion = $manifest.schema_version
+    if (($schemaVersion -isnot [int] -and $schemaVersion -isnot [long]) -or [long]$schemaVersion -ne $script:CleanupContextManifestSchemaVersion) {
+        return $false
+    }
+    if (-not $PSBoundParameters.ContainsKey('UtcNow')) {
+        return $true
+    }
+
+    if ($names -notcontains 'generated_at' -or $names -notcontains 'run_id') {
+        return $false
+    }
+    $generatedAt = [datetime]::MinValue
+    $styles = [System.Globalization.DateTimeStyles]::AdjustToUniversal -bor [System.Globalization.DateTimeStyles]::AssumeUniversal
+    if (-not [datetime]::TryParse([string]$manifest.generated_at, [cultureinfo]::InvariantCulture, $styles, [ref] $generatedAt)) {
+        return $false
+    }
+    if ($generatedAt -gt $UtcNow -or ($UtcNow - $generatedAt) -gt [timespan]::FromHours($script:CleanupContextFreshnessHours)) {
+        return $false
+    }
+    return ($manifest.run_id -is [string] -and -not [string]::IsNullOrWhiteSpace($manifest.run_id))
+}
+
+function Test-CleanupConsolidationRelativePath {
+    <#
+    .SYNOPSIS
+        Return $true when a repository-relative path is on the consolidation allowlist.
+    .DESCRIPTION
+        The path must use only the plain characters A-Z a-z 0-9 . _ / -, must not be rooted,
+        must carry no '..' segment, and must start with docs/ or .claude/agent-memory/ under
+        ordinal, case-sensitive comparison with at least one character after the prefix. Any
+        other Markdown path, such as CLAUDE.md or .claude/rules/x.md, is not admitted. With
+        -AllowReceipt the pr-author receipt artifacts/pr_body_<digits>.receipt.json is also
+        admitted; it never enters the staging allowlist.
+    .PARAMETER RelativePath
+        The repository-relative path or operand.
+    .PARAMETER AllowReceipt
+        Admit the pr-author receipt path (Write and Edit leg only).
+    .OUTPUTS
+        System.Boolean
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [AllowNull()][AllowEmptyString()][string] $RelativePath,
+        [switch] $AllowReceipt
+    )
+
+    $path = [string]$RelativePath
+    if ($path -cnotmatch '^[A-Za-z0-9._/-]+$' -or $path.StartsWith('/')) {
+        return $false
+    }
+    if (@($path -split '/') -contains '..') {
+        return $false
+    }
+    if ($AllowReceipt -and $path -cmatch '^artifacts/pr_body_[0-9]+\.receipt\.json$') {
+        return $true
+    }
+    foreach ($prefix in @('docs/', '.claude/agent-memory/')) {
+        if ($path.Length -gt $prefix.Length -and $path.StartsWith($prefix, [System.StringComparison]::Ordinal)) {
+            return $true
+        }
+    }
+    return $false
+}
+
+function Find-CleanupConsolidationRecord {
+    <#
+    .SYNOPSIS
+        Return the registered consolidation worktree record, or $null.
+    .DESCRIPTION
+        Takes the records ConvertFrom-HookTargetWorktreePorcelain emits. The first record (the
+        main worktree stanza), prunable records, and detached records are skipped. The single
+        remaining record whose Branch is ordinal-equal to documentationandmemories is returned;
+        none, or more than one, returns $null. The path is never consulted, because the
+        consolidation path can be overridden by CLEANUP_WT_CONSOLIDATION_PATH.
+    .PARAMETER Record
+        The porcelain records, in listing order.
+    .OUTPUTS
+        System.Management.Automation.PSCustomObject or $null
+    #>
+    [CmdletBinding()]
+    [OutputType([pscustomobject])]
+    param(
+        [AllowNull()][AllowEmptyCollection()][object[]] $Record
+    )
+
+    $records = @($Record | Where-Object { $null -ne $_ })
+    $found = [System.Collections.Generic.List[object]]::new()
+    for ($index = 1; $index -lt $records.Count; $index++) {
+        $candidate = $records[$index]
+        if ([bool]$candidate.Prunable -or $null -eq $candidate.Branch) {
+            continue
+        }
+        if ([string]$candidate.Branch -ceq $script:CleanupContextBranch) {
+            $found.Add($candidate)
+        }
+    }
+    if ($found.Count -ne 1) {
+        return $null
+    }
+    return $found[0]
+}
+
+function ConvertTo-CleanupContextPath {
+    <#
+    .SYNOPSIS
+        Normalize a path to forward slashes with one trailing slash removed (bare roots kept).
+    .OUTPUTS
+        System.String
+    #>
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [AllowNull()][AllowEmptyString()][string] $Path
+    )
+
+    $normalized = ([string]$Path).Replace('\', '/')
+    if ($normalized.Length -gt 1 -and $normalized.EndsWith('/') -and $normalized -notmatch '^[A-Za-z]:/$') {
+        $normalized = $normalized.Substring(0, $normalized.Length - 1)
+    }
+    return $normalized
+}
+
+function Test-CleanupContextPathUnder {
+    <#
+    .SYNOPSIS
+        Return $true when a normalized path equals a root or lies beneath it (OrdinalIgnoreCase).
+    .OUTPUTS
+        System.Boolean
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [Parameter(Mandatory)][AllowEmptyString()][string] $Path,
+        [AllowNull()][AllowEmptyString()][string] $Root
+    )
+
+    $normalizedRoot = ConvertTo-CleanupContextPath -Path $Root
+    if ([string]::IsNullOrEmpty($normalizedRoot)) {
+        return $false
+    }
+    if ([string]::Equals($Path, $normalizedRoot, [System.StringComparison]::OrdinalIgnoreCase)) {
+        return $true
+    }
+    $prefix = if ($normalizedRoot.EndsWith('/')) { $normalizedRoot } else { $normalizedRoot + '/' }
+    return $Path.StartsWith($prefix, [System.StringComparison]::OrdinalIgnoreCase)
+}
+
+function Test-CleanupScratchPath {
+    <#
+    .SYNOPSIS
+        Return $true when a path is a scratch path under a temporary root and outside every worktree.
+    .DESCRIPTION
+        The path must be absolute (drive-rooted or slash-rooted, not UNC), carry no '.' or '..'
+        segment and no surrounding whitespace, lie outside every registered worktree root and
+        outside the session root, and lie under at least one accepted temporary-root spelling.
+        Comparisons use forward-slash normalization and OrdinalIgnoreCase. The rule fails
+        closed when no registered root or no temporary root is supplied, and when any
+        registered worktree root lies under an accepted temporary root, because a path under
+        such a worktree could then be spelled so that it matches no registered root.
+    .PARAMETER Path
+        The Write or Edit file path.
+    .PARAMETER RegisteredRoot
+        Every registered worktree root from the listing, prunable ones included.
+    .PARAMETER SessionRoot
+        The session root.
+    .PARAMETER TemporaryRoot
+        Every accepted spelling of the operating-system temporary root.
+    .OUTPUTS
+        System.Boolean
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [AllowNull()][AllowEmptyString()][string] $Path,
+        [AllowNull()][AllowEmptyCollection()][string[]] $RegisteredRoot,
+        [AllowNull()][AllowEmptyString()][string] $SessionRoot,
+        [AllowNull()][AllowEmptyCollection()][string[]] $TemporaryRoot
+    )
+
+    $raw = [string]$Path
+    if ([string]::IsNullOrEmpty($raw) -or $raw.Trim() -cne $raw) {
+        return $false
+    }
+    $normalized = ConvertTo-CleanupContextPath -Path $raw
+    if ($normalized -notmatch '^([A-Za-z]:/|/(?!/))') {
+        return $false
+    }
+    $segments = @($normalized -split '/')
+    if ($segments -contains '.' -or $segments -contains '..') {
+        return $false
+    }
+    $roots = @($RegisteredRoot | Where-Object { -not [string]::IsNullOrWhiteSpace($_) })
+    $temporary = @($TemporaryRoot | Where-Object { -not [string]::IsNullOrWhiteSpace($_) })
+    if ($roots.Count -eq 0 -or $temporary.Count -eq 0 -or [string]::IsNullOrWhiteSpace($SessionRoot)) {
+        return $false
+    }
+    foreach ($registeredCandidate in $roots) {
+        $normalizedRoot = ConvertTo-CleanupContextPath -Path $registeredCandidate
+        foreach ($temporaryCandidate in $temporary) {
+            if (Test-CleanupContextPathUnder -Path $normalizedRoot -Root $temporaryCandidate) {
+                return $false
+            }
+        }
+        if (Test-CleanupContextPathUnder -Path $normalized -Root $registeredCandidate) {
+            return $false
+        }
+    }
+    if (Test-CleanupContextPathUnder -Path $normalized -Root $SessionRoot) {
+        return $false
+    }
+    foreach ($temporaryCandidate in $temporary) {
+        $normalizedTemporary = ConvertTo-CleanupContextPath -Path $temporaryCandidate
+        if (-not [string]::Equals($normalized, $normalizedTemporary, [System.StringComparison]::OrdinalIgnoreCase) -and
+            (Test-CleanupContextPathUnder -Path $normalized -Root $normalizedTemporary)) {
+            return $true
+        }
+    }
+    return $false
+}
+
+function Test-CleanupConsolidationBranchLabel {
+    <#
+    .SYNOPSIS
+        Return $true when a delegation prompt names the consolidation branch by exactly one label.
+    .DESCRIPTION
+        The prompt must contain exactly one 'branch:' label (case-insensitive count), on its own
+        line in the lowercase form 'branch: <value>', with the value ordinal-equal to
+        documentationandmemories, and no --head or --branch token anywhere, so the worktree
+        resolvers that read the first branch signal cannot select a different branch.
+    .PARAMETER PromptText
+        The delegation prompt.
+    .OUTPUTS
+        System.Boolean
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [AllowNull()][AllowEmptyString()][string] $PromptText
+    )
+
+    $text = [string]$PromptText
+    if ([regex]::Matches($text, '(?i)\bbranch:').Count -ne 1) {
+        return $false
+    }
+    if ([regex]::IsMatch($text, '(?i)(?<![\w-])--(?:head|branch)(?![\w-])')) {
+        return $false
+    }
+    $label = [regex]::Match($text, '(?m)^[ \t]*branch:[ \t]*(?<value>[^\r\n]*?)[ \t]*\r?$')
+    return ($label.Success -and $label.Groups['value'].Value -ceq $script:CleanupContextBranch)
+}

package/resources/claude-customizations/.claude/hooks/validate-feature-review-coverage-rules.ps1

@@ -1,12 +1,14 @@
 <#
 .SYNOPSIS
-    Artifact-path rules, changed-language set, and coverage-row rule for the feature-review coverage hook.
+    Artifact-path rules, changed-language set, narrowing-line reader, and coverage-row rule for the
+    feature-review coverage hook.
 
 .DESCRIPTION
     Dot-sourced by validate-feature-review-coverage.ps1. Defines the advertised-path reader
     (Get-ReviewArtifactPathFromOutput), the active-feature location rule (Get-ReviewArtifactInfo),
-    the changed-language reader for the PR context summary (Get-ChangedLanguageSet), and the
-    per-language coverage-row rule (Test-LanguageCoverageRow).
+    the changed-language reader for the PR context summary (Get-ChangedLanguageSet), the
+    scope-narrowing line reader (Get-CoverageNarrowingLine), and the per-language coverage-row
+    rule (Test-LanguageCoverageRow).
 
     The file has no param() block, writes nothing to the output stream, and runs no top-level
     statement other than function definitions.
@@ -95,6 +97,50 @@ function Get-ChangedLanguageSet {
     return $langs
 }
 
+function Get-CoverageNarrowingLine {
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyString()]
+        [string[]]$Lines,
+
+        [Parameter(Mandatory = $true)]
+        [string]$LabelPattern,
+
+        [Parameter(Mandatory = $true)]
+        [string]$Language
+    )
+
+    # Sanctioned narrowing text is not a scope narrowing by the audit: a line inside a
+    # '## Rejected Scope Narrowing' section (caller text recorded verbatim), and a PowerShell
+    # line naming branch coverage but not line coverage (Pester measures no branch coverage).
+    # The policy-audit template prescribes the no-pre-change-run record in three positions only,
+    # so the record is removed there and stays a narrowing form everywhere else.
+    $narrowingPattern = '(?i)(informational only|context only|out of plan scope|out of scope|not applicable|\bN/A\b|\bUNVERIFIED\b)'
+    $recordPatterns = @(
+        '(?<=(?:\bBaseline|\bbaseline coverage artifact):\s*)N/A - no pre-change run'
+        '(?<=^\s*\|(?:[^|]*\|){4}\s*)N/A - no pre-change run(?=\s*\|)'
+        '(?<!:\s*)`N/A - no pre-change run`'
+    )
+    $insideRejectedSection = $false
+    foreach ($line in $Lines) {
+        if ($line -match '^##\s') { $insideRejectedSection = $line -match '^##\s+Rejected Scope Narrowing\b' }
+        elseif ($insideRejectedSection) { continue }
+        if ($line -notmatch $LabelPattern -or $line -notmatch '(?i)(coverage|lcov|line[s]?\s+hit|pester)') { continue }
+        $reducedLine = $line
+        foreach ($recordPattern in $recordPatterns) { $reducedLine = [regex]::Replace($reducedLine, $recordPattern, '') }
+        # Tested on the original line, because the removals above strip the record it names.
+        if ($line.Contains('Baseline: N/A - no pre-change run')) {
+            $reducedLine = [regex]::Replace($reducedLine, '(?<![\w/-])Change: N/A', '')
+            $reducedLine = $reducedLine.Replace('New/changed-code coverage: N/A - no production file changed', '')
+        }
+        if ($reducedLine -notmatch $narrowingPattern) { continue }
+        if ($Language -eq 'PowerShell' -and $line -match '(?i)\bbranch\b' -and $line -notmatch '(?i)\bline\s+coverage\b') { continue }
+        $line
+    }
+}
+
 function Test-LanguageCoverageRow {
     [OutputType([System.Collections.Hashtable])]
     param(
@@ -141,19 +187,7 @@ function Test-LanguageCoverageRow {
         }
     }
 
-    # Sanctioned narrowing text is not a scope narrowing by the audit: a line inside a
-    # '## Rejected Scope Narrowing' section (caller text recorded verbatim), and a PowerShell
-    # line naming branch coverage but not line coverage (Pester measures no branch coverage).
-    $narrowingPattern = '(?i)(informational only|context only|out of plan scope|out of scope|not applicable|\bN/A\b|\bUNVERIFIED\b)'
-    $insideRejectedSection = $false
-    $narrowing = foreach ($line in $lines) {
-        if ($line -match '^##\s') { $insideRejectedSection = $line -match '^##\s+Rejected Scope Narrowing\b' }
-        elseif ($insideRejectedSection) { continue }
-        if ($line -notmatch $labelPattern -or $line -notmatch '(?i)(coverage|lcov|line[s]?\s+hit|pester)' -or $line -notmatch $narrowingPattern) { continue }
-        if ($Language -eq 'PowerShell' -and $line -match '(?i)\bbranch\b' -and $line -notmatch '(?i)\bline\s+coverage\b') { continue }
-        $line
-    }
-    $narrowing = @($narrowing)
+    $narrowing = @(Get-CoverageNarrowingLine -Lines $lines -LabelPattern $labelPattern -Language $Language)
     if ($narrowing.Count -gt 0) {
         $first = ($narrowing | Select-Object -First 1).ToString().Trim()
         return @{

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

@@ -297,7 +297,8 @@ function Get-OrchestratorStatePrCreationReadinessError {
     .DESCRIPTION
         Private readiness check mirroring validate_orchestrator_state_pr_creation_readiness in
         _orchestrator_state_pr_creation_readiness.py: steps 5-8 must not be pending, blocked, or
-        blocked_remediation_loop_limit; blocked_reason must be `none` or absent; and the
+        blocked_remediation_loop_limit, except a pending step 7 under review_mode concurrent;
+        blocked_reason must be `none` or absent; and the
         local_execution_overrides / delegation_bypasses lists must be empty when present. It does
         not enforce completion, CI, PR, or routing-contract gates.
     .PARAMETER State
@@ -313,11 +314,15 @@ function Get-OrchestratorStatePrCreationReadinessError {
     )
 
     $errors = [System.Collections.Generic.List[string]]::new()
+    $stateNames = @($State.PSObject.Properties | ForEach-Object { $_.Name })
+    $reviewMode = if ($stateNames -ccontains 'review_mode') { (Get-OrchestratorStateField -State $State -Name 'review_mode').Value } else { $null }
 
     # Reject an upstream step recorded as pending, blocked, or blocked_remediation_loop_limit; steps
     # 5-8 must have finished before the first PR of a branch is created.
     foreach ($key in $script:PR_CREATION_READY_STEP_KEYS) {
         $field = Get-OrchestratorStateField -State $State -Name $key
+        # Under review_mode concurrent the review runs beside CI and the merge guard holds the merge.
+        if ($key -ceq 'step7_status' -and $field.Value -ceq 'pending' -and $reviewMode -is [string] -and $reviewMode -ceq 'concurrent') { continue }
         if ($field.Present -and (@('pending', 'blocked', 'blocked_remediation_loop_limit') -contains $field.Value)) {
             $errors.Add("Checkpoint PR-creation readiness validation failed: $key is $($field.Value).")
         }

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

@@ -23,6 +23,7 @@
       C5        mandatory route phases
       C6        the routing contract, from `OrchestratorStateRoutingContract.psm1`
       C7        the preparation terminal contract
+      C8        the review record under review_mode concurrent
       M1        model-routing receipt required once delegated
       M2        a complexity assessment for every matched receipt phase
       M3        per-entry re-validation of the U6.C and U6.M families
@@ -408,8 +409,8 @@ function Test-OrchestratorStateCompletionReadiness {
     $errors.AddRange([string[]]@(Get-OrchestratorStateUnconditionalError -State $state))
 
     # C family, in the reference's require_complete order: step statuses,
-    # blocked_reason, pr_gate, ci_gate, phase completeness, routing contract, and
-    # the preparation terminal contract.
+    # blocked_reason, pr_gate, ci_gate, phase completeness, routing contract, the
+    # preparation terminal contract, and the concurrent review record.
     $errors.AddRange([string[]]@(Get-OrchestratorStateCompletionStepStatusError -State $state))
     $errors.AddRange([string[]]@(Get-OrchestratorStateCompletionBlockedReasonError -State $state))
     $errors.AddRange([string[]]@(Get-OrchestratorStateCompletionPrGateError -State $state))
@@ -417,6 +418,7 @@ function Test-OrchestratorStateCompletionReadiness {
     $errors.AddRange([string[]]@(Get-OrchestratorStatePhaseCompletenessError -State $state))
     $errors.AddRange([string[]]@(Get-OrchestratorStateRoutingContractError -State $state))
     $errors.AddRange([string[]]@(Get-OrchestratorStatePreparationTerminalError -State $state))
+    $errors.AddRange([string[]]@(Get-OrchestratorStateCompletionConcurrentReviewError -State $state))
 
     # M family. The gate's M3 leg re-invokes the U6.C and U6.M validators, so its
     # output is merged under the PD-2 single-emission rule rather than appended

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

@@ -1,6 +1,6 @@
 <#
 .SYNOPSIS
-    Portable completion-gate checks C1, C2, C3, C4, C5, and C7.
+    Portable completion-gate checks C1, C2, C3, C4, C5, C7, and C8.
 
 .DESCRIPTION
     Destination-runtime PowerShell port of the `--require-complete` checks the
@@ -19,6 +19,7 @@
       C5.1  mandatory route phases, from a static map
       C7.1  preparation terminal next_step (value-gated, repr rendering)
       C7.2  preparation terminal step statuses (value-gated, repr rendering)
+      C8    last review outcome under review_mode concurrent (value-gated)
 
     Route gating for C3 and C4 is resolved through
     `OrchestratorStateRoutingMatrix.psm1`, implementing deviation PD-1: the gate
@@ -407,6 +408,53 @@ function Get-OrchestratorStatePreparationTerminalError {
     return $errors.ToArray()
 }
 
+function Get-OrchestratorStateCompletionConcurrentReviewError {
+    <#
+    .SYNOPSIS
+        Return the review-record error under review_mode concurrent (row C8).
+    .DESCRIPTION
+        Mirrors validate_concurrent_review_completion. Only the exact string concurrent
+        activates the check, and only the final review_outcomes element counts. The head
+        error is reported only when the verdict error does not apply. The check does no
+        git work: head currency stays with the merge guard.
+    .PARAMETER State
+        The parsed checkpoint object.
+    .OUTPUTS
+        System.String[] - zero or one error string.
+    #>
+    [CmdletBinding()]
+    [OutputType([string[]])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [psobject] $State
+    )
+
+    $mode = $null
+    if ((Get-CheckpointObjectMemberName -Owner $State) -ccontains 'review_mode') { $mode = (Get-CheckpointObjectMember -Owner $State -Name 'review_mode').Value }
+    if (-not (($mode -is [string]) -and ($mode -ceq 'concurrent'))) {
+        return [string[]]@()
+    }
+
+    # A missing loop, a non-list value, an empty list, and a non-object last entry all
+    # leave $last unset, so each reports the verdict error.
+    $last = $null
+    $loop = (Get-CheckpointObjectMember -Owner $State -Name 'remediation_loop').Value
+    $outcomes = (Get-CheckpointObjectMember -Owner $loop -Name 'review_outcomes').Value
+    if ((Test-CheckpointListValue -Value $outcomes) -and $outcomes.Count -gt 0) {
+        $last = $outcomes[$outcomes.Count - 1]
+    }
+    $verdict = (Get-CheckpointObjectMember -Owner $last -Name 'verdict').Value
+    if (-not (($verdict -is [string]) -and ($verdict -ceq 'PASS'))) {
+        return [string[]]@('Checkpoint completion validation failed: review_mode concurrent requires a last review_outcomes entry with verdict PASS.')
+    }
+
+    $head = (Get-CheckpointObjectMember -Owner $last -Name 'head_sha').Value
+    if (-not (($head -is [string]) -and ($head -cmatch '\A[0-9a-f]{40}([0-9a-f]{24})?\z'))) {
+        return [string[]]@('Checkpoint completion validation failed: review_mode concurrent requires head_sha on the last review_outcomes entry.')
+    }
+    return [string[]]@()
+}
+
 # Each check family is exported individually so the completion entry point can
 # compose them in the Python reference's order; the gate-key helper stays private.
 Export-ModuleMember -Function `
@@ -415,4 +463,5 @@ Export-ModuleMember -Function `
     Get-OrchestratorStateCompletionPrGateError, `
     Get-OrchestratorStateCompletionCiGateError, `
     Get-OrchestratorStatePhaseCompletenessError, `
-    Get-OrchestratorStatePreparationTerminalError
+    Get-OrchestratorStatePreparationTerminalError, `
+    Get-OrchestratorStateCompletionConcurrentReviewError

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

@@ -264,9 +264,12 @@ function Get-RemediationCycleError {
 
     # Invariant 2: an execution status in the blocked set requires the nested
     # preflight to report exactly the cleared status; a missing or non-object
-    # preflight cannot satisfy it.
+    # preflight cannot satisfy it. An exact light cycle runs no preflight and is
+    # checked by invariant 8 instead.
     $executionStatus = (Get-CheckpointObjectMember -Owner $Cycle -Name 'execution_status').Value
-    if ($executionStatus -is [string] -and
+    $remediationPath = (Get-CheckpointObjectMember -Owner $Cycle -Name 'remediation_path').Value
+    $isLightCycle = ($remediationPath -is [string]) -and ([string]$remediationPath -ceq 'light')
+    if (-not $isLightCycle -and $executionStatus -is [string] -and
         ($script:EXECUTION_STATUSES_REQUIRING_CLEAR_PREFLIGHT -contains [string]$executionStatus)) {
         $preflight = (Get-CheckpointObjectMember -Owner $Cycle -Name 'preflight').Value
         $preflightStatus = (Get-CheckpointObjectMember -Owner $preflight -Name 'final_status').Value