@danmoisan/drm-copilot-mcp 0.0.1

package/resources/codex-and-agents-customizations/.codex/hooks/enforce-python-batch-budget.ps1

@@ -0,0 +1,238 @@
+# Converted hook
+# Review the generated hook behavior before enabling it.
+
+<#
+.SYNOPSIS
+    Pre-tool-use hook that enforces the Python per-batch change budget.
+
+.DESCRIPTION
+    This script is invoked by the Claude Code PreToolUse hook before any Write or Edit
+    operation. When the target file is a Python file, it classifies the file as either
+    production or test and checks the running count against the per-batch cap:
+      - 3 production .py files per batch
+      - 3 test .py files per batch
+
+    A "batch" is scoped to the current Claude Code session. The running count is
+    persisted under .claude/state/python-batch-budget.<session_id>.json. Only distinct
+    file paths are counted; repeated edits to the same file consume one slot.
+
+    Test files are those matching:
+      - tests/**/*.py
+      - test_*.py
+
+    All other .py files are treated as production files. Non-Python paths pass through.
+
+    The cap may be overridden per session by setting the environment variable
+    CLAUDE_PYTHON_BUDGET_PROD or CLAUDE_PYTHON_BUDGET_TEST to a positive integer before
+    the session starts, or by writing {"prodCap": N, "testCap": M} into the state file.
+
+    When the cap would be exceeded by a new file, the script emits a JSON response with
+    'decision': 'block' and exits 0. The session must explicitly reset the counter by
+    deleting the state file before starting a new batch. Files already counted are
+    always allowed through.
+
+.NOTES
+    Compatible with PowerShell 7+.
+#>
+[CmdletBinding()]
+param()
+
+function Get-PythonBatchBudgetState {
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param(
+        [Parameter(Mandatory)]
+        [int] $ProdCap,
+
+        [Parameter(Mandatory)]
+        [int] $TestCap
+    )
+
+    [ordered]@{
+        prodCap   = $ProdCap
+        testCap   = $TestCap
+        prodFiles = @()
+        testFiles = @()
+    }
+}
+
+function ConvertTo-PythonBatchBudgetState {
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param(
+        [Parameter(Mandatory)]
+        $InputObject,
+
+        [Parameter(Mandatory)]
+        [int] $ProdCap,
+
+        [Parameter(Mandatory)]
+        [int] $TestCap
+    )
+
+    $state = Get-PythonBatchBudgetState -ProdCap $ProdCap -TestCap $TestCap
+    if ($null -ne $InputObject.prodCap) { $state.prodCap = [int]$InputObject.prodCap }
+    if ($null -ne $InputObject.testCap) { $state.testCap = [int]$InputObject.testCap }
+    if ($null -ne $InputObject.prodFiles) { $state.prodFiles = @($InputObject.prodFiles) }
+    if ($null -ne $InputObject.testFiles) { $state.testFiles = @($InputObject.testFiles) }
+
+    return $state
+}
+
+function Get-PythonBatchBudgetBlockDecision {
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param(
+        [Parameter(Mandatory)]
+        [string] $Reason,
+
+        [System.Collections.IDictionary] $State
+    )
+
+    $decision = [ordered]@{
+        decision = 'block'
+        reason   = $Reason
+    }
+    if ($State) {
+        $decision.state = $State
+    }
+
+    return $decision
+}
+
+function Invoke-PythonBatchBudgetDecision {
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param(
+        [Parameter(Mandatory)]
+        [string] $FilePath,
+
+        [Parameter(Mandatory)]
+        [System.Collections.IDictionary] $State,
+
+        [Parameter(Mandatory)]
+        [string] $StateFile
+    )
+
+    $normalized = $FilePath -replace '\\', '/'
+    if ($normalized -notmatch '\.py$') {
+        return [ordered]@{ decision = 'allow'; state = $State; shouldWriteState = $false }
+    }
+
+    $isTestFile = ($normalized -match '(^|/)tests/.*\.py$') -or ($normalized -match '(^|/)test_[^/]+\.py$')
+    $targetList = if ($isTestFile) { @($State.testFiles) } else { @($State.prodFiles) }
+    $cap = if ($isTestFile) { [int]$State.testCap } else { [int]$State.prodCap }
+    $kind = if ($isTestFile) { 'test' } else { 'production' }
+
+    if ($targetList -contains $normalized) {
+        return [ordered]@{ decision = 'allow'; state = $State; shouldWriteState = $false }
+    }
+
+    if ($targetList.Count -ge $cap) {
+        $currentFiles = ($targetList -join ', ')
+        $kindUpper = $kind.ToUpperInvariant()
+        $reason = "Python per-batch budget exceeded: $kind file cap is $cap and is already full ($currentFiles). Requested new file: $normalized. Split the work into a new batch, raise the cap via CLAUDE_PYTHON_BUDGET_$kindUpper environment variable with approved scope, or reset the batch by deleting $StateFile."
+        return Get-PythonBatchBudgetBlockDecision -Reason $reason -State $State
+    }
+
+    if ($isTestFile) {
+        $State.testFiles = @($State.testFiles) + @($normalized)
+    } else {
+        $State.prodFiles = @($State.prodFiles) + @($normalized)
+    }
+
+    return [ordered]@{ decision = 'allow'; state = $State; shouldWriteState = $true }
+}
+
+function Invoke-PythonBatchBudgetHook {
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param(
+        [string] $ToolInputRaw,
+        [string] $SessionId = 'default',
+        [string] $Root = (Get-Location).Path,
+        [int] $ProdCap = 3,
+        [int] $TestCap = 3,
+        [scriptblock] $TestPathExists = { param([string] $Path) Test-Path -Path $Path },
+        [scriptblock] $EnsureDirectory = { param([string] $Path) New-Item -ItemType Directory -Path $Path -Force | Out-Null },
+        [scriptblock] $ReadState = { param([string] $Path) Get-Content -Path $Path -Raw },
+        [scriptblock] $WriteState = {
+            param([string] $Path, [System.Collections.IDictionary] $State)
+            $State | ConvertTo-Json -Depth 5 | Set-Content -Path $Path -Encoding UTF8
+        }
+    )
+
+    if (-not $ToolInputRaw) {
+        return [ordered]@{ decision = 'allow' }
+    }
+
+    try {
+        $toolInput = $ToolInputRaw | ConvertFrom-Json -ErrorAction Stop
+    } catch {
+        return Get-PythonBatchBudgetBlockDecision -Reason 'Python batch-budget hook received malformed JSON in CLAUDE_TOOL_INPUT.'
+    }
+
+    $filePath = $toolInput.file_path
+    if (-not $filePath) {
+        return [ordered]@{ decision = 'allow' }
+    }
+
+    $normalized = $filePath -replace '\\', '/'
+    if ($normalized -notmatch '\.py$') {
+        return [ordered]@{ decision = 'allow' }
+    }
+
+    $stateDir = Join-Path -Path $Root -ChildPath '.claude/state'
+    if (-not (& $TestPathExists $stateDir)) {
+        & $EnsureDirectory $stateDir
+    }
+
+    $stateFile = Join-Path -Path $stateDir -ChildPath ("python-batch-budget.$SessionId.json")
+    $state = Get-PythonBatchBudgetState -ProdCap $ProdCap -TestCap $TestCap
+
+    if (& $TestPathExists $stateFile) {
+        try {
+            $loaded = & $ReadState $stateFile | ConvertFrom-Json -ErrorAction Stop
+            $state = ConvertTo-PythonBatchBudgetState -InputObject $loaded -ProdCap $ProdCap -TestCap $TestCap
+        } catch {
+            Write-Verbose "Ignoring unreadable Python batch-budget state file '$stateFile': $($_.Exception.Message)"
+        }
+    }
+
+    $decision = Invoke-PythonBatchBudgetDecision -FilePath $filePath -State $state -StateFile $stateFile
+    if ($decision.shouldWriteState) {
+        try {
+            & $WriteState $stateFile $decision.state
+        } catch {
+            Write-Verbose "Unable to write Python batch-budget state file '$stateFile': $($_.Exception.Message)"
+        }
+    }
+
+    return $decision
+}
+
+if ($MyInvocation.InvocationName -eq '.') {
+    return
+}
+
+$sessionId = $env:CLAUDE_SESSION_ID
+if (-not $sessionId) {
+    $sessionId = 'default'
+}
+
+$prodCap = 3
+$testCap = 3
+if ($env:CLAUDE_PYTHON_BUDGET_PROD -match '^\d+$') {
+    $prodCap = [int]$env:CLAUDE_PYTHON_BUDGET_PROD
+}
+if ($env:CLAUDE_PYTHON_BUDGET_TEST -match '^\d+$') {
+    $testCap = [int]$env:CLAUDE_PYTHON_BUDGET_TEST
+}
+
+$decision = Invoke-PythonBatchBudgetHook -ToolInputRaw $env:CLAUDE_TOOL_INPUT -SessionId $sessionId -ProdCap $prodCap -TestCap $testCap
+if ($decision.decision -eq 'block') {
+    $decision.Remove('state')
+    $decision | ConvertTo-Json -Compress | Write-Output
+}
+
+exit 0

