prizmkit 1.1.100 → 1.1.102

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

@@ -2,7 +2,9 @@
 
 import json
 import os
+import shutil
 import subprocess
+import sys
 import time
 from pathlib import Path
 
@@ -15,6 +17,43 @@ from update_feature_status import (
 from utils import load_json_file, write_json_file
 
 
+ROOT = Path(__file__).resolve().parents[2]
+UNIX_RUNTIME_SNAPSHOT = ROOT / "tests" / "fixtures" / "dev-pipeline-behavior-snapshots" / "unix-runtime.json"
+
+
+def _python_310_plus() -> str:
+    if sys.version_info >= (3, 10):
+        return sys.executable
+    for executable in ("python3.12", "python3.11", "python3.10"):
+        resolved = shutil.which(executable)
+        if resolved:
+            return resolved
+    return sys.executable
+
+
+PYTHON_310_PLUS = _python_310_plus()
+
+
+def _load_unix_snapshot_section(section):
+    with open(UNIX_RUNTIME_SNAPSHOT, encoding="utf-8") as fh:
+        fixture = json.load(fh)
+    required = fixture.get("requiredScenarios", {}).get(section)
+    assert required, f"{section} required scenario list must not be empty"
+    section_data = fixture.get(section)
+    assert section_data, f"{section} fixture section must not be empty"
+    for scenario_id in required:
+        assert scenario_id in section_data, f"missing {section}.{scenario_id} from fixture"
+        assert section_data[scenario_id] not in ({}, [], "", None), f"empty {section}.{scenario_id} fixture"
+    return section_data
+
+
+def _assert_matches_unix_snapshot_section(section, actual):
+    expected = _load_unix_snapshot_section(section)
+    for scenario_id in expected:
+        assert scenario_id in actual, f"missing actual {section}.{scenario_id}"
+    assert actual == expected
+
+
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------
@@ -424,21 +463,21 @@ class TestContextOverflowRetrySemantics:
                 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):
+    def test_python_reset_warns_before_manual_continuation_reset(self, tmp_path):
         project_root = Path(__file__).resolve().parents[2]
+        cli_path = project_root / "dev-pipeline" / "cli.py"
         script_cases = [
             {
-                "script": "reset-feature.sh",
+                "target": "feature",
                 "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",
+                "target": "bugfix",
                 "list_name": "bug-fix-list.json",
                 "state_root": "bugfix",
                 "item_id": "B-001",
@@ -452,10 +491,9 @@ class TestContextOverflowRetrySemantics:
                         "status": "failed",
                     }],
                 },
-                "pipeline_error": "run-bugfix.sh run",
             },
             {
-                "script": "reset-refactor.sh",
+                "target": "refactor",
                 "list_name": "refactor-list.json",
                 "state_root": "refactor",
                 "item_id": "R-001",
@@ -470,7 +508,6 @@ class TestContextOverflowRetrySemantics:
                         "dependencies": [],
                     }],
                 },
-                "pipeline_error": "run-refactor.sh run",
             },
         ]
 
@@ -498,16 +535,19 @@ class TestContextOverflowRetrySemantics:
             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"])],
