prizmkit 1.1.98 → 1.1.100

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

@@ -3,6 +3,7 @@
 import os
 import re
 import time
+from argparse import Namespace
 from pathlib import Path
 
 from generate_bootstrap_prompt import (
@@ -18,7 +19,9 @@ from generate_bootstrap_prompt import (
     assemble_sections,
     generate_checkpoint_definition,
     merge_checkpoint_state,
+    load_log_size_section,
 )
+from continuation import append_continuation_handoff, checkpoint_cursor
 
 
 def scoped_report_text(verdict="PASS", boundary_missing=0,
@@ -656,3 +659,103 @@ class TestScopedFeatureTestGate:
         merged = merge_checkpoint_state(existing, fresh, str(tmp_path))
 
         assert merged["steps"][0]["status"] == "pending"
+
+
+# ---------------------------------------------------------------------------
+# Active compaction harness rollback
+# ---------------------------------------------------------------------------
+
+class TestHeadlessRecoveryReframing:
+    def test_log_size_awareness_is_passive_checkpoint_guidance(self):
+        content = load_log_size_section(str(Path("dev-pipeline/scripts").resolve()))
+
+        assert "Session Log Budget Awareness" in content
+        assert "passive checkpoint guidance" in content
+        assert "durable checkpoints and artifacts" 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_assembled_prompts_do_not_spawn_log_monitor_or_require_compact(self):
+        sections_dir = Path("dev-pipeline/templates/sections").resolve()
+
+        for mode in ("lite", "standard", "full"):
+            rendered = "\n".join(
+                section for _name, section in assemble_sections(
+                    mode, str(sections_dir), init_done=True, is_resume=False,
+                    critic_enabled=False, browser_enabled=False,
+                )
+            )
+            assert "Headless recovery must rely on durable checkpoints" in rendered
+            assert "fresh continuation session" in rendered
+            assert "monitor-log" not in rendered
+            assert "COMPACT_NEEDED" not in rendered
+            assert "log-size monitor" not in rendered
+            assert "The log-size monitor is the only allowed" not in rendered
+            assert "Run this command and keep it running" not in rendered
+            assert "Execute `/compact`" not in rendered
+            assert "run `/compact` after" not in rendered
+
+
+# ---------------------------------------------------------------------------
+# continuation handoff
+# ---------------------------------------------------------------------------
+
+class TestContinuationHandoff:
+    def test_addendum_and_summary_include_required_context(self, tmp_path):
+        args = Namespace(
+            output=str(tmp_path / ".prizmkit/state/features/F-123/sessions/F-123-new/bootstrap-prompt.md"),
+            state_dir=str(tmp_path / ".prizmkit/state/features"),
+            continuation_mode="context_overflow",
+            previous_session_id="F-123-old",
+            continuation_count="2",
+            context_overflow_count="2",
+            active_dev_branch="dev/F-123",
+            base_branch="main",
+            continuation_summary_path="",
+        )
+        checkpoint = {"steps": [
+            {"id": "S01", "skill": "test-baseline", "status": "completed"},
+            {"id": "S02", "skill": "context-snapshot", "status": "skipped"},
+            {"id": "S03", "skill": "prizmkit-implement", "status": "pending"},
+        ]}
+
+        rendered = append_continuation_handoff(
+            "NORMAL BOOTSTRAP", args, str(tmp_path), "feature", "F-123",
+            "123-continuation", checkpoint,
+        )
+
+        assert rendered.startswith("NORMAL BOOTSTRAP")
+        assert "## Continuation Addendum" in rendered
+        assert "This is an automatic continuation after context overflow." in rendered
+        assert "This is a fresh headless AI CLI session for the same task." in rendered
+        assert "Continue on the current branch/worktree." in rendered
+        assert "Do not reset, clean, switch branches, or discard work." in rendered
+        assert "Start with `git status` and `git diff`." in rendered
+        assert "Treat completed/skipped checkpoint steps as already done." in rendered
+        assert "Do not read the previous full `session.log` unless explicitly necessary." in rendered
+        assert "prefer synthesized artifacts and summaries over logs" in rendered
+        assert "Do not attempt `/compact` as the recovery mechanism." in rendered
+        assert ".prizmkit/specs/123-continuation/workflow-checkpoint.json" in rendered
+        assert ".prizmkit/state/features/F-123/sessions/F-123-new/logs/session.log" in rendered
+        assert ".prizmkit/state/features/F-123/sessions/F-123-new/logs/progress.json" in rendered
+        assert ".prizmkit/state/features/F-123/sessions/F-123-new/logs/ai.pid" in rendered
+
+        summary = tmp_path / ".prizmkit/specs/123-continuation/continuation-summary.md"
+        assert summary.exists()
+        summary_text = summary.read_text(encoding="utf-8")
+        assert "Previous session id: F-123-old" in summary_text
+        assert "First pending/in-progress checkpoint step: S03 (prizmkit-implement)" in summary_text
+        assert "Workflow checkpoint: .prizmkit/specs/123-continuation/workflow-checkpoint.json" in summary_text
+
+    def test_checkpoint_cursor_prefers_in_progress_before_pending(self):
+        checkpoint = {"steps": [
+            {"id": "S01", "skill": "done", "status": "completed"},
+            {"id": "S02", "skill": "active", "status": "in_progress"},
+            {"id": "S03", "skill": "later", "status": "pending"},
+        ]}
+        assert checkpoint_cursor(checkpoint)["first_cursor"] == "S02 (active)"

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
 }