prizmkit 1.1.99 → 1.1.101

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

@@ -1,967 +0,0 @@
-. "$PSScriptRoot\common.ps1"
-. "$PSScriptRoot\branch.ps1"
-$global:PRIZM_EXIT_CODE = 0
-
-function Invoke-PrizmPipeline {
-  param(
-    [ValidateSet('feature','bugfix','refactor')][string]$Kind,
-    [string]$ScriptRoot,
-    [string[]]$Args
-  )
-
-  $paths = Initialize-PrizmPaths $ScriptRoot
-  Import-PrizmEnv (Join-Path $paths.PrizmkitDir '.env')
-  Set-Location $paths.ProjectRoot
-  $python = Resolve-PrizmPython
-
-  $command = if ($Args.Count -gt 0) { $Args[0] } else { 'help' }
-  $remaining = if ($Args.Count -gt 1) { $Args[1..($Args.Count - 1)] } else { @() }
-
-  $idName = @{ feature = 'feature'; bugfix = 'bug'; refactor = 'refactor' }[$Kind]
-  $idOption = @{ feature = '--feature-id'; bugfix = '--bug-id'; refactor = '--refactor-id' }[$Kind]
-  $listOption = @{ feature = '--feature-list'; bugfix = '--bug-list'; refactor = '--refactor-list' }[$Kind]
-  $initScript = @{ feature = 'init-pipeline.py'; bugfix = 'init-bugfix-pipeline.py'; refactor = 'init-refactor-pipeline.py' }[$Kind]
-  $updateScript = @{ feature = 'update-feature-status.py'; bugfix = 'update-bug-status.py'; refactor = 'update-refactor-status.py' }[$Kind]
-  $promptScript = @{ feature = 'generate-bootstrap-prompt.py'; bugfix = 'generate-bugfix-prompt.py'; refactor = 'generate-refactor-prompt.py' }[$Kind]
-  $defaultList = Get-PrizmListDefault $Kind $paths.ProjectRoot
-  $stateDir = Get-PrizmStateDir $Kind $paths.ProjectRoot
-  $envMaxRetryArgs = @()
-  if ($env:MAX_RETRIES) {
-    $parsedEnvMaxRetries = 0
-    if (-not [int]::TryParse($env:MAX_RETRIES, [ref]$parsedEnvMaxRetries) -or $parsedEnvMaxRetries -lt 1) {
-      throw "MAX_RETRIES must be a positive integer: $($env:MAX_RETRIES)"
-    }
-    $envMaxRetryArgs = @('--max-retries', [string]$parsedEnvMaxRetries)
-  }
-
-  $envMaxInfraRetryArgs = @()
-  if ($env:MAX_INFRA_RETRIES) {
-    $parsedEnvMaxInfraRetries = 0
-    if (-not [int]::TryParse($env:MAX_INFRA_RETRIES, [ref]$parsedEnvMaxInfraRetries) -or $parsedEnvMaxInfraRetries -lt 1) {
-      throw "MAX_INFRA_RETRIES must be a positive integer: $($env:MAX_INFRA_RETRIES)"
-    }
-    $envMaxInfraRetryArgs = @('--max-infra-retries', [string]$parsedEnvMaxInfraRetries)
-  }
-
-  if ($command -in @('help','--help','-h')) {
-    Write-Host "Usage: .\run-$Kind.ps1 run [item-id] [list-path] [--dry-run] [--mode lite|standard|full] [--critic] [--max-retries N] [--max-infra-retries N]"
-    Write-Host "       .\run-$Kind.ps1 status [list-path]"
-    Write-Host "       .\run-$Kind.ps1 reset"
-    Write-Host ""
-    Write-Host "Environment Variables:"
-    Write-Host "  PRIZMKIT_EFFORT       AI reasoning effort (low|medium|high|xhigh|max; max is Claude Code only)"
-    Write-Host "  MAX_LOG_SIZE          Session log size threshold for compact warning (default: 2097152 = 2MB, set 0 to disable)"
-    Write-Host "  LOG_MONITOR_POLL_INTERVAL  Log monitor poll interval in seconds (default: 30)"
-    $global:PRIZM_EXIT_CODE = 0
-    return
-  }
-
-  if ($command -eq 'reset') {
-    if (Test-Path $stateDir) { Remove-Item -Recurse -Force $stateDir }
-    New-Item -ItemType Directory -Force -Path $stateDir | Out-Null
-    Write-PrizmSuccess "State reset: $stateDir"
-    $global:PRIZM_EXIT_CODE = 0
-    return
-  }
-
-  if ($command -eq 'status') {
-    $listPath = if ($remaining.Count -gt 0) { $remaining[0] } else { $defaultList }
-    Invoke-PrizmPythonText $python (@((Join-Path $paths.ScriptsDir $updateScript), $listOption, $listPath, '--state-dir', $stateDir, '--action', 'status') + $envMaxRetryArgs + $envMaxInfraRetryArgs)
-    $global:PRIZM_EXIT_CODE = $LASTEXITCODE
-    return
-  }
-
-  if ($command -ne 'run') { throw "Unknown command: $command" }
-
-  $itemId = $null
-  $listPath = $defaultList
-  $dryRun = $false
-  $mode = $null
-  if ($env:PIPELINE_MODE) { $mode = $env:PIPELINE_MODE.Trim() }
-  $critic = $null
-  $criticEnv = if ($env:ENABLE_CRITIC) { $env:ENABLE_CRITIC.Trim().ToLowerInvariant() } else { '' }
-  if ($criticEnv -in @('true','1','yes','on')) {
-    $critic = 'true'
-  } elseif ($criticEnv -in @('false','0','no','off')) {
-    $critic = 'false'
-  } elseif ($criticEnv) {
-    Write-PrizmWarn "Ignoring unsupported ENABLE_CRITIC value: $($env:ENABLE_CRITIC)"
-  }
-  $maxRetries = $null
-  if ($envMaxRetryArgs.Count -gt 0) { $maxRetries = [int]$envMaxRetryArgs[1] }
-  $maxInfraRetries = $null
-  if ($envMaxInfraRetryArgs.Count -gt 0) { $maxInfraRetries = [int]$envMaxInfraRetryArgs[1] }
-  $verboseEnabled = $env:VERBOSE -in @('1','true','yes','on')
-  $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 { '' }
-  $featuresFilter = $null
-
-  for ($i = 0; $i -lt $remaining.Count; $i++) {
-    $arg = $remaining[$i]
-    switch -Regex ($arg) {
-      '^--dry-run$' { $dryRun = $true; continue }
-      '^--critic$' { $critic = 'true'; continue }
-      '^--no-critic$' { $critic = 'false'; continue }
-      '^--mode$' { $i++; $mode = $remaining[$i]; continue }
-      '^--max-retries$' {
-        $i++
-        $parsedMaxRetries = 0
-        if (-not [int]::TryParse($remaining[$i], [ref]$parsedMaxRetries) -or $parsedMaxRetries -lt 1) {
-          throw "--max-retries must be a positive integer: $($remaining[$i])"
-        }
-        $maxRetries = $parsedMaxRetries
-        continue
-      }
-      '^--max-infra-retries$' {
-        $i++
-        $parsedMaxInfraRetries = 0
-        if (-not [int]::TryParse($remaining[$i], [ref]$parsedMaxInfraRetries) -or $parsedMaxInfraRetries -lt 1) {
-          throw "--max-infra-retries must be a positive integer: $($remaining[$i])"
-        }
-        $maxInfraRetries = $parsedMaxInfraRetries
-        continue
-      }
-      '^--features$' { $i++; $featuresFilter = $remaining[$i]; continue }
-      '^-' { Write-PrizmWarn "Ignoring unsupported option: $arg"; continue }
-      default {
-        if (-not $itemId -and $arg -match '^[FBR]-\d+') { $itemId = $arg; continue }
-        $listPath = $arg
-      }
-    }
-  }
-
-  if ($mode -and $mode -notin @('lite','standard','full')) {
-    throw "PIPELINE_MODE/--mode must be one of: lite, standard, full. Got: $mode"
-  }
-  $maxRetryArgs = @()
-  if ($maxRetries -ne $null) { $maxRetryArgs = @('--max-retries', [string]$maxRetries) }
-  $maxInfraRetryArgs = @()
-  if ($maxInfraRetries -ne $null) { $maxInfraRetryArgs = @('--max-infra-retries', [string]$maxInfraRetries) }
-  if ($verboseEnabled) {
-    $modeLabel = if ($mode) { $mode } else { 'auto' }
-    $criticLabel = if ($critic) { $critic } else { 'plan-default' }
-    $retryLabel = if ($maxRetries -ne $null) { [string]$maxRetries } else { 'default' }
-    $infraRetryLabel = if ($maxInfraRetries -ne $null) { [string]$maxInfraRetries } else { 'default' }
-    Write-PrizmInfo "Verbose mode enabled."
-    Write-PrizmInfo "Effective options: mode=$modeLabel critic=$criticLabel maxRetries=$retryLabel maxInfraRetries=$infraRetryLabel staleKillThreshold=$staleKillThreshold dryRun=$dryRun"
-  }
-
-  # Validate PRIZMKIT_EFFORT early (fail-fast before any sessions are spawned)
-  $cli = Resolve-PrizmAiCli $paths.ProjectRoot $paths.PrizmkitDir
-  Test-PrizmEffort $cli
-
-  if (-not (Test-Path $listPath)) { throw "List file not found: $listPath" }
-  $pipelineStatePath = Join-Path $stateDir 'pipeline.json'
-  if (-not $dryRun) {
-    New-Item -ItemType Directory -Force -Path $stateDir | Out-Null
-    if (-not (Test-Path $pipelineStatePath)) {
-      Invoke-PrizmPythonText $python @((Join-Path $paths.ScriptsDir $initScript), $listOption, $listPath, '--state-dir', $stateDir)
-    } else {
-      Write-PrizmInfo "Using existing pipeline state: $pipelineStatePath"
-    }
-  } elseif (-not (Test-Path $pipelineStatePath)) {
-    Write-PrizmInfo "Dry-run mode: not initializing pipeline state."
-  }
-
-  function Test-PrizmGitRepository {
-    param([string]$ProjectRoot)
-    & git -C $ProjectRoot rev-parse --is-inside-work-tree *> $null
-    return $LASTEXITCODE -eq 0
-  }
-
-  function Get-PrizmGitHead {
-    param([string]$ProjectRoot)
-    $head = & git -C $ProjectRoot rev-parse HEAD 2>$null
-    if ($LASTEXITCODE -eq 0 -and $head) { return ($head | Select-Object -First 1) }
-    return ''
-  }
-
-  function Test-PrizmGitCommitsSince {
-    param([string]$ProjectRoot, [string]$BaseCommit)
-    if (-not $BaseCommit) {
-      return -not [string]::IsNullOrWhiteSpace([string](Get-PrizmGitHead $ProjectRoot))
-    }
-    $commit = & git -C $ProjectRoot log "$BaseCommit..HEAD" --oneline 2>$null | Select-Object -First 1
-    return -not [string]::IsNullOrWhiteSpace([string]$commit)
-  }
-
-  function ConvertTo-PrizmGitRelativePath {
-    param([string]$ProjectRoot, [string]$Path)
-    if (-not $Path) { return '' }
-    try {
-      $rootFull = [System.IO.Path]::GetFullPath($ProjectRoot).TrimEnd([char[]]@('\', '/')) + [System.IO.Path]::DirectorySeparatorChar
-      $pathInput = if ([System.IO.Path]::IsPathRooted($Path)) { $Path } else { Join-Path $ProjectRoot $Path }
-      $pathFull = [System.IO.Path]::GetFullPath($pathInput)
-      $rootUri = [System.Uri]::new($rootFull)
-      $pathUri = [System.Uri]::new($pathFull)
-      return ([System.Uri]::UnescapeDataString($rootUri.MakeRelativeUri($pathUri).ToString()) -replace '\\', '/').TrimStart([char[]]@('.', '/'))
-    } catch {
-      return ($Path -replace '\\', '/').TrimStart([char[]]@('.', '/'))
-    }
-  }
-
-  function Get-PrizmGitDirtyPaths {
-    param([string]$ProjectRoot)
-    $hiddenToolWorktreeExcludes = Get-PrizmHiddenToolWorktreeExcludes
-    $lines = & git -C $ProjectRoot status --porcelain -- . @hiddenToolWorktreeExcludes 2>$null
-    $paths = @()
-    foreach ($line in $lines) {
-      if ([string]::IsNullOrWhiteSpace($line) -or $line.Length -lt 4) { continue }
-      $path = $line.Substring(3).Trim()
-      if ($path -match ' -> ') { $path = ($path -split ' -> ')[-1].Trim() }
-      $paths += (($path -replace '\\', '/').Trim('"').TrimStart([char[]]@('/')))
-    }
-    return @($paths)
-  }
-
-  function Test-PrizmPipelineIgnoredPath {
-    param([string]$Path)
-    $normalizedPath = (($Path -replace '\\', '/').Trim('"').TrimStart([char[]]@('/')))
-    $segments = @($normalizedPath -split '/' | Where-Object { -not [string]::IsNullOrWhiteSpace($_) })
-    if ($segments.Count -lt 2) { return $false }
-    if (-not $segments[0].StartsWith('.')) { return $false }
-    return $segments[1] -in @('worktree', 'worktrees')
-  }
-
-  function Test-PrizmPipelineBookkeepingPath {
-    param(
-      [string]$ProjectRoot,
-      [string]$Path,
-      [string]$StateDir,
-      [string]$ListPath
-    )
-    $normalizedPath = (($Path -replace '\\', '/').Trim('"').TrimStart([char[]]@('.', '/')))
-    $stateRel = ConvertTo-PrizmGitRelativePath $ProjectRoot $StateDir
-    $listRel = ConvertTo-PrizmGitRelativePath $ProjectRoot $ListPath
-    if ($stateRel -and ($normalizedPath -eq $stateRel -or $normalizedPath.StartsWith("$stateRel/"))) { return $true }
-    if ($listRel -and $normalizedPath -eq $listRel) { return $true }
-    return $false
-  }
-
-  function Test-PrizmGitWorkDirty {
-    param([string]$ProjectRoot, [string]$StateDir, [string]$ListPath)
-    foreach ($path in (Get-PrizmGitDirtyPaths $ProjectRoot)) {
-      if (Test-PrizmPipelineIgnoredPath $path) { continue }
-      if (-not (Test-PrizmPipelineBookkeepingPath $ProjectRoot $path $StateDir $ListPath)) {
-        return $true
-      }
-    }
-    return $false
-  }
-
-  function Test-PrizmGitDirty {
-    param([string]$ProjectRoot)
-    $hiddenToolWorktreeExcludes = Get-PrizmHiddenToolWorktreeExcludes
-    $dirty = & git -C $ProjectRoot status --porcelain -- . @hiddenToolWorktreeExcludes 2>$null | Select-Object -First 1
-    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)
-    $hiddenToolWorktreeExcludes = Get-PrizmHiddenToolWorktreeExcludes
-    & git -C $ProjectRoot add -A -- . @hiddenToolWorktreeExcludes *> $null
-    & git -C $ProjectRoot commit --no-verify -m $Message *> $null
-    return $LASTEXITCODE -eq 0
-  }
-
-  function Invoke-PrizmGitIncludeRemainingArtifacts {
-    param([string]$ProjectRoot, [string]$ItemId)
-    $hiddenToolWorktreeExcludes = Get-PrizmHiddenToolWorktreeExcludes
-    & git -C $ProjectRoot add -A -- . @hiddenToolWorktreeExcludes *> $null
-    & git -C $ProjectRoot commit --no-verify --amend --no-edit *> $null
-    if ($LASTEXITCODE -eq 0) { return }
-    & git -C $ProjectRoot commit --no-verify -m "chore($ItemId): include remaining session artifacts" *> $null
-  }
-
-  function Invoke-PrizmGitIncludeBookkeepingArtifacts {
-    param([string]$ProjectRoot, [string]$StateDir, [string]$ListPath)
-    $listRel = ConvertTo-PrizmGitRelativePath $ProjectRoot $ListPath
-    if (-not $listRel) { return }
-    & git -C $ProjectRoot ls-files --error-unmatch -- $listRel *> $null
-    if ($LASTEXITCODE -ne 0) { return }
-    & 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 Get-PrizmFeatureSlugFromList {
-    param([string]$ListPath, [string]$FeatureId)
-    if (-not (Test-Path $ListPath)) { return '' }
-    try { $data = Get-Content $ListPath -Raw | ConvertFrom-Json } catch { return '' }
-    foreach ($feature in @($data.features)) {
-      if ($feature.id -eq $FeatureId) {
-        $number = ([string]$feature.id).Replace('F-', '').Replace('f-', '').PadLeft(3, '0')
-        $title = ([string]$feature.title).ToLowerInvariant()
-        $title = [regex]::Replace($title, '[^a-z0-9\s-]', '')
-        $title = [regex]::Replace($title.Trim(), '[\s]+', '-')
-        $title = [regex]::Replace($title, '-+', '-').Trim('-')
-        if ($title) { return "$number-$title" }
-        return $number
-      }
-    }
-    return ''
-  }
-
-  function Test-PrizmCheckpointComplete {
-    param([string]$CheckpointPath)
-    if (-not (Test-Path $CheckpointPath)) { return $false }
-    try { $checkpoint = Get-Content $CheckpointPath -Raw | ConvertFrom-Json } catch { return $false }
-    if (-not $checkpoint.steps) { return $false }
-    foreach ($step in @($checkpoint.steps)) {
-      if ($step.status -notin @('completed', 'skipped')) { return $false }
-    }
-    return $true
-  }
-
-  function Get-PrizmFeatureTitleFromList {
-    param([string]$ListPath, [string]$FeatureId)
-    if (-not (Test-Path $ListPath)) { return '' }
-    try { $data = Get-Content $ListPath -Raw | ConvertFrom-Json } catch { return '' }
-    foreach ($feature in @($data.features)) {
-      if ($feature.id -eq $FeatureId) { return [string]$feature.title }
-    }
-    return ''
-  }
-
-  function Get-PrizmTitleWords {
-    param([string]$Text)
-    $matches = [regex]::Matches(([string]$Text).ToLowerInvariant(), '[a-z0-9]{3,}')
-    $words = @()
-    foreach ($match in $matches) { $words += [string]$match.Value }
-    return @($words)
-  }
-
-  function Test-PrizmCommitMatchesFeatureTitle {
-    param([string]$Subject, [string]$FeatureTitle)
-    $titleWords = @(Get-PrizmTitleWords $FeatureTitle)
-    if ($titleWords.Count -eq 0) { return $false }
-    $subjectWords = @(Get-PrizmTitleWords $Subject)
-    $subjectSet = @{}
-    foreach ($word in $subjectWords) { $subjectSet[$word] = $true }
-    $required = if ($titleWords.Count -le 3) { $titleWords.Count } else { [Math]::Max(3, [int][Math]::Ceiling($titleWords.Count * 0.75)) }
-    $matched = 0
-    foreach ($word in $titleWords) {
-      if ($subjectSet.ContainsKey($word)) { $matched++ }
-    }
-    return $matched -ge $required
-  }
-
-  function Get-PrizmFeatureCommit {
-    param([string]$ProjectRoot, [string]$BaseCommit, [string]$FeatureId, [bool]$AllowFallback = $false, [string]$FeatureTitle = '')
-    $range = if ($BaseCommit) { "$BaseCommit..HEAD" } else { 'HEAD' }
-    $lines = & git -C $ProjectRoot log $range '--format=%H%x09%s' 2>$null
-    if ($LASTEXITCODE -ne 0) { return '' }
-    foreach ($line in @($lines)) {
-      $parts = ([string]$line).Split("`t", 2)
-      if ($parts.Count -lt 2) { continue }
-      $subject = $parts[1]
-      if ($subject.Contains($FeatureId) -and $subject -notmatch '^wip(\(|:)') { return $parts[0] }
-    }
-    if ($AllowFallback -and $FeatureTitle) {
-      foreach ($line in @($lines)) {
-        $parts = ([string]$line).Split("`t", 2)
-        if ($parts.Count -lt 2) { continue }
-        $subject = $parts[1]
-        if ($subject -notmatch '^wip(\(|:)' -and (Test-PrizmCommitMatchesFeatureTitle $subject $FeatureTitle)) { return $parts[0] }
-      }
-    }
-    return ''
-  }
-
-  function Get-PrizmFeatureSemanticCompletion {
-    param([string]$ProjectRoot, [string]$ListPath, [string]$FeatureId, [string]$BaseCommit, [string]$PrizmkitDir)
-    $slug = Get-PrizmFeatureSlugFromList $ListPath $FeatureId
-    if (-not $slug) { return $null }
-    $checkpointPath = Join-Path $PrizmkitDir "specs\$slug\workflow-checkpoint.json"
-    if (-not (Test-PrizmCheckpointComplete $checkpointPath)) { return $null }
-    $featureTitle = Get-PrizmFeatureTitleFromList $ListPath $FeatureId
-    $commitSha = Get-PrizmFeatureCommit $ProjectRoot $BaseCommit $FeatureId $true $featureTitle
-    if (-not $commitSha) { return $null }
-    return [pscustomobject]@{ Slug = $slug; CommitSha = $commitSha; CheckpointPath = $checkpointPath }
-  }
-
-  function Write-PrizmRuntimeFailureLog {
-    param(
-      [string]$FailureLog,
-      [string]$FeatureId,
-      [string]$SessionId,
-      [string]$SessionStatus,
-      [int]$ExitCode,
-      [string]$StaleKillMarker,
-      [string]$ProgressJson,
-      [string]$CheckpointPath,
-      [string]$ProjectRoot,
-      [string]$BaseCommit
-    )
-    if (-not $FailureLog -or (Test-Path $FailureLog)) { return }
-    $dir = Split-Path $FailureLog -Parent
-    if ($dir) { New-Item -ItemType Directory -Force -Path $dir | Out-Null }
-    $stale = if (Test-Path $StaleKillMarker) { Get-Content $StaleKillMarker -Raw } else { 'No stale-kill marker.' }
-    $progressLines = @('Progress data unavailable.')
-    if (Test-Path $ProgressJson) {
-      try {
-        $progress = Get-Content $ProgressJson -Raw | ConvertFrom-Json
-        $progressLines = @()
-        foreach ($key in @('fatal_error_code','api_error_status','api_error_code','current_phase','current_tool','last_text_snippet','terminal_result_text')) {
-          if ($progress.PSObject.Properties[$key] -and $progress.$key) { $progressLines += "- ${key}: $($progress.$key)" }
-        }
-        if ($progressLines.Count -eq 0) { $progressLines = @('Progress data contained no terminal fields.') }
-      } catch { $progressLines = @("Progress parse error: $($_.Exception.Message)") }
-    }
-    $checkpointLines = @('No checkpoint file found.')
-    if (Test-Path $CheckpointPath) {
-      try {
-        $checkpoint = Get-Content $CheckpointPath -Raw | ConvertFrom-Json
-        $steps = @($checkpoint.steps)
-        $complete = @($steps | Where-Object { $_.status -in @('completed','skipped') }).Count
-        $checkpointLines = @("$complete/$($steps.Count) steps completed_or_skipped")
-        foreach ($step in $steps) {
-          if ($step.status -notin @('completed','skipped')) { $checkpointLines += "- incomplete: $($step.id) $($step.skill) = $($step.status)" }
-        }
-      } catch { $checkpointLines = @("Checkpoint parse error: $($_.Exception.Message)") }
-    }
-    $latestCommit = (& git -C $ProjectRoot rev-parse --short HEAD 2>$null | Select-Object -First 1)
-    if (-not $latestCommit) { $latestCommit = 'unavailable' }
-    $featureCommit = if (Get-PrizmFeatureCommit $ProjectRoot $BaseCommit $FeatureId $false) { 'yes' } else { 'no' }
-    $dirty = & git -C $ProjectRoot status --short 2>$null
-    if ([string]::IsNullOrWhiteSpace(($dirty -join "`n"))) { $dirty = @('clean') }
-    @(
-      '# Runtime-synthesized failure log',
-      '',
-      '## Session',
-      '',
-      "- feature_id: $FeatureId",
-      "- session_id: $SessionId",
-      "- session_status: $SessionStatus",
-      "- exit_code: $ExitCode",
-      '',
-      '## Stale kill marker',
-      '',
-      '```json',
-      $stale,
-      '```',
-      '',
-      '## Progress',
-      '',
-      $progressLines,
-      '',
-      '## Checkpoint',
-      '',
-      $checkpointLines,
-      '',
-      '## Git state',
-      '',
-      "- feature_commit_exists: $featureCommit",
-      "- latest_commit: $latestCommit",
-      '',
-      '```text',
-      $dirty,
-      '```',
-      '',
-      '## Recommended recovery action',
-      '',
-      '- If this is an AI runtime/provider error before checkpoint completion, retry the session with a fresh context.',
-      '- If the working tree is dirty, preserve or review those changes before any reset or merge.'
-    ) | Set-Content -Path $FailureLog -Encoding UTF8
-  }
-
-  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 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
-
-    $sessionId = New-PrizmSessionId $Kind
-    $runId = "run-$(Get-Date -Format 'yyyyMMdd-HHmmss')"
-    $retryCount = '0'
-    $resumePhase = 'null'
-    $isGitRepository = if (-not $dryRun) { Test-PrizmGitRepository $paths.ProjectRoot } else { $false }
-    $originalBranch = if ($isGitRepository) { Get-PrizmCurrentBranch $paths.ProjectRoot } else { '' }
-    $devBranchName = ''
-    $hadDirtyBaseline = if ($isGitRepository) { Test-PrizmGitWorkDirty $paths.ProjectRoot $stateDir $listPath } else { $false }
-    if ($hadDirtyBaseline) {
-      if ($dryRun) {
-        Write-PrizmWarn "Dirty working tree detected before $CurrentItemId; would auto-commit snapshot in real run."
-      } else {
-        Write-PrizmInfo "Dirty working tree detected before $CurrentItemId; auto-committing snapshot."
-        Invoke-PrizmGitAutoCommit $paths.ProjectRoot "chore: workspace snapshot ready for run $CurrentItemId" | Out-Null
-      }
-    }
-
-    if ($dryRun) {
-      $statusPath = Join-Path $stateDir "$CurrentItemId\status.json"
-      if (Test-Path $statusPath) {
-        try {
-          $itemStatus = Get-Content -Raw $statusPath | ConvertFrom-Json
-          if ($itemStatus.retry_count -ne $null) { $retryCount = [string]$itemStatus.retry_count }
-          if ($itemStatus.resume_from_phase -ne $null) { $resumePhase = [string]$itemStatus.resume_from_phase }
-        } catch {
-          Write-PrizmWarn "Could not read dry-run status file: $statusPath"
-        }
-      }
-    } else {
-      $start = Invoke-PrizmPythonJson $python (@((Join-Path $paths.ScriptsDir $updateScript), $listOption, $listPath, '--state-dir', $stateDir, '--action', 'start', $idOption, $CurrentItemId, '--session-id', $sessionId) + $maxRetryArgs + $maxInfraRetryArgs)
-      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-PrizmError "Failed to create dev branch: $candidateBranch from $originalBranch - aborting to avoid running on $originalBranch"
-          $script:PRIZM_ITEM_LIST_STATUS = ''
-          $script:PRIZM_ITEM_EXIT_CODE = 1
-          return
-        }
-      }
-    }
-
-    $baseCommit = if ($isGitRepository) { Get-PrizmGitHead $paths.ProjectRoot } else { '' }
-
-    $sessionDir = if ($dryRun) {
-      Join-Path ([System.IO.Path]::GetTempPath()) "prizmkit-dry-run\$sessionId"
-    } else {
-      Join-Path $stateDir "$CurrentItemId\sessions\$sessionId"
-    }
-    $logsDir = Join-Path $sessionDir 'logs'
-    New-Item -ItemType Directory -Force -Path $logsDir | Out-Null
-    $promptPath = Join-Path $sessionDir 'bootstrap-prompt.md'
-    $sessionLog = Join-Path $logsDir 'session.log'
-    $pidPath = Join-Path $logsDir 'ai.pid'
-
-    $cli = $null
-    if (-not $dryRun) {
-      $cli = Resolve-PrizmAiCli $paths.ProjectRoot $paths.PrizmkitDir
-      $env:PRIZMKIT_PLATFORM = Get-PrizmPlatformFromProject $paths.ProjectRoot $paths.PrizmkitDir $cli
-    }
-
-    $promptArgs = @((Join-Path $paths.ScriptsDir $promptScript), $listOption, $listPath, $idOption, $CurrentItemId, '--session-id', $sessionId, '--run-id', $runId, '--retry-count', $retryCount, '--resume-phase', $resumePhase, '--state-dir', $stateDir, '--output', $promptPath)
-    if ($mode) { $promptArgs += @('--mode', $mode) }
-    if ($critic) { $promptArgs += @('--critic', $critic) }
-    if ($dryRun) { $promptArgs += '--no-checkpoint' }
-    if ($verboseEnabled) { Write-PrizmInfo "Prompt args: $($promptArgs -join ' ')" }
-    $promptResult = Invoke-PrizmPythonJson $python $promptArgs
-    $itemModel = ''
-    if ($promptResult -and $promptResult.PSObject.Properties['model'] -and $promptResult.model) {
-      $itemModel = [string]$promptResult.model
-    }
-    $effectiveModel = if ($itemModel) { $itemModel } else { $env:MODEL }
-    Write-PrizmSuccess "Generated prompt: $promptPath"
-
-    if ($dryRun) {
-      Get-Content $promptPath
-      $script:PRIZM_ITEM_EXIT_CODE = 0
-      return
-    }
-
-    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
-
-    $elapsedSeconds = 0
-    $staleSeconds = 0
-    $previousLogSize = 0
-    $previousProgressSignature = ''
-    $previousChildActivitySignature = ''
-    $staleKillMarker = Join-Path $logsDir 'stale-kill.json'
-    $wasStaleKilled = $false
-    while ($true) {
-      $completed = Wait-Job $job -Timeout $heartbeatInterval
-      if ($completed) { break }
-
-      $elapsedSeconds += $heartbeatInterval
-      $currentLogSize = 0
-      if (Test-Path $sessionLog) {
-        $currentLogSize = [int64](Get-Item $sessionLog).Length
-      }
-      $growth = $currentLogSize - $previousLogSize
-      $previousLogSize = $currentLogSize
-
-      $progressActivity = Get-PrizmProgressActivity -ProgressFile $progressJson
-      $progressSignature = [string]$progressActivity.ProgressSignature
-      $progressAdvanced = ($progressSignature -and $progressSignature -ne $previousProgressSignature)
-      $previousProgressSignature = $progressSignature
-      $childSignature = [string]$progressActivity.ChildSignature
-      $childAdvanced = ($childSignature -and $childSignature -ne $previousChildActivitySignature)
-      $previousChildActivitySignature = $childSignature
-
-      $effectiveStaleKillThreshold = Get-PrizmEffectiveStaleKillThreshold -ProgressFile $progressJson -BaseThreshold $staleKillThreshold
-
-      if ($growth -gt 0 -or $childAdvanced -or $progressAdvanced) {
-        $staleSeconds = 0
-      } else {
-        $staleSeconds += $heartbeatInterval
-      }
-
-      $fatalErrorCode = Get-PrizmProgressFatalErrorCode -ProgressFile $progressJson
-      if ($fatalErrorCode) {
-        $wasStaleKilled = $true
-        Write-PrizmWarn "Session hit fatal AI runtime error: $fatalErrorCode"
-        $fatalErrorMarker = Join-Path $logsDir 'fatal-error.json'
-        Write-PrizmFatalErrorMarker $fatalErrorMarker $fatalErrorCode $staleSeconds $effectiveStaleKillThreshold
-        Write-PrizmFatalErrorMarker $staleKillMarker $fatalErrorCode $staleSeconds $effectiveStaleKillThreshold
-        Stop-PrizmSessionProcess $pidPath
-        if ($staleKillGraceSeconds -gt 0) { Start-Sleep -Seconds $staleKillGraceSeconds }
-        break
-      }
-      if ($effectiveStaleKillThreshold -gt 0 -and $staleSeconds -ge $effectiveStaleKillThreshold) {
-        $wasStaleKilled = $true
-        Write-PrizmWarn "Session stale-killed (no progress for ${effectiveStaleKillThreshold}s)"
-        Write-PrizmStaleKillMarker $staleKillMarker $staleSeconds $effectiveStaleKillThreshold
-        Stop-PrizmSessionProcess $pidPath
-        if ($staleKillGraceSeconds -gt 0) { Start-Sleep -Seconds $staleKillGraceSeconds }
-        break
-      }
-    }
-
-    $exitCode = 0
-    if ($wasStaleKilled) {
-      Stop-Job $job
-      Remove-Job $job
-      $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
-
-    $wasInfraError = ($exitCode -ne 0 -and (Test-PrizmInfraError -SessionLog $sessionLog -ProgressJson $progressJson))
-    $wasAiRuntimeError = Test-PrizmAiRuntimeError -SessionLog $sessionLog -ProgressJson $progressJson
-    $semanticCompletion = if ($Kind -eq 'feature' -and $isGitRepository) {
-      Get-PrizmFeatureSemanticCompletion $paths.ProjectRoot $listPath $CurrentItemId $baseCommit $paths.PrizmkitDir
-    } else { $null }
-
-    $status = 'crashed'
-    if ($semanticCompletion) {
-      $status = 'success'
-      if ($exitCode -ne 0 -or $wasStaleKilled -or $wasAiRuntimeError) {
-        Write-PrizmWarn "Session ended with a failure signal after semantic completion; treating as finalized success"
-        Write-PrizmWarn "Semantic completion commit: $($semanticCompletion.CommitSha)"
-      }
-    } elseif ($wasAiRuntimeError) {
-      $status = 'infra_error'
-      Write-PrizmWarn "AI session failed due to structured AI runtime/context error"
-      Write-PrizmWarn "AI runtime errors are retried without consuming code retry budget"
-    } elseif ($wasInfraError) {
-      $status = 'infra_error'
-      Write-PrizmWarn "AI session failed due to AI CLI/provider infrastructure error"
-      Write-PrizmWarn "Infrastructure errors are retried without consuming code retry budget"
-    } elseif ($wasStaleKilled -or (Test-Path $staleKillMarker)) {
-      Write-PrizmWarn "Session was stale-killed by heartbeat monitor (no progress for too long)"
-      Write-PrizmWarn "Heartbeat-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."
-    } elseif (Test-PrizmGitCommitsSince $paths.ProjectRoot $baseCommit) {
-      $status = 'success'
-    } elseif (Test-PrizmGitWorkDirty $paths.ProjectRoot $stateDir $listPath) {
-      Write-PrizmWarn "AI session exited cleanly but produced no commits; auto-committing dirty work tree."
-      if (Invoke-PrizmGitAutoCommit $paths.ProjectRoot "chore($CurrentItemId): auto-commit session work") {
-        $status = 'success'
-      } else {
-        Write-PrizmWarn "Auto-commit failed; treating session as crashed."
-      }
-    } else {
-      Write-PrizmWarn "AI session exited cleanly but produced no commits and no changes."
-    }
-
-    $mergeSucceeded = $true
-    $itemListStatus = ''
-    if ($status -eq 'success') {
-      if (Test-PrizmGitDirty $paths.ProjectRoot) {
-        Write-PrizmInfo "Auto-committing remaining session artifacts."
-        Invoke-PrizmGitIncludeRemainingArtifacts $paths.ProjectRoot $CurrentItemId
-      }
-
-      if ($status -eq 'success') {
-        $updateResult = Invoke-PrizmPythonJson $python (@((Join-Path $paths.ScriptsDir $updateScript), $listOption, $listPath, '--state-dir', $stateDir, '--action', 'update', $idOption, $CurrentItemId, '--session-id', $sessionId, '--session-status', $status) + $maxRetryArgs + $maxInfraRetryArgs)
-        if ($updateResult -and $updateResult.PSObject.Properties['new_status']) {
-          $itemListStatus = [string]$updateResult.new_status
-        }
-
-        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 ($isGitRepository -and $originalBranch) {
-      Restore-PrizmOriginalBranch $paths.ProjectRoot $originalBranch $devBranchName | Out-Null
-    }
-
-    if ($status -eq 'success' -and $mergeSucceeded -and $isGitRepository) {
-      Invoke-PrizmGitCommitPath $paths.ProjectRoot $listPath "chore($CurrentItemId): update $idName status" | Out-Null
-    }
-
-    if ($status -ne 'success') {
-      if ($Kind -eq 'feature') {
-        $failureSlug = if ($semanticCompletion) { [string]$semanticCompletion.Slug } else { Get-PrizmFeatureSlugFromList $listPath $CurrentItemId }
-        if ($failureSlug) {
-          $featureArtifactDir = Join-Path $paths.PrizmkitDir "specs\$failureSlug"
-          $failureLog = Join-Path $featureArtifactDir 'failure-log.md'
-          $checkpointPath = Join-Path $featureArtifactDir 'workflow-checkpoint.json'
-          Write-PrizmRuntimeFailureLog $failureLog $CurrentItemId $sessionId $status $exitCode $staleKillMarker $progressJson $checkpointPath $paths.ProjectRoot $baseCommit
-        }
-      }
-      $updateResult = Invoke-PrizmPythonJson $python (@((Join-Path $paths.ScriptsDir $updateScript), $listOption, $listPath, '--state-dir', $stateDir, '--action', 'update', $idOption, $CurrentItemId, '--session-id', $sessionId, '--session-status', $status) + $maxRetryArgs + $maxInfraRetryArgs)
-      if ($updateResult -and $updateResult.PSObject.Properties['new_status']) {
-        $itemListStatus = [string]$updateResult.new_status
-      }
-      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_LIST_STATUS = $itemListStatus
-    $script:PRIZM_ITEM_EXIT_CODE = if ($status -eq 'success' -and $mergeSucceeded) { 0 } else { 1 }
-    return
-  }
-
-  if ($itemId) {
-    Invoke-PrizmPipelineItem $itemId
-    $global:PRIZM_EXIT_CODE = $script:PRIZM_ITEM_EXIT_CODE
-    return
-  }
-
-  $processedCount = 0
-  $lastExitCode = 0
-  while ($true) {
-    $getNextArgs = @((Join-Path $paths.ScriptsDir $updateScript), $listOption, $listPath, '--state-dir', $stateDir, '--action', 'get_next')
-    if ($featuresFilter -and $Kind -eq 'feature') { $getNextArgs += @('--features', $featuresFilter) }
-    $getNextOutput = (Invoke-PrizmPythonOutput $python $getNextArgs).Trim()
-    if (-not $getNextOutput -or $getNextOutput -eq 'PIPELINE_COMPLETE') {
-      if ($processedCount -eq 0) {
-        Write-PrizmSuccess "No pending $Kind items."
-      } 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
-    }
-    if ($getNextOutput -eq 'PIPELINE_BLOCKED') {
-      Write-PrizmWarn "All remaining $Kind items are blocked."
-      Write-PrizmWarn "Run .\run-$Kind.ps1 status to see details."
-      $global:PRIZM_EXIT_CODE = $lastExitCode
-      return
-    }
-    if ($getNextOutput -notmatch '^\s*[\{\[]') {
-      throw "Unexpected get_next output: $getNextOutput"
-    }
-    $next = $getNextOutput | ConvertFrom-Json
-    $nextItemId = $next.PSObject.Properties["${idName}_id"].Value
-    if (-not $nextItemId) {
-      if ($processedCount -eq 0) {
-        Write-PrizmSuccess "No pending $Kind items."
-      } else {
-        Write-PrizmSuccess "Processed $processedCount $Kind item(s)."
-      }
-      $global:PRIZM_EXIT_CODE = $lastExitCode
-      return
-    }
-
-    $processedCount++
-    Invoke-PrizmPipelineItem $nextItemId
-    $lastExitCode = $script:PRIZM_ITEM_EXIT_CODE
-    if ($dryRun) {
-      $global:PRIZM_EXIT_CODE = $lastExitCode
-      return
-    }
-    if ($lastExitCode -ne 0 -and $stopOnFailure -and $script:PRIZM_ITEM_LIST_STATUS -eq 'failed') {
-      $global:PRIZM_EXIT_CODE = $lastExitCode
-      return
-    } elseif ($lastExitCode -ne 0 -and $stopOnFailure) {
-      Write-PrizmInfo "STOP_ON_FAILURE: $nextItemId is $($script:PRIZM_ITEM_LIST_STATUS); code/infra retry budget not exhausted, continuing."
-    }
-  }
-}