package/resources/codex-and-agents-customizations/.codex/hooks/validate-bash.ps1

@@ -0,0 +1,72 @@
+# Converted hook
+# Review the generated hook behavior before enabling it.
+
+<#
+.SYNOPSIS
+    Pre-tool-use hook for Claude Code that blocks dangerous Bash commands.
+
+.DESCRIPTION
+    This script is invoked by the Claude Code PreToolUse hook before any Bash
+    command is executed. It reads the proposed command string from the
+    CLAUDE_TOOL_INPUT environment variable (JSON with a 'command' field) or
+    falls back to the first positional argument. If the command matches any
+    blocked pattern (destructive operations such as forced deletions, forced
+    pushes, or hard resets), the script exits with code 1 to prevent execution.
+    Safe commands exit with code 0.
+
+.NOTES
+    Compatible with PowerShell 7+.
+    This script must not modify any state; it is a read-only validation gate.
+#>
+[CmdletBinding()]
+param(
+    [Parameter(Position = 0, Mandatory = $false)]
+    [string]$CommandInput
+)
+
+# Blocked patterns that represent destructive or irreversible operations.
+$blockedPatterns = @(
+    'rm -rf',
+    'git push --force',
+    'git push origin --force',
+    'Remove-Item -Recurse -Force',
+    'git reset --hard',
+    'git push -f'
+)
+
+# Resolve the command string from CLAUDE_TOOL_INPUT JSON or positional argument.
+$commandToCheck = ''
+
+if ($env:CLAUDE_TOOL_INPUT) {
+    try {
+        $parsed = $env:CLAUDE_TOOL_INPUT | ConvertFrom-Json
+        if ($parsed.command) {
+            $commandToCheck = $parsed.command
+        }
+    }
+    catch {
+        # If JSON parsing fails, treat the raw environment variable as the command.
+        $commandToCheck = $env:CLAUDE_TOOL_INPUT
+    }
+}
+
+# Fall back to positional argument when the environment variable is absent or empty.
+if (-not $commandToCheck -and $CommandInput) {
+    $commandToCheck = $CommandInput
+}
+
+# When no command is provided, allow execution (nothing to validate).
+if (-not $commandToCheck) {
+    exit 0
+}
+
+# Check the command against each blocked pattern.
+foreach ($pattern in $blockedPatterns) {
+    if ($commandToCheck.Contains($pattern)) {
+        Write-Error "Blocked dangerous command pattern detected: '$pattern'"
+        exit 1
+    }
+}
+
+# Command passed all checks.
+exit 0

