prizmkit 1.1.57 → 1.1.60

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

@@ -0,0 +1,140 @@
+. "$PSScriptRoot\common.ps1"
+
+function Get-PrizmDaemonProcess {
+  param([string]$PidFile)
+  if (-not (Test-Path $PidFile)) { return $null }
+  $rawPid = (Get-Content $PidFile -ErrorAction SilentlyContinue | Select-Object -First 1)
+  $processId = 0
+  if (-not [int]::TryParse($rawPid, [ref]$processId)) { return $null }
+  return Get-Process -Id $processId -ErrorAction SilentlyContinue
+}
+
+function Convert-PrizmEnvString {
+  param([string]$EnvString)
+  $envMap = @{}
+  foreach ($pair in ($EnvString -split '\s+')) {
+    if (-not $pair) { continue }
+    $parts = $pair -split '=', 2
+    if ($parts.Count -ne 2 -or -not $parts[0]) {
+      Write-PrizmWarn "Ignoring invalid env override: $pair"
+      continue
+    }
+    if ($parts[0] -notmatch '^[A-Za-z_][A-Za-z0-9_]*$') {
+      Write-PrizmWarn "Ignoring invalid env variable name: $($parts[0])"
+      continue
+    }
+    $envMap[$parts[0]] = $parts[1]
+  }
+  return $envMap
+}
+
+function Invoke-PrizmDaemon {
+  param(
+    [ValidateSet('feature','bugfix','refactor')][string]$Kind,
+    [string]$ScriptRoot,
+    [string]$RunScript,
+    [string[]]$Args
+  )
+
+  $global:PRIZM_DAEMON_EXIT_CODE = 0
+  $paths = Initialize-PrizmPaths $ScriptRoot
+  $command = if ($Args.Count -gt 0) { $Args[0] } else { 'start' }
+  $remaining = if ($Args.Count -gt 1) { $Args[1..($Args.Count - 1)] } else { @() }
+  $daemonDir = Join-Path $paths.PrizmkitDir 'state\daemon'
+  New-Item -ItemType Directory -Force -Path $daemonDir | Out-Null
+  $pidFile = Join-Path $daemonDir "$Kind.pid"
+  $logFile = Join-Path $daemonDir "$Kind-daemon.log"
+  $errorLogFile = Join-Path $daemonDir "$Kind-daemon.err.log"
+
+  switch ($command) {
+    { $_ -in @('help','--help','-h') } {
+      Write-Host "Usage: .\launch-$Kind-daemon.ps1 [start|status|stop|logs] [run options]"
+      Write-Host "  start   Launch .\run-$Kind.ps1 run in the background"
+      Write-Host "  status  Show daemon process state"
+      Write-Host "  stop    Stop the daemon process if it is still running"
+      Write-Host "  logs    Print daemon stdout/stderr logs"
+      return
+    }
+    'start' {
+      $existing = Get-PrizmDaemonProcess $pidFile
+      if ($existing) {
+        Write-PrizmWarn "$Kind daemon already running (PID $($existing.Id))."
+        return
+      }
+
+      $runArgs = @()
+      $envOverrides = @{}
+      for ($i = 0; $i -lt $remaining.Count; $i++) {
+        $arg = $remaining[$i]
+        if ($arg -eq '--env') {
+          if ($i + 1 -ge $remaining.Count) { throw '--env requires a value, for example --env "VERBOSE=1 MAX_RETRIES=5"' }
+          $parsedEnv = Convert-PrizmEnvString $remaining[$i + 1]
+          foreach ($key in $parsedEnv.Keys) {
+            $envOverrides[$key] = $parsedEnv[$key]
+          }
+          $i++
+          continue
+        }
+        $runArgs += $arg
+      }
+
+      $hostPath = Resolve-PrizmPowerShellHost
+      $arguments = Join-PrizmProcessArguments (@('-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', $RunScript, 'run') + $runArgs)
+      $originalEnv = @{}
+      foreach ($key in $envOverrides.Keys) {
+        $originalEnv[$key] = [Environment]::GetEnvironmentVariable($key, 'Process')
+        [Environment]::SetEnvironmentVariable($key, $envOverrides[$key], 'Process')
+      }
+      try {
+        $process = Start-Process -FilePath $hostPath `
+          -ArgumentList $arguments `
+          -WorkingDirectory $paths.ProjectRoot `
+          -RedirectStandardOutput $logFile `
+          -RedirectStandardError $errorLogFile `
+          -PassThru
+      } finally {
+        foreach ($key in $envOverrides.Keys) {
+          [Environment]::SetEnvironmentVariable($key, $originalEnv[$key], 'Process')
+        }
+      }
+      Set-Content -Path $pidFile -Value ([string]$process.Id) -Encoding UTF8
+      Write-PrizmSuccess "$Kind daemon started (PID $($process.Id))."
+      Write-PrizmInfo "Log: $logFile"
+      if (Test-Path $errorLogFile) { Write-PrizmInfo "Error log: $errorLogFile" }
+      return
+    }
+    'status' {
+      $process = Get-PrizmDaemonProcess $pidFile
+      if ($process) {
+        Write-PrizmSuccess "$Kind daemon running (PID $($process.Id))."
+      } else {
+        if (Test-Path $pidFile) { Remove-Item -Force $pidFile }
+        Write-PrizmInfo "$Kind daemon is not running."
+      }
+      Write-PrizmInfo "Log: $logFile"
+      return
+    }
+    'stop' {
+      $process = Get-PrizmDaemonProcess $pidFile
+      if (-not $process) {
+        if (Test-Path $pidFile) { Remove-Item -Force $pidFile }
+        Write-PrizmInfo "$Kind daemon is not running."
+        return
+      }
+      Stop-PrizmProcessTreeById -ProcessId $process.Id
+      Remove-Item -Force $pidFile
+      Write-PrizmSuccess "$Kind daemon stopped (PID $($process.Id))."
+      return
+    }
+    'logs' {
+      if (Test-Path $logFile) { Get-Content $logFile -Tail 120 }
+      if (Test-Path $errorLogFile) { Get-Content $errorLogFile -Tail 120 }
+      return
+    }
+    default {
+      Write-PrizmError "Unknown daemon command: $command"
+      $global:PRIZM_DAEMON_EXIT_CODE = 1
+      return
+    }
+  }
+}

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

@@ -0,0 +1,446 @@
+. "$PSScriptRoot\common.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)
+  }
+
+  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] [--timeout seconds]"
+    Write-Host "       .\run-$Kind.ps1 status [list-path]"
+    Write-Host "       .\run-$Kind.ps1 reset"
+    $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)
+    $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] }
+  $verboseEnabled = $env:VERBOSE -in @('1','true','yes','on')
+  $timeoutSeconds = 0
+  if ($env:SESSION_TIMEOUT) {
+    $parsedEnvTimeout = 0
+    if (-not [int]::TryParse($env:SESSION_TIMEOUT, [ref]$parsedEnvTimeout) -or $parsedEnvTimeout -lt 0) {
+      throw "SESSION_TIMEOUT must be a non-negative integer: $($env:SESSION_TIMEOUT)"
+    }
+    $timeoutSeconds = $parsedEnvTimeout
+  }
+  $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
+      }
+      '^--timeout$' {
+        $i++
+        if ($i -ge $remaining.Count) { throw '--timeout requires a seconds value.' }
+        $parsedTimeout = 0
+        if (-not [int]::TryParse($remaining[$i], [ref]$parsedTimeout) -or $parsedTimeout -lt 0) {
+          throw "--timeout must be a non-negative integer: $($remaining[$i])"
+        }
+        $timeoutSeconds = $parsedTimeout
+        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) }
+  if ($verboseEnabled) {
+    $modeLabel = if ($mode) { $mode } else { 'auto' }
+    $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"
+  }
+
+  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)
+    $lines = & git -C $ProjectRoot status --porcelain 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-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 (-not (Test-PrizmPipelineBookkeepingPath $ProjectRoot $path $StateDir $ListPath)) {
+        return $true
+      }
+    }
+    return $false
+  }
+
+  function Test-PrizmGitDirty {
+    param([string]$ProjectRoot)
+    $dirty = & git -C $ProjectRoot status --porcelain 2>$null | Select-Object -First 1
+    return -not [string]::IsNullOrWhiteSpace([string]$dirty)
+  }
+
+  function Invoke-PrizmGitAutoCommit {
+    param([string]$ProjectRoot, [string]$Message)
+    & git -C $ProjectRoot add -A *> $null
+    & git -C $ProjectRoot commit --no-verify -m $Message *> $null
+    return $LASTEXITCODE -eq 0
+  }
+
+  function Invoke-PrizmGitIncludeRemainingArtifacts {
+    param([string]$ProjectRoot, [string]$ItemId)
+    & git -C $ProjectRoot add -A *> $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-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 }
+    $baseCommit = if ($isGitRepository) { Get-PrizmGitHead $paths.ProjectRoot } else { '' }
+    $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."
+    }
+
+    if ($dryRun) {
+      $statusPath = Join-Path $stateDir "$($idName)s\$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)
+      if ($start.retry_count -ne $null) { $retryCount = [string]$start.retry_count }
+      if ($start.resume_from_phase -ne $null) { $resumePhase = [string]$start.resume_from_phase }
+    }
+
+    $sessionDir = if ($dryRun) {
+      Join-Path ([System.IO.Path]::GetTempPath()) "prizmkit-dry-run\$sessionId"
+    } else {
+      Join-Path $stateDir "$($idName)s\$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)"
+
+    $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
+        }
+      }
+      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 = [int](Receive-Job $job)
+    Remove-Job $job
+    $status = 'crashed'
+    if ($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 ($hadDirtyBaseline) {
+      Write-PrizmWarn "AI session exited cleanly but produced no new commits; pre-existing dirty tree will not be auto-committed."
+    } 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."
+    }
+
+    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 ($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 ($status -eq 'success') {
+      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 }
+    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)."
+      }
+      $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 $env:STOP_ON_FAILURE -eq '1') {
+      $global:PRIZM_EXIT_CODE = $lastExitCode
+      return
+    }
+  }
+}

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

@@ -0,0 +1,87 @@
+. "$PSScriptRoot\common.ps1"
+
+function Get-PrizmFeatureSlug {
+  param([string]$ListPath, [string]$FeatureId)
+  $data = Get-Content $ListPath -Raw | ConvertFrom-Json
+  $feature = $data.features | Where-Object { $_.id -eq $FeatureId } | Select-Object -First 1
+  if (-not $feature) { throw "Feature not found in list: $FeatureId" }
+  $numeric = ($FeatureId -replace '^[Ff]-', '').PadLeft(3, '0')
+  $slug = ([string]$feature.title).ToLowerInvariant()
+  $slug = $slug -replace '[^a-z0-9\s-]', ''
+  $slug = ($slug.Trim() -replace '\s+', '-')
+  $slug = ($slug -replace '-+', '-').Trim('-')
+  if (-not $slug) { $slug = 'feature' }
+  return "$numeric-$slug"
+}
+
+function Invoke-PrizmReset {
+  param(
+    [ValidateSet('feature','bugfix','refactor')][string]$Kind,
+    [string]$ScriptRoot,
+    [string[]]$Args
+  )
+
+  $global:PRIZM_RESET_EXIT_CODE = 0
+  $paths = Initialize-PrizmPaths $ScriptRoot
+  Set-Location $paths.ProjectRoot
+  $python = Resolve-PrizmPython
+
+  $idOption = @{ feature = '--feature-id'; bugfix = '--bug-id'; refactor = '--refactor-id' }[$Kind]
+  $listOption = @{ feature = '--feature-list'; bugfix = '--bug-list'; refactor = '--refactor-list' }[$Kind]
+  $updateScript = @{ feature = 'update-feature-status.py'; bugfix = 'update-bug-status.py'; refactor = 'update-refactor-status.py' }[$Kind]
+  $runScript = @{ feature = 'run-feature.ps1'; bugfix = 'run-bugfix.ps1'; refactor = 'run-refactor.ps1' }[$Kind]
+  $idPattern = @{ feature = '^[Ff]-\d+'; bugfix = '^[Bb]-\d+'; refactor = '^[Rr]-\d+' }[$Kind]
+  $label = @{ feature = 'feature'; bugfix = 'bug'; refactor = 'refactor' }[$Kind]
+  $listPath = Get-PrizmListDefault $Kind $paths.ProjectRoot
+  $stateDir = Get-PrizmStateDir $Kind $paths.ProjectRoot
+  $itemId = $null
+  $clean = $false
+  $runAfterReset = $false
+
+  foreach ($arg in $Args) {
+    switch -Regex ($arg) {
+      '^--clean$' { $clean = $true; continue }
+      '^--run$' { $runAfterReset = $true; continue }
+      '^(--help|-h)$' {
+        Write-Host "Usage: .\reset-$label.ps1 [$($label)-id] [--clean] [--run] [list-path]"
+        Write-Host "  No ID clears the whole $Kind pipeline state."
+        Write-Host "  With an ID, reset only that item. --clean removes item artifacts. --run retries it immediately."
+        return
+      }
+      '^-.*' { Write-PrizmWarn "Ignoring unsupported option: $arg"; continue }
+      default {
+        if (-not $itemId -and $arg -match $idPattern) {
+          $itemId = $arg.ToUpperInvariant()
+        } else {
+          $listPath = $arg
+        }
+      }
+    }
+  }
+
+  if (-not $itemId) {
+    & (Join-Path $paths.PipelineDir $runScript) reset
+    $global:PRIZM_RESET_EXIT_CODE = $LASTEXITCODE
+    return
+  }
+
+  if (-not (Test-Path $listPath)) { throw "List file not found: $listPath" }
+  New-Item -ItemType Directory -Force -Path $stateDir | Out-Null
+
+  $action = if ($clean) { 'clean' } else { 'reset' }
+  $resetArgs = @((Join-Path $paths.ScriptsDir $updateScript), $listOption, $listPath, '--state-dir', $stateDir, '--action', $action, $idOption, $itemId)
+  if ($clean) {
+    $resetArgs += @('--project-root', $paths.ProjectRoot)
+    if ($Kind -eq 'feature') {
+      $resetArgs += @('--feature-slug', (Get-PrizmFeatureSlug $listPath $itemId))
+    }
+  }
+
+  Invoke-PrizmPythonText $python $resetArgs
+  Write-PrizmSuccess "Reset $label item: $itemId"
+
+  if ($runAfterReset) {
+    & (Join-Path $paths.PipelineDir $runScript) run $itemId $listPath
+    $global:PRIZM_RESET_EXIT_CODE = $LASTEXITCODE
+  }
+}

package/bundled/dev-pipeline-windows/reset-bug.ps1

@@ -0,0 +1,9 @@
+#!/usr/bin/env pwsh
+. "$PSScriptRoot\lib\reset.ps1"
+try {
+  Invoke-PrizmReset -Kind bugfix -ScriptRoot $PSScriptRoot -Args $args
+  exit $global:PRIZM_RESET_EXIT_CODE
+} catch {
+  Write-PrizmError $_.Exception.Message
+  exit 1
+}