prizmkit 1.1.63 → 1.1.66

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.63",
-  "bundledAt": "2026-06-08T18:06:47.062Z",
-  "bundledFrom": "72acb14"
+  "frameworkVersion": "1.1.66",
+  "bundledAt": "2026-06-08T19:45:48.630Z",
+  "bundledFrom": "940cbd4"
 }

package/bundled/dev-pipeline-windows/.env.example

@@ -21,6 +21,17 @@
 # MAX_RETRIES=3              # Max retry attempts per task before marking failed
 # SESSION_TIMEOUT=0          # Session timeout in seconds (0 = no limit)
 # VERBOSE=1                  # Verbose logging (1=on, 0=off)
+# HEARTBEAT_INTERVAL=30      # Poll interval for session progress/stale checks
+# STALE_KILL_THRESHOLD=900   # Auto-kill session after N seconds without log progress (0 = disabled)
+# STALE_KILL_GRACE_SECONDS=10  # Grace period after stale-kill before force-stopping the job
+# CODEX_SUBAGENT_TIMEOUT_SECONDS=840  # Codex subagent max runtime; defaults to stale threshold - 60
+# LOG_CLEANUP_ENABLED=1      # Run periodic session log cleanup
+# LOG_RETENTION_DAYS=14      # Delete session logs older than N days
+# LOG_MAX_TOTAL_MB=1024      # Keep total logs under N MB via oldest-first cleanup
+# STOP_ON_FAILURE=0          # Stop after the first failed task (1=stop, 0=continue)
+# ENABLE_DEPLOY=0            # Start a deploy session after all tasks complete successfully
+# DEV_BRANCH=                # Optional custom dev branch name for each task
+# AUTO_PUSH=0                # Push original branch after successful merge (1=enabled)
 
 # ─── Feature Pipeline Only ────────────────────────────────────────────
 # ENABLE_CRITIC=false        # Enable adversarial critic review (true/false)

package/bundled/dev-pipeline-windows/SCHEMA_ANALYSIS.md

@@ -345,6 +345,17 @@ pending, in_progress, completed, failed, skipped
 | `MAX_RETRIES` | integer | (not specified) | Retry attempts per task |
 | `SESSION_TIMEOUT` | integer | 0 | 0 = no limit |
 | `VERBOSE` | integer | (not specified) | 1=on, 0=off |
+| `HEARTBEAT_INTERVAL` | integer | 30 | Poll interval for session progress/stale checks |
+| `STALE_KILL_THRESHOLD` | integer | 900 | Auto-kill after N seconds without log progress; 0 disables |
+| `STALE_KILL_GRACE_SECONDS` | integer | 10 | Grace period after stale-kill before force-stopping |
+| `CODEX_SUBAGENT_TIMEOUT_SECONDS` | integer | 840 | Codex subagent max runtime |
+| `LOG_CLEANUP_ENABLED` | boolean | 1 | Periodic session log cleanup |
+| `LOG_RETENTION_DAYS` | integer | 14 | Delete session logs older than N days |
+| `LOG_MAX_TOTAL_MB` | integer | 1024 | Keep total logs under N MB |
+| `STOP_ON_FAILURE` | boolean | 0 | Stop after the first failed task |
+| `ENABLE_DEPLOY` | boolean | 0 | Start deploy session after all tasks complete |
+| `DEV_BRANCH` | string | auto-generated | Optional custom dev branch name |
+| `AUTO_PUSH` | boolean | 0 | Push original branch after successful merge |
 | `ENABLE_CRITIC` | boolean | false | Adversarial review enable |
 | `PIPELINE_MODE` | string | auto-detect | lite/standard/full override |
 

package/bundled/dev-pipeline-windows/lib/branch.ps1