package/resources/codex-and-agents-customizations/.codex/hooks/validate-feature-review-coverage.ps1

@@ -0,0 +1,265 @@
+# Converted hook
+# Review the generated hook behavior before enabling it.
+
+<#
+.SYNOPSIS
+    SubagentStop hook that validates feature-review coverage verdicts against the branch diff.
+
+.DESCRIPTION
+    Runs when the feature-review subagent terminates. Cross-checks the most recent
+    policy-audit.<timestamp>.md under docs/features/active/**/ against the PR context
+    summary at artifacts/pr_context.summary.txt and against existing coverage artifacts.
+
+    Validation rules:
+      - Enumerate languages that have changed files in the branch diff:
+          .ts / .tsx            -> TypeScript
+          .py                   -> Python
+          .ps1 / .psm1          -> PowerShell
+          .cs                   -> CSharp
+      - For each language with one or more changed files, the policy audit must contain
+        a coverage-scoped row or line that states an explicit PASS or FAIL verdict for
+        that language. Scope-narrowing phrases on those rows are treated as validation
+        failures:
+          "informational only", "context only", "out of plan scope", "out of scope",
+          "not applicable", "N/A", "UNVERIFIED".
+      - If the coverage artifact for a language is present, repo-wide line coverage is
+        parsed and compared against the 80 percent floor. When repo-wide coverage is
+        below 80 percent and the audit does not carry a FAIL verdict on a coverage row
+        for that language, validation fails.
+
+    Coverage artifact paths by language:
+        TypeScript  coverage/lcov.info                          (LCOV text)
+        Python      artifacts/python/lcov.info                  (LCOV text)
+        PowerShell  artifacts/pester/powershell-coverage.xml    (JaCoCo XML)
+        CSharp      artifacts/csharp/coverage.xml               (JaCoCo XML)
+
+    On a validation failure the script writes a block decision to stdout and exits 1.
+    Read-only: inspects artifacts on disk and never modifies state.
+
+.NOTES
+    Compatible with PowerShell 7+.
+#>
+[CmdletBinding()]
+param()
+
+$ErrorActionPreference = 'Stop'
+
+function Get-RepoRoot {
+    $start = (Get-Location).Path
+    $current = $start
+    while ($true) {
+        if (Test-Path (Join-Path $current '.claude')) { return $current }
+        $parent = Split-Path $current -Parent
+        if (-not $parent -or $parent -eq $current) { break }
+        $current = $parent
+    }
+    return $start
+}
+
+function Get-LatestPolicyAudit {
+    [OutputType([System.IO.FileInfo])]
+    param([string]$RepoRoot)
+
+    $activeRoot = Join-Path $RepoRoot 'docs/features/active'
+    if (-not (Test-Path $activeRoot)) { return $null }
+
+    Get-ChildItem -Path $activeRoot -Recurse -File -Filter 'policy-audit.*.md' |
+        Sort-Object LastWriteTime -Descending |
+            Select-Object -First 1
+}
+
+function Get-ChangedLanguageSet {
+    [OutputType([System.Collections.Hashtable])]
+    param([string]$RepoRoot)
+
+    $prSummary = Join-Path $RepoRoot 'artifacts/pr_context.summary.txt'
+    $langs = [ordered]@{}
+    if (-not (Test-Path $prSummary)) { return $langs }
+
+    foreach ($line in Get-Content -Path $prSummary) {
+        if ($line -notmatch '^\s*-\s+(\S+)\s+\(\+\d+/-\d+\)\s*$') { continue }
+        $path = $matches[1]
+        $ext = [IO.Path]::GetExtension($path).ToLowerInvariant()
+        switch -Regex ($ext) {
+            '^\.(ts|tsx)$' { $langs['TypeScript'] = $true }
+            '^\.py$' { $langs['Python']     = $true }
+            '^\.(ps1|psm1)$' { $langs['PowerShell'] = $true }
+            '^\.cs$' { $langs['CSharp']     = $true }
+        }
+    }
+    return $langs
+}
+
+function Get-LcovRepoCoverage {
+    [OutputType([Nullable[double]])]
+    param([string]$Path)
+
+    if (-not (Test-Path $Path)) { return $null }
+
+    $totalFound = 0
+    $totalHit = 0
+    foreach ($line in Get-Content -Path $Path) {
+        if ($line.StartsWith('LF:')) {
+            $totalFound += [int]($line.Substring(3))
+        }
+        elseif ($line.StartsWith('LH:')) {
+            $totalHit += [int]($line.Substring(3))
+        }
+    }
+    if ($totalFound -le 0) { return $null }
+    return [math]::Round(($totalHit * 100.0) / $totalFound, 2)
+}
+
+function Get-JacocoRepoCoverage {
+    [OutputType([Nullable[double]])]
+    param([string]$Path)
+
+    if (-not (Test-Path $Path)) { return $null }
+
+    [xml]$doc = Get-Content -Path $Path -Raw
+    $counters = $doc.SelectNodes('//counter[@type="LINE"]')
+    if (-not $counters -or $counters.Count -eq 0) { return $null }
+
+    $missed = 0
+    $covered = 0
+    foreach ($counter in $counters) {
+        $missed += [int]$counter.missed
+        $covered += [int]$counter.covered
+    }
+    $total = $missed + $covered
+    if ($total -le 0) { return $null }
+    return [math]::Round(($covered * 100.0) / $total, 2)
+}
+
+function Get-LanguageRepoCoverage {
+    [OutputType([Nullable[double]])]
+    param(
+        [string]$RepoRoot,
+        [string]$Language
+    )
+
+    switch ($Language) {
+        'TypeScript' { return Get-LcovRepoCoverage -Path (Join-Path $RepoRoot 'coverage/lcov.info') }
+        'Python' { return Get-LcovRepoCoverage -Path (Join-Path $RepoRoot 'artifacts/python/lcov.info') }
+        'PowerShell' { return Get-JacocoRepoCoverage -Path (Join-Path $RepoRoot 'artifacts/pester/powershell-coverage.xml') }
+        'CSharp' { return Get-JacocoRepoCoverage -Path (Join-Path $RepoRoot 'artifacts/csharp/coverage.xml') }
+    }
+    return $null
+}
+
+function Test-LanguageCoverageRow {
+    [OutputType([System.Collections.Hashtable])]
+    param(
+        [string]$AuditText,
+        [string]$Language,
+        [Nullable[double]]$RepoWidePct
+    )
+
+    $languageLabelMap = @{
+        'TypeScript' = @('TypeScript', 'typescript')
+        'Python'     = @('Python', 'python', 'pytest')
+        'PowerShell' = @('PowerShell', 'powershell', 'pester')
+        'CSharp'     = @('C#', 'CSharp', 'csharp', '\.NET', 'dotnet')
+    }
+
+    $labels = $languageLabelMap[$Language]
+    $labelPattern = '(?i)(' + (($labels | ForEach-Object { [regex]::Escape($_) }) -join '|') + ')'
+
+    $lines = $AuditText -split "`r?`n"
+    $languageLines = $lines | Where-Object { $_ -match $labelPattern }
+
+    if (-not $languageLines -or $languageLines.Count -eq 0) {
+        return @{
+            Ok     = $false
+            Reason = "$Language has changed files on the branch but the policy-audit does not mention $Language."
+        }
+    }
+
+    $coverageLines = $languageLines | Where-Object { $_ -match '(?i)(coverage|lcov|line[s]?\s+hit|pester)' }
+    if (-not $coverageLines -or $coverageLines.Count -eq 0) {
+        return @{
+            Ok     = $false
+            Reason = "$Language has changed files on the branch but no coverage-scoped row in the policy-audit mentions $Language."
+        }
+    }
+
+    $narrowingPattern = '(?i)(informational only|context only|out of plan scope|out of scope|not applicable|\bN/A\b|\bUNVERIFIED\b)'
+    $narrowing = $coverageLines | Where-Object { $_ -match $narrowingPattern }
+    if ($narrowing -and $narrowing.Count -gt 0) {
+        $first = ($narrowing | Select-Object -First 1).ToString().Trim()
+        return @{
+            Ok     = $false
+            Reason = "$Language has changed files on the branch but a coverage-scoped row narrows scope: '$first'. Scope narrowing is not permitted for languages with changed files."
+        }
+    }
+
+    $verdictLines = $coverageLines | Where-Object { $_ -match '\b(PASS|FAIL)\b' }
+    if (-not $verdictLines -or $verdictLines.Count -eq 0) {
+        return @{
+            Ok     = $false
+            Reason = "$Language coverage rows contain neither a PASS nor a FAIL verdict."
+        }
+    }
+
+    if ($null -ne $RepoWidePct -and $RepoWidePct -lt 80.0) {
+        $failLines = $coverageLines | Where-Object { $_ -match '\bFAIL\b' }
+        if (-not $failLines -or $failLines.Count -eq 0) {
+            return @{
+                Ok     = $false
+                Reason = ("{0} repo-wide coverage is {1}% (below the 80% floor) but the policy-audit contains no FAIL verdict on a coverage row for {0}." -f $Language, $RepoWidePct)
+            }
+        }
+    }
+
+    return @{ Ok = $true; Reason = $null }
+}
+
+function Write-BlockDecision {
+    param([string]$Reason)
+
+    $payload = [ordered]@{
+        decision = 'block'
+        reason   = $Reason
+    } | ConvertTo-Json -Compress
+    Write-Output $payload
+}
+
+try {
+    $repoRoot = Get-RepoRoot
+    $audit = Get-LatestPolicyAudit -RepoRoot $repoRoot
+    if (-not $audit) {
+        # No audit to validate. The existing SubagentStop artifact-presence hook covers this case.
+        exit 0
+    }
+
+    $auditText = Get-Content -Path $audit.FullName -Raw
+    $changedLanguages = Get-ChangedLanguageSet -RepoRoot $repoRoot
+
+    if ($changedLanguages.Count -eq 0) {
+        exit 0
+    }
+
+    $failures = [System.Collections.Generic.List[string]]::new()
+
+    foreach ($lang in $changedLanguages.Keys) {
+        $repoPct = Get-LanguageRepoCoverage -RepoRoot $repoRoot -Language $lang
+        $result = Test-LanguageCoverageRow -AuditText $auditText -Language $lang -RepoWidePct $repoPct
+        if (-not $result.Ok) {
+            $failures.Add($result.Reason)
+        }
+    }
+
+    if ($failures.Count -gt 0) {
+        $header = "Feature-review coverage validation failed against branch diff."
+        $body   = "  - " + ($failures -join "`n  - ")
+        $footer = "Audit file: $($audit.FullName)`nFix the policy-audit to carry an explicit PASS or FAIL verdict per language with changed files, and reflect repo-wide coverage below 80% as FAIL."
+        Write-BlockDecision -Reason ("{0}`n{1}`n{2}" -f $header, $body, $footer)
+        exit 1
+    }
+
+    exit 0
+}
+catch {
+    Write-BlockDecision -Reason ("Feature-review coverage validator error: {0}" -f $_.Exception.Message)
+    exit 1
+}

