prizmkit 1.1.99 → 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,
@@ -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
 # ---------------------------------------------------------------------------
@@ -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'

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)"