@danmoisan/drm-copilot-mcp 1.0.1 → 1.0.8

package/resources/claude-customizations/.claude/hooks/enforce-epic-worktree-removal-gate.ps1

@@ -0,0 +1,237 @@
+<#
+.SYNOPSIS
+    Pre-tool-use hook that gates git worktree remove behind epic checkpoint merge state.
+
+.DESCRIPTION
+    Invoked by the Claude Code PreToolUse hook on the "Bash" matcher before any Bash
+    command runs. Regex-matches git worktree remove against CLAUDE_TOOL_INPUT.command,
+    extracts the target worktree path argument, reads
+    artifacts/orchestration/epic-orchestrator-state.json, and finds the features[] record
+    whose worktree_path matches. Allows removal only when that record's merge_status is
+    merged or worktree_removed. Denies with reason EPIC_WORKTREE_REMOVAL_BLOCKED when the
+    checkpoint is unreadable, no matching record exists, or merge_status is anything else -
+    fail-closed, following the enforce-orchestration-preimplementation-gate.ps1 precedent of
+    treating an unreadable/no-match checkpoint as deny.
+
+.NOTES
+    Compatible with PowerShell 7+. No external module dependencies. Filesystem reads go
+    through an injectable wrapper function so tests can mock the boundary without writing
+    temporary files.
+#>
+[CmdletBinding()]
+param()
+
+$script:EpicCheckpointPath = 'artifacts/orchestration/epic-orchestrator-state.json'
+$script:AllowedMergeStatuses = @('merged', 'worktree_removed')
+
+function Get-EpicWorktreeGateCheckpointContent {
+    <#
+    .SYNOPSIS
+        Read the raw JSON text of the epic checkpoint. Tests mock this function
+        (read seam).
+    .OUTPUTS
+        System.String or $null
+    #>
+    [CmdletBinding()]
+    [OutputType([string])]
+    param()
+
+    if (-not (Test-Path -LiteralPath $script:EpicCheckpointPath -PathType Leaf)) {
+        return $null
+    }
+    return (Get-Content -LiteralPath $script:EpicCheckpointPath -Raw)
+}
+
+function Get-EpicWorktreeRemovalCommandPath {
+    <#
+    .SYNOPSIS
+        Extract the target worktree path argument from a git worktree remove command.
+    .PARAMETER CommandText
+        The Bash command text under evaluation.
+    .OUTPUTS
+        System.String or $null
+    #>
+    [CmdletBinding()]
+    [OutputType([string])]
+    param(
+        [Parameter(Mandatory)]
+        [string] $CommandText
+    )
+
+    if ($CommandText -match '(?i)\bgit\s+worktree\s+remove\s+(?<path>\S+)') {
+        return $Matches['path'].Trim('"''')
+    }
+    return $null
+}
+
+function Find-EpicWorktreeFeatureRecord {
+    <#
+    .SYNOPSIS
+        Locate the features[] record whose worktree_path matches the target path.
+    .PARAMETER Checkpoint
+        Parsed epic checkpoint, or $null when absent/unreadable.
+    .PARAMETER WorktreePath
+        The target worktree path extracted from the command text.
+    .OUTPUTS
+        System.Object or $null
+    #>
+    [CmdletBinding()]
+    param(
+        [AllowNull()]
+        $Checkpoint,
+
+        [AllowNull()]
+        [string] $WorktreePath
+    )
+
+    if ($null -eq $Checkpoint -or [string]::IsNullOrWhiteSpace($WorktreePath)) {
+        return $null
+    }
+    $checkpointProps = @($Checkpoint.PSObject.Properties.Name)
+    if ($checkpointProps -notcontains 'features') {
+        return $null
+    }
+
+    $normalizedTarget = ($WorktreePath -replace '\\', '/').TrimEnd('/')
+
+    # Scan every recorded feature for a worktree_path that matches the removal target;
+    # path separators are normalized so Windows- and POSIX-style paths compare equal.
+    foreach ($feature in @($Checkpoint.features)) {
+        $featureProps = @($feature.PSObject.Properties.Name)
+        if ($featureProps -notcontains 'worktree_path') {
+            continue
+        }
+        $normalizedFeaturePath = (([string]$feature.worktree_path) -replace '\\', '/').TrimEnd('/')
+        if ($normalizedFeaturePath -eq $normalizedTarget) {
+            return $feature
+        }
+    }
+    return $null
+}
+
+function Test-EpicWorktreeRemovalAllowed {
+    <#
+    .SYNOPSIS
+        Decision logic: allow only when the matching feature record's merge_status is
+        merged or worktree_removed.
+    .PARAMETER FeatureRecord
+        The matched features[] record, or $null when no match was found.
+    .OUTPUTS
+        System.Boolean
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [AllowNull()]
+        $FeatureRecord
+    )
+
+    if ($null -eq $FeatureRecord) {
+        return $false
+    }
+    $props = @($FeatureRecord.PSObject.Properties.Name)
+    if ($props -notcontains 'merge_status') {
+        return $false
+    }
+    return $script:AllowedMergeStatuses -contains ([string]$FeatureRecord.merge_status)
+}
+
+function Get-EpicWorktreeGateAllowDecision {
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param()
+
+    return [ordered]@{
+        hookSpecificOutput = [ordered]@{
+            hookEventName      = 'PreToolUse'
+            permissionDecision = 'allow'
+        }
+    }
+}
+
+function Get-EpicWorktreeGateBlockDecision {
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param(
+        [Parameter(Mandatory)]
+        [string] $Reason
+    )
+
+    return [ordered]@{
+        hookSpecificOutput = [ordered]@{
+            hookEventName            = 'PreToolUse'
+            permissionDecision       = 'deny'
+            permissionDecisionReason = $Reason
+        }
+    }
+}
+
+function Invoke-EpicWorktreeRemovalGateDecision {
+    <#
+    .SYNOPSIS
+        Parses CLAUDE_TOOL_INPUT and returns an allow-or-block decision.
+    .PARAMETER ToolInputRaw
+        The raw JSON tool payload supplied by Claude Code.
+    .OUTPUTS
+        System.Collections.Specialized.OrderedDictionary
+    #>
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param(
+        [string] $ToolInputRaw
+    )
+
+    if (-not $ToolInputRaw) {
+        return Get-EpicWorktreeGateAllowDecision
+    }
+
+    try {
+        $toolInput = $ToolInputRaw | ConvertFrom-Json -ErrorAction Stop
+    } catch {
+        throw "enforce-epic-worktree-removal-gate hook received malformed JSON in CLAUDE_TOOL_INPUT: $_"
+    }
+
+    $commandText = $toolInput.command
+    if (-not $commandText) {
+        return Get-EpicWorktreeGateAllowDecision
+    }
+
+    if ($commandText -notmatch '(?i)\bgit\s+worktree\s+remove\b') {
+        return Get-EpicWorktreeGateAllowDecision
+    }
+
+    $worktreePath = Get-EpicWorktreeRemovalCommandPath -CommandText $commandText
+
+    $checkpointRaw = Get-EpicWorktreeGateCheckpointContent
+    $checkpoint = $null
+    if (-not [string]::IsNullOrWhiteSpace($checkpointRaw)) {
+        try {
+            $checkpoint = $checkpointRaw | ConvertFrom-Json -ErrorAction Stop
+        } catch {
+            $checkpoint = $null
+        }
+    }
+
+    $featureRecord = Find-EpicWorktreeFeatureRecord -Checkpoint $checkpoint -WorktreePath $worktreePath
+    if (Test-EpicWorktreeRemovalAllowed -FeatureRecord $featureRecord) {
+        return Get-EpicWorktreeGateAllowDecision
+    }
+
+    return Get-EpicWorktreeGateBlockDecision -Reason "EPIC_WORKTREE_REMOVAL_BLOCKED: git worktree remove for '$worktreePath' requires a matching epic checkpoint features[] record with merge_status in {merged, worktree_removed}. The checkpoint was unreadable, no matching record was found, or merge_status was not yet safe for removal."
+}
+
+# Guard allows dot-sourcing in tests without executing the entrypoint.
+if ($MyInvocation.InvocationName -eq '.') {
+    return
+}
+
+try {
+    $decision = Invoke-EpicWorktreeRemovalGateDecision -ToolInputRaw $env:CLAUDE_TOOL_INPUT
+} catch {
+    Write-Error $_
+    exit 1
+}
+
+$decision | ConvertTo-Json -Compress -Depth 5 | Write-Output
+
+exit 0

