prizmkit 1.1.99 → 1.1.100

package/bundled/dev-pipeline/tests/test_generate_bugfix_prompt.py

@@ -1,5 +1,8 @@
 """Tests for generate-bugfix-prompt.py core functions."""
 
+from argparse import Namespace
+from pathlib import Path
+
 from generate_bugfix_prompt import (
     find_bug,
     format_acceptance_criteria,
@@ -8,7 +11,9 @@ from generate_bugfix_prompt import (
     format_environment,
     process_conditional_blocks,
     render_template,
+    load_log_size_section,
 )
+from continuation import append_continuation_handoff
 
 
 # ---------------------------------------------------------------------------
@@ -166,3 +171,58 @@ class TestSharedHelpers:
     def test_format_global_context_dict(self):
         result = format_global_context({"lang": "Python"})
         assert "**lang**: Python" in result
+
+
+# ---------------------------------------------------------------------------
+# Active compaction harness rollback
+# ---------------------------------------------------------------------------
+
+class TestHeadlessRecoveryReframing:
+    def test_bugfix_log_size_section_is_passive_checkpoint_guidance(self):
+        content = load_log_size_section(str(Path("dev-pipeline/scripts").resolve()))
+
+        assert "passive checkpoint guidance" in content
+        assert "Headless recovery must rely on durable checkpoints" in content
+        assert "fresh continuation session" in content
+        assert "optional interactive convenience only" in content
+        assert "COMPACT_NEEDED" not in content
+        assert "monitor-log" not in content
+        assert "background monitoring subagent" not in content
+        assert "Execute `/compact`" not in content
+        assert "run `/compact`" not in content.lower()
+
+    def test_bugfix_template_does_not_spawn_monitor_or_require_compact(self):
+        content = Path("dev-pipeline/templates/bugfix-bootstrap-prompt.md").read_text(encoding="utf-8")
+
+        assert "Do not spawn persistent background subagents for headless recovery" in content
+        assert "log-size monitor" not in content
+        assert "monitor-log" not in content
+        assert "COMPACT_NEEDED" not in content
+        assert "Run this command and keep it running" not in content
+        assert "Execute `/compact`" not in content
+        assert "run `/compact` after" not in content
+
+
+class TestBugfixContinuationHandoff:
+    def test_writes_specs_and_task_local_summaries(self, tmp_path):
+        args = Namespace(
+            output=str(tmp_path / ".prizmkit/state/bugfix/B-007/sessions/B-007-new/bootstrap-prompt.md"),
+            state_dir=str(tmp_path / ".prizmkit/state/bugfix"),
+            continuation_mode="context_overflow",
+            previous_session_id="B-007-old",
+            continuation_count="1",
+            context_overflow_count="1",
+            active_dev_branch="bugfix/B-007",
+            base_branch="main",
+            continuation_summary_path=".prizmkit/specs/B-007/continuation-summary.md",
+        )
+        prompt = append_continuation_handoff(
+            "BUGFIX PROMPT", args, str(tmp_path), "bugfix", "B-007", "B-007",
+            {"steps": [{"id": "S01", "skill": "diagnose", "status": "pending"}]},
+        )
+
+        assert prompt.startswith("BUGFIX PROMPT")
+        assert "This is an automatic continuation after context overflow." in prompt
+        assert "Do not attempt `/compact` as the recovery mechanism." in prompt
+        assert (tmp_path / ".prizmkit/specs/B-007/continuation-summary.md").exists()
+        assert (tmp_path / ".prizmkit/bugfix/B-007/continuation-summary.md").exists()

package/bundled/dev-pipeline/tests/test_generate_refactor_prompt.py

@@ -0,0 +1,43 @@
+"""Tests for generate-refactor-prompt.py continuation behavior."""
+
+from argparse import Namespace
+
+from continuation import append_continuation_handoff
+from generate_refactor_prompt import generate_refactor_checkpoint, merge_refactor_checkpoint_state
+
+
+class TestRefactorContinuationHandoff:
+    def test_writes_specs_and_task_local_summaries(self, tmp_path):
+        args = Namespace(
+            output=str(tmp_path / ".prizmkit/state/refactor/R-007/sessions/R-007-new/bootstrap-prompt.md"),
+            state_dir=str(tmp_path / ".prizmkit/state/refactor"),
+            continuation_mode="context_overflow",
+            previous_session_id="R-007-old",
+            continuation_count="1",
+            context_overflow_count="1",
+            active_dev_branch="refactor/R-007",
+            base_branch="main",
+            continuation_summary_path=".prizmkit/specs/R-007/continuation-summary.md",
+        )
+        prompt = append_continuation_handoff(
+            "REFACTOR PROMPT", args, str(tmp_path), "refactor", "R-007", "R-007",
+            {"steps": [{"id": "S01", "skill": "plan", "status": "pending"}]},
+        )
+
+        assert prompt.startswith("REFACTOR PROMPT")
+        assert "This is a fresh headless AI CLI session for the same task." in prompt
+        assert "Do not attempt `/compact` as the recovery mechanism." in prompt
+        assert (tmp_path / ".prizmkit/specs/R-007/continuation-summary.md").exists()
+        assert (tmp_path / ".prizmkit/refactor/R-007/continuation-summary.md").exists()
+
+
+class TestRefactorCheckpointMerge:
+    def test_preserves_skipped_without_artifacts(self, tmp_path):
+        fresh = generate_refactor_checkpoint("R-008", "R-008-new")
+        existing = generate_refactor_checkpoint("R-008", "R-008-old")
+        existing["steps"][0]["status"] = "skipped"
+
+        merged = merge_refactor_checkpoint_state(existing, fresh, str(tmp_path))
+
+        assert merged["steps"][0]["status"] == "skipped"
+        assert merged["steps"][1]["status"] == "pending"

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

@@ -175,19 +175,30 @@ function Test-PrizmInfraError {
   return ($haystack -match '(?i)auth_unavailable|no auth available|502 Bad Gateway|503 Service Unavailable|504 Gateway Timeout|gateway timeout|upstream (connect )?error|connection reset|ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|rate limit|rate_limit|temporarily unavailable|overloaded')
 }
 
-function Test-PrizmAiRuntimeError {
+function Test-PrizmContextOverflowError {
   param([string]$SessionLog, [string]$ProgressJson)
 
+  $parts = @()
+  $codeParts = @()
+  $progressErrorLike = $false
+
   if ($ProgressJson -and (Test-Path $ProgressJson)) {
     try {
       $progress = Get-Content $ProgressJson -Raw -ErrorAction Stop | ConvertFrom-Json -ErrorAction Stop
-      if ($progress.PSObject.Properties['fatal_error_code'] -and $progress.fatal_error_code) {
-        return $true
+      foreach ($name in @('fatal_error_code', 'api_error_code', 'error_code', 'stop_reason')) {
+        if ($progress.PSObject.Properties[$name] -and $progress.$name) { $codeParts += [string]$progress.$name }
+      }
+      if (($progress.PSObject.Properties['last_result_is_error'] -and $progress.last_result_is_error) -or ($progress.PSObject.Properties['api_error_status'] -and $progress.api_error_status)) {
+        $progressErrorLike = $true
       }
+      $parts += ($progress | ConvertTo-Json -Depth 12 -Compress)
     } catch {}
   }
 
-  $parts = @()
+  $codeText = $codeParts -join ' '
+  $codePattern = '(?i)\b(context_overflow|context_too_large|context_length_exceeded|model_context_window_exceeded)\b'
+  if ($codeText -match $codePattern) { return $true }
+
   if ($SessionLog -and (Test-Path $SessionLog)) {
     try {
       $text = Get-Content $SessionLog -Raw -ErrorAction Stop
@@ -195,15 +206,166 @@ function Test-PrizmAiRuntimeError {
       $parts += $text
     } catch {}
   }
-  if ($ProgressJson -and (Test-Path $ProgressJson)) {
-    try { $parts += (Get-Content $ProgressJson -Raw -ErrorAction Stop) } catch {}
-  }
   if ($parts.Count -eq 0) { return $false }
 
   $haystack = $parts -join "`n"
-  $contextPattern = '(?i)context_too_large|model_context_window_exceeded|input exceeds the context window|context window of this model|context window (was )?exceeded|exceeded (the )?context window|invalid_request_error.*context window|context window.*invalid_request_error'
-  $errorPattern = '(?i)api error|invalid_request_error|api_error_status|api_error_code|status\s*[:=]?\s*(400|413)|last_result_is_error\s*["'':=]?\s*true|is_error\s*["'':=]?\s*true'
-  if (($haystack -match $contextPattern) -and ($haystack -match $errorPattern)) { return $true }
+  $wrapperPattern = '(?i)\bPRIZMKIT_FATAL_ERROR\s*=\s*context_overflow\b'
+  if ($haystack -match $wrapperPattern) { return $true }
+  if ($haystack -match $codePattern) { return $true }
+
+  $errorPattern = '(?i)\bapi error\b|invalid_request_error|\bbad request\b|\bstatus\s*[:=]?\s*(400|413)\b|\bapi_error_status\b|\bapi_error_code\b|\blast_result_is_error\b\s*["'':=]*\s*true\b|\bis_error\b\s*["'':=]*\s*true\b|\berror\s*[:=]|\bfatal\s*[:=]'
+  $hasErrorContext = $progressErrorLike -or ($haystack -match $errorPattern)
+  if (-not $hasErrorContext) { return $false }
+
+  $weakPattern = '(?i)Your input exceeds the context window|input exceeds (?:the )?(?:model )?context window|context window of this model|context window (?:was )?exceeded|exceeded (?:the )?context window|maximum context length exceeded|prompt is too long|too many tokens|input token count exceeds|input tokens? exceeds?|token count exceeds'
+  if ($haystack -match $weakPattern) { return $true }
+
+  $requestTooLargePattern = '(?i)\brequest (?:is )?too large\b'
+  $requestSemanticsPattern = '(?i)\b(context|token|tokens|prompt|input|model)\b'
+  if (($haystack -match $requestTooLargePattern) -and ($haystack -match $requestSemanticsPattern)) { return $true }
+
+  return $false
+}
+
+function Test-PrizmAiRuntimeError {
+  param([string]$SessionLog, [string]$ProgressJson)
+
+  if (Test-PrizmContextOverflowError -SessionLog $SessionLog -ProgressJson $ProgressJson) { return $false }
+
+  if ($ProgressJson -and (Test-Path $ProgressJson)) {
+    try {
+      $progress = Get-Content $ProgressJson -Raw -ErrorAction Stop | ConvertFrom-Json -ErrorAction Stop
+      if ($progress.PSObject.Properties['fatal_error_code'] -and $progress.fatal_error_code) {
+        return $true
+      }
+    } catch {}
+  }
+
+  return $false
+}
+
+function Get-PrizmContextProgressFingerprint {
+  param(
+    [string]$ProjectRoot,
+    [string]$TaskType,
+    [string]$TaskId,
+    [string]$ArtifactDir = '',
+    [string]$CheckpointFile = ''
+  )
+
+  $projectRootResolved = if ($ProjectRoot) { $ProjectRoot } else { (Get-Location).Path }
+  $artifactArg = if ($ArtifactDir) { $ArtifactDir } else { '' }
+  $checkpointArg = if ($CheckpointFile) { $CheckpointFile } else { '' }
+  $python = @'
+import hashlib
+import json
+import os
+import subprocess
+import sys
+
+project_root, task_type, task_id, artifact_dir, checkpoint_file = sys.argv[1:6]
+project_root = os.path.abspath(project_root or ".")
+artifact_dir = os.path.abspath(os.path.join(project_root, artifact_dir)) if artifact_dir and not os.path.isabs(artifact_dir) else artifact_dir
+checkpoint_file = os.path.abspath(os.path.join(project_root, checkpoint_file)) if checkpoint_file and not os.path.isabs(checkpoint_file) else checkpoint_file
+
+def run_git(args):
+    try:
+        return subprocess.check_output(["git", "-C", project_root, *args], stderr=subprocess.DEVNULL)
+    except Exception:
+        return b""
+
+def sha_bytes(*parts):
+    h = hashlib.sha256()
+    for part in parts:
+        if isinstance(part, str):
+            part = part.encode("utf-8", errors="surrogateescape")
+        h.update(part or b"")
+        h.update(b"\0")
+    return h.hexdigest()
+
+def checkpoint_cursor(path):
+    if not path or not os.path.exists(path):
+        return "missing"
+    try:
+        with open(path, encoding="utf-8") as fh:
+            data = json.load(fh)
+    except Exception as exc:
+        return "unreadable:{}".format(type(exc).__name__)
+    steps = data.get("steps") if isinstance(data, dict) else None
+    if not isinstance(steps, list):
+        return "no-steps"
+    counts = {"completed": 0, "skipped": 0, "pending": 0, "in_progress": 0, "failed": 0}
+    first_open = None
+    for step in steps:
+        if not isinstance(step, dict):
+            continue
+        status = str(step.get("status", "pending"))
+        counts[status] = counts.get(status, 0) + 1
+        if first_open is None and status in ("pending", "in_progress"):
+            first_open = "{}:{}:{}".format(step.get("id", ""), step.get("skill", ""), status)
+    return "first_open={};counts={}".format(first_open or "none", ",".join("{}:{}".format(k, counts[k]) for k in sorted(counts)))
+
+def artifact_fingerprint(path):
+    if not path or not os.path.isdir(path):
+        return "missing"
+    h = hashlib.sha256()
+    for root, dirs, files in os.walk(path):
+        dirs[:] = sorted(d for d in dirs if d not in {".git", "node_modules", "__pycache__"})
+        for name in sorted(files):
+            file_path = os.path.join(root, name)
+            rel = os.path.relpath(file_path, path).replace(os.sep, "/")
+            h.update(rel.encode("utf-8", errors="surrogateescape"))
+            h.update(b"\0")
+            try:
+                with open(file_path, "rb") as fh:
+                    for chunk in iter(lambda: fh.read(65536), b""):
+                        h.update(chunk)
+            except Exception as exc:
+                h.update("unreadable:{}".format(type(exc).__name__).encode("utf-8"))
+            h.update(b"\0")
+    return h.hexdigest()
+
+fingerprint = {
+    "task_type": task_type,
+    "task_id": task_id,
+    "git_diff_fingerprint": sha_bytes(run_git(["status", "--porcelain", "--untracked-files=all", "--", "."]), run_git(["diff", "--binary", "HEAD", "--", "."])),
+    "checkpoint_cursor": checkpoint_cursor(checkpoint_file),
+    "artifact_fingerprint": artifact_fingerprint(artifact_dir),
+    "head_commit": run_git(["rev-parse", "HEAD"]).decode("utf-8", errors="ignore").strip(),
+}
+print(json.dumps(fingerprint, sort_keys=True, ensure_ascii=False))
+'@
+  $scriptPath = [System.IO.Path]::GetTempFileName()
+  try {
+    Set-Content -Path $scriptPath -Value $python -Encoding UTF8
+    $pythonCmd = Get-Command python -ErrorAction SilentlyContinue
+    if ($pythonCmd) {
+      $output = & $pythonCmd.Source $scriptPath $projectRootResolved $TaskType $TaskId $artifactArg $checkpointArg
+    } else {
+      $pyCmd = Get-Command py -ErrorAction SilentlyContinue
+      if (-not $pyCmd) { throw 'Python 3 is required for progress fingerprinting.' }
+      $output = & $pyCmd.Source -3 $scriptPath $projectRootResolved $TaskType $TaskId $artifactArg $checkpointArg
+    }
+    if ($LASTEXITCODE -ne 0) { throw 'progress fingerprint python helper failed' }
+    return ($output -join "`n")
+  } finally {
+    Remove-Item -Force $scriptPath -ErrorAction SilentlyContinue
+  }
+}
+
+function Test-PrizmContextProgressChanged {
+  param([string]$BeforeJson, [string]$AfterJson)
+  try {
+    $before = if ($BeforeJson) { $BeforeJson | ConvertFrom-Json } else { $null }
+    $after = if ($AfterJson) { $AfterJson | ConvertFrom-Json } else { $null }
+  } catch {
+    return $true
+  }
+  foreach ($key in @('git_diff_fingerprint', 'checkpoint_cursor', 'artifact_fingerprint', 'head_commit')) {
+    $beforeValue = if ($before -and $before.PSObject.Properties[$key]) { [string]$before.$key } else { '' }
+    $afterValue = if ($after -and $after.PSObject.Properties[$key]) { [string]$after.$key } else { '' }
+    if ($beforeValue -ne $afterValue) { return $true }
+  }
   return $false
 }
 

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

@@ -50,8 +50,7 @@ function Invoke-PrizmPipeline {
     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)"
+    Write-Host "  MAX_LOG_SIZE          Include passive log-size checkpoint guidance above this threshold (default: 2097152 = 2MB, set 0 to disable)"
     $global:PRIZM_EXIT_CODE = 0
     return
   }
@@ -626,7 +625,10 @@ function Invoke-PrizmPipeline {
   }
 
   function Invoke-PrizmPipelineItem {
-    param([string]$CurrentItemId)
+    param(
+      [string]$CurrentItemId,
+      [object]$ContinuationState = $null
+    )
     $script:PRIZM_ITEM_EXIT_CODE = 0
 
     $sessionId = New-PrizmSessionId $Kind
@@ -636,6 +638,27 @@ function Invoke-PrizmPipeline {
     $isGitRepository = if (-not $dryRun) { Test-PrizmGitRepository $paths.ProjectRoot } else { $false }
     $originalBranch = if ($isGitRepository) { Get-PrizmCurrentBranch $paths.ProjectRoot } else { '' }
     $devBranchName = ''
+    $activeDevBranch = ''
+    $continuationPending = $false
+    $continuationReason = ''
+    $contextOverflowCount = 0
+    $continuationCount = 0
+    $previousSessionId = ''
+    $noProgressCount = 0
+    if ($ContinuationState) {
+      if ($ContinuationState.PSObject.Properties['active_dev_branch'] -and $ContinuationState.active_dev_branch) { $activeDevBranch = [string]$ContinuationState.active_dev_branch }
+      if ($ContinuationState.PSObject.Properties['base_branch'] -and $ContinuationState.base_branch) { $originalBranch = [string]$ContinuationState.base_branch }
+      if ($ContinuationState.PSObject.Properties['continuation_pending']) { $continuationPending = [bool]$ContinuationState.continuation_pending }
+      if ($ContinuationState.PSObject.Properties['continuation_reason'] -and $ContinuationState.continuation_reason) { $continuationReason = [string]$ContinuationState.continuation_reason }
+      if ($ContinuationState.PSObject.Properties['context_overflow_count'] -and $ContinuationState.context_overflow_count -ne $null) { $contextOverflowCount = [int]$ContinuationState.context_overflow_count }
+      if ($ContinuationState.PSObject.Properties['continuation_count'] -and $ContinuationState.continuation_count -ne $null) { $continuationCount = [int]$ContinuationState.continuation_count }
+      if ($ContinuationState.PSObject.Properties['last_context_overflow_session_id'] -and $ContinuationState.last_context_overflow_session_id) { $previousSessionId = [string]$ContinuationState.last_context_overflow_session_id }
+      if ($ContinuationState.PSObject.Properties['no_progress_count'] -and $ContinuationState.no_progress_count -ne $null) { $noProgressCount = [int]$ContinuationState.no_progress_count }
+    }
+    if ($continuationPending -and $activeDevBranch) {
+      Write-PrizmInfo "Continuation pending ($continuationReason); reusing dev branch: $activeDevBranch"
+      Write-PrizmInfo "Continuation count: $continuationCount (context overflows: $contextOverflowCount)"
+    }
     $hadDirtyBaseline = if ($isGitRepository) { Test-PrizmGitWorkDirty $paths.ProjectRoot $stateDir $listPath } else { $false }
     if ($hadDirtyBaseline) {
       if ($dryRun) {
@@ -664,7 +687,7 @@ function Invoke-PrizmPipeline {
 
       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 }
+        $candidateBranch = if ($devBranchOverride) { $devBranchOverride } elseif ($continuationPending -and $activeDevBranch) { $activeDevBranch } else { New-PrizmDefaultDevBranchName $Kind $CurrentItemId }
         if (New-PrizmDevBranch $paths.ProjectRoot $candidateBranch $originalBranch) {
           $devBranchName = $candidateBranch
           Write-PrizmInfo "Dev branch: $devBranchName"
@@ -679,6 +702,7 @@ function Invoke-PrizmPipeline {
 
     $baseCommit = if ($isGitRepository) { Get-PrizmGitHead $paths.ProjectRoot } else { '' }
 
+    while ($true) {
     $sessionDir = if ($dryRun) {
       Join-Path ([System.IO.Path]::GetTempPath()) "prizmkit-dry-run\$sessionId"
     } else {
@@ -697,6 +721,15 @@ function Invoke-PrizmPipeline {
     }
 
     $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)
+    $continuationSummaryPath = ".prizmkit/$Kind/$CurrentItemId/continuation-summary.md"
+    if ($Kind -eq 'feature') {
+      $featureSlug = Get-PrizmFeatureSlugFromList $listPath $CurrentItemId
+      if ($featureSlug) { $continuationSummaryPath = ".prizmkit/specs/$featureSlug/continuation-summary.md" }
+    }
+    if ($continuationPending) {
+      $modeForContinuation = if ($continuationReason) { $continuationReason } else { 'context_overflow' }
+      $promptArgs += @('--continuation-mode', $modeForContinuation, '--previous-session-id', $previousSessionId, '--continuation-count', [string]$continuationCount, '--context-overflow-count', [string]$contextOverflowCount, '--task-type', $Kind, '--active-dev-branch', $activeDevBranch, '--base-branch', $originalBranch, '--continuation-summary-path', $continuationSummaryPath)
+    }
     if ($mode) { $promptArgs += @('--mode', $mode) }
     if ($critic) { $promptArgs += @('--critic', $critic) }
     if ($dryRun) { $promptArgs += '--no-checkpoint' }
@@ -717,6 +750,10 @@ function Invoke-PrizmPipeline {
 
     Write-PrizmInfo "Starting $cli session for $CurrentItemId ($sessionId)"
 
+    $artifactDirForFingerprint = if ($Kind -eq 'feature') { Split-Path $continuationSummaryPath -Parent } else { ".prizmkit/$Kind/$CurrentItemId" }
+    $checkpointForFingerprint = Join-Path $artifactDirForFingerprint 'workflow-checkpoint.json'
+    $progressBefore = Get-PrizmContextProgressFingerprint -ProjectRoot $paths.ProjectRoot -TaskType $Kind -TaskId $CurrentItemId -ArtifactDir $artifactDirForFingerprint -CheckpointFile $checkpointForFingerprint
+
     $progressJson = Join-Path $logsDir 'progress.json'
     $parserProcess = Start-PrizmProgressParser -PythonCommand $python -ScriptsDir $paths.ScriptsDir -SessionLog $sessionLog -ProgressFile $progressJson -CliCommand $cli
 
@@ -798,22 +835,34 @@ function Invoke-PrizmPipeline {
     }
     Stop-PrizmProgressParser $parserProcess
 
+    $wasContextOverflow = Test-PrizmContextOverflowError -SessionLog $sessionLog -ProgressJson $progressJson
     $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 }
 
+    $hasSuccessfulCommit = $false
+    if ($Kind -ne 'feature' -and $isGitRepository) {
+      $hasSuccessfulCommit = Test-PrizmGitCommitsSince $paths.ProjectRoot $baseCommit
+    }
+
     $status = 'crashed'
     if ($semanticCompletion) {
       $status = 'success'
-      if ($exitCode -ne 0 -or $wasStaleKilled -or $wasAiRuntimeError) {
+      if ($exitCode -ne 0 -or $wasStaleKilled -or $wasContextOverflow -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 ($hasSuccessfulCommit) {
+      $status = 'success'
+    } elseif ($wasContextOverflow) {
+      $status = 'context_overflow'
+      Write-PrizmWarn "AI session failed because the AI CLI exceeded the model context window"
+      Write-PrizmWarn "Context overflow is retried without consuming code retry budget"
     } elseif ($wasAiRuntimeError) {
       $status = 'infra_error'
-      Write-PrizmWarn "AI session failed due to structured AI runtime/context error"
+      Write-PrizmWarn "AI session failed due to structured AI runtime error"
       Write-PrizmWarn "AI runtime errors are retried without consuming code retry budget"
     } elseif ($wasInfraError) {
       $status = 'infra_error'
@@ -841,6 +890,38 @@ function Invoke-PrizmPipeline {
 
     $mergeSucceeded = $true
     $itemListStatus = ''
+    $activeDevBranchForStatus = $devBranchName
+    $progressAfter = ''
+    $statusContinuationArgs = @('--active-dev-branch', $activeDevBranchForStatus, '--base-branch', $originalBranch, '--last-fatal-error-code', 'context_overflow', '--continuation-summary-path', $continuationSummaryPath)
+    if ($status -eq 'context_overflow') {
+      $progressAfter = Get-PrizmContextProgressFingerprint -ProjectRoot $paths.ProjectRoot -TaskType $Kind -TaskId $CurrentItemId -ArtifactDir $artifactDirForFingerprint -CheckpointFile $checkpointForFingerprint
+      if (Test-PrizmContextProgressChanged -BeforeJson $progressBefore -AfterJson $progressAfter) {
+        $noProgressCount = 0
+        Write-PrizmInfo "Context-overflow session made observable progress; continuing on $devBranchName"
+      } else {
+        $noProgressCount++
+        Write-PrizmWarn "Context-overflow session made no observable progress ($noProgressCount consecutive)"
+      }
+      $statusContinuationArgs = @('--active-dev-branch', $activeDevBranchForStatus, '--base-branch', $originalBranch, '--last-fatal-error-code', 'context_overflow', '--continuation-summary-path', $continuationSummaryPath, '--no-progress-count', [string]$noProgressCount, '--progress-fingerprint', $progressAfter)
+      if ($noProgressCount -ge 2) {
+        Write-PrizmWarn 'Pausing automatic continuation: context_overflow_without_git_checkpoint_or_artifact_progress'
+        $status = 'stalled_context_continuation'
+      } else {
+        $updateResult = Invoke-PrizmPythonJson $python (@((Join-Path $paths.ScriptsDir $updateScript), $listOption, $listPath, '--state-dir', $stateDir, '--action', 'update', $idOption, $CurrentItemId, '--session-id', $sessionId, '--session-status', 'context_overflow') + $maxRetryArgs + $maxInfraRetryArgs + $statusContinuationArgs)
+        if ($updateResult -and $updateResult.PSObject.Properties['new_status']) { $itemListStatus = [string]$updateResult.new_status }
+        $continuationPending = $true
+        $continuationReason = 'context_overflow'
+        $previousSessionId = $sessionId
+        $activeDevBranch = $devBranchName
+        $contextOverflowCount++
+        $continuationCount++
+        $sessionId = New-PrizmSessionId $Kind
+        $runId = "run-$(Get-Date -Format 'yyyyMMdd-HHmmss')"
+        Write-PrizmInfo "Launching automatic continuation for $CurrentItemId on same branch/worktree"
+        continue
+      }
+    }
+
     if ($status -eq 'success') {
       if (Test-PrizmGitDirty $paths.ProjectRoot) {
         Write-PrizmInfo "Auto-committing remaining session artifacts."
@@ -848,7 +929,7 @@ function Invoke-PrizmPipeline {
       }
 
       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)
+        $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 + $statusContinuationArgs)
         if ($updateResult -and $updateResult.PSObject.Properties['new_status']) {
           $itemListStatus = [string]$updateResult.new_status
         }
@@ -885,7 +966,7 @@ function Invoke-PrizmPipeline {
           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)
+      $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 + $statusContinuationArgs)
       if ($updateResult -and $updateResult.PSObject.Properties['new_status']) {
         $itemListStatus = [string]$updateResult.new_status
       }
@@ -894,6 +975,9 @@ function Invoke-PrizmPipeline {
       }
     }
 
+    break
+    }
+
     if ($status -eq 'success' -and $mergeSucceeded) {
       Write-PrizmSuccess "$Kind item completed: $CurrentItemId"
     } else {
@@ -951,7 +1035,7 @@ function Invoke-PrizmPipeline {
     }
 
     $processedCount++
-    Invoke-PrizmPipelineItem $nextItemId
+    Invoke-PrizmPipelineItem $nextItemId $next
     $lastExitCode = $script:PRIZM_ITEM_EXIT_CODE
     if ($dryRun) {
       $global:PRIZM_EXIT_CODE = $lastExitCode

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

@@ -14,6 +14,35 @@ function Get-PrizmFeatureSlug {
   return "$numeric-$slug"
 }
 
+function Write-PrizmContinuationResetWarning {
+  param([string]$StatusPath, [string]$ItemId, [string]$Label)
+  if (-not (Test-Path $StatusPath)) { return }
+  try {
+    $status = Get-Content $StatusPath -Raw | ConvertFrom-Json
+  } catch {
+    return
+  }
+  if ($status.continuation_pending -eq $true) {
+    $reason = $status.continuation_reason
+    if (-not $reason) { $reason = 'context_overflow' }
+    Write-PrizmWarn "Continuation pending for $Label $ItemId ($reason). Manual reset will abandon automatic continuation progress."
+    if ($status.active_dev_branch) {
+      Write-PrizmWarn "Pending continuation branch: $($status.active_dev_branch)"
+    }
+  }
+}
+
+function Write-PrizmContinuationResetWarningsForState {
+  param([string]$StateDir, [string]$Label)
+  if (-not (Test-Path $StateDir)) { return }
+  Get-ChildItem -Path $StateDir -Directory -ErrorAction SilentlyContinue | ForEach-Object {
+    Write-PrizmContinuationResetWarning `
+      -StatusPath (Join-Path $_.FullName 'status.json') `
+      -ItemId $_.Name `
+      -Label $Label
+  }
+}
+
 function Invoke-PrizmReset {
   param(
     [ValidateSet('feature','bugfix','refactor')][string]$Kind,
@@ -60,6 +89,7 @@ function Invoke-PrizmReset {
   }
 
   if (-not $itemId) {
+    Write-PrizmContinuationResetWarningsForState -StateDir $stateDir -Label $label
     & (Join-Path $paths.PipelineDir $runScript) reset
     $global:PRIZM_RESET_EXIT_CODE = $LASTEXITCODE
     return
@@ -67,6 +97,10 @@ function Invoke-PrizmReset {
 
   if (-not (Test-Path $listPath)) { throw "List file not found: $listPath" }
   New-Item -ItemType Directory -Force -Path $stateDir | Out-Null
+  Write-PrizmContinuationResetWarning `
+    -StatusPath (Join-Path (Join-Path $stateDir $itemId) 'status.json') `
+    -ItemId $itemId `
+    -Label $label
 
   $action = if ($clean) { 'clean' } else { 'reset' }
   $resetArgs = @((Join-Path $paths.ScriptsDir $updateScript), $listOption, $listPath, '--state-dir', $stateDir, '--action', $action, $idOption, $itemId)

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

@@ -1,4 +1,5 @@
 #!/usr/bin/env pwsh
+# Manual reset entrypoint; shared warning/reset behavior lives in lib/reset.ps1.
 . "$PSScriptRoot\lib\reset.ps1"
 try {
   Invoke-PrizmReset -Kind bugfix -ScriptRoot $PSScriptRoot -Args $args

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

@@ -1,4 +1,5 @@
 #!/usr/bin/env pwsh
+# Manual reset entrypoint; shared warning/reset behavior lives in lib/reset.ps1.
 . "$PSScriptRoot\lib\reset.ps1"
 try {
   Invoke-PrizmReset -Kind feature -ScriptRoot $PSScriptRoot -Args $args

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

@@ -1,4 +1,5 @@
 #!/usr/bin/env pwsh
+# Manual reset entrypoint; shared warning/reset behavior lives in lib/reset.ps1.
 . "$PSScriptRoot\lib\reset.ps1"
 try {
   Invoke-PrizmReset -Kind refactor -ScriptRoot $PSScriptRoot -Args $args