package/resources/codex-and-agents-customizations/.codex/prompts/feature-review-remediate.md

@@ -0,0 +1,10 @@
+---
+description: Run feature review and, if needed, remediation planning with executor preflight
+---
+
+$feature-review
+Use pr_context as authoritative if present and valid. Only fall back to an explicit base branch if pr_context is missing, stale, or ambiguous.
+If remediation is required, explicitly spawn atomic-planner to create or revise the remediation plan.
+Before atomic-planner finalizes the plan, it must explicitly spawn atomic-executor in preflight-validation-only mode against that same file.
+If atomic-executor returns PREFLIGHT: REVISIONS REQUIRED, atomic-planner must revise the same file and repeat until PREFLIGHT: ALL CLEAR.
+Only then finalize the remediation plan and report all generated artifacts.

package/resources/codex-and-agents-customizations/.codex/prompts/generate-commit-message-repo.md

@@ -0,0 +1,11 @@
+---
+description: Generate a conventional commit message for the current repository by spawning commit-steward
+---
+
+Spawn `commit-steward` to generate a single audit-quality conventional commit message for the current repository.
+
+Use an explicitly supplied commit-context artifact as the primary input when one is provided.
+If no explicit commit-context artifact is provided, prefer `artifacts/commit_context.txt` when that file exists in the workspace.
+If no commit-context artifact is available, have `commit-steward` inspect staged changes directly and scope the message to staged changes only.
+
+Return exactly one fenced `text` code block containing only the commit message.

