prizmkit 1.1.69 → 1.1.72

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

@@ -335,6 +335,242 @@ function Invoke-PrizmPipeline {
     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 Save-PrizmPostCompletionDirtyArtifacts {
+    param([string]$ProjectRoot, [string]$ArtifactDir, [string]$ItemId, [string]$SessionId)
+    $status = & git -C $ProjectRoot status --porcelain --untracked-files=all 2>$null
+    if ([string]::IsNullOrWhiteSpace(($status -join "`n"))) { return $true }
+
+    New-Item -ItemType Directory -Force -Path $ArtifactDir | Out-Null
+    ($status -join "`n") | Set-Content -Path (Join-Path $ArtifactDir 'post-completion-status.txt') -Encoding UTF8
+    & git -C $ProjectRoot diff --binary | Set-Content -Path (Join-Path $ArtifactDir 'post-completion-dirty.patch') -Encoding UTF8
+    if ($LASTEXITCODE -ne 0) { return $false }
+    & git -C $ProjectRoot diff --cached --binary | Set-Content -Path (Join-Path $ArtifactDir 'post-completion-staged.patch') -Encoding UTF8
+    if ($LASTEXITCODE -ne 0) { return $false }
+
+    $untracked = & git -C $ProjectRoot ls-files --others --exclude-standard 2>$null
+    $manifest = Join-Path $ArtifactDir 'post-completion-untracked.txt'
+    @($untracked) | Set-Content -Path $manifest -Encoding UTF8
+    $untrackedDir = Join-Path $ArtifactDir 'untracked'
+    foreach ($rel in @($untracked)) {
+      if (-not $rel) { continue }
+      $source = Join-Path $ProjectRoot $rel
+      $dest = Join-Path $untrackedDir $rel
+      $destParent = Split-Path $dest -Parent
+      if ($destParent) { New-Item -ItemType Directory -Force -Path $destParent | Out-Null }
+      if (Test-Path $source -PathType Leaf) { Copy-Item -LiteralPath $source -Destination $dest -Force }
+      elseif (Test-Path $source -PathType Container) { New-Item -ItemType Directory -Force -Path $dest | Out-Null }
+    }
+
+    @(
+      '# Post-completion dirty changes preserved',
+      '',
+      "- Feature: $ItemId",
+      "- Session: $SessionId",
+      '- Reason: workflow checkpoint and feature commit were already complete, but delayed post-commit activity left the working tree dirty.',
+      '',
+      '## Recovery guidance',
+      '',
+      'The finalized feature commit was kept unchanged for merge. Review these follow-up artifacts separately; do not assume they were merged:',
+      '',
+      '- `post-completion-status.txt` — original dirty working tree status',
+      '- `post-completion-dirty.patch` — unstaged tracked changes',
+      '- `post-completion-staged.patch` — staged changes',
+      '- `post-completion-untracked.txt` and `untracked/` — untracked files copied before cleanup'
+    ) | Set-Content -Path (Join-Path $ArtifactDir 'post-completion-findings.md') -Encoding UTF8
+
+    & git -C $ProjectRoot reset --hard *> $null
+    if ($LASTEXITCODE -ne 0) { return $false }
+    foreach ($rel in @($untracked)) {
+      if (-not $rel -or $rel -like '.prizmkit/*') { continue }
+      $target = Join-Path $ProjectRoot $rel
+      if (Test-Path $target) { Remove-Item -LiteralPath $target -Recurse -Force -ErrorAction SilentlyContinue }
+    }
+    $remaining = & git -C $ProjectRoot status --porcelain --untracked-files=all 2>$null | Where-Object { $_ -notmatch '^\?\? \.prizmkit/' }
+    return [string]::IsNullOrWhiteSpace(($remaining -join "`n"))
+  }
+
+  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 checkpoint completion and a feature commit both exist, inspect post-completion artifacts and finalize manually rather than rebuilding from scratch.',
+      '- 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'
@@ -588,6 +824,17 @@ function Invoke-PrizmPipeline {
       }
 
       $effectiveStaleKillThreshold = Get-PrizmEffectiveStaleKillThreshold -ProgressFile $progressJson -BaseThreshold $staleKillThreshold
+      $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)"
@@ -619,9 +866,23 @@ function Invoke-PrizmPipeline {
     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 ($wasTimedOut) {
+    if ($semanticCompletion) {
+      $status = 'success'
+      if ($exitCode -ne 0 -or $wasStaleKilled -or $wasTimedOut -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 ($wasTimedOut) {
       $status = 'timed_out'
       Write-PrizmWarn "AI session timed out after $timeoutSeconds seconds"
     } elseif ($wasInfraError) {
@@ -653,13 +914,17 @@ function Invoke-PrizmPipeline {
     $mergeSucceeded = $true
     $itemListStatus = ''
     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)
-      if ($updateResult -and $updateResult.PSObject.Properties['new_status']) {
-        $itemListStatus = [string]$updateResult.new_status
-      }
-
       if (Test-PrizmGitDirty $paths.ProjectRoot) {
-        if ($hadDirtyBaseline) {
+        if ($semanticCompletion) {
+          $artifactDir = Join-Path $paths.PrizmkitDir "specs\$($semanticCompletion.Slug)"
+          if (Save-PrizmPostCompletionDirtyArtifacts $paths.ProjectRoot $artifactDir $CurrentItemId $sessionId) {
+            Write-PrizmWarn "Post-completion dirty changes preserved under $artifactDir"
+            Write-PrizmWarn "They were not included in the finalized feature commit."
+          } else {
+            Write-PrizmWarn "Could not safely preserve post-completion dirty changes; preserving dev branch for manual finalization"
+            $status = 'finalization_needed'
+          }
+        } elseif ($hadDirtyBaseline) {
           Write-PrizmInfo "Auto-committing pipeline bookkeeping artifacts only."
           Invoke-PrizmGitIncludeBookkeepingArtifacts $paths.ProjectRoot $stateDir $listPath
         } else {
@@ -668,13 +933,20 @@ function Invoke-PrizmPipeline {
         }
       }
 
-      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"
+      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)
+        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) {
@@ -685,7 +957,20 @@ function Invoke-PrizmPipeline {
       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)
       if ($updateResult -and $updateResult.PSObject.Properties['new_status']) {
         $itemListStatus = [string]$updateResult.new_status

package/bundled/dev-pipeline-windows/scripts/generate-bootstrap-prompt.py

@@ -286,7 +286,7 @@ def extract_baseline_failures(test_commands, project_root):
 def format_ac_checklist(acceptance_criteria):
     """Format acceptance criteria as a markdown checkbox list."""
     if not acceptance_criteria:
-        return "- [ ] (no acceptance criteria specified)"
+        return "- (no Verification Gates specified)"
     lines = []
     for item in acceptance_criteria:
         lines.append("- [ ] {}".format(item))
@@ -323,10 +323,10 @@ def format_user_context(user_context):
     if not items:
         return ""
     lines = [
-        "### User-Provided Context (HIGHEST PRIORITY)",
-        "",
-        "> The following materials were provided by the user. "
-        "They take precedence over AI inference.",
+        "> These materials were provided by the user and are authoritative "
+        "when they clarify or constrain this feature. They do not expand "
+        "the current scope by themselves; use the Task Contract to decide "
+        "what belongs to this session.",
         "",
     ]
     for item in items:
@@ -970,6 +970,10 @@ def assemble_sections(pipeline_mode, sections_dir, init_done, is_resume,
     mission += "\n\n" + tier_desc
     sections.append(("mission", mission))
 
+    # --- Task Contract: single source of current scope and gates ---
+    sections.append(("task-contract",
+                      load_section(sections_dir, "task-contract.md")))
+
     # --- Feature Context (XML-wrapped, optimization 3) ---
     sections.append(("feature-context",
                       load_section(sections_dir, "feature-context.md")))
@@ -1079,13 +1083,8 @@ def assemble_sections(pipeline_mode, sections_dir, init_done, is_resume,
                           load_section(sections_dir,
                                        "test-failure-recovery-agent.md")))
 
-    # --- AC Verification Checklist (all tiers) ---
-    ac_checklist_path = os.path.join(sections_dir, "ac-verification-checklist.md")
-    if os.path.isfile(ac_checklist_path):
-        sections.append(("ac-verification-checklist",
-                          load_section(sections_dir,
-                                       "ac-verification-checklist.md")))
-
+    # Verification Gates are included in Task Contract. Keep AC in one place so
+    # background context and implementation prompts cannot redefine scope.
     # --- Review (only for agent tiers) ---
     if pipeline_mode == "full":
         sections.append(("phase-review",

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

@@ -17,6 +17,7 @@ The script runs until:
 import argparse
 import json
 import os
+import re
 import signal
 import sys
 import tempfile
@@ -59,6 +60,58 @@ PHASE_KEYWORDS = {
     },
 }
 
+CONTEXT_ERROR_PATTERNS = [
+    re.compile(pattern, re.IGNORECASE)
+    for pattern in (
+        r"context_too_large",
+        r"model_context_window_exceeded",
+        r"Your input exceeds the context window",
+        r"input exceeds the context window",
+        r"context window of this model",
+        r"context window exceeded",
+        r"invalid_request_error.*context window",
+        r"context window.*invalid_request_error",
+    )
+]
+
+ERROR_CONTEXT_PATTERNS = [
+    re.compile(pattern, re.IGNORECASE)
+    for pattern in (
+        r"\bapi error\b",
+        r"invalid_request_error",
+        r"\bstatus\s*[:=]?\s*(400|413)\b",
+        r"\bapi_error_status\b",
+        r"\bapi_error_code\b",
+        r"\blast_result_is_error\b\s*[\"':=]*\s*true\b",
+        r"\bis_error\b\s*[\"':=]*\s*true\b",
+    )
+]
+
+
+def _has_error_context(text):
+    """Return true when free text looks like a runtime/provider error."""
+    if not text:
+        return False
+    return any(pattern.search(text) for pattern in ERROR_CONTEXT_PATTERNS)
+
+
+def detect_api_error_code(text, require_error_context=False):
+    """Return a normalized fatal/runtime error code from terminal text.
+
+    Structured terminal result/error events and raw stderr can be matched
+    directly. Ordinary assistant prose is noisier: it may mention the phrase
+    "input exceeds the context window" while explaining a test or recovery
+    rule, so callers can require additional error-like context there.
+    """
+    if not text:
+        return ""
+    if require_error_context and not _has_error_context(text):
+        return ""
+    for pattern in CONTEXT_ERROR_PATTERNS:
+        if pattern.search(text):
+            return "context_too_large"
+    return ""
+
 
 class ProgressTracker:
     """Tracks progress state from stream-json events."""
@@ -73,6 +126,12 @@ class ProgressTracker:
         self.tool_call_counts = Counter()
         self.total_tool_calls = 0
         self.last_text_snippet = ""
+        self.last_result_is_error = False
+        self.api_error_status = None
+        self.api_error_code = ""
+        self.terminal_result_text = ""
+        self.terminal_success_at = ""
+        self.fatal_error_code = ""
         self.is_active = True
         self.errors = []
         self.event_format = ""
@@ -164,11 +223,13 @@ class ProgressTracker:
             elif event_type == "turn.failed":
                 error = event.get("error") or event.get("message") or "Codex turn failed"
                 self.errors.append(str(error))
+                self._detect_terminal_error(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))
+                self._detect_terminal_error(str(error))
 
             return
 
@@ -196,6 +257,7 @@ class ProgressTracker:
                     if text.strip():
                         self.last_text_snippet = text.strip()[:120]
                     self._detect_phase(text)
+                    self._detect_terminal_error(text, require_error_context=True)
 
         elif event_type == "tool_result" or event_type == "user":
             # tool_result contains output from tool execution
@@ -274,6 +336,28 @@ class ProgressTracker:
                         state.setdefault("subagent_type", "")
                     self._update_claude_subagent_status_counts()
 
+        elif event_type == "result":
+            self.event_format = self.event_format or "stream-json"
+            self.is_active = False
+            result_text = event.get("result") or event.get("message") or ""
+            error_obj = event.get("error")
+            if isinstance(error_obj, dict):
+                error_text = " ".join(
+                    str(error_obj.get(key) or "")
+                    for key in ("type", "code", "message")
+                    if error_obj.get(key)
+                )
+                result_text = " ".join(part for part in (str(result_text), error_text) if part)
+            api_error_code = event.get("api_error_code") or event.get("error_code") or ""
+            if isinstance(error_obj, dict) and not api_error_code:
+                api_error_code = error_obj.get("code") or error_obj.get("type") or ""
+            self._record_terminal_result(
+                text=str(result_text or ""),
+                is_error=bool(event.get("is_error")),
+                api_error_status=event.get("api_error_status"),
+                api_error_code=str(api_error_code or ""),
+            )
+
         # ── Claude API raw stream format ────────────────────────────
         elif event_type == "message_start":
             self.event_format = self.event_format or "stream-json"
@@ -316,6 +400,7 @@ class ProgressTracker:
                     self.last_text_snippet = stripped[:120]
                 # Try to detect phase from text
                 self._detect_phase(text)
+                self._detect_terminal_error(text, require_error_context=True)
 
             elif delta_type == "input_json_delta":
                 partial = delta.get("partial_json", "")
@@ -331,21 +416,73 @@ class ProgressTracker:
                 self._extract_tool_summary(full_input)
                 self._detect_phase(full_input)
             else:
-                # Text block finished - detect phase from accumulated text
+                # Text block finished - detect phase and terminal errors from accumulated text
                 if self._text_buffer:
                     self._detect_phase(self._text_buffer)
+                    self._detect_terminal_error(
+                        self._text_buffer,
+                        require_error_context=True,
+                    )
             self._in_tool_use = False
             self._current_tool_input_parts = []
 
         elif event_type == "error":
             error_msg = event.get("error", {}).get("message", "Unknown error")
             self.errors.append(error_msg)
+            self._detect_terminal_error(str(error_msg))
 
         # Check for subagent indicator
         if event.get("parent_tool_use_id"):
             # This is a sub-agent event; tool name is still tracked normally
             pass
 
+    def _record_terminal_result(self, text="", is_error=False, api_error_status=None, api_error_code=""):
+        """Record a Claude Code terminal result event."""
+        terminal_text = str(text or "")
+        self.last_result_is_error = bool(is_error)
+        if api_error_status not in (None, ""):
+            try:
+                self.api_error_status = int(api_error_status)
+            except (TypeError, ValueError):
+                self.api_error_status = api_error_status
+        error_like_result = (
+            self.last_result_is_error
+            or api_error_status not in (None, "")
+            or bool(api_error_code)
+            or _has_error_context(terminal_text)
+        )
+        normalized_code = detect_api_error_code(
+            " ".join([str(api_error_code or ""), terminal_text]),
+            require_error_context=not error_like_result,
+        )
+        if normalized_code:
+            self.api_error_code = normalized_code
+            self.fatal_error_code = normalized_code
+        elif api_error_code:
+            self.api_error_code = str(api_error_code)
+        self.terminal_result_text = terminal_text[:1000]
+        if terminal_text.strip():
+            self.last_text_snippet = terminal_text.strip()[:120]
+        if not self.last_result_is_error and not self.fatal_error_code:
+            self.terminal_success_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        elif self.fatal_error_code:
+            self.errors.append(self.fatal_error_code)
+
+    def _detect_terminal_error(self, text, require_error_context=False):
+        """Detect fatal context-window errors from unstructured text."""
+        code = detect_api_error_code(
+            str(text or ""),
+            require_error_context=require_error_context,
+        )
+        if not code:
+            return
+        self.last_result_is_error = True
+        self.api_error_code = code
+        self.fatal_error_code = code
+        self.terminal_result_text = str(text or "")[:1000]
+        if text:
+            self.last_text_snippet = str(text).strip()[:120]
+
     def _detect_phase(self, text):
         """Detect pipeline phase from text content.
 
@@ -692,6 +829,12 @@ class ProgressTracker:
             "child_activity_signature": self.child_activity_signature,
             "last_child_activity_at": self.last_child_activity_at,
             "last_text_snippet": self.last_text_snippet,
+            "last_result_is_error": self.last_result_is_error,
+            "api_error_status": self.api_error_status,
+            "api_error_code": self.api_error_code,
+            "terminal_result_text": self.terminal_result_text,
+            "terminal_success_at": self.terminal_success_at,
+            "fatal_error_code": self.fatal_error_code,
             "is_active": self.is_active,
             "errors": self.errors[-10:],  # Keep last 10 errors
         }
@@ -728,6 +871,12 @@ def tail_and_parse(session_log, progress_file, poll_interval=0.5):
             state["current_phase"],
             state["total_tool_calls"],
             state.get("child_activity_signature", ""),
+            state.get("last_result_is_error"),
+            state.get("api_error_status"),
+            state.get("api_error_code", ""),
+            state.get("fatal_error_code", ""),
+            state.get("terminal_result_text", ""),
+            tuple(state.get("errors", [])),
         )
 
     # Wait for log file to appear
@@ -752,11 +901,19 @@ def tail_and_parse(session_log, progress_file, poll_interval=0.5):
                     event = json.loads(line)
                     tracker.process_event(event)
                 except json.JSONDecodeError:
-                    # Not a JSON line (could be stderr mixed in)
-                    # Use it as a text snippet if meaningful
+                    # Not a JSON line (could be stderr mixed in). Use it as a
+                    # text snippet and only treat it as terminal when it has a
+                    # strong API/runtime error marker; ordinary assistant prose
+                    # can discuss context limits without being fatal.
                     stripped = line.strip()
                     if stripped and len(stripped) > 5:
                         tracker.last_text_snippet = stripped[:120]
+                        tracker._detect_terminal_error(stripped, require_error_context=True)
+                        current_state = tracker.to_dict()
+                        current_state_key = state_key(current_state)
+                        if current_state_key != last_write_state:
+                            atomic_write_json(current_state, progress_file)
+                            last_write_state = current_state_key
                     continue
 
                 # Write progress if state changed