prizmkit 1.1.98 → 1.1.100

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

@@ -2,6 +2,9 @@
 
 import json
 import os
+import subprocess
+import time
+from pathlib import Path
 
 from update_feature_status import (
     auto_skip_blocked_features,
@@ -38,11 +41,11 @@ def _make_feature_list(features):
 
 def _init_state(tmp_path, feature_ids):
     """Create state dir with status.json for each feature."""
-    state_dir = str(tmp_path / "state")
+    state_dir = str(tmp_path / "state" / "features")
     for fid in feature_ids:
-        feature_dir = os.path.join(state_dir, "features", fid, "sessions")
+        feature_dir = os.path.join(state_dir, fid, "sessions")
         os.makedirs(feature_dir, exist_ok=True)
-        status_path = os.path.join(state_dir, "features", fid, "status.json")
+        status_path = os.path.join(state_dir, fid, "status.json")
         write_json_file(status_path, {
             "feature_id": fid,
             "status": "pending",
@@ -70,6 +73,455 @@ def _read_statuses(fl_path):
     return {f["id"]: f["status"] for f in data["features"]}
 
 
+
+
+# ---------------------------------------------------------------------------
+# context_overflow retry semantics
+# ---------------------------------------------------------------------------
+
+class TestContextOverflowRetrySemantics:
+    def _script_cases(self, scripts_dir):
+        return [
+            {
+                "script": scripts_dir / "update-feature-status.py",
+                "list_option": "--feature-list",
+                "id_option": "--feature-id",
+                "id": "F-001",
+                "list_name": "feature-list.json",
+                "collection": "features",
+                "list_payload": {
+                    "features": [_make_feature("F-001", "Context Overflow", status="in_progress")],
+                },
+            },
+            {
+                "script": scripts_dir / "update-bug-status.py",
+                "list_option": "--bug-list",
+                "id_option": "--bug-id",
+                "id": "B-001",
+                "list_name": "bug-fix-list.json",
+                "collection": "bugs",
+                "list_payload": {
+                    "bugs": [{
+                        "id": "B-001",
+                        "title": "Context Overflow Bug",
+                        "description": "desc",
+                        "severity": "medium",
+                        "priority": "medium",
+                        "status": "in_progress",
+                    }],
+                },
+            },
+            {
+                "script": scripts_dir / "update-refactor-status.py",
+                "list_option": "--refactor-list",
+                "id_option": "--refactor-id",
+                "id": "R-001",
+                "list_name": "refactor-list.json",
+                "collection": "refactors",
+                "list_payload": {
+                    "refactors": [{
+                        "id": "R-001",
+                        "title": "Context Overflow Refactor",
+                        "description": "desc",
+                        "complexity": "medium",
+                        "priority": "medium",
+                        "status": "in_progress",
+                        "dependencies": [],
+                    }],
+                },
+            },
+        ]
+
+    def _run_case_update(self, case, list_path, state_dir, session_status, session_id="sess-1", extra_args=None):
+        cmd = [
+            "python3",
+            str(case["script"]),
+            case["list_option"],
+            str(list_path),
+            "--state-dir",
+            str(state_dir),
+            case["id_option"],
+            case["id"],
+            "--session-id",
+            session_id,
+            "--session-status",
+            session_status,
+            "--max-retries",
+            "3",
+            "--max-infra-retries",
+            "3",
+            "--action",
+            "update",
+        ]
+        if extra_args:
+            cmd.extend(extra_args)
+        result = subprocess.run(cmd, text=True, capture_output=True, check=True)
+        return json.loads(result.stdout)
+
+    def _runtime_status(self, state_dir, item_id):
+        with open(Path(state_dir) / item_id / "status.json", encoding="utf-8") as fh:
+            return json.load(fh)
+
+    def _assert_no_continuation_runtime_state(self, status):
+        for key in [
+            "active_dev_branch",
+            "base_branch",
+            "continuation_pending",
+            "continuation_reason",
+            "last_context_overflow_session_id",
+            "previous_session_id",
+            "last_fatal_error_code",
+            "continuation_summary_path",
+            "no_progress_count",
+            "last_progress_fingerprint",
+            "needs_attention",
+            "stalled_context_continuation",
+            "stalled_reason",
+            "context_overflow_count",
+            "continuation_count",
+        ]:
+            assert key not in status
+
+    def test_context_overflow_stays_in_progress_and_records_continuation_metadata(self, tmp_path):
+        scripts_dir = Path(__file__).resolve().parents[1] / "scripts"
+
+        for case in self._script_cases(scripts_dir):
+            case_dir = tmp_path / case["id"]
+            state_dir = case_dir / "state"
+            list_path = case_dir / case["list_name"]
+            session_dir = state_dir / case["id"] / "sessions" / "sess-1"
+            session_dir.mkdir(parents=True)
+            (session_dir / "session.log").write_text("context overflow diagnostics", encoding="utf-8")
+            write_json_file(str(list_path), case["list_payload"])
+            status_path = state_dir / case["id"] / "status.json"
+            write_json_file(str(status_path), {
+                "retry_count": 2,
+                "infra_error_count": 1,
+                "sessions": [],
+                "last_session_id": None,
+                "resume_from_phase": None,
+            })
+            before_mtime = list_path.stat().st_mtime_ns
+            time.sleep(0.01)
+
+            summary = self._run_case_update(
+                case,
+                list_path,
+                state_dir,
+                "context_overflow",
+                extra_args=[
+                    "--active-dev-branch",
+                    "dev/existing-branch",
+                    "--base-branch",
+                    "main",
+                    "--last-fatal-error-code",
+                    "context_overflow",
+                    "--continuation-summary-path",
+                    str(session_dir / "continuation-summary.md"),
+                ],
+            )
+
+            assert summary["new_status"] == "in_progress"
+            assert summary["retry_count"] == 2
+            assert summary["infra_error_count"] == 1
+            assert summary["context_overflow_count"] == 1
+            assert summary["continuation_count"] == 1
+            assert summary["continuation_pending"] is True
+            assert summary["restart_policy"] == "context_overflow_continuation"
+            assert summary["artifacts_preserved"] is True
+            assert "cleanup_performed" not in summary
+            assert (session_dir / "session.log").exists()
+            assert list_path.stat().st_mtime_ns == before_mtime
+
+            list_data, _ = load_json_file(str(list_path))
+            assert list_data[case["collection"]][0]["status"] == "in_progress"
+
+            runtime = self._runtime_status(state_dir, case["id"])
+            assert runtime["retry_count"] == 2
+            assert runtime["infra_error_count"] == 1
+            assert runtime["active_dev_branch"] == "dev/existing-branch"
+            assert runtime["base_branch"] == "main"
+            assert runtime["continuation_pending"] is True
+            assert runtime["continuation_reason"] == "context_overflow"
+            assert runtime["last_context_overflow_session_id"] == "sess-1"
+            assert runtime["last_fatal_error_code"] == "context_overflow"
+            assert runtime["context_overflow_count"] == 1
+            assert runtime["continuation_count"] == 1
+            assert runtime["continuation_summary_path"].endswith("continuation-summary.md")
+            assert runtime["last_session_id"] == "sess-1"
+            assert runtime.get("last_infra_error_session_id") is None
+
+            get_next = subprocess.run(
+                [
+                    "python3",
+                    str(case["script"]),
+                    case["list_option"],
+                    str(list_path),
+                    "--state-dir",
+                    str(state_dir),
+                    "--action",
+                    "get_next",
+                ],
+                text=True,
+                capture_output=True,
+                check=True,
+            )
+            selected = json.loads(get_next.stdout)
+            assert selected["active_dev_branch"] == "dev/existing-branch"
+            assert selected["base_branch"] == "main"
+            assert selected["continuation_pending"] is True
+            assert selected["continuation_reason"] == "context_overflow"
+            assert selected["last_context_overflow_session_id"] == "sess-1"
+            assert selected["last_fatal_error_code"] == "context_overflow"
+            assert selected["context_overflow_count"] == 1
+            assert selected["continuation_count"] == 1
+            assert selected["continuation_summary_path"].endswith("continuation-summary.md")
+
+    def test_context_overflow_from_non_started_item_marks_in_progress_once(self, tmp_path):
+        scripts_dir = Path(__file__).resolve().parents[1] / "scripts"
+
+        for case in self._script_cases(scripts_dir):
+            case_dir = tmp_path / f"pending-{case['id']}"
+            state_dir = case_dir / "state"
+            list_path = case_dir / case["list_name"]
+            payload = json.loads(json.dumps(case["list_payload"]))
+            payload[case["collection"]][0]["status"] = "pending"
+            write_json_file(str(list_path), payload)
+
+            summary = self._run_case_update(
+                case,
+                list_path,
+                state_dir,
+                "context_overflow",
+                extra_args=["--active-dev-branch", "dev/new", "--base-branch", "main"],
+            )
+
+            list_data, _ = load_json_file(str(list_path))
+            assert summary["new_status"] == "in_progress"
+            assert list_data[case["collection"]][0]["status"] == "in_progress"
+
+    def test_success_clears_pending_continuation_fields_but_preserves_counters(self, tmp_path):
+        scripts_dir = Path(__file__).resolve().parents[1] / "scripts"
+
+        for case in self._script_cases(scripts_dir):
+            case_dir = tmp_path / f"success-{case['id']}"
+            state_dir = case_dir / "state"
+            list_path = case_dir / case["list_name"]
+            write_json_file(str(list_path), case["list_payload"])
+            status_path = state_dir / case["id"] / "status.json"
+            status_path.parent.mkdir(parents=True)
+            write_json_file(str(status_path), {
+                "retry_count": 0,
+                "infra_error_count": 0,
+                "active_dev_branch": "dev/existing-branch",
+                "base_branch": "main",
+                "continuation_pending": True,
+                "continuation_reason": "context_overflow",
+                "last_context_overflow_session_id": "sess-overflow",
+                "last_fatal_error_code": "context_overflow",
+                "continuation_summary_path": "summary.md",
+                "context_overflow_count": 2,
+                "continuation_count": 2,
+                "sessions": [],
+                "last_session_id": None,
+                "resume_from_phase": None,
+            })
+
+            summary = self._run_case_update(case, list_path, state_dir, "success", session_id="sess-success")
+
+            assert summary["new_status"] == "completed"
+            runtime = self._runtime_status(state_dir, case["id"])
+            for key in [
+                "active_dev_branch",
+                "base_branch",
+                "continuation_pending",
+                "continuation_reason",
+                "last_context_overflow_session_id",
+                "last_fatal_error_code",
+                "continuation_summary_path",
+            ]:
+                assert key not in runtime
+            assert runtime["context_overflow_count"] == 2
+            assert runtime["continuation_count"] == 2
+
+    def test_manual_reset_clean_and_unskip_clear_all_continuation_state(self, tmp_path):
+        scripts_dir = Path(__file__).resolve().parents[1] / "scripts"
+
+        for action in ["reset", "clean", "unskip"]:
+            for case in self._script_cases(scripts_dir):
+                case_dir = tmp_path / f"{action}-{case['id']}"
+                state_dir = case_dir / "state"
+                list_path = case_dir / case["list_name"]
+                payload = json.loads(json.dumps(case["list_payload"]))
+                payload[case["collection"]][0]["status"] = "failed"
+                write_json_file(str(list_path), payload)
+                status_path = state_dir / case["id"] / "status.json"
+                status_path.parent.mkdir(parents=True)
+                write_json_file(str(status_path), {
+                    "retry_count": 3,
+                    "infra_error_count": 2,
+                    "active_dev_branch": "dev/existing-branch",
+                    "base_branch": "main",
+                    "continuation_pending": True,
+                    "continuation_reason": "context_overflow",
+                    "last_context_overflow_session_id": "sess-overflow",
+                    "previous_session_id": "sess-overflow",
+                    "last_fatal_error_code": "context_overflow",
+                    "continuation_summary_path": "continuation-summary.md",
+                    "no_progress_count": 1,
+                    "last_progress_fingerprint": {"checkpoint": "old"},
+                    "needs_attention": True,
+                    "stalled_context_continuation": True,
+                    "stalled_reason": "context_overflow_without_git_checkpoint_or_artifact_progress",
+                    "context_overflow_count": 2,
+                    "continuation_count": 2,
+                    "sessions": ["old"],
+                    "last_session_id": "old",
+                    "resume_from_phase": 4,
+                })
+                continuation_files = []
+                if action == "clean":
+                    stored_summary = case_dir / "continuation-summary.md"
+                    stored_summary.write_text("stored", encoding="utf-8")
+                    continuation_files.append(stored_summary)
+                    if case["id_option"] == "--feature-id":
+                        conventional_summary = case_dir / ".prizmkit" / "specs" / "001-context-overflow" / "continuation-summary.md"
+                    elif case["id_option"] == "--bug-id":
+                        conventional_summary = case_dir / ".prizmkit" / "bugfix" / case["id"] / "continuation-summary.md"
+                    else:
+                        conventional_summary = case_dir / ".prizmkit" / "refactor" / case["id"] / "continuation-summary.md"
+                    conventional_summary.parent.mkdir(parents=True)
+                    conventional_summary.write_text("conventional", encoding="utf-8")
+                    continuation_files.append(conventional_summary)
+
+                cmd = [
+                    "python3",
+                    str(case["script"]),
+                    case["list_option"],
+                    str(list_path),
+                    "--state-dir",
+                    str(state_dir),
+                    "--action",
+                    action,
+                ]
+                if action in ("reset", "clean"):
+                    cmd.extend([case["id_option"], case["id"]])
+                elif action == "unskip":
+                    cmd.extend([case["id_option"], case["id"]])
+                if action == "clean":
+                    cmd.extend(["--project-root", str(case_dir)])
+                    if case["id_option"] == "--feature-id":
+                        cmd.extend(["--feature-slug", "001-context-overflow"])
+
+                result = subprocess.run(cmd, text=True, capture_output=True, check=True)
+                assert result.returncode == 0
+                for continuation_file in continuation_files:
+                    assert not continuation_file.exists()
+                runtime = self._runtime_status(state_dir, case["id"])
+                self._assert_no_continuation_runtime_state(runtime)
+                assert runtime["retry_count"] == 0
+                assert runtime["infra_error_count"] == 0
+                assert runtime["last_infra_error_session_id"] is None
+                list_data, _ = load_json_file(str(list_path))
+                assert list_data[case["collection"]][0]["status"] == "pending"
+    def test_unix_reset_scripts_warn_before_manual_continuation_reset(self, tmp_path):
+        project_root = Path(__file__).resolve().parents[2]
+        script_cases = [
+            {
+                "script": "reset-feature.sh",
+                "list_name": "feature-list.json",
+                "state_root": "features",
+                "item_id": "F-001",
+                "list_payload": {
+                    "features": [_make_feature("F-001", "Context Overflow", status="failed")],
+                },
+                "pipeline_error": "run-feature.sh run",
+            },
+            {
+                "script": "reset-bug.sh",
+                "list_name": "bug-fix-list.json",
+                "state_root": "bugfix",
+                "item_id": "B-001",
+                "list_payload": {
+                    "bugs": [{
+                        "id": "B-001",
+                        "title": "Context Overflow Bug",
+                        "description": "desc",
+                        "severity": "medium",
+                        "priority": "medium",
+                        "status": "failed",
+                    }],
+                },
+                "pipeline_error": "run-bugfix.sh run",
+            },
+            {
+                "script": "reset-refactor.sh",
+                "list_name": "refactor-list.json",
+                "state_root": "refactor",
+                "item_id": "R-001",
+                "list_payload": {
+                    "refactors": [{
+                        "id": "R-001",
+                        "title": "Context Overflow Refactor",
+                        "description": "desc",
+                        "complexity": "medium",
+                        "priority": "medium",
+                        "status": "failed",
+                        "dependencies": [],
+                    }],
+                },
+                "pipeline_error": "run-refactor.sh run",
+            },
+        ]
+
+        for case in script_cases:
+            case_dir = tmp_path / case["item_id"]
+            prizmkit_dir = case_dir / ".prizmkit"
+            state_dir = prizmkit_dir / "state" / case["state_root"]
+            item_state_dir = state_dir / case["item_id"]
+            item_state_dir.mkdir(parents=True)
+            write_json_file(str(prizmkit_dir / "plans" / case["list_name"]), case["list_payload"])
+            write_json_file(str(state_dir / "pipeline.json"), {"status": "running"})
+            write_json_file(str(item_state_dir / "status.json"), {
+                "retry_count": 1,
+                "infra_error_count": 0,
+                "continuation_pending": True,
+                "continuation_reason": "context_overflow",
+                "active_dev_branch": "dev/manual-continuation",
+                "sessions": [],
+            })
+            subprocess.run(["git", "init", "-q"], cwd=case_dir, check=True)
+            subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=case_dir, check=True)
+            subprocess.run(["git", "config", "user.name", "Test User"], cwd=case_dir, check=True)
+            (case_dir / "README.md").write_text("test\n", encoding="utf-8")
+            subprocess.run(["git", "add", "README.md"], cwd=case_dir, check=True)
+            subprocess.run(["git", "commit", "-q", "-m", "init"], cwd=case_dir, check=True)
+
+            result = subprocess.run(
+                ["bash", str(project_root / "dev-pipeline" / case["script"]), case["item_id"], str(prizmkit_dir / "plans" / case["list_name"])],
+                cwd=case_dir,
+                text=True,
+                capture_output=True,
+                env={
+                    **os.environ,
+                    "PROJECT_ROOT": str(case_dir),
+                    "PRIZMKIT_DIR": str(prizmkit_dir),
+                    "PIPELINE_DIR": str(project_root / "dev-pipeline"),
+                },
+            )
+
+            output = result.stdout + result.stderr
+            assert "Manual reset will abandon automatic continuation progress" in output
+            assert "Pending continuation branch: dev/manual-continuation" in output
+            assert output.index("Manual reset will abandon automatic continuation progress") < output.index("Resetting")
+            assert result.returncode == 0, output
+            runtime = self._runtime_status(state_dir, case["item_id"])
+            self._assert_no_continuation_runtime_state(runtime)
+            assert runtime["retry_count"] == 0
+            assert runtime["infra_error_count"] == 0
+            assert runtime["last_infra_error_session_id"] is None
+
+
 # ---------------------------------------------------------------------------
 # TERMINAL_STATUSES
 # ---------------------------------------------------------------------------
@@ -325,7 +777,7 @@ class TestInfraErrorUpdate:
         features = [_make_feature("F-001", "Root", status="in_progress")]
         fl_path = _write_fl(tmp_path, features)
         state_dir = _init_state(tmp_path, ["F-001"])
-        status_path = os.path.join(state_dir, "features", "F-001", "status.json")
+        status_path = os.path.join(state_dir, "F-001", "status.json")
         fs = load_feature_status(state_dir, "F-001")
         fs["retry_count"] = 2
         write_json_file(status_path, fs)
@@ -357,7 +809,7 @@ class TestInfraErrorUpdate:
         features = [_make_feature("F-001", "Root", status="in_progress")]
         fl_path = _write_fl(tmp_path, features)
         state_dir = _init_state(tmp_path, ["F-001"])
-        status_path = os.path.join(state_dir, "features", "F-001", "status.json")
+        status_path = os.path.join(state_dir, "F-001", "status.json")
         fs = load_feature_status(state_dir, "F-001")
         fs["retry_count"] = 1
         fs["infra_error_count"] = 2
@@ -389,7 +841,7 @@ class TestInfraErrorUpdate:
         features = [_make_feature("F-001", "Root", status="failed")]
         fl_path = _write_fl(tmp_path, features)
         state_dir = _init_state(tmp_path, ["F-001"])
-        status_path = os.path.join(state_dir, "features", "F-001", "status.json")
+        status_path = os.path.join(state_dir, "F-001", "status.json")
         fs = load_feature_status(state_dir, "F-001")
         fs["retry_count"] = 3
         fs["infra_error_count"] = 3
@@ -416,7 +868,7 @@ class TestInfraErrorUpdate:
         features = [_make_feature("F-001", "Root", status="failed")]
         fl_path = _write_fl(tmp_path, features)
         state_dir = _init_state(tmp_path, ["F-001"])
-        status_path = os.path.join(state_dir, "features", "F-001", "status.json")
+        status_path = os.path.join(state_dir, "F-001", "status.json")
         fs = load_feature_status(state_dir, "F-001")
         fs["retry_count"] = 3
         fs["infra_error_count"] = 3
@@ -563,7 +1015,7 @@ class TestAutoSkipIntegration:
         fl_path = _write_fl(tmp_path, features)
         state_dir = _init_state(tmp_path, ["F-001"])
         # Simulate retry_count = 3
-        fs_path = os.path.join(state_dir, "features", "F-001", "status.json")
+        fs_path = os.path.join(state_dir, "F-001", "status.json")
         with open(fs_path) as f:
             fs = json.load(f)
         fs["retry_count"] = 3
@@ -579,3 +1031,61 @@ class TestAutoSkipIntegration:
         assert "status" not in fs
         statuses = _read_statuses(fl_path)
         assert statuses["F-001"] == "pending"
+
+
+def test_context_overflow_records_no_progress_fingerprint_and_stall(tmp_path):
+    scripts_dir = Path(__file__).resolve().parents[1] / 'scripts'
+    feature_list = tmp_path / 'feature-list.json'
+    state_dir = tmp_path / 'state'
+    write_json_file(str(feature_list), _make_feature_list([
+        _make_feature('F-001', 'Context Continuation', status='in_progress')
+    ]))
+    fingerprint = json.dumps({
+        'git_diff_fingerprint': 'same',
+        'checkpoint_cursor': 'S02:pending',
+        'artifact_fingerprint': 'artifact',
+        'head_commit': 'abc123',
+    })
+
+    first = subprocess.run([
+        'python3', str(scripts_dir / 'update-feature-status.py'),
+        '--feature-list', str(feature_list),
+        '--state-dir', str(state_dir),
+        '--feature-id', 'F-001',
+        '--session-id', 's1',
+        '--session-status', 'context_overflow',
+        '--active-dev-branch', 'dev/F-001',
+        '--base-branch', 'main',
+        '--no-progress-count', '1',
+        '--progress-fingerprint', fingerprint,
+        '--action', 'update',
+    ], text=True, capture_output=True, check=True)
+    first_summary = json.loads(first.stdout)
+    assert first_summary['new_status'] == 'in_progress'
+    assert first_summary['retry_count'] == 0
+    assert first_summary['infra_error_count'] == 0
+    assert first_summary['no_progress_count'] == 1
+
+    second = subprocess.run([
+        'python3', str(scripts_dir / 'update-feature-status.py'),
+        '--feature-list', str(feature_list),
+        '--state-dir', str(state_dir),
+        '--feature-id', 'F-001',
+        '--session-id', 's2',
+        '--session-status', 'stalled_context_continuation',
+        '--active-dev-branch', 'dev/F-001',
+        '--base-branch', 'main',
+        '--no-progress-count', '2',
+        '--progress-fingerprint', fingerprint,
+        '--action', 'update',
+    ], text=True, capture_output=True, check=True)
+    second_summary = json.loads(second.stdout)
+    status = load_feature_status(str(state_dir), 'F-001')
+    assert second_summary['new_status'] == 'failed'
+    assert second_summary['retry_count'] == 0
+    assert second_summary['infra_error_count'] == 0
+    assert second_summary['needs_attention'] is True
+    assert second_summary['stalled_context_continuation'] is True
+    assert second_summary['stalled_reason'] == 'context_overflow_without_git_checkpoint_or_artifact_progress'
+    assert status['no_progress_count'] == 2
+    assert status['last_progress_fingerprint']['head_commit'] == 'abc123'