@@ -0,0 +1,222 @@
+Set-StrictMode -Version 2.0
+$ErrorActionPreference = 'Stop'
+
+function Get-PrizmCurrentBranch {
+  param([string]$ProjectRoot)
+  $branch = & git -C $ProjectRoot rev-parse --abbrev-ref HEAD 2>$null
+  if ($LASTEXITCODE -eq 0 -and $branch) { return [string]($branch | Select-Object -First 1) }
+  return ''
+}
+
+function Test-PrizmTrackedDirty {
+  param([string]$ProjectRoot)
+  $trackedDirty = & git -C $ProjectRoot diff --name-only 2>$null
+  $stagedDirty = & git -C $ProjectRoot diff --cached --name-only 2>$null
+  return -not [string]::IsNullOrWhiteSpace((@($trackedDirty) + @($stagedDirty) -join "`n"))
+}
+
+function New-PrizmDevBranch {
+  param(
+    [string]$ProjectRoot,
+    [string]$DevBranch,
+    [string]$SourceBranch
+  )
+
+  if (-not $DevBranch -or -not $SourceBranch) { return $false }
+
+  & git -C $ProjectRoot rev-parse --verify $DevBranch *> $null
+  if ($LASTEXITCODE -eq 0) {
+    Write-PrizmInfo "Branch already exists: $DevBranch - checking out"
+    & git -C $ProjectRoot checkout $DevBranch *> $null
+    if ($LASTEXITCODE -ne 0) {
+      Write-PrizmError "Failed to checkout existing branch: $DevBranch"
+      return $false
+    }
+    return $true
+  }
+
+  & git -C $ProjectRoot checkout -b $DevBranch $SourceBranch *> $null
+  if ($LASTEXITCODE -ne 0) {
+    Write-PrizmWarn "Failed to create branch: $DevBranch from $SourceBranch"
+    return $false
+  }
+
+  Write-PrizmInfo "Created and checked out branch: $DevBranch (from $SourceBranch)"
+  return $true
+}
+
+function Switch-PrizmOriginalBranch {
+  param(
+    [string]$ProjectRoot,
+    [string]$OriginalBranch
+  )
+
+  if (-not $OriginalBranch) { return $false }
+  $currentBranch = Get-PrizmCurrentBranch $ProjectRoot
+  if ($currentBranch -eq $OriginalBranch) { return $true }
+
+  & git -C $ProjectRoot checkout $OriginalBranch *> $null
+  if ($LASTEXITCODE -ne 0) {
+    Write-PrizmError "Failed to checkout original branch: $OriginalBranch"
+    return $false
+  }
+
+  Write-PrizmInfo "Returned to branch: $OriginalBranch"
+  return $true
+}
+
+function Save-PrizmBranchWip {
+  param(
+    [string]$ProjectRoot,
+    [string]$DevBranch
+  )
+
+  if (-not $DevBranch) { return $true }
+
+  $currentBranch = Get-PrizmCurrentBranch $ProjectRoot
+  if ($currentBranch -ne $DevBranch) { return $true }
+
+  $changes = & git -C $ProjectRoot status --porcelain 2>$null
+  if ([string]::IsNullOrWhiteSpace(($changes -join "`n"))) { return $true }
+
+  Write-PrizmWarn "Saving uncommitted work-in-progress on branch: $DevBranch"
+  & git -C $ProjectRoot add -A *> $null
+  if ($LASTEXITCODE -ne 0) {
+    Write-PrizmWarn "git add -A failed - uncommitted work may remain on $DevBranch"
+    return $true
+  }
+
+  & git -C $ProjectRoot commit --no-verify `
+    -m "wip($DevBranch): interrupted - uncommitted work saved" `
+    -m "Pipeline was interrupted or failed. This commit preserves work-in-progress." `
+    -m "To resume: git checkout $DevBranch" *> $null
+
+  if ($LASTEXITCODE -eq 0) {
+    Write-PrizmInfo "Saved uncommitted work on branch $DevBranch"
+  } else {
+    Write-PrizmWarn "git commit failed - uncommitted work may remain on $DevBranch"
+  }
+
+  return $true
+}
+
+function Merge-PrizmDevBranch {
+  param(
+    [string]$ProjectRoot,
+    [string]$DevBranch,
+    [string]$OriginalBranch,
+    [bool]$AutoPush = $false
+  )
+
+  if (-not $DevBranch -or -not $OriginalBranch) { return $false }
+
+  $hadStash = $false
+  if (Test-PrizmTrackedDirty $ProjectRoot) {
+    & git -C $ProjectRoot stash push -m 'pipeline-merge-stash' *> $null
+    if ($LASTEXITCODE -eq 0) {
+      $hadStash = $true
+    } else {
+      Write-PrizmWarn "git stash failed - tracked changes may block branch merge"
+    }
+  }
+
+  Write-PrizmInfo "Merging $DevBranch into $OriginalBranch..."
+  & git -C $ProjectRoot rebase $OriginalBranch $DevBranch
+  if ($LASTEXITCODE -ne 0) {
+    Write-PrizmError "Rebase of $DevBranch onto $OriginalBranch failed - resolve manually"
+    & git -C $ProjectRoot rebase --abort *> $null
+    if ($hadStash) {
+      & git -C $ProjectRoot stash pop *> $null
+      if ($LASTEXITCODE -ne 0) { Write-PrizmWarn "git stash pop failed after rebase abort" }
+    }
+    return $false
+  }
+
+  & git -C $ProjectRoot checkout $OriginalBranch *> $null
+  if ($LASTEXITCODE -ne 0) {
+    Write-PrizmError "Failed to checkout $OriginalBranch for merge"
+    if ($hadStash) {
+      & git -C $ProjectRoot stash pop *> $null
+      if ($LASTEXITCODE -ne 0) { Write-PrizmWarn "git stash pop failed after checkout failure" }
+    }
+    return $false
+  }
+
+  & git -C $ProjectRoot merge --ff-only $DevBranch
+  if ($LASTEXITCODE -ne 0) {
+    Write-PrizmError "Merge failed after rebase - resolve manually"
+    if ($hadStash) {
+      & git -C $ProjectRoot stash pop *> $null
+      if ($LASTEXITCODE -ne 0) { Write-PrizmWarn "git stash pop failed after merge failure" }
+    }
+    return $false
+  }
+
+  Write-PrizmSuccess "Merged $DevBranch into $OriginalBranch"
+
+  if ($AutoPush) {
+    Write-PrizmInfo "Pushing $OriginalBranch to remote..."
+    & git -C $ProjectRoot push *> $null
+    if ($LASTEXITCODE -eq 0) {
+      Write-PrizmSuccess "Pushed $OriginalBranch to remote"
+    } else {
+      Write-PrizmWarn "Push failed - run git push manually"
+    }
+  }
+
+  & git -C $ProjectRoot branch -d $DevBranch *> $null
+  if ($LASTEXITCODE -eq 0) { Write-PrizmInfo "Deleted merged branch: $DevBranch" }
+
+  if ($hadStash) {
+    & git -C $ProjectRoot stash pop *> $null
+    if ($LASTEXITCODE -ne 0) { Write-PrizmWarn "git stash pop failed after merge" }
+  }
+
+  return $true
+}
+
+function Restore-PrizmOriginalBranch {
+  param(
+    [string]$ProjectRoot,
+    [string]$OriginalBranch,
+    [string]$DevBranch = ''
+  )
+
+  if (-not $OriginalBranch) { return $true }
+
+  & git -C $ProjectRoot rebase --show-current-patch *> $null
+  if ($LASTEXITCODE -eq 0) {
+    Write-PrizmWarn "Aborting in-progress rebase..."
+    & git -C $ProjectRoot rebase --abort *> $null
+  }
+
+  $currentBranch = Get-PrizmCurrentBranch $ProjectRoot
+  if ($currentBranch -eq $OriginalBranch) { return $true }
+
+  $wipBranch = if ($DevBranch) { $DevBranch } else { $currentBranch }
+  if ($wipBranch -and $wipBranch -ne $OriginalBranch) {
+    Save-PrizmBranchWip $ProjectRoot $wipBranch | Out-Null
+  }
+
+  Write-PrizmInfo "Ensuring return to original branch: $OriginalBranch (currently on: $currentBranch)"
+
+  $hadStash = $false
+  if (Test-PrizmTrackedDirty $ProjectRoot) {
+    & git -C $ProjectRoot stash push -m 'pipeline-ensure-return-stash' *> $null
+    if ($LASTEXITCODE -eq 0) { $hadStash = $true }
+  }
+
+  & git -C $ProjectRoot checkout $OriginalBranch *> $null
+  if ($LASTEXITCODE -eq 0) {
+    Write-PrizmInfo "Returned to branch: $OriginalBranch"
+  } else {
+    Write-PrizmError "Failed to checkout $OriginalBranch - manual recovery needed"
+  }
+
+  if ($hadStash) {
+    & git -C $ProjectRoot stash pop *> $null
+    if ($LASTEXITCODE -ne 0) { Write-PrizmWarn "git stash pop failed during branch return" }
+  }
+
+  return $true
+}

package/bundled/dev-pipeline-windows/lib/common.ps1

@@ -3,6 +3,47 @@ $ErrorActionPreference = 'Stop'
 
 $script:PrizmAiProcess = $null
 
+if (-not ('PrizmLineLogBridge' -as [type])) {
+  Add-Type -TypeDefinition @'
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Text;
+
+public sealed class PrizmLineLogBridge : IDisposable
+{
+    private readonly StreamWriter writer;
+    private readonly object sync = new object();
+    public readonly DataReceivedEventHandler Handler;
+
+    public PrizmLineLogBridge(string logPath)
+    {
+        writer = new StreamWriter(logPath, false, new UTF8Encoding(false));
+        Handler = new DataReceivedEventHandler(OnDataReceived);
+    }
+
+    private void OnDataReceived(object sender, DataReceivedEventArgs eventArgs)
+    {
+        if (eventArgs.Data == null) return;
+        lock (sync)
+        {
+            writer.WriteLine(eventArgs.Data);
+            writer.Flush();
+        }
+    }
+
+    public void Dispose()
+    {
+        lock (sync)
+        {
+            writer.Flush();
+            writer.Dispose();
+        }
+    }
+}
+'@
+}
+
 function Write-PrizmInfo { param([string]$Message) Write-Host "[INFO]    $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') $Message" -ForegroundColor Blue }
 function Write-PrizmWarn { param([string]$Message) Write-Host "[WARN]    $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') $Message" -ForegroundColor Yellow }
 function Write-PrizmError { param([string]$Message) Write-Host "[ERROR]   $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') $Message" -ForegroundColor Red }
@@ -298,6 +339,90 @@ function Get-PrizmSessionPlatform {
   return Get-PrizmPlatformFromCli $CliCommand
 }
 
+function Get-PrizmCodexSubagentTimeoutSeconds {
+  $configuredTimeout = 0
+  if ([int]::TryParse($env:CODEX_SUBAGENT_TIMEOUT_SECONDS, [ref]$configuredTimeout) -and $configuredTimeout -gt 0) {
+    return $configuredTimeout
+  }
+
+  $outerThreshold = 0
+  $outerThresholdText = if ($env:STALE_KILL_THRESHOLD) { $env:STALE_KILL_THRESHOLD } else { $env:SESSION_TIMEOUT }
+  if ([int]::TryParse($outerThresholdText, [ref]$outerThreshold) -and $outerThreshold -gt 120) {
+    return ($outerThreshold - 60)
+  }
+
+  return 840
+}
+
+function Test-PrizmCodexJsonSupport {
+  param([string]$CliExecutable)
+  try {
+    $helpOutput = & $CliExecutable exec --help 2>&1
+    return (($helpOutput -join "`n") -match '--json')
+  } catch {
+    return $false
+  }
+}
+
+function Test-PrizmStreamJsonSupport {
+  param([string]$CliCommand)
+  $sessionPlatform = Get-PrizmSessionPlatform $CliCommand
+  $parsedCli = Split-PrizmCommandLine $CliCommand
+
+  if ($sessionPlatform -eq 'codebuddy') { return $true }
+  if ($sessionPlatform -eq 'codex') { return (Test-PrizmCodexJsonSupport $parsedCli.Command) }
+
+  try {
+    $helpOutput = & $parsedCli.Command --help 2>&1
+    return (($helpOutput -join "`n") -match 'stream-json')
+  } catch {
+    return $false
+  }
+}
+
+function Start-PrizmProgressParser {
+  param(
+    [string[]]$PythonCommand,
+    [string]$ScriptsDir,
+    [string]$SessionLog,
+    [string]$ProgressFile,
+    [string]$CliCommand
+  )
+
+  if (-not (Test-PrizmStreamJsonSupport $CliCommand)) { return $null }
+
+  $parserScript = Join-Path $ScriptsDir 'parse-stream-progress.py'
+  if (-not (Test-Path $parserScript)) { return $null }
+
+  $cmd = $PythonCommand[0]
+  $prefix = @()
+  if ($PythonCommand.Count -gt 1) { $prefix = $PythonCommand[1..($PythonCommand.Count - 1)] }
+
+  $progressDir = Split-Path $ProgressFile -Parent
+  if ($progressDir) { New-Item -ItemType Directory -Force -Path $progressDir | Out-Null }
+
+  $psi = [System.Diagnostics.ProcessStartInfo]::new()
+  $psi.UseShellExecute = $false
+  $psi.CreateNoWindow = $true
+  $psi.FileName = $cmd
+  $psi.Arguments = Join-PrizmProcessArguments ($prefix + @($parserScript, '--session-log', $SessionLog, '--progress-file', $ProgressFile))
+  return [System.Diagnostics.Process]::Start($psi)
+}
+
+function Stop-PrizmProgressParser {
+  param($Process)
+  if ($Process -eq $null) { return }
+  try {
+    if (-not $Process.HasExited) {
+      try {
+        $Process.Kill($true)
+      } catch {
+        Stop-PrizmProcessTreeById -ProcessId ([int]$Process.Id)
+      }
+    }
+  } catch {}
+}
+
 function Stop-PrizmProcessTreeById {
   param([int]$ProcessId)
   if ($ProcessId -le 0) { return }
@@ -328,6 +453,28 @@ function Stop-PrizmProcessTreeById {
   }
 }
 
