@danmoisan/drm-copilot-mcp 0.0.6 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danmoisan/drm-copilot-mcp",
-  "version": "0.0.6",
+  "version": "1.0.0",
   "description": "Stdio MCP server exposing drm-copilot repo-automation tools.",
   "license": "MIT",
   "type": "commonjs",
@@ -35,7 +35,7 @@
   "author": "Dan Moisan",
   "scripts": {
     "build": "node esbuild-mcp-server.cjs",
-    "prepack": "node -e \"const{cpSync}=require('fs');cpSync('../../extensions/drm-copilot/resources','./resources',{recursive:true,force:true})\""
+    "prepack": "node prepack.cjs"
   },
   "overrides": {
     "fast-uri": "^3.1.2",

package/resources/claude-customizations/.claude/hooks/enforce-completion-consistency.ps1

@@ -39,6 +39,11 @@
 [CmdletBinding()]
 param()
 
+# Dot-source the shared validation helpers. Guarded so a missing file produces a
+# clear error and so dot-sourcing this hook in tests loads the helpers too.
+$script:CompletionHelpersPath = Join-Path $PSScriptRoot 'enforce-completion-helpers.ps1'
+. $script:CompletionHelpersPath
+
 function ConvertFrom-CheckpointJson {
     <#
     .SYNOPSIS
@@ -53,6 +58,29 @@ function ConvertFrom-CheckpointJson {
     return $Json | ConvertFrom-Json -ErrorAction Stop
 }
 
+function Get-CheckpointFileContent {
+    <#
+    .SYNOPSIS
+        Reads the on-disk checkpoint content for the read-then-validate Edit path.
+    .DESCRIPTION
+        Returns the full file text when the path resolves to a file on disk, or
+        $null when the file does not exist. Tests inject a CheckpointReader
+        scriptblock instead of mocking this function so no temporary files are
+        required.
+    #>
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter(Mandatory)]
+        [string] $Path
+    )
+
+    if (-not (Test-Path -LiteralPath $Path -PathType Leaf)) {
+        return $null
+    }
+    return Get-Content -LiteralPath $Path -Raw -ErrorAction Stop
+}
+
 function Test-IsCheckpointPath {
     [CmdletBinding()]
     [OutputType([bool])]
@@ -149,7 +177,13 @@ function Get-MissingCompletionEvidence {
     param(
         [Parameter(Mandatory)]
         [AllowNull()]
-        $Payload
+        $Payload,
+
+        [Parameter(Mandatory = $false)]
+        [scriptblock] $FolderExistsCheck = { param($p) Test-Path -LiteralPath $p -PathType Container },
+
+        [Parameter(Mandatory = $false)]
+        [scriptblock] $RoutingMatrixReader
     )
 
     $missing = @()
@@ -158,16 +192,17 @@ function Get-MissingCompletionEvidence {
     if (-not $issueNum -and $null -ne $Payload -and ($Payload.PSObject.Properties.Name -contains 'variables')) {
         $issueNum = Get-CheckpointStringValue -Payload $Payload.variables -Name 'issue-num'
     }
-    if (-not $issueNum) {
-        $missing += 'issue-num'
+    if (-not (Test-IsValidIssueNum -Value $issueNum)) {
+        # Name the offending value so sentinel/placeholder inputs are explicit.
+        $missing += "issue-num value '$issueNum' is not a valid issue number (must be digits-only)"
     }
 
     $featureFolder = Get-CheckpointStringValue -Payload $Payload -Name 'feature-folder'
     if (-not $featureFolder -and $null -ne $Payload -and ($Payload.PSObject.Properties.Name -contains 'variables')) {
         $featureFolder = Get-CheckpointStringValue -Payload $Payload.variables -Name 'feature-folder'
     }
-    if (-not $featureFolder) {
-        $missing += 'feature-folder'
+    if (-not (Test-IsValidFeatureFolder -Value $featureFolder -FolderExistsCheck $FolderExistsCheck)) {
+        $missing += "feature-folder value '$featureFolder' is not a valid feature folder (must be under docs/features/active/ and exist)"
     }
 
     $ciGate = $null
@@ -188,7 +223,14 @@ function Get-MissingCompletionEvidence {
         }
     }
 
-    if ($issueNum -eq '232') {
+    # PR-gate evidence is required only when the checkpoint's selected route
+    # opts into it via requires_pr_gate in the routing matrix. This replaces the
+    # former issue-number special-casing with route-driven enforcement.
+    $prGateArgs = @{ Payload = $Payload }
+    if ($PSBoundParameters.ContainsKey('RoutingMatrixReader') -and $null -ne $RoutingMatrixReader) {
+        $prGateArgs['RoutingMatrixReader'] = $RoutingMatrixReader
+    }
+    if (Test-RouteRequiresPrGate @prGateArgs) {
         $prGate = $null
         if ($null -ne $Payload -and ($Payload.PSObject.Properties.Name -contains 'pr_gate')) {
             $prGate = $Payload.pr_gate
@@ -213,6 +255,60 @@ function Get-MissingCompletionEvidence {
     return [string[]]$missing
 }
 
+function Resolve-EditedCheckpointContent {
+    <#
+    .SYNOPSIS
+        Returns the patched checkpoint content for an Edit-tool call, or $null
+        when the patch cannot be applied against the on-disk checkpoint.
+    .DESCRIPTION
+        Implements the read-then-validate Edit path. When the tool input carries
+        an old_string (an Edit patch), the on-disk checkpoint is read through the
+        injectable CheckpointReader seam and the old_string -> new_string
+        replacement is applied in memory (no on-disk mutation). Returns $null
+        when there is no old_string, the on-disk file does not exist, or the
+        old_string is not present in the on-disk content, signalling the caller
+        to allow (defer).
+    #>
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter(Mandatory)]
+        [AllowNull()]
+        $ToolInput,
+
+        [Parameter(Mandatory)]
+        [scriptblock] $CheckpointReader
+    )
+
+    $oldString = $null
+    if ($null -ne $ToolInput -and ($ToolInput.PSObject.Properties.Name -contains 'old_string')) {
+        $oldString = [string]$ToolInput.old_string
+    }
+    if ([string]::IsNullOrEmpty($oldString)) {
+        return $null
+    }
+
+    $newString = ''
+    if ($ToolInput.PSObject.Properties.Name -contains 'new_string') {
+        $newString = [string]$ToolInput.new_string
+    }
+
+    $onDisk = & $CheckpointReader 'artifacts/orchestration/orchestrator-state.json'
+    if ([string]::IsNullOrEmpty([string]$onDisk)) {
+        # The on-disk checkpoint does not exist (or is empty); cannot patch.
+        return $null
+    }
+
+    $onDiskText = [string]$onDisk
+    if (-not $onDiskText.Contains($oldString)) {
+        # The old_string is not present, so the patch does not apply here.
+        return $null
+    }
+
+    # Apply the patch in memory using a literal (non-regex) replacement.
+    return $onDiskText.Replace($oldString, $newString)
+}
+
 function Invoke-CompletionConsistencyDecision {
     <#
     .SYNOPSIS
@@ -222,7 +318,16 @@ function Invoke-CompletionConsistencyDecision {
     [CmdletBinding()]
     [OutputType([System.Collections.Specialized.OrderedDictionary])]
     param(
-        [string] $ToolInputRaw
+        [string] $ToolInputRaw,
+
+        [Parameter(Mandatory = $false)]
+        [scriptblock] $FolderExistsCheck = { param($p) Test-Path -LiteralPath $p -PathType Container },
+
+        [Parameter(Mandatory = $false)]
+        [scriptblock] $CheckpointReader = { param($Path) Get-CheckpointFileContent -Path $Path },
+
+        [Parameter(Mandatory = $false)]
+        [scriptblock] $RoutingMatrixReader
     )
 
     if (-not $ToolInputRaw) {
@@ -246,11 +351,17 @@ function Invoke-CompletionConsistencyDecision {
         return [ordered]@{ decision = 'allow' }
     }
 
-    # Write tool: validate the content payload. Edit tool: partial new_string is
-    # not reliable without the full target file content, so allow.
+    # Write tool: validate the content payload directly. Edit tool: no content is
+    # supplied, so read the on-disk checkpoint through the injectable seam and
+    # apply the old_string -> new_string patch in memory (read-then-validate).
     $content = $toolInput.content
     if (-not $content) {
-        return [ordered]@{ decision = 'allow' }
+        $content = Resolve-EditedCheckpointContent -ToolInput $toolInput -CheckpointReader $CheckpointReader
+        if (-not $content) {
+            # No content, and the Edit could not be resolved against on-disk
+            # state (missing file or non-matching patch): defer and allow.
+            return [ordered]@{ decision = 'allow' }
+        }
     }
 
     try {
@@ -266,19 +377,18 @@ function Invoke-CompletionConsistencyDecision {
         return [ordered]@{ decision = 'allow' }
     }
 
-    $missing = Get-MissingCompletionEvidence -Payload $payload
+    $missingArgs = @{ Payload = $payload; FolderExistsCheck = $FolderExistsCheck }
+    if ($PSBoundParameters.ContainsKey('RoutingMatrixReader') -and $null -ne $RoutingMatrixReader) {
+        $missingArgs['RoutingMatrixReader'] = $RoutingMatrixReader
+    }
+    $missing = Get-MissingCompletionEvidence @missingArgs
     if ($missing.Count -eq 0) {
         return [ordered]@{ decision = 'allow' }
     }
 
-    $issueContext = ''
-    if ((Get-CheckpointStringValue -Payload $payload -Name 'issue-num') -eq '232') {
-        $issueContext = ' Issue #232 requires pr_gate evidence and current-head ci_gate evidence.'
-    }
-
     return [ordered]@{
         decision = 'block'
-        reason   = "COMPLETION_CONSISTENCY_BLOCKED: the checkpoint asserts completion but is missing required completion evidence: $($missing -join ', ').$issueContext A completion-asserting checkpoint must include a non-empty issue-num, a non-empty feature-folder, and a ci_gate object with conclusion == 'success' and a non-empty head_sha. Supply the missing evidence or remove the completion assertion."
+        reason   = "COMPLETION_CONSISTENCY_BLOCKED: the checkpoint asserts completion but is missing required completion evidence: $($missing -join ', '). A completion-asserting checkpoint must include a non-empty issue-num, a non-empty feature-folder, and a ci_gate object with conclusion == 'success' and a non-empty head_sha; routes whose requires_pr_gate is true must also include pr_gate evidence with a matching head_sha. Supply the missing evidence or remove the completion assertion."
     }
 }
 

package/resources/claude-customizations/.claude/hooks/enforce-completion-helpers.ps1

@@ -0,0 +1,163 @@
+<#
+.SYNOPSIS
+    Dot-sourced helper functions for enforce-completion-consistency.ps1.
+
+.DESCRIPTION
+    Provides testable validation helpers used by the completion-consistency
+    PreToolUse hook:
+
+      - Test-IsValidIssueNum: rejects sentinel/placeholder and non-digit issue
+        numbers; accepts digits-only strings.
+      - Test-IsValidFeatureFolder: rejects sentinel/placeholder feature folders
+        and folders not anchored under docs/features/active/<segment>; optionally
+        verifies on-disk existence through an injectable scriptblock seam.
+
+    This script is dot-sourced by enforce-completion-consistency.ps1. It contains
+    no entrypoint logic, so dot-sourcing it in tests has no side effects.
+
+.NOTES
+    Compatible with PowerShell 7+.
+#>
+[CmdletBinding()]
+param()
+
+# Sentinel/placeholder values that must never satisfy a presence check.
+$script:CompletionEvidenceSentinels = @('n/a', 'none', 'tbd')
+
+function Test-IsValidIssueNum {
+    <#
+    .SYNOPSIS
+        Returns $true only for a digits-only issue number.
+    .DESCRIPTION
+        Returns $false when the value is empty, whitespace-only, a sentinel
+        (n/a, none, tbd; case-insensitive), or contains any non-digit character.
+        Returns $true only when the trimmed value matches ^\d+$.
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [AllowEmptyString()]
+        [string] $Value
+    )
+
+    if ([string]::IsNullOrWhiteSpace($Value)) {
+        return $false
+    }
+    $trimmed = $Value.Trim()
+    # Sentinel placeholders are explicitly rejected even though they are
+    # non-empty strings; the comparison is case-insensitive.
+    if ($script:CompletionEvidenceSentinels -contains $trimmed.ToLowerInvariant()) {
+        return $false
+    }
+    return $trimmed -match '^\d+$'
+}
+
+function Test-IsValidFeatureFolder {
+    <#
+    .SYNOPSIS
+        Returns $true only for a sentinel-free feature folder anchored under
+        docs/features/active/ with a non-empty trailing segment that exists.
+    .DESCRIPTION
+        Returns $false when the value is empty, whitespace-only, or a sentinel
+        (n/a, none, tbd; case-insensitive). Requires the value to start with
+        'docs/features/active/' and to carry at least one additional non-empty
+        path segment after that prefix. Invokes the injectable FolderExistsCheck
+        scriptblock (default Test-Path -PathType Container) and returns $false
+        when it reports the folder does not exist.
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [AllowNull()]
+        [AllowEmptyString()]
+        [string] $Value,
+
+        [Parameter(Mandatory = $false)]
+        [scriptblock] $FolderExistsCheck = { param($p) Test-Path -LiteralPath $p -PathType Container }
+    )
+
+    if ([string]::IsNullOrWhiteSpace($Value)) {
+        return $false
+    }
+    $trimmed = $Value.Trim()
+    if ($script:CompletionEvidenceSentinels -contains $trimmed.ToLowerInvariant()) {
+        return $false
+    }
+
+    $prefix = 'docs/features/active/'
+    $normalized = $trimmed -replace '\\', '/'
+    if (-not $normalized.StartsWith($prefix)) {
+        return $false
+    }
+
+    # Require a non-empty segment after the active/ prefix so the bare prefix is
+    # not accepted as a valid folder.
+    $suffix = $normalized.Substring($prefix.Length).TrimEnd('/')
+    if ([string]::IsNullOrWhiteSpace($suffix)) {
+        return $false
+    }
+
+    return [bool](& $FolderExistsCheck $normalized)
+}
+
+function Test-RouteRequiresPrGate {
+    <#
+    .SYNOPSIS
+        Returns $true when the payload's selected route opts into the PR gate.
+    .DESCRIPTION
+        Resolves the route id from the payload (route_id, falling back to
+        path_selected), looks it up in the routing matrix returned by the
+        injectable RoutingMatrixReader seam, and returns $true only when that
+        route's requires_pr_gate value is the boolean $true. A missing route id,
+        an unknown route, a matrix without routes, or a missing/false
+        requires_pr_gate returns $false. This generalizes the former issue-232
+        special-casing into a route-driven check.
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [Parameter(Mandatory)]
+        [AllowNull()]
+        $Payload,
+
+        [Parameter(Mandatory = $false)]
+        [scriptblock] $RoutingMatrixReader = {
+            $configPath = Join-Path $PSScriptRoot '../../config/orchestration-routing.json'
+            if (-not (Test-Path -LiteralPath $configPath)) { return $null }
+            Get-Content -LiteralPath $configPath -Raw | ConvertFrom-Json
+        }
+    )
+
+    if ($null -eq $Payload) {
+        return $false
+    }
+
+    # Resolve the selected route id, preferring route_id over path_selected.
+    $routeId = ''
+    if ($Payload.PSObject.Properties.Name -contains 'route_id') {
+        $routeId = ([string]$Payload.route_id).Trim()
+    }
+    if (-not $routeId -and ($Payload.PSObject.Properties.Name -contains 'path_selected')) {
+        $routeId = ([string]$Payload.path_selected).Trim()
+    }
+    if (-not $routeId) {
+        return $false
+    }
+
+    $matrix = & $RoutingMatrixReader
+    if ($null -eq $matrix -or -not ($matrix.PSObject.Properties.Name -contains 'routes')) {
+        return $false
+    }
+    $routes = $matrix.routes
+    if ($null -eq $routes -or -not ($routes.PSObject.Properties.Name -contains $routeId)) {
+        return $false
+    }
+    $route = $routes.$routeId
+    if ($null -eq $route -or -not ($route.PSObject.Properties.Name -contains 'requires_pr_gate')) {
+        return $false
+    }
+    return ([bool]$route.requires_pr_gate -eq $true)
+}

package/resources/claude-customizations/.claude/hooks/enforce-orchestration-preimplementation-gate.ps1

@@ -6,7 +6,6 @@
 param()
 
 $script:CheckpointPath = 'artifacts/orchestration/orchestrator-state.json'
-$script:Issue232FeatureFolder = 'docs/features/active/2026-06-24-harden-orchestrate-skill-232'
 
 function ConvertFrom-CheckpointJson {
     [CmdletBinding()]
@@ -113,10 +112,6 @@ function Test-OrchestrationReady {
         return $false
     }
 
-    if ($issueNum -eq '232' -and $featureFolder -ne $script:Issue232FeatureFolder) {
-        return $false
-    }
-
     return (
         $featureFolder.StartsWith('docs/features/active/') -and
         $routeId -and
@@ -182,13 +177,6 @@ function Invoke-OrchestrationPreimplementationGateDecision {
     if (Test-OrchestrationReady -Payload $checkpoint) {
         return [ordered]@{ decision = 'allow' }
     }
-    $issueNum = Get-StringProperty -Value $checkpoint -Name 'issue-num'
-    if ($issueNum -eq '232') {
-        return [ordered]@{
-            decision = 'block'
-            reason   = 'PREIMPLEMENTATION_GATE_BLOCKED: Issue #232 implementation operations require artifacts/orchestration/orchestrator-state.json to contain route metadata, lifecycle readiness, and checkpoint state before implementation begins.'
-        }
-    }
     return [ordered]@{
         decision = 'block'
         reason   = 'PREIMPLEMENTATION_GATE_BLOCKED: Implementation operations require artifacts/orchestration/orchestrator-state.json to contain issue number, feature folder, route metadata, lifecycle readiness, and checkpoint state before implementation begins.'

package/resources/claude-customizations/.claude/hooks/validate-orchestrator-output.ps1

@@ -141,6 +141,58 @@ function Test-HumanInteractionShape {
     return @{ Ok = $true; Message = $null }
 }
 
+function Invoke-RoutingContractValidation {
+    <#
+    .SYNOPSIS
+        Runs the authoritative Python routing-contract validator against the
+        on-disk checkpoint and reports whether it emitted errors.
+    .DESCRIPTION
+        Invokes the validator through an injectable subprocess scriptblock seam.
+        The default Invoker runs the authoritative Python CLI:
+          python -m scripts.dev_tools.validate_orchestration_artifacts \
+              orchestrator-state <CheckpointPath> --require-complete
+        Tests inject a mock scriptblock so no Python process runs. The function
+        does not reimplement routing logic; it delegates to the Python validator.
+
+        Returns a hashtable with keys:
+          - HasErrors:  $true when the validator reported a non-zero exit or
+                        produced any error text; $false when clean.
+          - ErrorText:  the validator's combined output text (empty on success).
+    #>
+    [CmdletBinding()]
+    [OutputType([hashtable])]
+    param(
+        [Parameter(Mandatory = $true)]
+        [string] $CheckpointPath,
+
+        [Parameter(Mandatory = $false)]
+        [scriptblock] $Invoker = {
+            param($Path)
+            $output = & python -m scripts.dev_tools.validate_orchestration_artifacts `
+                orchestrator-state $Path --require-complete 2>&1
+            [pscustomobject]@{
+                ExitCode = $LASTEXITCODE
+                Output   = ($output | Out-String)
+            }
+        }
+    )
+
+    $result = & $Invoker $CheckpointPath
+    $exitCode = 0
+    if ($null -ne $result -and ($result.PSObject.Properties.Name -contains 'ExitCode')) {
+        $exitCode = [int]$result.ExitCode
+    }
+    $outputText = ''
+    if ($null -ne $result -and ($result.PSObject.Properties.Name -contains 'Output')) {
+        $outputText = ([string]$result.Output).Trim()
+    }
+
+    # The validator signals a routing-contract failure either through a non-zero
+    # exit code or through emitted error text; either condition blocks DONE.
+    $hasErrors = ($exitCode -ne 0) -or (-not [string]::IsNullOrWhiteSpace($outputText))
+    return @{ HasErrors = $hasErrors; ErrorText = $outputText }
+}
+
 function Invoke-OrchestratorOutputValidation {
     <#
     .SYNOPSIS
@@ -154,7 +206,10 @@ function Invoke-OrchestratorOutputValidation {
     [OutputType([hashtable])]
     param(
         [string] $RawPayload,
-        [string] $CheckpointPath = 'artifacts/orchestration/orchestrator-state.json'
+        [string] $CheckpointPath = 'artifacts/orchestration/orchestrator-state.json',
+
+        [Parameter(Mandatory = $false)]
+        [scriptblock] $RoutingInvoker
     )
 
     if ([string]::IsNullOrWhiteSpace($RawPayload)) {
@@ -217,6 +272,18 @@ function Invoke-OrchestratorOutputValidation {
         return @{ Ok = $false; Message = $hiResult.Message }
     }
 
+    # Delegate to the authoritative Python routing-contract validator. The
+    # optional RoutingInvoker seam lets tests inject a mock; the default seam
+    # produces the real subprocess call.
+    $routingArgs = @{ CheckpointPath = $CheckpointPath }
+    if ($PSBoundParameters.ContainsKey('RoutingInvoker') -and $null -ne $RoutingInvoker) {
+        $routingArgs['Invoker'] = $RoutingInvoker
+    }
+    $routingResult = Invoke-RoutingContractValidation @routingArgs
+    if ($routingResult.HasErrors) {
+        return @{ Ok = $false; Message = "ROUTING_CONTRACT_BLOCKED: $($routingResult.ErrorText)" }
+    }
+
     return @{ Ok = $true; Message = $null }
 }
 

package/resources/config/orchestration-routing.json

@@ -27,13 +27,14 @@
     },
     "large": {
       "description": "Full feature or bug path for work outside small-path budget.",
+      "requires_pr_gate": true,
       "required_agents": [
         "task-researcher",
         "prd-feature",
         "atomic-planner",
         "atomic-executor",
-        "feature-reviewer",
-        "commit-steward"
+        "feature-review",
+        "pr-author"
       ],
       "required_skills": [
         "orchestrate",
@@ -49,7 +50,6 @@
         "new_potential_entry",
         "potential_to_issue",
         "new_active_feature_folder",
-        "collect_commit_context",
         "collect_pr_context",
         "validate_orchestration_artifacts"
       ]

package/resources/codex-and-agents-customizations/.codex/scripts/post-codex-worktree-session.ps1

@@ -1,5 +0,0 @@
-[CmdletBinding()]
-param()
-
-Set-StrictMode -Version Latest
-$ErrorActionPreference = 'Stop'

package/resources/scripts/dev_tools/_orchestrator_state_human_interaction.py

@@ -1,127 +0,0 @@
-"""Human-interaction invariants for orchestrator-state checkpoints.
-
-Purpose:
-    Hold the optional ``human_interaction`` block constants and the
-    ``_validate_human_interaction`` helper so the primary validator module
-    (`scripts.dev_tools.validate_orchestrator_state`) can stay within the
-    repository's 500-line file limit while preserving the existing validator
-    contract.
-
-Usage:
-    Import ``HUMAN_INTERACTION_KEY`` and ``_validate_human_interaction`` from
-    this module. The primary validator re-exports both symbols so existing
-    callers and tests continue to resolve them from
-    ``scripts.dev_tools.validate_orchestrator_state`` unchanged.
-
-Invariants / Constraints:
-    - The three permitted ``response`` values are ``scope_change``,
-      ``exception``, and ``halt``.
-    - An ``exception`` response requires a non-empty ``runbook_path`` string.
-    - The validator never imports ``schemas/orchestrator-state.schema.json``;
-      the invariants are expressed directly here per
-      `.claude/rules/orchestrator-state.md`.
-
-Side Effects:
-    None.
-"""
-
-from __future__ import annotations
-
-from typing import Any, cast
-
-# Declare the module's intended exported surface. Listing ``_validate_human_
-# interaction`` here marks it as a deliberate re-export consumed by
-# ``validate_orchestrator_state``, so static analysis does not flag the helper
-# as unused locally or as private-usage when imported across the module boundary.
-__all__ = [
-    "HUMAN_INTERACTION_KEY",
-    "HUMAN_INTERACTION_REQUIREMENTS_KEY",
-    "HUMAN_INTERACTION_RESPONSE_ENUM",
-    "HUMAN_INTERACTION_EXCEPTION_RESPONSE",
-    "_validate_human_interaction",
-]
-
-HUMAN_INTERACTION_KEY = "human_interaction"
-HUMAN_INTERACTION_REQUIREMENTS_KEY = "requirements"
-# The three permitted responses for an unautomatable requirement under the
-# autonomous-execution mandate (see `.claude/skills/orchestrate/SKILL.md`).
-HUMAN_INTERACTION_RESPONSE_ENUM = {"scope_change", "exception", "halt"}
-HUMAN_INTERACTION_EXCEPTION_RESPONSE = "exception"
-
-
-def _validate_human_interaction(human_interaction: object) -> list[str]:
-    """Validate the optional ``human_interaction`` block invariants.
-
-    Purpose:
-        Apply the autonomous-execution mandate invariants to the checkpoint's
-        optional top-level ``human_interaction`` object, mirroring the schema
-        invariants documented in `.claude/rules/orchestrator-state.md`. The
-        validator never imports `schemas/orchestrator-state.schema.json`; the
-        invariants are expressed directly here in the existing helper-plus-
-        error-list style.
-
-    Args:
-        human_interaction (object): The raw value of the checkpoint's top-level
-            ``human_interaction`` key. Callers invoke this helper only when the
-            key is present, so a non-object value is itself a malformed block.
-
-    Returns:
-        list[str]: One error string per violated invariant; an empty list when
-        the block is well-formed. The three invariants are: ``requirements`` is
-        present and is a list; each requirement is an object whose ``response``
-        is within the permitted enum; a requirement whose ``response`` is
-        ``exception`` carries a non-empty ``runbook_path`` string.
-
-    Raises:
-        None.
-
-    Side Effects:
-        None.
-    """
-
-    errors: list[str] = []
-
-    # A non-object human_interaction cannot carry a requirements list; the key
-    # was present, so this is a malformed block rather than an absent one.
-    if not isinstance(human_interaction, dict):
-        errors.append("Checkpoint human_interaction must be an object when present.")
-        return errors
-    human_interaction_map = cast("dict[str, Any]", human_interaction)
-
-    # Invariant 1: requirements must be present and a list.
-    requirements = human_interaction_map.get(HUMAN_INTERACTION_REQUIREMENTS_KEY)
-    if not isinstance(requirements, list):
-        errors.append("Checkpoint human_interaction.requirements must be a list.")
-        return errors
-    requirement_list = cast("list[object]", requirements)
-
-    # Validate each requirement independently so callers receive a complete
-    # error list instead of stopping at the first malformed requirement.
-    for index, requirement in enumerate(requirement_list):
-        if not isinstance(requirement, dict):
-            errors.append(
-                f"Checkpoint human_interaction.requirements #{index} must be an "
-                "object."
-            )
-            continue
-        requirement_map = cast("dict[str, Any]", requirement)
-
-        # Invariant 2: response must be within the permitted enum.
-        response = requirement_map.get("response")
-        if response not in HUMAN_INTERACTION_RESPONSE_ENUM:
-            errors.append(
-                f"Checkpoint human_interaction.requirements #{index} response "
-                f"must be one of scope_change, exception, halt; got: {response}"
-            )
-            continue
-
-        # Invariant 3: an exception response requires a non-empty runbook_path.
-        if response == HUMAN_INTERACTION_EXCEPTION_RESPONSE:
-            runbook_path = requirement_map.get("runbook_path")
-            if not isinstance(runbook_path, str) or not runbook_path.strip():
-                errors.append(
-                    f"Checkpoint human_interaction.requirements #{index} "
-                    "response is exception but runbook_path is missing or empty."
-                )
-
-    return errors