1# Check if all phases in task_plan.md are complete
2# Default invocation: advisory echo, always exits 0 (Stop hook status report).
3# With -Gate: deliberate completion gate, opt-in per plan via <plan-dir>/.mode.
4# Used by Stop hook to report task completion status.
5#
6# Gate mode (v3, -Gate flag) blocks ONLY when ALL hold (design "Gate decision table"):
7#   1. <plan-dir>/.mode exists and contains "gate" (explicit opt-in)
8#   2. an in_progress phase exists (not merely complete<total)
9#   3. the Stop hook input JSON on stdin does not set stop_hook_active=true
10#   4. the block counter (<plan-dir>/.stop_blocks) is below cap (PWF_GATE_CAP, default 20)
11#   5. the ledger advanced since the last block (stall -> allow stop)
12# When all hold, emits a single-line block-decision JSON on stdout and exits 0.
13# Otherwise advisory output and exit 0. Without -Gate, byte-equivalent to v2.43.
14#
15# Stdin: read only when input is redirected ([Console]::IsInputRedirected), so an
16# interactive console never blocks. Hook-piped JSON is EOF-terminated.
17 
18param(
19    [string]$PlanFile = "",
20    [switch]$Gate
21)
22 
23if ($PlanFile -ne "") {
24    $PlanDir = Split-Path -Parent $PlanFile
25    if ($PlanDir -eq "") { $PlanDir = "." }
26} else {
27    $scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
28    $resolver = Join-Path $scriptDir "resolve-plan-dir.ps1"
29    $resolvedDir = ""
30    if (Test-Path $resolver) {
31        try {
32            $resolvedDir = (& $resolver 2>$null | Select-Object -First 1)
33            if ($null -eq $resolvedDir) { $resolvedDir = "" }
34        } catch {
35            $resolvedDir = ""
36        }
37    }
38    if ($resolvedDir -ne "" -and (Test-Path (Join-Path $resolvedDir "task_plan.md"))) {
39        $PlanFile = Join-Path $resolvedDir "task_plan.md"
40        $PlanDir = $resolvedDir
41    } else {
42        $PlanFile = "task_plan.md"
43        $PlanDir = "."
44    }
45}
46 
47if (-not (Test-Path $PlanFile)) {
48    Write-Host '[planning-with-files] No task_plan.md found -- no active planning session.'
49    exit 0
50}
51 
52# Read file content
53$content = Get-Content $PlanFile -Raw
54 
55# Count total phases
56$TOTAL = ([regex]::Matches($content, "### Phase")).Count
57 
58# Count both formats per field and keep the larger of the two. A plan may mix
59# '**Status:** pending' on one phase with '[in_progress]' on another; counting
60# only the primary format (and falling back to inline ONLY when all three
61# primaries are zero) lost the inline count and let an in_progress plan slip
62# past the gate. Per-field max preserves the legacy single-format result
63# (the other format contributes 0) while catching mixed plans.
64$completePrimary = ([regex]::Matches($content, "\*\*Status:\*\* complete")).Count
65$inProgressPrimary = ([regex]::Matches($content, "\*\*Status:\*\* in_progress")).Count
66$pendingPrimary = ([regex]::Matches($content, "\*\*Status:\*\* pending")).Count
67 
68$completeInline = ([regex]::Matches($content, "\[complete\]")).Count
69$inProgressInline = ([regex]::Matches($content, "\[in_progress\]")).Count
70$pendingInline = ([regex]::Matches($content, "\[pending\]")).Count
71 
72$COMPLETE = [Math]::Max($completePrimary, $completeInline)
73$IN_PROGRESS = [Math]::Max($inProgressPrimary, $inProgressInline)
74$PENDING = [Math]::Max($pendingPrimary, $pendingInline)
75 
76# advisory_report: the v2.43 status echo.
77function Write-AdvisoryReport {
78    if ($COMPLETE -eq $TOTAL -and $TOTAL -gt 0) {
79        Write-Host ('[planning-with-files] ALL PHASES COMPLETE (' + $COMPLETE + '/' + $TOTAL + '). If the user has additional work, add new phases to task_plan.md before starting.')
80    } else {
81        Write-Host ('[planning-with-files] Task in progress (' + $COMPLETE + '/' + $TOTAL + ' phases complete). Update progress.md before stopping.')
82        if ($IN_PROGRESS -gt 0) {
83            Write-Host ('[planning-with-files] ' + $IN_PROGRESS + ' phase(s) still in progress.')
84        }
85        if ($PENDING -gt 0) {
86            Write-Host ('[planning-with-files] ' + $PENDING + ' phase(s) pending.')
87        }
88    }
89}
90 
91# ---- Default (advisory) path: byte-equivalent to v2.43 ----
92if (-not $Gate) {
93    Write-AdvisoryReport
94    exit 0
95}
96 
97# ---- Gate path (-Gate). Resolves to advisory unless every guard says block. ----
98 
99# Guard 1: gated mode. The .mode file must contain "gate".
100$modeFile = Join-Path $PlanDir ".mode"
101$gatedMode = $false
102if (Test-Path $modeFile) {
103    $modeContent = Get-Content $modeFile -Raw -ErrorAction SilentlyContinue
104    if ($null -ne $modeContent -and $modeContent -match "gate") {
105        $gatedMode = $true
106    }
107}
108if (-not $gatedMode) {
109    Write-AdvisoryReport
110    exit 0
111}
112 
113# Guard 3: stop_hook_active. Read stdin only when input is redirected, so an
114# interactive console never blocks. A true value means we are already inside a
115# forced continuation; allow the stop.
116$stdinJson = ""
117try {
118    if ([Console]::IsInputRedirected) {
119        $stdinJson = [Console]::In.ReadToEnd()
120    }
121} catch {
122    $stdinJson = ""
123}
124# Anchor on the literal value: "stop_hook_active" then colon then exactly true,
125# with a JSON-structural boundary after it (whitespace, comma, closing brace, or
126# end of input). Without the boundary 'true' could match a longer token; the
127# boundary keeps a 'false' value (or any other key set to true) from tripping
128# the guard and silently disabling the gate.
129if ($stdinJson -match '"stop_hook_active"\s*:\s*true(\s|,|}|$)') {
130    Write-AdvisoryReport
131    exit 0
132}
133 
134# Guard 2: an in_progress phase must exist.
135if ($IN_PROGRESS -le 0) {
136    Write-AdvisoryReport
137    exit 0
138}
139 
140# ledger_line_count: total lines across all <plan-dir>/ledger-*.jsonl files.
141function Get-LedgerLineCount {
142    $total = 0
143    $files = Get-ChildItem -Path $PlanDir -Filter "ledger-*.jsonl" -File -ErrorAction SilentlyContinue
144    foreach ($f in $files) {
145        $lines = @(Get-Content $f.FullName -ErrorAction SilentlyContinue)
146        $total += $lines.Count
147    }
148    return $total
149}
150 
151$cap = 20
152if ($env:PWF_GATE_CAP -match '^\d+$') {
153    $cap = [int]$env:PWF_GATE_CAP
154}
155 
156$blocksFile = Join-Path $PlanDir ".stop_blocks"
157$blocks = 0
158if (Test-Path $blocksFile) {
159    $raw = (Get-Content $blocksFile -Raw -ErrorAction SilentlyContinue)
160    if ($raw -match '^\s*(\d+)') { $blocks = [int]$Matches[1] }
161}
162 
163$ledgerFile = Join-Path $PlanDir ".gate_last_ledger"
164$ledgerPrev = 0
165if (Test-Path $ledgerFile) {
166    $raw = (Get-Content $ledgerFile -Raw -ErrorAction SilentlyContinue)
167    if ($raw -match '^\s*(\d+)') { $ledgerPrev = [int]$Matches[1] }
168}
169$ledgerNow = Get-LedgerLineCount
170 
171# Guard 4: block-count cap.
172if ($blocks -ge $cap) {
173    Write-AdvisoryReport
174    Write-Host ('[planning-with-files] gate cap reached (' + $blocks + '/' + $cap + ') -- allowing stop.')
175    exit 0
176}
177 
178# Guard 5: stall detection.
179if ($blocks -gt 0 -and $ledgerNow -eq $ledgerPrev) {
180    Write-AdvisoryReport
181    Write-Host '[planning-with-files] no progress since last gate block -- allowing stop.'
182    exit 0
183}
184 
185# All guards passed: block the stop.
186# Get-FirstInProgressPhase: heading text of the first phase whose Status is
187# in_progress. Plain text only -- no plan body beyond the heading.
188function Get-FirstInProgressPhase {
189    $heading = ""
190    foreach ($line in ($content -split "`n")) {
191        $trimmed = $line.TrimEnd("`r")
192        if ($trimmed -match '^### (.*)$') {
193            $heading = $Matches[1]
194        } elseif ($trimmed -match '\*\*Status:\*\* in_progress' -or $trimmed -match '\[in_progress\]') {
195            return $heading
196        }
197    }
198    return ""
199}
200 
201$phaseName = Get-FirstInProgressPhase
202if ($phaseName -eq "") { $phaseName = "unknown phase" }
203 
204# JSON-escape: backslash and double-quote, plus every bare control character
205# JSON forbids (below 0x20) mapped to a space. A phase heading may carry a
206# literal tab; left raw it produces invalid JSON the Stop hook rejects. Same
207# logic as ledger-append.ps1 ConvertTo-JsonString.
208function ConvertTo-JsonEscaped {
209    param([string] $Value)
210    $sb = New-Object System.Text.StringBuilder
211    foreach ($ch in $Value.ToCharArray()) {
212        switch ($ch) {
213            '"'  { [void]$sb.Append('\"') }
214            '\'  { [void]$sb.Append('\\') }
215            default {
216                if ([int]$ch -lt 32) {
217                    [void]$sb.Append(' ')
218                } else {
219                    [void]$sb.Append($ch)
220                }
221            }
222        }
223    }
224    return $sb.ToString()
225}
226$phaseEscaped = ConvertTo-JsonEscaped $phaseName
227 
228$newBlocks = $blocks + 1
229# Write sidecars as ASCII (single-byte digits) with an explicit LF and no BOM.
230# Set-Content on Windows emits CRLF; check-complete.sh then reads '5\r', whose
231# trailing CR makes the numeric guard reset BLOCKS to 0 on every cross-platform
232# read, so the cap and stall guards never fire. WriteAllText with ASCII gives
233# byte-for-byte '5\n' that both shells parse identically.
234try { [System.IO.File]::WriteAllText($blocksFile, [string]$newBlocks + "`n", [System.Text.Encoding]::ASCII) } catch {}
235try { [System.IO.File]::WriteAllText($ledgerFile, [string]$ledgerNow + "`n", [System.Text.Encoding]::ASCII) } catch {}
236 
237# Reason built from the JSON-escaped phase name; the surrounding template text
238# has no quotes or backslashes, so only the heading needs escaping.
239$reason = "[planning-with-files] Gated plan incomplete: phase '" + $phaseEscaped + "' is in_progress (" + $COMPLETE + "/" + $TOTAL + " complete, gate block " + $newBlocks + "/" + $cap + "). Finish or update the plan, then stop."
240 
241[Console]::Out.Write('{"decision":"block","reason":"' + $reason + '"}' + "`n")
242exit 0
243