+function Stop-PrizmSessionProcess {
+  param([string]$PidPath)
+  if (-not (Test-Path $PidPath)) { return }
+  $rawPid = Get-Content $PidPath -ErrorAction SilentlyContinue | Select-Object -First 1
+  $aiPid = 0
+  if ([int]::TryParse($rawPid, [ref]$aiPid)) {
+    Stop-PrizmProcessTreeById -ProcessId $aiPid
+  }
+}
+
+function Write-PrizmStaleKillMarker {
+  param([string]$MarkerPath, [int]$StaleSeconds, [int]$Threshold)
+  $markerDir = Split-Path $MarkerPath -Parent
+  if ($markerDir) { New-Item -ItemType Directory -Force -Path $markerDir | Out-Null }
+  [ordered]@{
+    killed_at = (Get-Date).ToUniversalTime().ToString('yyyy-MM-ddTHH:mm:ssZ')
+    reason = 'stale_session'
+    stale_seconds = $StaleSeconds
+    threshold = $Threshold
+  } | ConvertTo-Json -Compress | Set-Content -Path $MarkerPath -Encoding UTF8
+}
+
 function Invoke-PrizmAiSession {
   param(
     [string]$CliCommand,
@@ -352,16 +499,27 @@ function Invoke-PrizmAiSession {
   $parsedCli = Split-PrizmCommandLine $CliCommand
   $cliExecutable = $parsedCli.Command
   $sessionPlatform = Get-PrizmSessionPlatform $CliCommand
+  $useStreamJson = Test-PrizmStreamJsonSupport $CliCommand
 
   if ($sessionPlatform -eq 'claude') {
     $cliArgs += @('-p', '--dangerously-skip-permissions')
+    if ($env:VERBOSE -in @('1','true','yes','on') -or $useStreamJson) { $cliArgs += '--verbose' }
+    if ($useStreamJson) { $cliArgs += @('--output-format', 'stream-json') }
     if ($Model) { $cliArgs += @('--model', $Model) }
   } elseif ($sessionPlatform -eq 'codex') {
-    $cliArgs += @('--ask-for-approval', 'never', '--sandbox', 'danger-full-access', 'exec', '--cd', $ProjectRoot, '--skip-git-repo-check')
+    $cliArgs += @('--ask-for-approval', 'never', '--sandbox', 'danger-full-access')
+    $codexSubagentTimeout = Get-PrizmCodexSubagentTimeoutSeconds
+    if ($codexSubagentTimeout -gt 0) {
+      $cliArgs += @('--config', "agents.job_max_runtime_seconds=$codexSubagentTimeout")
+    }
+    $cliArgs += @('exec', '--cd', $ProjectRoot, '--skip-git-repo-check')
+    if ($useStreamJson) { $cliArgs += '--json' }
     if ($Model) { $cliArgs += @('--model', $Model) }
     $cliArgs += '-'
   } else {
     $cliArgs += @('--print', '-y')
+    if ($env:VERBOSE -in @('1','true','yes','on')) { $cliArgs += '--verbose' }
+    if ($useStreamJson) { $cliArgs += @('--output-format', 'stream-json') }
     if ($Model) { $cliArgs += @('--model', $Model) }
   }
   $generatedArgs = (($cliArgs | ForEach-Object { ConvertTo-PrizmProcessArgument $_ }) -join ' ')
@@ -390,20 +548,27 @@ function Invoke-PrizmAiSession {
 
   $process = [System.Diagnostics.Process]::Start($psi)
   $script:PrizmAiProcess = $process
+  $logBridge = [PrizmLineLogBridge]::new($LogPath)
+  $process.add_OutputDataReceived($logBridge.Handler)
+  $process.add_ErrorDataReceived($logBridge.Handler)
   if ($PidPath) {
     $pidDir = Split-Path $PidPath -Parent
     if ($pidDir) { New-Item -ItemType Directory -Force -Path $pidDir | Out-Null }
     Set-Content -Path $PidPath -Value ([string]$process.Id) -Encoding UTF8
   }
-  $process.StandardInput.Write($prompt)
-  $process.StandardInput.Close()
-  $stdoutTask = $process.StandardOutput.ReadToEndAsync()
-  $stderrTask = $process.StandardError.ReadToEndAsync()
-  $process.WaitForExit()
-  $stdout = $stdoutTask.Result
-  $stderr = $stderrTask.Result
-  Set-Content -Path $LogPath -Value ($stdout + $stderr) -Encoding UTF8
-  return $process.ExitCode
+  try {
+    $process.BeginOutputReadLine()
+    $process.BeginErrorReadLine()
+    $process.StandardInput.Write($prompt)
+    $process.StandardInput.Close()
+    $process.WaitForExit()
+    $process.WaitForExit()
+    return $process.ExitCode
+  } finally {
+    $process.remove_OutputDataReceived($logBridge.Handler)
+    $process.remove_ErrorDataReceived($logBridge.Handler)
+    $logBridge.Dispose()
+  }
 }
 
 function New-PrizmSessionId {

package/bundled/dev-pipeline-windows/lib/pipeline.ps1

@@ -1,4 +1,5 @@
 . "$PSScriptRoot\common.ps1"
+. "$PSScriptRoot\branch.ps1"
 $global:PRIZM_EXIT_CODE = 0
 
 function Invoke-PrizmPipeline {
@@ -83,6 +84,54 @@ function Invoke-PrizmPipeline {
     }
     $timeoutSeconds = $parsedEnvTimeout
   }
+  $heartbeatInterval = 30
+  if ($env:HEARTBEAT_INTERVAL) {
+    $parsedHeartbeatInterval = 0
+    if (-not [int]::TryParse($env:HEARTBEAT_INTERVAL, [ref]$parsedHeartbeatInterval) -or $parsedHeartbeatInterval -lt 1) {
+      throw "HEARTBEAT_INTERVAL must be a positive integer: $($env:HEARTBEAT_INTERVAL)"
+    }
+    $heartbeatInterval = $parsedHeartbeatInterval
+  }
+  $staleKillThreshold = 900
+  if ($env:STALE_KILL_THRESHOLD) {
+    $parsedStaleKillThreshold = 0
+    if (-not [int]::TryParse($env:STALE_KILL_THRESHOLD, [ref]$parsedStaleKillThreshold) -or $parsedStaleKillThreshold -lt 0) {
+      throw "STALE_KILL_THRESHOLD must be a non-negative integer: $($env:STALE_KILL_THRESHOLD)"
+    }
+    $staleKillThreshold = $parsedStaleKillThreshold
+  }
+  $staleKillGraceSeconds = 10
+  if ($env:STALE_KILL_GRACE_SECONDS) {
+    $parsedStaleKillGraceSeconds = 0
+    if (-not [int]::TryParse($env:STALE_KILL_GRACE_SECONDS, [ref]$parsedStaleKillGraceSeconds) -or $parsedStaleKillGraceSeconds -lt 0) {
+      throw "STALE_KILL_GRACE_SECONDS must be a non-negative integer: $($env:STALE_KILL_GRACE_SECONDS)"
+    }
+    $staleKillGraceSeconds = $parsedStaleKillGraceSeconds
+  }
+  $autoPush = $env:AUTO_PUSH -in @('1','true','yes','on')
+  $enableDeploy = $env:ENABLE_DEPLOY -in @('1','true','yes','on')
+  $stopOnFailure = $env:STOP_ON_FAILURE -in @('1','true','yes','on')
+  $devBranchOverride = if ($env:DEV_BRANCH) { $env:DEV_BRANCH.Trim() } else { '' }
+  $logCleanupEnabled = $true
+  if ($env:LOG_CLEANUP_ENABLED) {
+    $logCleanupEnabled = $env:LOG_CLEANUP_ENABLED -in @('1','true','yes','on')
+  }
+  $logRetentionDays = 14
+  if ($env:LOG_RETENTION_DAYS) {
+    $parsedLogRetentionDays = 0
+    if (-not [int]::TryParse($env:LOG_RETENTION_DAYS, [ref]$parsedLogRetentionDays) -or $parsedLogRetentionDays -lt 0) {
+      throw "LOG_RETENTION_DAYS must be a non-negative integer: $($env:LOG_RETENTION_DAYS)"
+    }
+    $logRetentionDays = $parsedLogRetentionDays
+  }
+  $logMaxTotalMb = 1024
+  if ($env:LOG_MAX_TOTAL_MB) {
+    $parsedLogMaxTotalMb = 0
+    if (-not [int]::TryParse($env:LOG_MAX_TOTAL_MB, [ref]$parsedLogMaxTotalMb) -or $parsedLogMaxTotalMb -lt 0) {
+      throw "LOG_MAX_TOTAL_MB must be a non-negative integer: $($env:LOG_MAX_TOTAL_MB)"
+    }
+    $logMaxTotalMb = $parsedLogMaxTotalMb
+  }
   $featuresFilter = $null
 
   for ($i = 0; $i -lt $remaining.Count; $i++) {
@@ -130,7 +179,7 @@ function Invoke-PrizmPipeline {
     $criticLabel = if ($critic) { $critic } else { 'plan-default' }
     $retryLabel = if ($maxRetries -ne $null) { [string]$maxRetries } else { 'default' }
     Write-PrizmInfo "Verbose mode enabled."
-    Write-PrizmInfo "Effective options: mode=$modeLabel critic=$criticLabel maxRetries=$retryLabel timeoutSeconds=$timeoutSeconds dryRun=$dryRun"
+    Write-PrizmInfo "Effective options: mode=$modeLabel critic=$criticLabel maxRetries=$retryLabel timeoutSeconds=$timeoutSeconds staleKillThreshold=$staleKillThreshold dryRun=$dryRun"
   }
 
   if (-not (Test-Path $listPath)) { throw "List file not found: $listPath" }
@@ -227,6 +276,28 @@ function Invoke-PrizmPipeline {
     return -not [string]::IsNullOrWhiteSpace([string]$dirty)
   }
 
+  function Stop-PrizmSessionProcess {
+    param([string]$PidPath)
+    if (-not (Test-Path $PidPath)) { return }
+    $rawPid = Get-Content $PidPath -ErrorAction SilentlyContinue | Select-Object -First 1
+    $aiPid = 0
+    if ([int]::TryParse($rawPid, [ref]$aiPid)) {
+      Stop-PrizmProcessTreeById -ProcessId $aiPid
+    }
+  }
+
+  function Write-PrizmStaleKillMarker {
+    param([string]$MarkerPath, [int]$StaleSeconds, [int]$Threshold)
+    $markerDir = Split-Path $MarkerPath -Parent
+    if ($markerDir) { New-Item -ItemType Directory -Force -Path $markerDir | Out-Null }
+    [ordered]@{
+      killed_at = (Get-Date).ToUniversalTime().ToString('yyyy-MM-ddTHH:mm:ssZ')
+      reason = 'stale_session'
+      stale_seconds = $StaleSeconds
+      threshold = $Threshold
+    } | ConvertTo-Json -Compress | Set-Content -Path $MarkerPath -Encoding UTF8
+  }
+
   function Invoke-PrizmGitAutoCommit {
     param([string]$ProjectRoot, [string]$Message)
     & git -C $ProjectRoot add -A *> $null
@@ -251,6 +322,140 @@ function Invoke-PrizmPipeline {
     & git -C $ProjectRoot commit --no-verify --amend --no-edit --only -- $listRel *> $null
   }
 
+  function Invoke-PrizmGitCommitPath {
+    param([string]$ProjectRoot, [string]$Path, [string]$Message)
+    if (-not $Path) { return $false }
+    $relPath = ConvertTo-PrizmGitRelativePath $ProjectRoot $Path
+    if (-not $relPath) { return $false }
+    & git -C $ProjectRoot diff --quiet -- $relPath 2>$null
+    if ($LASTEXITCODE -eq 0) { return $false }
+    & git -C $ProjectRoot add -- $relPath *> $null
+    if ($LASTEXITCODE -ne 0) { return $false }
+    & git -C $ProjectRoot commit --no-verify -m $Message *> $null
+    return $LASTEXITCODE -eq 0
+  }
+
+  function New-PrizmDefaultDevBranchName {
+    param([string]$Kind, [string]$CurrentItemId)
+    $timestamp = Get-Date -Format 'yyyyMMddHHmm'
+    switch ($Kind) {
+      'feature' { return "dev/$CurrentItemId-$timestamp" }
+      'bugfix' { return "bugfix/$CurrentItemId-$timestamp" }
+      'refactor' { return "refactor/$CurrentItemId-$timestamp" }
+      default { return "dev/$CurrentItemId-$timestamp" }
+    }
+  }
+
+  function Invoke-PrizmLogCleanup {
+    if (-not $logCleanupEnabled) { return }
+    if (-not (Test-Path $stateDir)) { return }
+
+    try {
+      $cleanup = Invoke-PrizmPythonJson $python @(
+        (Join-Path $paths.ScriptsDir 'cleanup-logs.py'),
+        '--state-dir', $stateDir,
+        '--retention-days', [string]$logRetentionDays,
+        '--max-total-mb', [string]$logMaxTotalMb
+      )
+      if ($cleanup -and $cleanup.deleted_files -gt 0) {
+        $reclaimedKb = [int]([int64]$cleanup.reclaimed_bytes / 1024)
+        Write-PrizmInfo "Log cleanup: deleted $($cleanup.deleted_files) files, reclaimed ${reclaimedKb}KB"
+      }
+    } catch {
+      Write-PrizmWarn "Log cleanup failed (continuing)"
+    }
+  }
+
+  function Get-PrizmDeployIncompleteItems {
+    param([string]$Kind, [string]$ListPath)
+
+    if (-not (Test-Path $ListPath)) { return @("List file not found: $ListPath") }
+    try {
+      $data = Get-Content -Raw $ListPath | ConvertFrom-Json
+    } catch {
+      return @("List file is not valid JSON: $ListPath")
+    }
+
+    $collectionName = @{ feature = 'features'; bugfix = 'bugs'; refactor = 'refactors' }[$Kind]
+    $allowedStatuses = @{
+      feature = @('completed', 'skipped')
+      bugfix = @('completed', 'skipped', 'needs_info')
+      refactor = @('completed', 'skipped')
+    }[$Kind]
+
+    $items = @()
+    $property = $data.PSObject.Properties[$collectionName]
+    if ($property -and $property.Value) { $items = @($property.Value) }
+
+    $bad = @()
+    foreach ($item in $items) {
+      $status = if ($item.PSObject.Properties['status']) { [string]$item.status } else { 'unknown' }
+      if ($status -notin $allowedStatuses) {
+        $itemIdText = if ($item.PSObject.Properties['id']) { [string]$item.id } else { 'unknown' }
+        $titleText = if ($item.PSObject.Properties['title']) { [string]$item.title } else { '' }
+        $bad += "  ${itemIdText}: $status - $titleText"
+      }
+    }
+    return @($bad)
+  }
+
+  function Invoke-PrizmDeploySession {
+    param([string]$Kind, [string]$ListPath)
+
+    if (-not $enableDeploy) { return 0 }
+
+    $incomplete = @(Get-PrizmDeployIncompleteItems $Kind $ListPath)
+    if ($incomplete.Count -gt 0) {
+      Write-PrizmWarn "DEPLOY BLOCKED: $($incomplete.Count) task(s) not completed successfully."
+      foreach ($line in $incomplete) { Write-PrizmWarn $line }
+      Write-PrizmWarn "Fix failed tasks and re-run, or manually run /prizmkit-deploy."
+      return 1
+    }
+
+    Write-PrizmInfo "All tasks completed - starting deploy session..."
+    Write-PrizmInfo "ENABLE_DEPLOY=1"
+
+    $deploySessionId = "deploy-$(Get-Date -Format 'yyyyMMddHHmmss')"
+    $deploySessionDir = Join-Path $stateDir "deploy\$deploySessionId"
+    $deployLogsDir = Join-Path $deploySessionDir 'logs'
+    New-Item -ItemType Directory -Force -Path $deployLogsDir | Out-Null
+
+    $deployPrompt = Join-Path $deploySessionDir 'bootstrap-prompt.md'
+    $deployLog = Join-Path $deployLogsDir 'session.log'
+    $deployPidPath = Join-Path $deployLogsDir 'ai.pid'
+    $deployBranch = Get-PrizmCurrentBranch $paths.ProjectRoot
+    if (-not $deployBranch) { $deployBranch = 'unknown' }
+    $deployCommit = & git -C $paths.ProjectRoot rev-parse --short HEAD 2>$null
+    if ($LASTEXITCODE -ne 0 -or -not $deployCommit) { $deployCommit = 'unknown' }
+    $deployCommit = [string]($deployCommit | Select-Object -First 1)
+
+    @(
+      '## Deploy',
+      '',
+      "All $Kind tasks in the pipeline completed successfully.",
+      '',
+      "- Branch: $deployBranch",
+      "- Commit: $deployCommit",
+      '',
+      'Run /prizmkit-deploy to deploy the project. Read .prizmkit/deploy/deploy.config.json',
+      'for deployment configuration. If no deploy config exists, guide the user through',
+      'setting one up before deploying.'
+    ) | Set-Content -Path $deployPrompt -Encoding UTF8
+
+    Write-PrizmInfo "Deploy prompt: $deployPrompt"
+    Write-PrizmInfo "Deploy log: $deployLog"
+
+    $cli = Resolve-PrizmAiCli $paths.ProjectRoot $paths.PrizmkitDir
+    $env:PRIZMKIT_PLATFORM = Get-PrizmPlatformFromProject $paths.ProjectRoot $paths.PrizmkitDir $cli
+    $exitCode = Invoke-PrizmAiSession -CliCommand $cli -PromptPath $deployPrompt -LogPath $deployLog -ProjectRoot $paths.ProjectRoot -Model $env:MODEL -PidPath $deployPidPath
+    if ($exitCode -eq 0) {
+      Write-PrizmSuccess "Deploy session completed"
+    } else {
+      Write-PrizmWarn "Deploy session failed with exit code $exitCode"
+    }
+    return $exitCode
+  }
+
   function Invoke-PrizmPipelineItem {
     param([string]$CurrentItemId)
     $script:PRIZM_ITEM_EXIT_CODE = 0
@@ -260,7 +465,8 @@ function Invoke-PrizmPipeline {
     $retryCount = '0'
     $resumePhase = 'null'
     $isGitRepository = if (-not $dryRun) { Test-PrizmGitRepository $paths.ProjectRoot } else { $false }
-    $baseCommit = if ($isGitRepository) { Get-PrizmGitHead $paths.ProjectRoot } else { '' }
+    $originalBranch = if ($isGitRepository) { Get-PrizmCurrentBranch $paths.ProjectRoot } else { '' }
+    $devBranchName = ''
     $hadDirtyBaseline = if ($isGitRepository) { Test-PrizmGitWorkDirty $paths.ProjectRoot $stateDir $listPath } else { $false }
     if ($hadDirtyBaseline) {
       Write-PrizmWarn "Dirty working tree detected before pipeline bookkeeping; session success requires a new commit."
@@ -281,8 +487,21 @@ function Invoke-PrizmPipeline {
       $start = Invoke-PrizmPythonJson $python (@((Join-Path $paths.ScriptsDir $updateScript), $listOption, $listPath, '--state-dir', $stateDir, '--action', 'start', $idOption, $CurrentItemId, '--session-id', $sessionId) + $maxRetryArgs)
       if ($start.retry_count -ne $null) { $retryCount = [string]$start.retry_count }
       if ($start.resume_from_phase -ne $null) { $resumePhase = [string]$start.resume_from_phase }
+
+      if ($isGitRepository -and $originalBranch) {
+        Invoke-PrizmGitCommitPath $paths.ProjectRoot $listPath "chore($CurrentItemId): mark in_progress" | Out-Null
+        $candidateBranch = if ($devBranchOverride) { $devBranchOverride } else { New-PrizmDefaultDevBranchName $Kind $CurrentItemId }
+        if (New-PrizmDevBranch $paths.ProjectRoot $candidateBranch $originalBranch) {
+          $devBranchName = $candidateBranch
+          Write-PrizmInfo "Dev branch: $devBranchName"
+        } else {
+          Write-PrizmWarn "Failed to create dev branch; running on current branch: $originalBranch"
+        }
+      }
     }
 
+    $baseCommit = if ($isGitRepository) { Get-PrizmGitHead $paths.ProjectRoot } else { '' }
+
     $sessionDir = if ($dryRun) {
       Join-Path ([System.IO.Path]::GetTempPath()) "prizmkit-dry-run\$sessionId"
     } else {
@@ -321,35 +540,84 @@ function Invoke-PrizmPipeline {
 
     Write-PrizmInfo "Starting $cli session for $CurrentItemId ($sessionId)"
 
+    $progressJson = Join-Path $logsDir 'progress.json'
+    $parserProcess = Start-PrizmProgressParser -PythonCommand $python -ScriptsDir $paths.ScriptsDir -SessionLog $sessionLog -ProgressFile $progressJson -CliCommand $cli
+
     $job = Start-Job -ScriptBlock {
       param($commonPath, $cli, $promptPath, $sessionLog, $projectRoot, $model, $pidPath)
       . $commonPath
       Invoke-PrizmAiSession -CliCommand $cli -PromptPath $promptPath -LogPath $sessionLog -ProjectRoot $projectRoot -Model $model -PidPath $pidPath
     } -ArgumentList (Join-Path $paths.PipelineDir 'lib\common.ps1'), $cli, $promptPath, $sessionLog, $paths.ProjectRoot, $effectiveModel, $pidPath
 
-    $completed = if ($timeoutSeconds -le 0) {
-      Wait-Job $job
-    } else {
-      Wait-Job $job -Timeout $timeoutSeconds
-    }
-    if (-not $completed) {
-      if (Test-Path $pidPath) {
-        $rawPid = Get-Content $pidPath -ErrorAction SilentlyContinue | Select-Object -First 1
-        $aiPid = 0
-        if ([int]::TryParse($rawPid, [ref]$aiPid)) {
-          Stop-PrizmProcessTreeById -ProcessId $aiPid
-        }
+    $elapsedSeconds = 0
+    $staleSeconds = 0
+    $previousLogSize = 0
+    $wasTimedOut = $false
+    $staleKillMarker = Join-Path $logsDir 'stale-kill.json'
+    $wasStaleKilled = $false
+    while ($true) {
+      $remainingTimeout = if ($timeoutSeconds -gt 0) { $timeoutSeconds - $elapsedSeconds } else { $heartbeatInterval }
+      $waitSeconds = if ($timeoutSeconds -gt 0) { [Math]::Min($heartbeatInterval, [Math]::Max(1, $remainingTimeout)) } else { $heartbeatInterval }
+      $completed = Wait-Job $job -Timeout $waitSeconds
+      if ($completed) { break }
+
+      $elapsedSeconds += $waitSeconds
+      $currentLogSize = 0
+      if (Test-Path $sessionLog) {
+        $currentLogSize = [int64](Get-Item $sessionLog).Length
+      }
+      $growth = $currentLogSize - $previousLogSize
+      $previousLogSize = $currentLogSize
+      if ($growth -gt 0) {
+        $staleSeconds = 0
+      } else {
+        $staleSeconds += $waitSeconds
       }
+
+      if ($timeoutSeconds -gt 0 -and $elapsedSeconds -ge $timeoutSeconds) {
+        $wasTimedOut = $true
+        Stop-PrizmSessionProcess $pidPath
+        break
+      }
+
+      if ($staleKillThreshold -gt 0 -and $staleSeconds -ge $staleKillThreshold) {
+        $wasStaleKilled = $true
+        Write-PrizmWarn "Session stale-killed (no progress for ${staleKillThreshold}s)"
+        Write-PrizmStaleKillMarker $staleKillMarker $staleSeconds $staleKillThreshold
+        Stop-PrizmSessionProcess $pidPath
+        if ($staleKillGraceSeconds -gt 0) { Start-Sleep -Seconds $staleKillGraceSeconds }
+        break
+      }
+    }
+
+    $exitCode = 0
+    if ($wasTimedOut) {
+      Stop-Job $job
+      Remove-Job $job
+      $exitCode = 124
+    } elseif ($wasStaleKilled) {
       Stop-Job $job
       Remove-Job $job
-      Invoke-PrizmPythonText $python (@((Join-Path $paths.ScriptsDir $updateScript), $listOption, $listPath, '--state-dir', $stateDir, '--action', 'update', $idOption, $CurrentItemId, '--session-id', $sessionId, '--session-status', 'timed_out') + $maxRetryArgs)
-      throw "AI session timed out after $timeoutSeconds seconds. Log: $sessionLog"
+      $exitCode = 143
+    } else {
+      try {
+        $exitCode = [int](Receive-Job $job)
+      } catch {
+        Write-PrizmWarn "AI session job failed: $($_.Exception.Message)"
+        $exitCode = 1
+      }
+      Remove-Job $job
     }
+    Stop-PrizmProgressParser $parserProcess
 
-    $exitCode = [int](Receive-Job $job)
-    Remove-Job $job
     $status = 'crashed'
-    if ($exitCode -ne 0) {
+    if ($wasTimedOut) {
+      $status = 'timed_out'
+      Write-PrizmWarn "AI session timed out after $timeoutSeconds seconds"
+    } elseif ($wasStaleKilled -or (Test-Path $staleKillMarker)) {
+      Write-PrizmWarn "Session was stale-killed by heartbeat monitor (no progress for too long)"
+      Write-PrizmWarn "Stale-killed sessions are treated as failed; dev branch is preserved for inspection"
+    } elseif ($exitCode -ne 0) {
       Write-PrizmWarn "AI session exited with code $exitCode"
     } elseif (-not $isGitRepository) {
       Write-PrizmWarn "AI session exited cleanly, but project is not a git repository; cannot verify work was committed."
@@ -368,27 +636,57 @@ function Invoke-PrizmPipeline {
       Write-PrizmWarn "AI session exited cleanly but produced no commits and no changes."
     }
 
-    Invoke-PrizmPythonText $python (@((Join-Path $paths.ScriptsDir $updateScript), $listOption, $listPath, '--state-dir', $stateDir, '--action', 'update', $idOption, $CurrentItemId, '--session-id', $sessionId, '--session-status', $status) + $maxRetryArgs)
+    $mergeSucceeded = $true
+    if ($status -eq 'success') {
+      Invoke-PrizmPythonText $python (@((Join-Path $paths.ScriptsDir $updateScript), $listOption, $listPath, '--state-dir', $stateDir, '--action', 'update', $idOption, $CurrentItemId, '--session-id', $sessionId, '--session-status', $status) + $maxRetryArgs)
+
+      if (Test-PrizmGitDirty $paths.ProjectRoot) {
+        if ($hadDirtyBaseline) {
+          Write-PrizmInfo "Auto-committing pipeline bookkeeping artifacts only."
+          Invoke-PrizmGitIncludeBookkeepingArtifacts $paths.ProjectRoot $stateDir $listPath
+        } else {
+          Write-PrizmInfo "Auto-committing remaining session artifacts."
+          Invoke-PrizmGitIncludeRemainingArtifacts $paths.ProjectRoot $CurrentItemId
+        }
+      }
 
-    if ($status -eq 'success' -and (Test-PrizmGitDirty $paths.ProjectRoot)) {
-      if ($hadDirtyBaseline) {
-        Write-PrizmInfo "Auto-committing pipeline bookkeeping artifacts only."
-        Invoke-PrizmGitIncludeBookkeepingArtifacts $paths.ProjectRoot $stateDir $listPath
-      } else {
-        Write-PrizmInfo "Auto-committing remaining session artifacts."
-        Invoke-PrizmGitIncludeRemainingArtifacts $paths.ProjectRoot $CurrentItemId
+      if ($isGitRepository -and $devBranchName) {
+        if (Merge-PrizmDevBranch $paths.ProjectRoot $devBranchName $originalBranch $autoPush) {
+          $devBranchName = ''
+        } else {
+          $mergeSucceeded = $false
+          $status = 'merge_conflict'
+          Write-PrizmWarn "Auto-merge failed - dev branch preserved for inspection"
+        }
       }
+    } elseif ($isGitRepository -and $devBranchName) {
+      Write-PrizmWarn "Session failed - dev branch preserved for inspection: $devBranchName"
     }
 
-    if ($status -eq 'success') {
+    if ($isGitRepository -and $originalBranch) {
+      Restore-PrizmOriginalBranch $paths.ProjectRoot $originalBranch $devBranchName | Out-Null
+    }
+
+    if ($status -ne 'success') {
+      Invoke-PrizmPythonText $python (@((Join-Path $paths.ScriptsDir $updateScript), $listOption, $listPath, '--state-dir', $stateDir, '--action', 'update', $idOption, $CurrentItemId, '--session-id', $sessionId, '--session-status', $status) + $maxRetryArgs)
+      if ($isGitRepository) {
+        Invoke-PrizmGitCommitPath $paths.ProjectRoot $listPath "chore($CurrentItemId): update $idName status" | Out-Null
+      }
+    }
+
+    if ($status -eq 'success' -and $mergeSucceeded) {
       Write-PrizmSuccess "$Kind item completed: $CurrentItemId"
     } else {
       Write-PrizmError "$Kind item failed: $CurrentItemId. Log: $sessionLog"
     }
-    $script:PRIZM_ITEM_EXIT_CODE = if ($status -eq 'success') { 0 } else { 1 }
+    $script:PRIZM_ITEM_EXIT_CODE = if ($status -eq 'success' -and $mergeSucceeded) { 0 } else { 1 }
     return
   }
 
+  if (-not $dryRun) {
+    Invoke-PrizmLogCleanup
+  }
+
   if ($itemId) {
     Invoke-PrizmPipelineItem $itemId
     $global:PRIZM_EXIT_CODE = $script:PRIZM_ITEM_EXIT_CODE
@@ -407,6 +705,10 @@ function Invoke-PrizmPipeline {
       } else {
         Write-PrizmSuccess "Processed $processedCount $Kind item(s)."
       }
+      if (-not $dryRun) {
+        $deployExit = Invoke-PrizmDeploySession $Kind $listPath
+        if ($deployExit -ne 0 -and $lastExitCode -eq 0) { $lastExitCode = $deployExit }
+      }
       $global:PRIZM_EXIT_CODE = $lastExitCode
       return
     }
@@ -438,7 +740,7 @@ function Invoke-PrizmPipeline {
       $global:PRIZM_EXIT_CODE = $lastExitCode
       return
     }
-    if ($lastExitCode -ne 0 -and $env:STOP_ON_FAILURE -eq '1') {
+    if ($lastExitCode -ne 0 -and $stopOnFailure) {
       $global:PRIZM_EXIT_CODE = $lastExitCode
       return
     }

package/bundled/dev-pipeline-windows/run-recovery.ps1

@@ -41,6 +41,22 @@ for ($i = 0; $i -lt $remaining.Count; $i++) {
   }
 }
 
+function Get-PrizmRecoveryIntEnv {
+  param([string]$Name, [int]$DefaultValue, [int]$MinimumValue = 0)
+  $value = [Environment]::GetEnvironmentVariable($Name, 'Process')
+  if (-not $value) { return $DefaultValue }
+  $parsed = 0
+  if (-not [int]::TryParse($value, [ref]$parsed) -or $parsed -lt $MinimumValue) {
+    throw "$Name must be an integer >= $MinimumValue`: $value"
+  }
+  return $parsed
+}
+
+$timeoutSeconds = Get-PrizmRecoveryIntEnv 'SESSION_TIMEOUT' 0 0
+$heartbeatInterval = Get-PrizmRecoveryIntEnv 'HEARTBEAT_INTERVAL' 30 1
+$staleKillThreshold = Get-PrizmRecoveryIntEnv 'STALE_KILL_THRESHOLD' 900 0
+$staleKillGraceSeconds = Get-PrizmRecoveryIntEnv 'STALE_KILL_GRACE_SECONDS' 10 0
+
 $recoveryDetectScript = $null
 foreach ($candidate in @(
   (Join-Path $paths.ProjectRoot '.agents\skills\recovery-workflow\scripts\detect-recovery-state.py'),
@@ -60,17 +76,97 @@ if (-not $recoveryDetectScript) {
 $stateDir = Join-Path $paths.PrizmkitDir 'state\recovery'
 New-Item -ItemType Directory -Force -Path $stateDir | Out-Null
 $detectionPath = Join-Path $stateDir 'detection.json'
-$promptPath = Join-Path $paths.PrizmkitDir 'state\recovery-bootstrap-prompt.md'
-$logPath = Join-Path $paths.PrizmkitDir 'state\recovery-session.log'
 
 Invoke-PrizmPythonText $python @($recoveryDetectScript, '--project-root', $paths.ProjectRoot) | Set-Content -Path $detectionPath -Encoding UTF8
 if ($command -eq 'detect') { Get-Content $detectionPath; exit 0 }
 
-Invoke-PrizmPythonText $python @((Join-Path $paths.ScriptsDir 'generate-recovery-prompt.py'), '--detection-json', $detectionPath, '--project-root', $paths.ProjectRoot, '--session-id', (New-PrizmSessionId 'recovery'), '--output', $promptPath)
+$sessionId = New-PrizmSessionId 'recovery'
+$sessionDir = Join-Path $stateDir "sessions\$sessionId"
+$logsDir = Join-Path $sessionDir 'logs'
+New-Item -ItemType Directory -Force -Path $logsDir | Out-Null
+$sessionDetectionPath = Join-Path $sessionDir 'detection.json'
+Copy-Item -Path $detectionPath -Destination $sessionDetectionPath -Force
+$promptPath = Join-Path $sessionDir 'bootstrap-prompt.md'
+$logPath = Join-Path $logsDir 'session.log'
+$progressPath = Join-Path $logsDir 'progress.json'
+$pidPath = Join-Path $logsDir 'ai.pid'
+$staleKillMarker = Join-Path $logsDir 'stale-kill.json'
+
+Invoke-PrizmPythonText $python @((Join-Path $paths.ScriptsDir 'generate-recovery-prompt.py'), '--detection-json', $sessionDetectionPath, '--project-root', $paths.ProjectRoot, '--session-id', $sessionId, '--output', $promptPath)
 if ($dryRun) { Get-Content $promptPath; exit 0 }
 $cli = Resolve-PrizmAiCli $paths.ProjectRoot $paths.PrizmkitDir
 $env:PRIZMKIT_PLATFORM = Get-PrizmPlatformFromProject $paths.ProjectRoot $paths.PrizmkitDir $cli
-$pidPath = Join-Path $paths.PrizmkitDir 'state\recovery-session.pid'
-$exitCode = Invoke-PrizmAiSession -CliCommand $cli -PromptPath $promptPath -LogPath $logPath -ProjectRoot $paths.ProjectRoot -Model $model -PidPath $pidPath
+Write-PrizmInfo "Starting recovery session: $sessionId"
+Write-PrizmInfo "Prompt: $promptPath"
+Write-PrizmInfo "Log: $logPath"
+
+$parserProcess = Start-PrizmProgressParser -PythonCommand $python -ScriptsDir $paths.ScriptsDir -SessionLog $logPath -ProgressFile $progressPath -CliCommand $cli
+$job = Start-Job -ScriptBlock {
+  param($commonPath, $cli, $promptPath, $logPath, $projectRoot, $model, $pidPath)
+  . $commonPath
+  Invoke-PrizmAiSession -CliCommand $cli -PromptPath $promptPath -LogPath $logPath -ProjectRoot $projectRoot -Model $model -PidPath $pidPath
+} -ArgumentList (Join-Path $paths.PipelineDir 'lib\common.ps1'), $cli, $promptPath, $logPath, $paths.ProjectRoot, $model, $pidPath
+
+$elapsedSeconds = 0
+$staleSeconds = 0
+$previousLogSize = 0
+$wasTimedOut = $false
+$wasStaleKilled = $false
+while ($true) {
+  $remainingTimeout = if ($timeoutSeconds -gt 0) { $timeoutSeconds - $elapsedSeconds } else { $heartbeatInterval }
+  $waitSeconds = if ($timeoutSeconds -gt 0) { [Math]::Min($heartbeatInterval, [Math]::Max(1, $remainingTimeout)) } else { $heartbeatInterval }
+  $completed = Wait-Job $job -Timeout $waitSeconds
+  if ($completed) { break }
+
+  $elapsedSeconds += $waitSeconds
+  $currentLogSize = 0
+  if (Test-Path $logPath) { $currentLogSize = [int64](Get-Item $logPath).Length }
+  $growth = $currentLogSize - $previousLogSize
+  $previousLogSize = $currentLogSize
+  if ($growth -gt 0) { $staleSeconds = 0 } else { $staleSeconds += $waitSeconds }
+
+  if ($timeoutSeconds -gt 0 -and $elapsedSeconds -ge $timeoutSeconds) {
+    $wasTimedOut = $true
+    Stop-PrizmSessionProcess $pidPath
+    break
+  }
+
+  if ($staleKillThreshold -gt 0 -and $staleSeconds -ge $staleKillThreshold) {
+    $wasStaleKilled = $true
+    Write-PrizmWarn "Recovery session stale-killed (no progress for ${staleKillThreshold}s)"
+    Write-PrizmStaleKillMarker $staleKillMarker $staleSeconds $staleKillThreshold
+    Stop-PrizmSessionProcess $pidPath
+    if ($staleKillGraceSeconds -gt 0) { Start-Sleep -Seconds $staleKillGraceSeconds }
+    break
+  }
+}
+
+$exitCode = 0
+if ($wasTimedOut) {
+  Stop-Job $job
+  Remove-Job $job
+  $exitCode = 124
+} elseif ($wasStaleKilled) {
+  Stop-Job $job
+  Remove-Job $job
+  $exitCode = 143
+} else {
+  try {
+    $exitCode = [int](Receive-Job $job)
+  } catch {
+    Write-PrizmWarn "Recovery session job failed: $($_.Exception.Message)"
+    $exitCode = 1
+  }
+  Remove-Job $job
+}
+Stop-PrizmProgressParser $parserProcess
+
+if (Test-Path $logPath) {
+  $lineCount = (Get-Content $logPath | Measure-Object -Line).Lines
+  $sizeKb = [int](([int64](Get-Item $logPath).Length) / 1024)
+  Write-PrizmInfo "Session log: $lineCount lines, ${sizeKb}KB"
+}
+if ($wasTimedOut) { Write-PrizmWarn "Recovery session timed out after $timeoutSeconds seconds." }
+if ($wasStaleKilled -or (Test-Path $staleKillMarker)) { Write-PrizmWarn "Recovery session was stale-killed." }
 if ($exitCode -eq 0) { Write-PrizmSuccess "Recovery session completed." } else { Write-PrizmError "Recovery session failed. Log: $logPath" }
 exit $exitCode

package/bundled/dev-pipeline-windows/scripts/parse-stream-progress.py

@@ -73,6 +73,9 @@ class ProgressTracker:
         self.last_text_snippet = ""
         self.is_active = True
         self.errors = []
+        self.event_format = ""
+        self.active_subagent_count = 0
+        self.subagent_status_counts = Counter()
         self._text_buffer = ""
         self._in_tool_use = False
         self._current_tool_input_parts = []
@@ -87,8 +90,72 @@ class ProgressTracker:
         """
         event_type = event.get("type", "")
 
+        # ── Codex exec --json JSONL format ──────────────────────────
+        if event_type in (
+            "thread.started", "turn.started", "turn.completed",
+            "turn.failed", "item.started", "item.completed", "error",
+        ):
+            self.event_format = "codex-json"
+            self.is_active = True
+
+            if event_type == "turn.started":
+                self.message_count += 1
+
+            elif event_type in ("item.started", "item.completed"):
+                item = event.get("item", {})
+                item_type = item.get("type", "")
+
+                if item_type == "agent_message":
+                    text = item.get("text", "")
+                    if text.strip():
+                        self.last_text_snippet = text.strip()[:120]
+                        self._detect_phase(text)
+
+                elif item_type == "collab_tool_call":
+                    tool_name = item.get("tool", "collab")
+                    if event_type == "item.started":
+                        self.current_tool = tool_name
+                        self.tool_call_counts[tool_name] += 1
+                        self.total_tool_calls += 1
+                    elif item.get("status") == "completed":
+                        self.current_tool = None
+                    self._extract_tool_summary_from_dict(item)
+                    self._update_subagent_status_counts(
+                        item.get("agents_states", {})
+                    )
+
+                    prompt = item.get("prompt")
+                    if prompt:
+                        self._detect_phase(prompt)
+
+                else:
+                    tool_name = item.get("tool") or item.get("name")
+                    if tool_name:
+                        if event_type == "item.started":
+                            self.current_tool = tool_name
+                            self.tool_call_counts[tool_name] += 1
+                            self.total_tool_calls += 1
+                        elif item.get("status") == "completed":
+                            self.current_tool = None
+                        self._extract_tool_summary_from_dict(item)
+
+            elif event_type == "turn.completed":
+                self.current_tool = None
+
+            elif event_type == "turn.failed":
+                error = event.get("error") or event.get("message") or "Codex turn failed"
+                self.errors.append(str(error))
+                self.current_tool = None
+
+            elif event_type == "error":
+                error = event.get("error") or event.get("message") or "Unknown error"
+                self.errors.append(str(error))
+
+            return
+
         # ── Claude Code verbose format ──────────────────────────────
         if event_type == "assistant":
+            self.event_format = self.event_format or "stream-json"
             self.message_count += 1
             self.is_active = True
             message = event.get("message", {})
@@ -113,16 +180,19 @@ class ProgressTracker:
 
         elif event_type == "tool_result" or event_type == "user":
             # tool_result contains output from tool execution
+            self.event_format = self.event_format or "stream-json"
             self.is_active = True
 
         elif event_type == "system":
             # System events (hooks, init, etc.) — track but don't count as messages
+            self.event_format = self.event_format or "stream-json"
             subtype = event.get("subtype", "")
             if subtype == "init":
                 self.is_active = True
 
         # ── Claude API raw stream format ────────────────────────────
         elif event_type == "message_start":
+            self.event_format = self.event_format or "stream-json"
             self.message_count += 1
             self.is_active = True
 
@@ -256,14 +326,38 @@ class ProgressTracker:
             elif "prompt" in data:
                 self.current_tool_input_summary = str(data["prompt"])[:100]
 
+    def _update_subagent_status_counts(self, agents_states):
+        """Track Codex subagent state counts from collab_tool_call items."""
+        counts = Counter()
+        active = 0
+        if isinstance(agents_states, dict):
+            for state in agents_states.values():
+                if not isinstance(state, dict):
+                    continue
+                status = str(state.get("status", "unknown"))
+                counts[status] += 1
+                if status not in ("completed", "failed", "cancelled", "canceled"):
+                    active += 1
+                message = state.get("message")
+                if message:
+                    self.last_text_snippet = str(message).strip()[:120]
+                    self._detect_phase(str(message))
+        self.subagent_status_counts = counts
+        self.active_subagent_count = active
+
     def to_dict(self):
         """Export current state as a dictionary for JSON serialization."""
         tool_calls = [
             {"name": name, "count": count}
             for name, count in self.tool_call_counts.most_common()
         ]
+        subagent_states = [
+            {"status": status, "count": count}
+            for status, count in self.subagent_status_counts.most_common()
+        ]
         return {
             "updated_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "event_format": self.event_format,
             "message_count": self.message_count,
             "current_tool": self.current_tool,
             "current_tool_input_summary": self.current_tool_input_summary,
@@ -271,6 +365,8 @@ class ProgressTracker:
             "detected_phases": self.detected_phases,
             "tool_calls": tool_calls,
             "total_tool_calls": self.total_tool_calls,
+            "active_subagent_count": self.active_subagent_count,
+            "subagent_states": subagent_states,
             "last_text_snippet": self.last_text_snippet,
             "is_active": self.is_active,
             "errors": self.errors[-10:],  # Keep last 10 errors

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.63",
+  "version": "1.1.66",
   "skills": {
     "prizm-kit": {
       "description": "Full-lifecycle dev toolkit. Covers spec-driven development, Prizm context docs, code quality, debugging, deployment, and knowledge management.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prizmkit",
-  "version": "1.1.63",
+  "version": "1.1.66",
   "description": "Create a new PrizmKit-powered project with clean initialization — no framework dev files, just what you need.",
   "type": "module",
   "bin": {