package/resources/claude-customizations/.claude/hooks/enforce-evidence-locations.ps1

@@ -27,10 +27,11 @@
     is written to the tracked roots docs/features/<feature>/research/
     (feature-associated) or docs/research/ (one-off).
 
-    If the file_path resolves to a forbidden prefix, the script writes a JSON response
-    to stdout with 'decision': 'block' and exits with code 0 so Claude Code surfaces
-    the reason. For allowed paths, 'decision': 'allow' is written to stdout and the
-    script exits 0. On hard failure (malformed JSON input), the script exits 1.
+    If the file_path resolves to a forbidden prefix, the script writes a PreToolUse JSON
+    response to stdout with hookSpecificOutput.permissionDecision = 'deny' and exits with
+    code 0 so Claude Code surfaces the reason. For allowed paths, a PreToolUse response
+    with permissionDecision = 'allow' is written to stdout and the script exits 0. On hard
+    failure (malformed JSON input), the script exits 1.
 
 .NOTES
     Compatible with PowerShell 7+.
@@ -83,9 +84,9 @@ function Test-EvidenceLocationForbidden {
 function Get-EvidenceLocationBlockDecision {
     <#
     .SYNOPSIS
-        Constructs a block-decision ordered dictionary for the supplied forbidden path.
+        Constructs a deny-decision ordered dictionary for the supplied forbidden path.
     .PARAMETER FilePath
-        The file path that triggered the block.
+        The file path that triggered the deny decision.
     #>
     [CmdletBinding()]
     [OutputType([System.Collections.Specialized.OrderedDictionary])]
@@ -95,8 +96,11 @@ function Get-EvidenceLocationBlockDecision {
     )
 
     [ordered]@{
-        decision = 'block'
-        reason   = "EVIDENCE_LOCATION_BLOCKED: '$FilePath' is not a canonical evidence location. Use <FEATURE>/evidence/<kind>/ instead. See .claude/skills/evidence-and-timestamp-conventions/SKILL.md for the canonical scheme."
+        hookSpecificOutput = [ordered]@{
+            hookEventName            = 'PreToolUse'
+            permissionDecision       = 'deny'
+            permissionDecisionReason = "EVIDENCE_LOCATION_BLOCKED: '$FilePath' is not a canonical evidence location. Use <FEATURE>/evidence/<kind>/ instead. See .claude/skills/evidence-and-timestamp-conventions/SKILL.md for the canonical scheme."
+        }
     }
 }
 
@@ -115,7 +119,7 @@ function Invoke-EvidenceLocationDecision {
     )
 
     if (-not $ToolInputRaw) {
-        return [ordered]@{ decision = 'allow' }
+        return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
     }
 
     try {
@@ -127,14 +131,14 @@ function Invoke-EvidenceLocationDecision {
 
     $filePath = $toolInput.file_path
     if (-not $filePath) {
-        return [ordered]@{ decision = 'allow' }
+        return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
     }
 
     if (Test-EvidenceLocationForbidden -FilePath $filePath) {
         return Get-EvidenceLocationBlockDecision -FilePath $filePath
     }
 
-    return [ordered]@{ decision = 'allow' }
+    return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
 }
 
 function Invoke-EvidenceLocationEntryPoint {
@@ -163,7 +167,7 @@ function Invoke-EvidenceLocationEntryPoint {
         return 1
     }
 
-    $decision | ConvertTo-Json -Compress | Write-Output
+    $decision | ConvertTo-Json -Compress -Depth 5 | Write-Output
 
     return 0
 }

package/resources/claude-customizations/.claude/hooks/enforce-feature-folder-order.ps1

@@ -10,9 +10,10 @@
     docs/features/(active|archive)/<folder>/plan.md, the script verifies that
     each of issue.md, spec.md, and user-story.md exists in the same folder.
 
-    If any of the three sibling files is missing, the script emits a JSON
-    response with decision='block' and exits 0 so Claude Code surfaces the
-    reason. All other paths pass through with decision='allow'.
+    If any of the three sibling files is missing, the script emits a PreToolUse
+    JSON response with hookSpecificOutput.permissionDecision='deny' and exits 0 so
+    Claude Code surfaces the reason. All other paths pass through with
+    permissionDecision='allow'.
 
     Filesystem reads go through Get-FeatureFolderFileExistence so tests can
     inject a fake without touching disk.
@@ -97,7 +98,7 @@ function Invoke-FeatureFolderOrderDecision {
     )
 
     if (-not $ToolInputRaw) {
-        return [ordered]@{ decision = 'allow' }
+        return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
     }
 
     try {
@@ -109,24 +110,27 @@ function Invoke-FeatureFolderOrderDecision {
 
     $filePath = $toolInput.file_path
     if (-not $filePath) {
-        return [ordered]@{ decision = 'allow' }
+        return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
     }
 
     $normalized = $filePath -replace '\\', '/'
 
     if (-not (Test-IsFeaturePlanPath -NormalizedPath $normalized)) {
-        return [ordered]@{ decision = 'allow' }
+        return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
     }
 
     $missing = Get-FeatureFolderMissingFile -PlanFilePath $normalized
     if ($missing.Count -eq 0) {
-        return [ordered]@{ decision = 'allow' }
+        return [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
     }
 
     $list = ($missing -join ', ')
     return [ordered]@{
-        decision = 'block'
-        reason   = "FEATURE_FOLDER_ORDER_BLOCKED: cannot write plan.md before producing prerequisite documents. Missing in feature folder: $list. Invoke the prd-feature subagent to generate the missing file(s) before authoring plan.md."
+        hookSpecificOutput = [ordered]@{
+            hookEventName            = 'PreToolUse'
+            permissionDecision       = 'deny'
+            permissionDecisionReason = "FEATURE_FOLDER_ORDER_BLOCKED: cannot write plan.md before producing prerequisite documents. Missing in feature folder: $list. Invoke the prd-feature subagent to generate the missing file(s) before authoring plan.md."
+        }
     }
 }
 
@@ -143,6 +147,6 @@ catch {
     exit 1
 }
 
-$decision | ConvertTo-Json -Compress | Write-Output
+$decision | ConvertTo-Json -Compress -Depth 5 | Write-Output
 
 exit 0

package/resources/claude-customizations/.claude/hooks/enforce-model-routing-receipt.ps1

@@ -0,0 +1,182 @@
+<#
+.SYNOPSIS
+    Pre-tool-use hook that blocks a delegation to a gated subagent when the
+    orchestrator checkpoint records no model-routing receipt for that agent.
+
+.DESCRIPTION
+    Invoked by the Claude Code PreToolUse hook on the Agent (Task) tool. Reads
+    tool input JSON from the CLAUDE_TOOL_INPUT environment variable and the
+    orchestrator checkpoint from artifacts/orchestration/orchestrator-state.json.
+
+    The hook enforces presence only: it cannot read the delegate's chosen
+    `model` (no `model` field is exposed in the tool input), so it verifies that
+    a `model_routing_receipts[]` entry already exists for the target
+    `subagent_type`. Correctness of the recorded model stays with the
+    authoritative Python validator.
+
+    Gated subagent types are the Agent-tool delegates that participate in model
+    selection: atomic-planner, atomic-executor, feature-review, task-researcher,
+    prd-feature, pr-author. The `orchestrator` type is deliberately excluded: it
+    is the calling agent, not a subagent delegated via the Agent tool, so it is
+    never a receipt-gated `subagent_type`.
+
+    Allow-through (graceful allow) applies to a non-delegating `subagent_type`,
+    empty or absent tool input, and malformed tool-input JSON.
+
+    The checkpoint read goes through Get-ModelRoutingCheckpoint so tests can
+    inject a synthetic checkpoint without touching disk.
+
+.NOTES
+    Compatible with PowerShell 7+. Read-only presence-gating deterrent.
+#>
+[CmdletBinding()]
+param()
+
+function Get-ModelRoutingCheckpoint {
+    <#
+    .SYNOPSIS
+        Returns the parsed orchestrator checkpoint object, or $null when the
+        file is missing or not valid JSON. Tests mock this seam.
+    #>
+    [CmdletBinding()]
+    [OutputType([object])]
+    param(
+        [string] $CheckpointPath = 'artifacts/orchestration/orchestrator-state.json'
+    )
+
+    if (-not (Test-Path -LiteralPath $CheckpointPath -PathType Leaf)) {
+        return $null
+    }
+
+    try {
+        $raw = Get-Content -LiteralPath $CheckpointPath -Raw -ErrorAction Stop
+        return $raw | ConvertFrom-Json -ErrorAction Stop
+    }
+    catch {
+        return $null
+    }
+}
+
+function Get-ModelRoutingGatedAgent {
+    <#
+    .SYNOPSIS
+        Returns the set of subagent types that are receipt-gated: the Agent-tool
+        delegates that participate in model selection. `orchestrator` is
+        excluded because it is the caller, not a delegated subagent.
+    #>
+    [CmdletBinding()]
+    [OutputType([string[]])]
+    param()
+
+    return [string[]] @(
+        'atomic-planner',
+        'atomic-executor',
+        'feature-review',
+        'task-researcher',
+        'prd-feature',
+        'pr-author'
+    )
+}
+
+function Test-ModelRoutingReceiptPresent {
+    <#
+    .SYNOPSIS
+        Returns $true when the checkpoint carries a model_routing_receipts entry
+        whose agent equals the target subagent type.
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param(
+        [Parameter(Mandatory)]
+        [AllowNull()]
+        $Checkpoint,
+
+        [Parameter(Mandatory)]
+        [string] $Subagent
+    )
+
+    if ($null -eq $Checkpoint) {
+        return $false
+    }
+    if ($Checkpoint.PSObject.Properties.Name -notcontains 'model_routing_receipts') {
+        return $false
+    }
+
+    # Scan every receipt for one whose agent matches the delegated subagent type.
+    foreach ($receipt in @($Checkpoint.model_routing_receipts)) {
+        if ($null -eq $receipt) {
+            continue
+        }
+        if ($receipt.PSObject.Properties.Name -contains 'agent' -and
+            [string]$receipt.agent -eq $Subagent) {
+            return $true
+        }
+    }
+    return $false
+}
+
+function Invoke-ModelRoutingReceiptDecision {
+    <#
+    .SYNOPSIS
+        Parses CLAUDE_TOOL_INPUT and returns an allow-or-block decision object.
+    #>
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param(
+        [string] $ToolInputRaw
+    )
+
+    $allow = [ordered]@{ hookSpecificOutput = [ordered]@{ hookEventName = 'PreToolUse'; permissionDecision = 'allow' } }
+
+    # Empty or absent tool input is not a delegation this hook can gate.
+    if (-not $ToolInputRaw) {
+        return $allow
+    }
+
+    # Malformed tool-input JSON is allowed through gracefully; this hook is a
+    # deterrent, not the authoritative validator.
+    try {
+        $toolInput = $ToolInputRaw | ConvertFrom-Json -ErrorAction Stop
+    }
+    catch {
+        return $allow
+    }
+
+    $subagent = [string]$toolInput.subagent_type
+
+    # Only the gated Agent-tool delegates are receipt-checked; any other
+    # subagent_type (including orchestrator) passes through.
+    if (-not $subagent -or ((Get-ModelRoutingGatedAgent) -notcontains $subagent)) {
+        return $allow
+    }
+
+    $checkpoint = Get-ModelRoutingCheckpoint
+    if (Test-ModelRoutingReceiptPresent -Checkpoint $checkpoint -Subagent $subagent) {
+        return $allow
+    }
+
+    return [ordered]@{
+        hookSpecificOutput = [ordered]@{
+            hookEventName            = 'PreToolUse'
+            permissionDecision       = 'deny'
+            permissionDecisionReason = "MODEL_ROUTING_RECEIPT_BLOCKED: cannot delegate to '$subagent' before a model_routing_receipts entry for it is recorded in the orchestrator checkpoint. Perform Model Selection (record the complexity assessment and routing receipt) before delegating."
+        }
+    }
+}
+
+# Guard allows dot-sourcing in tests without executing the entrypoint.
+if ($MyInvocation.InvocationName -eq '.') {
+    return
+}
+
+try {
+    $decision = Invoke-ModelRoutingReceiptDecision -ToolInputRaw $env:CLAUDE_TOOL_INPUT
+}
+catch {
+    Write-Error $_
+    exit 1
+}
+
+$decision | ConvertTo-Json -Compress -Depth 5 | Write-Output
+
+exit 0

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

@@ -130,6 +130,36 @@ function Get-CheckpointContent {
     return Get-Content -Raw -LiteralPath $script:CheckpointPath
 }
 
+function Get-OrchestrationPreimplementationGateAllowDecision {
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param()
+
+    return [ordered]@{
+        hookSpecificOutput = [ordered]@{
+            hookEventName      = 'PreToolUse'
+            permissionDecision = 'allow'
+        }
+    }
+}
+
+function Get-OrchestrationPreimplementationGateBlockDecision {
+    [CmdletBinding()]
+    [OutputType([System.Collections.Specialized.OrderedDictionary])]
+    param(
+        [Parameter(Mandatory)]
+        [string] $Reason
+    )
+
+    return [ordered]@{
+        hookSpecificOutput = [ordered]@{
+            hookEventName            = 'PreToolUse'
+            permissionDecision       = 'deny'
+            permissionDecisionReason = $Reason
+        }
+    }
+}
+
 function Invoke-OrchestrationPreimplementationGateDecision {
     [CmdletBinding()]
     [OutputType([System.Collections.Specialized.OrderedDictionary])]
@@ -139,7 +169,7 @@ function Invoke-OrchestrationPreimplementationGateDecision {
     )
 
     if (-not $ToolInputRaw) {
-        return [ordered]@{ decision = 'allow' }
+        return Get-OrchestrationPreimplementationGateAllowDecision
     }
     try {
         $toolInput = $ToolInputRaw | ConvertFrom-Json -ErrorAction Stop
@@ -162,7 +192,7 @@ function Invoke-OrchestrationPreimplementationGateDecision {
     }
 
     if (-not $requiresReadyCheckpoint) {
-        return [ordered]@{ decision = 'allow' }
+        return Get-OrchestrationPreimplementationGateAllowDecision
     }
 
     if (-not $CheckpointRaw) {
@@ -175,12 +205,9 @@ function Invoke-OrchestrationPreimplementationGateDecision {
     }
 
     if (Test-OrchestrationReady -Payload $checkpoint) {
-        return [ordered]@{ decision = 'allow' }
-    }
-    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.'
+        return Get-OrchestrationPreimplementationGateAllowDecision
     }
+    return Get-OrchestrationPreimplementationGateBlockDecision -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.'
 }
 
 if ($MyInvocation.InvocationName -eq '.') {
@@ -194,5 +221,5 @@ try {
     exit 1
 }
 
-$decision | ConvertTo-Json -Compress | Write-Output
+$decision | ConvertTo-Json -Compress -Depth 5 | Write-Output
 exit 0