package/resources/codex-and-agents-customizations/.codex/prompts/generate-pr.md

@@ -0,0 +1,15 @@
+---
+description: Generate a GitHub-ready PR body from the canonical PR-context bundle by spawning pr-author
+argument-hint: Optional notes or PR intent edits to apply while writing the PR body
+---
+
+Spawn `pr-author` to generate a GitHub-ready pull request body.
+
+Use only:
+- the canonical PR-context bundle
+- the additional context files enumerated inside that bundle
+- any explicit user directives supplied with this prompt invocation
+
+If the PR-context bundle is missing or stale, refresh it using the canonical mechanism before generating the PR body.
+
+Return exactly one fenced `markdown` code block containing only the pull request message.

package/resources/codex-and-agents-customizations/.codex/prompts/orchestrate-work.md

@@ -0,0 +1,22 @@
+---
+description: Route a request through budget-based orchestration and persist until the selected delivery path is complete
+argument-hint: Provide objective, likely files, feature-or-bug hint, constraints, and whether small-path execution should stop after Phase 0 for manual bootstrap
+---
+
+Spawn `orchestrator` to coordinate the current request from intake through completion.
+
+Inputs to provide or infer:
+- request summary and expected outcome
+- likely affected production and test files, when known
+- initial classification hint: `feature` or `bug`, when known
+- constraints, preserved APIs, or forbidden changes
+- whether small-path execution should stop after Phase 0 for manual bootstrap
+
+Required behavior:
+- estimate change budget first and choose the correct small or large path
+- maintain and resume from the canonical orchestration checkpoint
+- use migrated Codex subagents when available
+- route host-specific lifecycle automation through the shared adapter rules
+- continue until planning, execution, validation, and review are complete for the selected path, unless the request explicitly requires a manual-bootstrap pause
+
+On completion, report the selected route, branch, key variables, `plan-path` when applicable, checkpoint path, created or updated artifact paths, and final readiness summary.