@danmoisan/drm-copilot-mcp 1.1.19 → 1.1.21

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

@@ -10,9 +10,14 @@
       - the SubagentStop envelope read from stdin carries a non-empty last_assistant_message,
       - output advertises `plan-path: <path>` (or supported equivalent forms),
       - the advertised plan exists on disk,
-      - preflight-only runs return an exact preflight signal and may not claim
-        non-canonical blocked text,
-      - non-preflight runs may not stop in a blocked state,
+      - a run is classified as preflight from the delegation prompt in the subagent
+        transcript (Test-IsPreflightRun), falling back to the plan file or one output signal,
+      - preflight runs return exactly one preflight signal consistent with their
+        PREFLIGHT-DEFECT lines, name an existing fix record for any PREFLIGHT-FIX line,
+        and may not claim non-canonical blocked text,
+      - non-preflight runs may not stop in a blocked state, except a canonical preflight
+        block with a plan delta and no checked task (combined proportionate run); only the
+        uppercase BLOCKED token counts as a blocked claim, and lowercase prose does not,
       - non-preflight plans contain checkboxes and all are checked,
       - non-preflight output includes `AC Status Summary`,
       - non-preflight output includes command/status reporting,
@@ -43,33 +48,21 @@ $script:SubagentStopReportAndHaltLine = 'This condition is not repairable by the
 function Get-PlanFileContent {
     [CmdletBinding()]
     [OutputType([hashtable])]
-    param(
-        [Parameter(Mandatory = $true)]
-        [string] $Path
-    )
+    param([Parameter(Mandatory = $true)] [string] $Path)
 
     if (-not (Test-Path -LiteralPath $Path -PathType Leaf)) {
         return @{ Exists = $false; Lines = @() }
     }
 
-    $lines = Get-Content -LiteralPath $Path -ErrorAction Stop
-    if ($null -eq $lines) {
-        $lines = @()
-    }
-    elseif ($lines -isnot [array]) {
-        $lines = @($lines)
-    }
-
+    # @() yields an array for any line count; the filter drops a $null emitted at the read boundary.
+    $lines = @(Get-Content -LiteralPath $Path -ErrorAction Stop | Where-Object { $null -ne $_ })
     return @{ Exists = $true; Lines = $lines }
 }
 
 function Get-PlanPathFromOutput {
     [CmdletBinding()]
     [OutputType([string])]
-    param(
-        [Parameter(Mandatory = $true)]
-        [string] $AgentOutput
-    )
+    param([Parameter(Mandatory = $true)] [string] $AgentOutput)
 
     $pattern = 'plan-path\s*[:=]\s*["'']?([^\s"''\)`]+)|\[plan-path\]\(([^)]+)\)'
     $match = [regex]::Match($AgentOutput, $pattern, [System.Text.RegularExpressions.RegexOptions]::IgnoreCase)
@@ -89,22 +82,180 @@ function Get-PlanPathFromOutput {
 function Test-IsPreflightPlan {
     [CmdletBinding()]
     [OutputType([bool])]
-    param(
-        [Parameter(Mandatory = $true)]
-        [AllowEmptyString()] [string[]] $Lines
-    )
+    param([Parameter(Mandatory = $true)] [AllowEmptyCollection()] [AllowEmptyString()] [string[]] $Lines)
 
     return @($Lines | Where-Object { $_ -match '(?i)^\s*DIRECTIVE:\s*PREFLIGHT VALIDATION ONLY\s*$' }).Count -gt 0
 }
 
-function Get-TouchedLanguagesFromPlan {
+function Get-JsonPropertyValue {
+    # Returns a named property of a parsed JSON object, or $null; safe under StrictMode.
+    [CmdletBinding()]
+    [OutputType([object])]
+    param([AllowNull()] [object] $Object, [Parameter(Mandatory = $true)] [string] $Name)
+
+    if ($null -eq $Object -or -not ($Object -is [System.Management.Automation.PSCustomObject])) {
+        return $null
+    }
+    $property = @($Object.PSObject.Properties | Where-Object { $_.Name -ceq $Name })
+    if ($property.Count -eq 0) {
+        return $null
+    }
+    return $property[0].Value
+}
+
+function Get-TranscriptPathFromEnvelope {
+    # Returns agent_transcript_path from the SubagentStop envelope with a leading ~ expanded, or $null.
+    [CmdletBinding()]
+    [OutputType([string])]
+    param([AllowNull()] [object] $Envelope)
+
+    $path = Get-JsonPropertyValue -Object $Envelope -Name 'agent_transcript_path'
+    if (-not ($path -is [string]) -or [string]::IsNullOrWhiteSpace($path)) {
+        return $null
+    }
+    if ($path.StartsWith('~')) {
+        $path = $HOME + $path.Substring(1)
+    }
+    return $path
+}
+
+function Get-TranscriptFirstUserText {
+    # Returns the text of the first `user` entry of transcript JSONL lines, or $null when none parses.
+    [CmdletBinding()]
+    [OutputType([string])]
+    param([AllowEmptyString()] [string[]] $Lines = @())
+
+    foreach ($line in $Lines) {
+        if ([string]::IsNullOrWhiteSpace($line)) {
+            continue
+        }
+        try {
+            $entry = ConvertFrom-Json -InputObject $line -ErrorAction Stop
+        }
+        catch {
+            continue
+        }
+        if ((Get-JsonPropertyValue -Object $entry -Name 'type') -ne 'user') {
+            continue
+        }
+        $container = Get-JsonPropertyValue -Object $entry -Name 'message'
+        if ($null -eq $container) {
+            $container = $entry
+        }
+        $content = Get-JsonPropertyValue -Object $container -Name 'content'
+        if ($content -is [string]) {
+            return $content
+        }
+        $textBlocks = @(@($content) | Where-Object { (Get-JsonPropertyValue -Object $_ -Name 'type') -eq 'text' })
+        $texts = @($textBlocks | ForEach-Object { [string](Get-JsonPropertyValue -Object $_ -Name 'text') })
+        if ($texts.Count -gt 0) {
+            return ($texts -join "`n")
+        }
+    }
+    return $null
+}
+
+function Read-TranscriptHead {
+    # File seam: returns the first 50 lines of the transcript at Path, or $null when no file exists.
     [CmdletBinding()]
     [OutputType([string[]])]
+    param([Parameter(Mandatory = $true)] [string] $Path)
+
+    if (-not (Test-Path -LiteralPath $Path -PathType Leaf)) {
+        return $null
+    }
+    return [string[]]@(Get-Content -LiteralPath $Path -TotalCount 50 -ErrorAction Stop)
+}
+
+function Test-IsPreflightRun {
+    <#
+    .SYNOPSIS
+        Classifies an executor run as preflight or execution (issue #964).
+    .DESCRIPTION
+        A readable transcript is authoritative: its first `user` entry (the delegation prompt) decides, even
+        against a stale plan-file directive. Otherwise the plan-file directive, then exactly one output
+        `PREFLIGHT:` signal, decide (self-declared). ReadTranscriptHead returns JSONL lines or $null.
+    #>
+    [CmdletBinding()]
+    [OutputType([bool])]
     param(
-        [Parameter(Mandatory = $true)]
-        [AllowEmptyString()] [string[]] $Lines
+        [Parameter(Mandatory = $true)] [AllowEmptyString()] [string] $AgentOutput,
+        [Parameter(Mandatory = $true)] [AllowEmptyCollection()] [AllowEmptyString()] [string[]] $PlanLines,
+        [AllowNull()] [AllowEmptyString()] [string] $TranscriptPath,
+        [scriptblock] $ReadTranscriptHead = ${function:Read-TranscriptHead}
     )
 
+    if (-not [string]::IsNullOrWhiteSpace($TranscriptPath)) {
+        $head = $null
+        try {
+            $head = & $ReadTranscriptHead $TranscriptPath
+        }
+        catch {
+            $head = $null
+        }
+        if ($null -ne $head) {
+            $prompt = Get-TranscriptFirstUserText -Lines ([string[]]@($head))
+            if ($null -ne $prompt) {
+                return [regex]::IsMatch($prompt, '(?im)^\s*DIRECTIVE:\s*PREFLIGHT VALIDATION ONLY\s*$')
+            }
+        }
+    }
+    if (Test-IsPreflightPlan -Lines $PlanLines) {
+        return $true
+    }
+    return [regex]::Matches($AgentOutput, '(?m)^\s*PREFLIGHT:\s*(ALL CLEAR|REVISIONS REQUIRED)\s*$').Count -eq 1
+}
+
+function Test-PreflightFixRecord {
+    # File seam for the preflight-fix-record path.
+    [CmdletBinding()]
+    [OutputType([bool])]
+    param([Parameter(Mandatory = $true)] [string] $Path)
+    return [bool](Test-Path -LiteralPath $Path -PathType Leaf)
+}
+
+function Get-PreflightRunBlockDecision {
+    <#
+    .SYNOPSIS
+        Applies the single-pass preflight output rules (issue #964); every block is repairable.
+    #>
+    [CmdletBinding()]
+    [OutputType([hashtable])]
+    param([Parameter(Mandatory = $true)] [string] $AgentOutput)
+
+    if (-not (Test-HasCanonicalBlockedText -AgentOutput $AgentOutput)) {
+        return @{ Ok = $false; Repairable = $true; Message = 'atomic-executor hook: blocked preflight output must include the exact text `BLOCKED at preflight (before [P0-T1])` plus a concrete plan delta.' }
+    }
+    if ($AgentOutput -cmatch 'BLOCKED') {
+        return @{ Ok = $true; Message = $null }
+    }
+
+    $signals = @([regex]::Matches($AgentOutput, '(?m)^\s*PREFLIGHT:\s*(?<Signal>ALL CLEAR|REVISIONS REQUIRED)\s*$'))
+    if ($signals.Count -ne 1) {
+        return @{ Ok = $false; Repairable = $true; Message = "atomic-executor hook: preflight output must carry exactly one ``PREFLIGHT: ALL CLEAR`` or ``PREFLIGHT: REVISIONS REQUIRED`` signal line; found $($signals.Count)." }
+    }
+    $defectCount = [regex]::Matches($AgentOutput, '(?m)^\s*PREFLIGHT-DEFECT:\s*\S').Count
+    if ($signals[0].Groups['Signal'].Value -eq 'ALL CLEAR' -and $defectCount -gt 0) {
+        return @{ Ok = $false; Repairable = $true; Message = 'atomic-executor hook: `PREFLIGHT: ALL CLEAR` must not carry a `PREFLIGHT-DEFECT:` line; fix trivial defects in place or return `PREFLIGHT: REVISIONS REQUIRED`.' }
+    }
+    if ($signals[0].Groups['Signal'].Value -eq 'REVISIONS REQUIRED' -and $defectCount -eq 0) {
+        return @{ Ok = $false; Repairable = $true; Message = 'atomic-executor hook: `PREFLIGHT: REVISIONS REQUIRED` must list every substantive defect as a `PREFLIGHT-DEFECT:` line.' }
+    }
+    if ([regex]::IsMatch($AgentOutput, '(?m)^\s*PREFLIGHT-FIX:\s*\S')) {
+        $record = [regex]::Match($AgentOutput, '(?im)^\s*preflight-fix-record:\s*`?(?<Path>[^\s`]+)`?\s*$')
+        $recordPath = if ($record.Success) { ($record.Groups['Path'].Value -replace '\\', '/') -replace '^\./', '' } else { '' }
+        if (-not $recordPath.StartsWith('docs/features/', [System.StringComparison]::OrdinalIgnoreCase) -or -not (Test-PreflightFixRecord -Path $recordPath)) {
+            return @{ Ok = $false; Repairable = $true; Message = 'atomic-executor hook: a `PREFLIGHT-FIX:` line requires a `preflight-fix-record: <path>` line naming an existing record under docs/features/.' }
+        }
+    }
+    return @{ Ok = $true; Message = $null }
+}
+
+function Get-TouchedLanguagesFromPlan {
+    [CmdletBinding()]
+    [OutputType([string[]])]
+    param([Parameter(Mandatory = $true)] [AllowEmptyString()] [string[]] $Lines)
+
     $languages = [System.Collections.Generic.HashSet[string]]::new([System.StringComparer]::OrdinalIgnoreCase)
     $pathPattern = '(?i)(?:[.\w*?-]+[\\/])+[.\w*?-]+'
 
@@ -126,13 +277,7 @@ function Get-TouchedLanguagesFromPlan {
 function Test-OutputHasLanguageStatus {
     [CmdletBinding()]
     [OutputType([bool])]
-    param(
-        [Parameter(Mandatory = $true)]
-        [string] $AgentOutput,
-
-        [Parameter(Mandatory = $true)]
-        [string] $Language
-    )
+    param([Parameter(Mandatory = $true)] [string] $AgentOutput, [Parameter(Mandatory = $true)] [string] $Language)
 
     $labelMap = @{
         'TypeScript' = @('TypeScript', 'typescript')
@@ -149,34 +294,28 @@ function Test-OutputHasLanguageStatus {
 function Test-HasPreflightSignal {
     [CmdletBinding()]
     [OutputType([bool])]
-    param(
-        [Parameter(Mandatory = $true)]
-        [string] $AgentOutput
-    )
+    param([Parameter(Mandatory = $true)] [string] $AgentOutput)
 
-    return [regex]::IsMatch(
-        $AgentOutput,
-        '(?m)^\s*PREFLIGHT:\s*(ALL CLEAR|REVISIONS REQUIRED)\s*$'
-    )
+    return [regex]::IsMatch($AgentOutput, '(?m)^\s*PREFLIGHT:\s*(ALL CLEAR|REVISIONS REQUIRED)\s*$')
 }
 
 function Test-HasCanonicalBlockedText {
     [CmdletBinding()]
     [OutputType([bool])]
-    param(
-        [Parameter(Mandatory = $true)]
-        [string] $AgentOutput
-    )
+    param([Parameter(Mandatory = $true)] [string] $AgentOutput)
 
-    if ($AgentOutput -notmatch 'BLOCKED') {
+    # Case-sensitive: lowercase prose such as `blocked_reason` is not a BLOCKED claim (issue #964).
+    if ($AgentOutput -cnotmatch 'BLOCKED') {
         return $true
     }
 
-    if ($AgentOutput -notmatch 'BLOCKED at preflight \(before \[P0-T1\]\)') {
+    if ($AgentOutput -cnotmatch 'BLOCKED at preflight \(before \[P0-T1\]\)') {
         return $false
     }
 
-    if ($AgentOutput -notmatch '(?i)plan delta' -and $AgentOutput -notmatch '\[P\d+-T\d+\]') {
+    # The canonical phrase itself carries [P0-T1], so it is removed before looking for a plan delta.
+    $remainder = $AgentOutput -creplace 'BLOCKED at preflight \(before \[P0-T1\]\)', ''
+    if ($remainder -notmatch '(?i)plan delta' -and $remainder -notmatch '\[P\d+-T\d+\]') {
         return $false
     }
 
@@ -190,15 +329,13 @@ function Invoke-ExecutorOutputValidation {
     #>
     [CmdletBinding()]
     [OutputType([hashtable])]
-    param(
-        [AllowNull()] [AllowEmptyString()] [string] $InputText
-    )
+    param([AllowNull()] [AllowEmptyString()] [string] $InputText)
 
     $envelope = if ($PSBoundParameters.ContainsKey('InputText')) { Read-SubagentStopEnvelope -InputText $InputText } else { Read-SubagentStopEnvelope }
     if (-not $envelope.IsValid) { $decision = @{ Ok = $false; Repairable = $false; Message = ('{0} payload anomaly - {1}' -f 'atomic-executor hook:', (Get-SubagentStopEnvelopeAnomalyReason -Anomaly $envelope.Anomaly)) } }
     else {
         $agentOutput = $envelope.AssistantText
-        $decision = Get-ExecutorOutputBlockDecision -AgentOutput ([string]$agentOutput)
+        $decision = Get-ExecutorOutputBlockDecision -AgentOutput ([string]$agentOutput) -TranscriptPath (Get-TranscriptPathFromEnvelope -Envelope $envelope.Envelope)
     }
     if ($decision.Ok) { return @{ Ok = $true; Message = $null } }
     if (-not $decision.Repairable) {
@@ -216,13 +353,16 @@ function Get-ExecutorOutputBlockDecision {
         Returns @{ Ok = $true; Message = $null } to allow, or a hashtable with Ok = $false, a
         Repairable boolean, and Message. Repairable is $false for a non-preflight BLOCKED claim
         and for a plan with no task checkboxes; every other block is repairable by the subagent.
+        TranscriptPath and ReadTranscriptHead feed Test-IsPreflightRun. An execution run that
+        stops with the canonical preflight BLOCKED text, a plan delta, and no checked task is a
+        preflight block inside a combined proportionate run and is allowed.
     #>
     [CmdletBinding()]
     [OutputType([hashtable])]
     param(
-        [Parameter(Mandatory = $true)]
-        [AllowEmptyString()]
-        [string] $AgentOutput
+        [Parameter(Mandatory = $true)] [AllowEmptyString()] [string] $AgentOutput,
+        [AllowNull()] [AllowEmptyString()] [string] $TranscriptPath,
+        [scriptblock] $ReadTranscriptHead
     )
 
     if ([string]::IsNullOrWhiteSpace($agentOutput)) {
@@ -239,35 +379,29 @@ function Get-ExecutorOutputBlockDecision {
         return @{ Ok = $false; Repairable = $true; Message = "atomic-executor hook: executor advertised plan-path '$planPath' but no file exists at that location." }
     }
 
-    $isPreflight = Test-IsPreflightPlan -Lines $file.Lines
-    if ($isPreflight) {
-        if (-not (Test-HasCanonicalBlockedText -AgentOutput $agentOutput)) {
-            return @{ Ok = $false; Repairable = $true; Message = 'atomic-executor hook: blocked preflight output must include the exact text `BLOCKED at preflight (before [P0-T1])` plus a concrete plan delta.' }
-        }
-        if ($agentOutput -notmatch 'BLOCKED' -and -not (Test-HasPreflightSignal -AgentOutput $agentOutput)) {
+    $runArguments = @{ AgentOutput = $agentOutput; PlanLines = [string[]]@($file.Lines); TranscriptPath = $TranscriptPath }
+    if ($null -ne $ReadTranscriptHead) { $runArguments['ReadTranscriptHead'] = $ReadTranscriptHead }
+    if (Test-IsPreflightRun @runArguments) {
+        if ($agentOutput -cnotmatch 'BLOCKED' -and -not (Test-HasPreflightSignal -AgentOutput $agentOutput)) {
             return @{ Ok = $false; Repairable = $true; Message = 'atomic-executor hook: preflight output must include `PREFLIGHT: ALL CLEAR` or `PREFLIGHT: REVISIONS REQUIRED`.' }
         }
-        return @{ Ok = $true; Message = $null }
+        return Get-PreflightRunBlockDecision -AgentOutput $agentOutput
     }
 
-    if ($agentOutput -match 'BLOCKED') {
+    if ($agentOutput -cmatch 'BLOCKED') {
+        $hasCheckedTask = @($file.Lines | Where-Object { $_ -match '^\s*-\s\[[xX]\]\s\[P\d+-T\d+\]' }).Count -gt 0
+        if ($agentOutput -cmatch 'BLOCKED at preflight \(before \[P0-T1\]\)' -and (Test-HasCanonicalBlockedText -AgentOutput $agentOutput) -and -not $hasCheckedTask) {
+            return @{ Ok = $true; Message = $null }
+        }
         return @{ Ok = $false; Repairable = $false; Message = 'atomic-executor hook: blocking is permitted only during preflight validation (before [P0-T1]).' }
     }
 
-    $checkboxLineCount = 0
+    $checkboxLineCount = @($file.Lines | Where-Object { $_ -match '^\s*-\s\[(?:\s|[xX])\]\s' }).Count
     $uncheckedLineNumbers = [System.Collections.Generic.List[int]]::new()
-    $uncheckedPattern = '^\s*-\s\[\s\]\s'
-    $checkedPattern = '^\s*-\s\[[xX]\]\s'
-
     for ($i = 0; $i -lt $file.Lines.Count; $i++) {
-        $line = $file.Lines[$i]
-        if ($line -match $uncheckedPattern) {
-            $checkboxLineCount++
+        if ($file.Lines[$i] -match '^\s*-\s\[\s\]\s') {
             $uncheckedLineNumbers.Add($i + 1)
         }
-        elseif ($line -match $checkedPattern) {
-            $checkboxLineCount++
-        }
     }
 
     if ($checkboxLineCount -eq 0) {
@@ -281,8 +415,7 @@ function Get-ExecutorOutputBlockDecision {
             $reported = $uncheckedLineNumbers.GetRange(0, 5)
             $suffix = ' (showing first 5)'
         }
-        $lineList = ($reported -join ', ')
-        $message = "atomic-executor hook: plan file '$planPath' has $($uncheckedLineNumbers.Count) unchecked task(s) at line(s) ${lineList}${suffix}. All `- [ ]` items must be ticked to `- [x]` before termination."
+        $message = "atomic-executor hook: plan file '$planPath' has $($uncheckedLineNumbers.Count) unchecked task(s) at line(s) $($reported -join ', ')${suffix}. All `- [ ]` items must be ticked to `- [x]` before termination."
         return @{ Ok = $false; Repairable = $true; Message = $message }
     }
 
@@ -296,16 +429,9 @@ function Get-ExecutorOutputBlockDecision {
         return @{ Ok = $false; Repairable = $true; Message = 'atomic-executor hook: completion output must report commands run and pass/fail status results.' }
     }
 
-    $missingLanguageStatuses = [System.Collections.Generic.List[string]]::new()
-    foreach ($language in Get-TouchedLanguagesFromPlan -Lines $file.Lines) {
-        if (-not (Test-OutputHasLanguageStatus -AgentOutput $agentOutput -Language $language)) {
-            $missingLanguageStatuses.Add($language)
-        }
-    }
-
+    $missingLanguageStatuses = @(Get-TouchedLanguagesFromPlan -Lines $file.Lines | Where-Object { -not (Test-OutputHasLanguageStatus -AgentOutput $agentOutput -Language $_) })
     if ($missingLanguageStatuses.Count -gt 0) {
-        $missingList = $missingLanguageStatuses -join ', '
-        return @{ Ok = $false; Repairable = $true; Message = "atomic-executor hook: completion output is missing explicit PASS/FAIL toolchain status lines for: $missingList." }
+        return @{ Ok = $false; Repairable = $true; Message = "atomic-executor hook: completion output is missing explicit PASS/FAIL toolchain status lines for: $($missingLanguageStatuses -join ', ')." }
     }
 
     return @{ Ok = $true; Message = $null }

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

@@ -19,7 +19,9 @@
       - each task uses `- [ ] [P#-T#]` (or checked equivalent),
       - task numbering is sequential within each phase,
       - every task includes at least one explicit path token,
-      - the final phase contains QA-oriented work.
+      - the final phase contains QA-oriented work,
+      - the plan carries a complete `## Pre-Mortem` section (Test-PreMortemSection, issue #964),
+      - no internal-review `CITATION:` locator is a line reference (issue #964).
 
 .NOTES
     Reads the SubagentStop envelope from stdin through Read-SubagentStopEnvelope
@@ -39,6 +41,7 @@ $script:HookDependencyGuardLoadFailed = $false; try { . (Join-Path $PSScriptRoot
 
 Set-StrictMode -Version Latest
 try { . (Join-Path $PSScriptRoot 'subagentstop-envelope.ps1') } catch { Add-HookDependencyFailure -Name 'subagentstop-envelope.ps1' -ErrorRecord $_ }
+try { . (Join-Path $PSScriptRoot 'premortem-section.ps1') } catch { Add-HookDependencyFailure -Name 'premortem-section.ps1' -ErrorRecord $_ }
 $ErrorActionPreference = 'Stop'
 $script:SubagentStopReportAndHaltLine = 'This condition is not repairable by the subagent. Report it to the operator and halt.'
 
@@ -186,6 +189,10 @@ function Get-PlannerInternalReviewValidation {
         if (-not $citation.Success -or $citation.Groups['Path'].Value -notmatch '^(?![A-Za-z]:)(?!/)(?!\\)(?:\.?[^/\\|\s]+)(?:/[^/\\|\s]+)+$') {
             return @{ Ok = $false; Message = 'planner internal review citations require a repository-relative path and nonblank locator.' }
         }
+        # Issue #964: a line reference goes stale when main moves (consistent with validator rule G11).
+        if ($citation.Groups['Locator'].Value.Trim() -match '(?i)^(?:\d+(?:\s*-\s*\d+)?|#?L\d+(?:-L?\d+)?|lines?\s+\d+.*|[^\s:|]+:\d+(?:-\d+)?)$') {
+            return @{ Ok = $false; Message = "planner internal review citation locator ``$($citation.Groups['Locator'].Value.Trim())`` is a line reference; cite a symbol, heading, or test name instead." }
+        }
     }
 
     $inventoryLines = @($recordLines | Where-Object { $_ -match '^\s*AC-INVENTORY\s*:' })
@@ -421,6 +428,11 @@ function Get-PlannerOutputBlockDecision {
         return @{ Ok = $false; Repairable = $true; Message = $message }
     }
 
+    $preMortem = Test-PreMortemSection -Content ($file.Lines -join "`n")
+    if (-not $preMortem.Ok) {
+        return @{ Ok = $false; Repairable = $true; Message = "atomic-planner hook: plan '$planPath' $($preMortem.Message) See ``## Design-Level Plan Contract (Mandatory)`` in atomic-plan-contract." }
+    }
+
     $review = Get-PlannerInternalReviewValidation -AgentOutput $agentOutput
     if (-not $review.Ok) {
         return @{ Ok = $false; Repairable = $true; Message = "atomic-planner hook: $($review.Message)" }

package/resources/claude-customizations/.claude/hooks/validate-task-researcher-output.ps1

@@ -8,7 +8,10 @@
     under one of the two tracked research roots
     (docs/features/<feature>/research/ for feature-associated research, or
     docs/research/ for one-off research), matches the documented filename
-    convention, and the file exists on disk.
+    convention, and the file exists on disk. Feature-associated research under
+    docs/features/ must also carry a complete `## Pre-Mortem` section
+    (Test-PreMortemSection in premortem-section.ps1, issue #964); one-off
+    research under docs/research/ is exempt.
 
 .NOTES
     Reads the SubagentStop envelope JSON from stdin through the shared
@@ -18,8 +21,8 @@
     exits 2 through the shared envelope helper; an invalid envelope blocks
     with a payload anomaly reason. A hook dependency that fails to load
     blocks with exit 2 and the validate-task-researcher-output: prefix.
-    Filesystem reads go through Test-ResearchFile so tests can mock the
-    boundary without writing temporary files.
+    Filesystem reads go through Test-ResearchFile and Get-ResearchFileContent
+    so tests can mock the boundary without writing temporary files.
     An unhandled error during validation blocks with exit 2 and a reason (issue #928).
 #>
 
@@ -27,6 +30,7 @@
 param()
 $script:HookDependencyGuardLoadFailed = $false; try { . (Join-Path $PSScriptRoot 'hook-dependency-guard.ps1') } catch { $script:HookDependencyGuardLoadFailed = $true }
 try { . (Join-Path $PSScriptRoot 'subagentstop-envelope.ps1') } catch { Add-HookDependencyFailure -Name 'subagentstop-envelope.ps1' -ErrorRecord $_ }
+try { . (Join-Path $PSScriptRoot 'premortem-section.ps1') } catch { Add-HookDependencyFailure -Name 'premortem-section.ps1' -ErrorRecord $_ }
 
 Set-StrictMode -Version Latest
 $ErrorActionPreference = 'Stop'
@@ -42,6 +46,16 @@ function Test-ResearchFile {
     return [bool](Test-Path -LiteralPath $Path -PathType Leaf)
 }
 
+function Get-ResearchFileContent {
+    # File seam: returns the research file text, or $null when no file exists at the path.
+    [CmdletBinding()]
+    [OutputType([string])]
+    param([Parameter(Mandatory = $true)] [string] $Path)
+
+    if (-not (Test-Path -LiteralPath $Path -PathType Leaf)) { return $null }
+    return Get-Content -LiteralPath $Path -Raw -ErrorAction Stop
+}
+
 function Get-ResearchPathFromOutput {
     [CmdletBinding()]
     [OutputType([string])]
@@ -268,12 +282,17 @@ function Invoke-TaskResearcherOutputValidation {
         return @{ Ok = $false; Message = $feasibilityResult.Message }
     }
 
-    if (Test-Path -LiteralPath $researchPath -PathType Leaf) {
-        try { $researchContent = Get-Content -LiteralPath $researchPath -Raw -ErrorAction Stop } catch { return @{ Ok = $false; Message = "task-researcher hook: failed to read research-path '$researchPath': $($_.Exception.Message)" } }
+    try { $researchContent = Get-ResearchFileContent -Path $researchPath } catch { return @{ Ok = $false; Message = "task-researcher hook: failed to read research-path '$researchPath': $($_.Exception.Message)" } }
+    if ($null -ne $researchContent) {
         $numericEvidenceResult = Test-NumericDerivationEvidence -Content $researchContent
         if (-not $numericEvidenceResult.Ok) {
             return $numericEvidenceResult
         }
+        # Issue #964: feature research carries a Pre-Mortem; one-off research under docs/research/ is exempt.
+        if ((($researchPath -replace '\\', '/') -replace '^\./', '').StartsWith('docs/features/', [System.StringComparison]::OrdinalIgnoreCase)) {
+            $preMortem = Test-PreMortemSection -Content ([string]$researchContent)
+            if (-not $preMortem.Ok) { return @{ Ok = $false; Message = "task-researcher hook: feature research '$researchPath' $($preMortem.Message)" } }
+        }
     }
 
     return @{ Ok = $true; Message = $null }