+                [
+                    PYTHON_310_PLUS,
+                    str(cli_path),
+                    "--project-root",
+                    str(case_dir),
+                    "reset",
+                    case["target"],
+                    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
@@ -522,6 +562,388 @@ class TestContextOverflowRetrySemantics:
             assert runtime["last_infra_error_session_id"] is None
 
 
+# ---------------------------------------------------------------------------
+# Unix runtime snapshot oracle: status updater behavior
+# ---------------------------------------------------------------------------
+
+_STATUS_SUMMARY_KEYS = [
+    "new_status",
+    "retry_count",
+    "infra_error_count",
+    "max_infra_retries",
+    "restart_policy",
+    "context_overflow_count",
+    "continuation_count",
+    "continuation_pending",
+    "artifacts_preserved",
+    "needs_attention",
+    "stalled_context_continuation",
+    "stalled_reason",
+    "no_progress_count",
+]
+
+_RUNTIME_STATUS_KEYS = [
+    "retry_count",
+    "infra_error_count",
+    "last_infra_error_session_id",
+    "last_failed_session_id",
+    "active_dev_branch",
+    "base_branch",
+    "continuation_pending",
+    "continuation_reason",
+    "last_context_overflow_session_id",
+    "previous_session_id",
+    "last_fatal_error_code",
+    "continuation_summary_path",
+    "context_overflow_count",
+    "continuation_count",
+    "no_progress_count",
+    "last_progress_fingerprint",
+    "needs_attention",
+    "stalled_context_continuation",
+    "stalled_reason",
+    "last_session_id",
+]
+
+
+def _status_snapshot_cases(scripts_dir):
+    return [
+        {
+            "task": "feature",
+            "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", "Snapshot", status="in_progress")]},
+            "feature_slug": "001-snapshot",
+        },
+        {
+            "task": "bugfix",
+            "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": "Snapshot Bug",
+                    "description": "desc",
+                    "severity": "medium",
+                    "priority": "medium",
+                    "status": "in_progress",
+                }],
+            },
+        },
+        {
+            "task": "refactor",
+            "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": "Snapshot Refactor",
+                    "description": "desc",
+                    "complexity": "medium",
+                    "priority": "medium",
+                    "status": "in_progress",
+                    "dependencies": [],
+                }],
+            },
+        },
+    ]
+
+
+def _deepcopy_json(value):
+    return json.loads(json.dumps(value))
+
+
+def _prepare_snapshot_case(base_dir, case, list_status="in_progress", runtime_status=None):
+    case_dir = base_dir / case["task"]
+    state_dir = case_dir / "state"
+    list_path = case_dir / case["list_name"]
+    list_path.parent.mkdir(parents=True, exist_ok=True)
+    payload = _deepcopy_json(case["list_payload"])
+    payload[case["collection"]][0]["status"] = list_status
+    write_json_file(str(list_path), payload)
+
+    status_path = state_dir / case["id"] / "status.json"
+    status_path.parent.mkdir(parents=True, exist_ok=True)
+    status_payload = {
+        "retry_count": 0,
+        "infra_error_count": 0,
+        "sessions": [],
+        "last_session_id": None,
+        "resume_from_phase": None,
+    }
+    if runtime_status:
+        status_payload.update(runtime_status)
+    write_json_file(str(status_path), status_payload)
+    return case_dir, list_path, state_dir
+
+
+def _run_status_snapshot_action(case, list_path, state_dir, action, session_status=None, session_id="sess-1", extra_args=None):
+    cmd = [
+        "python3",
+        str(case["script"]),
+        case["list_option"],
+        str(list_path),
+        "--state-dir",
+        str(state_dir),
+        "--action",
+        action,
+    ]
+    if action in {"update", "reset", "clean", "unskip"}:
+        cmd.extend([case["id_option"], case["id"]])
+    if action == "update":
+        cmd.extend([
+            "--session-id",
+            session_id,
+            "--session-status",
+            session_status,
+            "--max-retries",
+            "3",
+            "--max-infra-retries",
+            "3",
+        ])
+    if extra_args:
+        cmd.extend(extra_args)
+    result = subprocess.run(cmd, text=True, capture_output=True, check=True)
+    return json.loads(result.stdout) if result.stdout.strip() else {}
+
+
+def _runtime_snapshot(state_dir, case):
+    with open(state_dir / case["id"] / "status.json", encoding="utf-8") as fh:
+        return json.load(fh)
+
+
+def _list_item_status(list_path, case):
+    data, _ = load_json_file(str(list_path))
+    return data[case["collection"]][0]["status"]
+
+
+def _select_stable_fields(data, keys):
+    selected = {key: data[key] for key in keys if key in data}
+    if selected.get("continuation_summary_path"):
+        selected["continuation_summary_path"] = "<CONTINUATION_SUMMARY>"
+    return selected
+
+
+def _normalize_status_update(summary, runtime, list_status):
+    return {
+        "summary": _select_stable_fields(summary, _STATUS_SUMMARY_KEYS),
+        "runtime": _select_stable_fields(runtime, _RUNTIME_STATUS_KEYS),
+        "listStatus": list_status,
+    }
+
+
+def _continuation_conventional_path(case_dir, case):
+    if case["task"] == "feature":
+        return case_dir / ".prizmkit" / "specs" / case["feature_slug"] / "continuation-summary.md"
+    if case["task"] == "bugfix":
+        return case_dir / ".prizmkit" / "bugfix" / case["id"] / "continuation-summary.md"
+    return case_dir / ".prizmkit" / "refactor" / case["id"] / "continuation-summary.md"
+
+
+def _build_status_updater_behavior_snapshot(tmp_path):
+    scripts_dir = Path(__file__).resolve().parents[1] / "scripts"
+    cases = _status_snapshot_cases(scripts_dir)
+    snapshot = {
+        "contextOverflowMetadata": {},
+        "infraErrorRetryBudget": {},
+        "crashFailureBudget": {},
+        "resetCleanMetadataCleanup": {},
+        "noProgressStall": {},
+    }
+
+    for case in cases:
+        task = case["task"]
+        case_dir, list_path, state_dir = _prepare_snapshot_case(
+            tmp_path / "context-overflow",
+            case,
+            runtime_status={"retry_count": 2, "infra_error_count": 1},
+        )
+        summary_path = case_dir / "continuation-summary.md"
+        summary = _run_status_snapshot_action(
+            case,
+            list_path,
+            state_dir,
+            "update",
+            session_status="context_overflow",
+            extra_args=[
+                "--active-dev-branch",
+                "dev/snapshot-branch",
+                "--base-branch",
+                "main",
+                "--last-fatal-error-code",
+                "context_overflow",
+                "--continuation-summary-path",
+                str(summary_path),
+            ],
+        )
+        snapshot["contextOverflowMetadata"][task] = _normalize_status_update(
+            summary,
+            _runtime_snapshot(state_dir, case),
+            _list_item_status(list_path, case),
+        )
+
+        case_dir, list_path, state_dir = _prepare_snapshot_case(
+            tmp_path / "infra-error",
+            case,
+            runtime_status={"retry_count": 2, "infra_error_count": 0},
+        )
+        summary = _run_status_snapshot_action(
+            case,
+            list_path,
+            state_dir,
+            "update",
+            session_status="infra_error",
+            session_id="sess-infra",
+        )
+        snapshot["infraErrorRetryBudget"][task] = _normalize_status_update(
+            summary,
+            _runtime_snapshot(state_dir, case),
+            _list_item_status(list_path, case),
+        )
+
+        case_dir, list_path, state_dir = _prepare_snapshot_case(tmp_path / "crash-failure", case)
+        summary = _run_status_snapshot_action(
+            case,
+            list_path,
+            state_dir,
+            "update",
+            session_status="failed",
+            session_id="sess-failed",
+        )
+        snapshot["crashFailureBudget"][task] = _normalize_status_update(
+            summary,
+            _runtime_snapshot(state_dir, case),
+            _list_item_status(list_path, case),
+        )
+
+        snapshot["resetCleanMetadataCleanup"][task] = {}
+        for action in ["reset", "clean"]:
+            cleanup_root = tmp_path / f"{action}-cleanup"
+            cleanup_case_dir = cleanup_root / case["task"]
+            case_dir, list_path, state_dir = _prepare_snapshot_case(
+                cleanup_root,
+                case,
+                list_status="failed",
+                runtime_status={
+                    "retry_count": 3,
+                    "infra_error_count": 2,
+                    "last_infra_error_session_id": "sess-infra",
+                    "active_dev_branch": "dev/snapshot-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": str(cleanup_case_dir / "continuation-summary.md"),
+                    "no_progress_count": 1,
+                    "last_progress_fingerprint": {"head_commit": "abc123"},
+                    "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 = []
+            extra_args = []
+            if action == "clean":
+                stored_summary = case_dir / "continuation-summary.md"
+                stored_summary.write_text("stored", encoding="utf-8")
+                conventional_summary = _continuation_conventional_path(case_dir, case)
+                conventional_summary.parent.mkdir(parents=True)
+                conventional_summary.write_text("conventional", encoding="utf-8")
+                continuation_files = [stored_summary, conventional_summary]
+                extra_args = ["--project-root", str(case_dir)]
+                if case["task"] == "feature":
+                    extra_args.extend(["--feature-slug", case["feature_slug"]])
+            _run_status_snapshot_action(case, list_path, state_dir, action, extra_args=extra_args)
+            runtime = _runtime_snapshot(state_dir, case)
+            snapshot["resetCleanMetadataCleanup"][task][action] = {
+                "runtime": _select_stable_fields(runtime, _RUNTIME_STATUS_KEYS),
+                "listStatus": _list_item_status(list_path, case),
+                "continuationFilesDeleted": all(not path.exists() for path in continuation_files),
+            }
+
+        case_dir, list_path, state_dir = _prepare_snapshot_case(tmp_path / "no-progress", case)
+        fingerprint = json.dumps({
+            "git_diff_fingerprint": "same",
+            "checkpoint_cursor": "S02:pending",
+            "artifact_fingerprint": "artifact",
+            "head_commit": "abc123",
+        })
+        first_summary = _run_status_snapshot_action(
+            case,
+            list_path,
+            state_dir,
+            "update",
+            session_status="context_overflow",
+            session_id="sess-1",
+            extra_args=[
+                "--active-dev-branch",
+                "dev/snapshot-branch",
+                "--base-branch",
+                "main",
+                "--no-progress-count",
+                "1",
+                "--progress-fingerprint",
+                fingerprint,
+            ],
+        )
+        second_summary = _run_status_snapshot_action(
+            case,
+            list_path,
+            state_dir,
+            "update",
+            session_status="stalled_context_continuation",
+            session_id="sess-2",
+            extra_args=[
+                "--active-dev-branch",
+                "dev/snapshot-branch",
+                "--base-branch",
+                "main",
+                "--no-progress-count",
+                "2",
+                "--progress-fingerprint",
+                fingerprint,
+            ],
+        )
+        snapshot["noProgressStall"][task] = {
+            "first": _normalize_status_update(
+                first_summary,
+                _runtime_snapshot(state_dir, case),
+                _list_item_status(list_path, case),
+            )["summary"],
+            "second": _normalize_status_update(
+                second_summary,
+                _runtime_snapshot(state_dir, case),
+                _list_item_status(list_path, case),
+            ),
+        }
+
+    return snapshot
+
+
+def test_status_updater_behavior_matches_unix_runtime_snapshot(tmp_path):
+    actual = _build_status_updater_behavior_snapshot(tmp_path)
+    _assert_matches_unix_snapshot_section("statusUpdaterBehavior", actual)
+
+
 # ---------------------------------------------------------------------------
 # TERMINAL_STATUSES
 # ---------------------------------------------------------------------------