prizmkit 1.1.130 → 1.1.131

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

@@ -10,6 +10,8 @@ from generate_refactor_prompt import (
     build_replacements,
     generate_refactor_checkpoint,
     merge_refactor_checkpoint_state,
+    refactor_checkpoint_metadata,
+    route_refactor_repair,
 )
 
 REMOVED_MAX_LOG_ENV = "MAX_" + "LOG_SIZE"
@@ -54,12 +56,24 @@ 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["refactor_state"] = refactor_checkpoint_metadata(
+            ".prizmkit/refactor/R-008",
+            stage="test",
+            status="TEST_FAIL",
+            stage_result="TEST_FAIL",
+            repair_scope="public-interface",
+            repair_round=2,
+            next_stage="prizmkit-implement",
+            resume_from="prizmkit-implement",
+        )
         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"
+        assert merged["refactor_state"]["repair_scope"] == "public-interface"
+        assert merged["refactor_state"]["repair_round"] == 2
 
 
 class TestExplicitProjectRoot:
@@ -197,6 +211,11 @@ def test_template_source_is_clean_for_headless_prompt_contract():
     content = Path("dev-pipeline/templates/refactor-bootstrap-prompt.md").read_text(encoding="utf-8")
     for forbidden in HEADLESS_FORBIDDEN_PROMPT_STRINGS:
         assert forbidden not in content
+    assert "prizmkit-workflow" not in content
+    assert "/prizmkit-test scope=this-change artifact_dir=.prizmkit/refactor/{{REFACTOR_ID}}/" in content
+    assert "local_commit_authorized=true" in content
+    assert "push_authorized=false" in content
+    assert "Behavior-preservation checks remain supporting evidence" in content
 
 
 # ---------------------------------------------------------------------------
@@ -315,6 +334,78 @@ class TestRefactorBootstrapShellExtraction:
 
 
 class TestRefactorCheckpointGeneration:
+    def test_default_checkpoint_has_all_atomic_gates_in_order(self):
+        checkpoint = generate_refactor_checkpoint("R-001", "session-1")
+
+        assert [step["skill"] for step in checkpoint["steps"]] == [
+            "prizmkit-init",
+            "prizmkit-plan",
+            "prizmkit-implement",
+            "prizmkit-code-review",
+            "prizmkit-test",
+            "prizmkit-retrospective",
+            "prizmkit-committer",
+            "refactor-report",
+            "completion-summary",
+        ]
+        assert checkpoint["steps"][4]["depends_on"] == "S04"
+        assert checkpoint["steps"][5]["depends_on"] == "S05"
+
+    def test_refactor_repair_routing_preserves_behavior_review_and_test(self):
+        test_infra = route_refactor_repair(
+            "TEST_FAIL", "test-infrastructure", repair_round=1,
+        )
+        production = route_refactor_repair("TEST_FAIL", "public-interface", repair_round=1)
+        blocked = route_refactor_repair("TEST_BLOCKED", "production", repair_round=1)
+
+        assert test_infra["route"] == ["prizmkit-implement", "prizmkit-test"]
+        assert production["route"] == [
+            "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
+        ]
+        unknown = route_refactor_repair("TEST_FAIL", "contract", repair_round=1)
+        exhausted = route_refactor_repair("TEST_FAIL", "production", repair_round=3)
+        assert unknown["blocked"] is True
+        assert unknown["route"] == []
+        assert exhausted["blocked"] is True
+        assert exhausted["repair_round"] == 3
+        assert blocked["blocked"] is True
+        assert blocked["route"] == []
+        assert blocked["next_stage"] is None
+        assert blocked["terminal_status"] == "WORKFLOW_BLOCKED"
+        assert blocked["blocked_reason"] == "test_blocked"
+
+    def test_refactor_checkpoint_metadata_preserves_artifact_and_evidence_handoff(self):
+        metadata = refactor_checkpoint_metadata(
+            ".prizmkit/refactor/R-001",
+            evidence={"manifest_path": "manifest.json"},
+            stage="test",
+            status="TEST_PASS",
+            stage_result="TEST_PASS",
+            next_stage="prizmkit-retrospective",
+            resume_from="prizmkit-retrospective",
+        )
+
+        assert metadata["artifact_dir"] == ".prizmkit/refactor/R-001"
+        assert metadata["authoritative_evidence_paths"]["manifest"] == "manifest.json"
+        assert metadata["next_stage"] == "prizmkit-retrospective"
+        assert metadata["resume_from"] == "prizmkit-retrospective"
+
+    def test_rendered_refactor_prompt_is_atomic_headless_and_local_commit_only(self, tmp_path):
+        prompt = _render_refactor_prompt_full(tmp_path)
+
+        assert prompt.index("/prizmkit-code-review") < prompt.index(
+            "/prizmkit-test scope=this-change artifact_dir=.prizmkit/refactor/R-001/"
+        ) < prompt.index("### Headless Commit Authorization")
+        assert "prizmkit-workflow" not in prompt
+        assert "Behavior-preservation checks collected during planning and implementation remain supporting evidence" in prompt
+        assert '"local_commit_authorized": true' in prompt
+        assert '"push_authorized": false' in prompt
+        assert "Do not ask questions, wait for user input" in prompt
+        assert "automatic push" not in prompt.lower()
+        assert "push_authorized\": true" not in prompt
+
+
+class TestRefactorCheckpointGenerationLegacy:
     def test_setup_section_is_step_and_finalization_group_expands(self):
         checkpoint = generate_refactor_checkpoint(
             "R-001",

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

@@ -90,6 +90,93 @@ def _item_id_from_next_result(kind, result):
     return result.data[key]
 
 
+def _write_semantic_completion_checkpoint(project_root, artifact_dir, workflow_type="feature-pipeline"):
+    validator = (
+        project_root / ".claude" / "command-assets" / "prizmkit-test"
+        / "scripts" / "validate_test_evidence.py"
+    )
+    validator.parent.mkdir(parents=True, exist_ok=True)
+    validator.write_text("import sys\nsys.exit(0)\n", encoding="utf-8")
+    contracts = {
+        "feature-pipeline": (
+            "feature_state",
+            [
+                "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
+                "prizmkit-retrospective", "prizmkit-committer", "completion-summary",
+            ],
+        ),
+        "bugfix-pipeline": (
+            "bugfix_state",
+            [
+                "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
+                "prizmkit-retrospective", "prizmkit-committer", "bug-report",
+            ],
+        ),
+        "refactor-pipeline": (
+            "refactor_state",
+            [
+                "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
+                "prizmkit-retrospective", "prizmkit-committer", "refactor-report",
+                "completion-summary",
+            ],
+        ),
+    }
+    state_key, skills = contracts[workflow_type]
+    evidence_id = "semantic-evidence"
+    evidence_dir = project_root / ".prizmkit" / "test" / "evidence" / evidence_id
+    evidence_dir.mkdir(parents=True, exist_ok=True)
+    evidence = {
+        "manifest": evidence_dir / "manifest.json",
+        "verdict": evidence_dir / "verdict.json",
+        "validation": evidence_dir / "validation.json",
+    }
+    evidence["manifest"].write_text(
+        json.dumps({"evidence_id": evidence_id, "final_verdict": "TEST_PASS"}),
+        encoding="utf-8",
+    )
+    evidence["verdict"].write_text(json.dumps({"verdict": "TEST_PASS"}), encoding="utf-8")
+    evidence["validation"].write_text(
+        json.dumps({"verdict": "TEST_PASS", "result": "passed"}), encoding="utf-8"
+    )
+    relative_evidence = {
+        key: str(path.relative_to(project_root)) for key, path in evidence.items()
+    }
+    steps = []
+    previous = None
+    for index, skill in enumerate(skills, start=1):
+        step = {
+            "id": f"S{index:02d}",
+            "skill": skill,
+            "name": skill,
+            "status": "completed",
+            "required_artifacts": [],
+            "depends_on": previous,
+        }
+        if skill == "prizmkit-code-review":
+            step["stage_result"] = "REVIEW_PASS"
+        if skill == "prizmkit-test":
+            step["stage_result"] = "TEST_PASS"
+            step["authoritative_evidence_paths"] = relative_evidence
+        steps.append(step)
+        previous = step["id"]
+    artifact_dir.mkdir(parents=True, exist_ok=True)
+    checkpoint = artifact_dir / "workflow-checkpoint.json"
+    checkpoint.write_text(
+        json.dumps({
+            "version": 1,
+            "workflow_type": workflow_type,
+            "steps": steps,
+            state_key: {
+                "repair_round": 0,
+                "authoritative_evidence_paths": relative_evidence,
+                "terminal_status": "WORKFLOW_COMPLETED",
+            },
+        }),
+        encoding="utf-8",
+    )
+    return checkpoint
+
+
 def test_retired_shell_runtime_files_are_absent_from_source():
     retired = [
         "run-feature.sh",
@@ -346,6 +433,7 @@ def test_runner_models_parse_legacy_args_and_environment(tmp_path):
     assert env.stale_kill_threshold_seconds == 9
     assert env.max_retries == 9
     assert env.strict_behavior_check is False
+    assert not hasattr(env, "enable_deploy")
     assert not hasattr(env, "max_" + "log_size")
 
 
@@ -1443,8 +1531,7 @@ def test_has_branch_completion_evidence_requires_task_branch_ahead_of_base(tmp_p
     subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=tmp_path, check=True)
     subprocess.run(["git", "config", "user.name", "Test"], cwd=tmp_path, check=True)
     artifact_dir = tmp_path / ".prizmkit" / "specs" / "001-done"
-    artifact_dir.mkdir(parents=True)
-    (artifact_dir / "completion-summary.json").write_text(json.dumps({"completion_notes": ["Completed durable workflow"]}), encoding="utf-8")
+    _write_semantic_completion_checkpoint(tmp_path, artifact_dir)
     (tmp_path / "base.txt").write_text("base", encoding="utf-8")
     subprocess.run(["git", "add", "base.txt"], cwd=tmp_path, check=True)
     subprocess.run(["git", "commit", "-m", "base"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
@@ -1505,11 +1592,7 @@ def test_no_worktree_recovers_completed_pending_branch_before_new_session(monkey
     session_dir = paths.feature_state_dir / "F-001" / "sessions" / "F-001-session-old"
     session_dir.mkdir(parents=True)
     artifact_dir = paths.project_root / ".prizmkit" / "specs" / "001-low"
-    artifact_dir.mkdir(parents=True)
-    (artifact_dir / "workflow-checkpoint.json").write_text(
-        json.dumps({"steps": [{"id": "S01", "skill": "done", "name": "Done", "status": "completed"}]}),
-        encoding="utf-8",
-    )
+    _write_semantic_completion_checkpoint(paths.project_root, artifact_dir)
     updates = []
     events = []
 
@@ -2555,9 +2638,7 @@ def test_classification_accepts_late_infra_error_with_completed_checkpoint_and_c
     subprocess.run(["git", "add", "done.txt"], cwd=tmp_path, check=True)
     subprocess.run(["git", "commit", "-m", "done"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
     artifact_dir = tmp_path / ".prizmkit" / "specs" / "001-done"
-    artifact_dir.mkdir(parents=True)
-    checkpoint = artifact_dir / "workflow-checkpoint.json"
-    checkpoint.write_text(json.dumps({"steps": [{"id": "S01", "skill": "done", "name": "Done", "status": "completed"}]}), encoding="utf-8")
+    checkpoint = _write_semantic_completion_checkpoint(tmp_path, artifact_dir)
     log = tmp_path / "session.log"
     log.write_text("model quota exceeded; API error after commit", encoding="utf-8")
     raw = AISessionResult(
@@ -2579,10 +2660,10 @@ def test_classification_accepts_late_infra_error_with_completed_checkpoint_and_c
     classification = classify_session(raw, project_root=tmp_path, base_head=base_head, prompt=prompt)
 
     assert classification.session_status == "success"
-    assert classification.reason == "completed_checkpoint_with_late_runtime_error"
+    assert classification.reason == "semantic_checkpoint_with_late_runtime_error"
 
 
-def test_classification_accepts_late_infra_with_completion_artifact_without_new_commit(tmp_path):
+def test_classification_rejects_late_infra_with_completion_summary_only(tmp_path):
     from prizmkit_runtime.runner_classification import classify_session
     from prizmkit_runtime.runner_models import PromptGenerationResult
     from prizmkit_runtime.sessions import AISessionCommand, AISessionResult
@@ -2627,8 +2708,8 @@ def test_classification_accepts_late_infra_with_completion_artifact_without_new_
 
     classification = classify_session(raw, project_root=tmp_path, base_head=side_head, prompt=prompt)
 
-    assert classification.session_status == "success"
-    assert classification.reason == "completed_checkpoint_with_late_runtime_error"
+    assert classification.session_status == "infra_error"
+    assert classification.reason == "ai_runtime_or_provider_error"
 
 
 def test_classification_keeps_pre_completion_provider_error_as_infra_error(tmp_path):
@@ -2681,9 +2762,7 @@ def test_classification_accepts_terminal_success_with_completed_checkpoint_witho
     subprocess.run(["git", "commit", "-m", "base"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
     base_head = subprocess.run(["git", "rev-parse", "HEAD"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True).stdout.strip()
     artifact_dir = tmp_path / ".prizmkit" / "specs" / "001-done"
-    artifact_dir.mkdir(parents=True)
-    checkpoint = artifact_dir / "workflow-checkpoint.json"
-    checkpoint.write_text(json.dumps({"steps": [{"id": "S01", "skill": "done", "name": "Done", "status": "completed"}]}), encoding="utf-8")
+    checkpoint = _write_semantic_completion_checkpoint(tmp_path, artifact_dir)
     (artifact_dir / "completion-summary.json").write_text(json.dumps({"completion_notes": ["Completed durable workflow"]}), encoding="utf-8")
     log = tmp_path / "session.log"
     log.write_text("terminal success", encoding="utf-8")
@@ -2709,7 +2788,7 @@ def test_classification_accepts_terminal_success_with_completed_checkpoint_witho
 
     classification = classify_session(raw, project_root=tmp_path, base_head=base_head, prompt=prompt)
     assert classification.session_status == "success"
-    assert classification.reason == "terminal_success_with_completed_checkpoint"
+    assert classification.reason == "terminal_success_with_semantic_checkpoint"
 
 
 def test_classification_preserves_success_before_context_overflow(tmp_path):
@@ -3475,3 +3554,317 @@ def test_timeout_and_stale_termination_override_provider_error_markers(tmp_path,
 
     assert classification.session_status == expected_status
     assert classification.reason == expected_reason
+
+
+
+@pytest.mark.parametrize("workflow_type", ["feature-pipeline", "bugfix-pipeline", "refactor-pipeline"])
+def test_semantic_completion_classification_has_cross_family_parity(tmp_path, workflow_type):
+    from prizmkit_runtime.runner_classification import classify_session
+    from prizmkit_runtime.runner_models import PromptGenerationResult
+    from prizmkit_runtime.sessions import AISessionCommand, AISessionResult
+    from prizmkit_runtime.status import ProgressSummary
+
+    subprocess.run(["git", "init", "-b", "main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "config", "user.name", "Test"], cwd=tmp_path, check=True)
+    (tmp_path / "base.txt").write_text("base", encoding="utf-8")
+    subprocess.run(["git", "add", "base.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "base"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    artifact = tmp_path / ".prizmkit" / "artifacts" / workflow_type
+    checkpoint = _write_semantic_completion_checkpoint(tmp_path, artifact, workflow_type)
+    log = tmp_path / f"{workflow_type}.log"
+    log.write_text("success", encoding="utf-8")
+    raw = AISessionResult(
+        command=AISessionCommand(("fake",), None, "claude", "stdin"),
+        exit_code=0,
+        timed_out=False,
+        termination_reason=None,
+        stale_marker=None,
+        fatal_error_code="",
+        progress_summary=ProgressSummary(result_subtype="success"),
+        session_log=log,
+        backup_log=tmp_path / "backup.log",
+        log_recovery=None,
+        started_epoch=0,
+        ended_epoch=1,
+    )
+
+    classification = classify_session(
+        raw,
+        project_root=tmp_path,
+        base_head="",
+        prompt=PromptGenerationResult(
+            output_path=tmp_path / "prompt.md",
+            checkpoint_path=checkpoint,
+            artifact_path=artifact,
+        ),
+    )
+
+    assert classification.session_status == "success"
+    assert classification.checkpoint_state["terminal_status"] == "WORKFLOW_COMPLETED"
+
+
+def test_semantic_blocked_classification_is_terminal_and_retry_neutral(tmp_path):
+    from prizmkit_runtime.runner_classification import classify_session
+    from prizmkit_runtime.runner_models import PromptGenerationResult
+    from prizmkit_runtime.sessions import AISessionCommand, AISessionResult
+    from prizmkit_runtime.status import ProgressSummary
+
+    subprocess.run(["git", "init", "-b", "main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "config", "user.name", "Test"], cwd=tmp_path, check=True)
+    (tmp_path / "base.txt").write_text("base", encoding="utf-8")
+    subprocess.run(["git", "add", "base.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "base"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    artifact = tmp_path / ".prizmkit" / "specs" / "blocked"
+    checkpoint = _write_semantic_completion_checkpoint(tmp_path, artifact)
+    data = json.loads(checkpoint.read_text(encoding="utf-8"))
+    data["feature_state"].update(
+        terminal_status="WORKFLOW_BLOCKED",
+        blocked_reason="repair_round_limit",
+        repair_round=3,
+    )
+    checkpoint.write_text(json.dumps(data), encoding="utf-8")
+    log = tmp_path / "blocked.log"
+    log.write_text("ambiguous failure", encoding="utf-8")
+    raw = AISessionResult(
+        command=AISessionCommand(("fake",), None, "codebuddy", "stdin"),
+        exit_code=1,
+        timed_out=False,
+        termination_reason=None,
+        stale_marker=None,
+        fatal_error_code="",
+        progress_summary=ProgressSummary(terminal_result_text="ambiguous failure"),
+        session_log=log,
+        backup_log=tmp_path / "backup.log",
+        log_recovery=None,
+        started_epoch=0,
+        ended_epoch=1,
+    )
+
+    classification = classify_session(
+        raw,
+        project_root=tmp_path,
+        base_head="",
+        prompt=PromptGenerationResult(
+            output_path=tmp_path / "prompt.md",
+            checkpoint_path=checkpoint,
+            artifact_path=artifact,
+        ),
+    )
+
+    assert classification.session_status == "workflow_blocked"
+    assert classification.reason == "repair_round_limit"
+    assert classification.checkpoint_state["repair_round"] == 3
+
+
+def test_recovery_outcome_preserves_dirty_partial_work_and_uses_semantic_checkpoint(tmp_path):
+    from prizmkit_runtime.runner_recovery import _recovery_outcome
+
+    subprocess.run(["git", "init", "-b", "main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "config", "user.name", "Test"], cwd=tmp_path, check=True)
+    (tmp_path / "base.txt").write_text("base", encoding="utf-8")
+    subprocess.run(["git", "add", "base.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "base"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "partial.txt").write_text("preserve me", encoding="utf-8")
+    artifact = tmp_path / ".prizmkit" / "specs" / "done"
+    checkpoint = _write_semantic_completion_checkpoint(tmp_path, artifact)
+
+    outcome, semantic = _recovery_outcome(tmp_path, 1, checkpoint_path=checkpoint)
+
+    assert outcome == "success"
+    assert semantic["terminal_status"] == "WORKFLOW_COMPLETED"
+    assert (tmp_path / "partial.txt").read_text(encoding="utf-8") == "preserve me"
+    assert subprocess.run(
+        ["git", "status", "--porcelain", "--", "partial.txt"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.startswith("??")
+
+
+def test_runtime_semantic_paths_do_not_invoke_composite_workflow():
+    sources = [
+        PIPELINE_ROOT / "prizmkit_runtime" / "checkpoint_state.py",
+        PIPELINE_ROOT / "prizmkit_runtime" / "runner_classification.py",
+        PIPELINE_ROOT / "prizmkit_runtime" / "runner_recovery.py",
+        PIPELINE_ROOT / "prizmkit_runtime" / "runners.py",
+    ]
+
+    for source in sources:
+        assert "prizmkit-workflow" not in source.read_text(encoding="utf-8")
+
+
+
+@pytest.mark.parametrize(
+    ("kind", "item_id", "blocked_status"),
+    [("feature", "F-001", "failed"), ("bugfix", "B-001", "needs_info"), ("refactor", "R-001", "failed")],
+)
+def test_family_status_persists_identical_semantic_blocked_snapshot_without_retry_spend(
+    tmp_path, kind, item_id, blocked_status
+):
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+    from prizmkit_runtime.runner_status import start_item, update_item
+
+    paths = _make_paths(tmp_path)
+    item = {
+        "id": item_id,
+        "title": "Semantic blocked",
+        "status": "pending",
+        "priority": "high",
+        "dependencies": [],
+    }
+    if kind == "bugfix":
+        item.update(severity="high", description="blocked", reproduction_steps=["run"])
+    elif kind == "refactor":
+        item.update(description="blocked", targets=["src"], goals=["preserve"])
+    _write_family_plan(paths, kind, [item])
+    family = family_for(kind, paths)
+    invocation = parse_invocation(family, "run", ())
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": family.plan_path})
+    assert start_item(family, invocation, item_id, paths.project_root).ok is True
+    semantic = {
+        "current_stage": None,
+        "next_stage": None,
+        "stage_result": "TEST_BLOCKED",
+        "repair_scope": "production",
+        "repair_round": 2,
+        "authoritative_evidence_paths": {
+            "manifest": ".prizmkit/test/evidence/id/manifest.json",
+            "verdict": ".prizmkit/test/evidence/id/verdict.json",
+            "validation": ".prizmkit/test/evidence/id/validation.json",
+        },
+        "blocked_reason": "test_blocked",
+        "terminal_status": "WORKFLOW_BLOCKED",
+    }
+
+    result = update_item(
+        family,
+        invocation,
+        item_id,
+        "workflow_blocked",
+        "session-1",
+        paths.project_root,
+        checkpoint_state=semantic,
+    )
+    status = json.loads((family.state_dir / item_id / "status.json").read_text(encoding="utf-8"))
+
+    assert result.ok is True
+    assert result.data["new_status"] == blocked_status
+    assert result.data["checkpoint_state"] == semantic
+    assert result.data["restart_policy"] == "terminal_blocked"
+    assert status["retry_count"] == 0
+    assert status["infra_error_count"] == 0
+    for key, value in semantic.items():
+        assert status[key] == value
+
+
+
+def test_recovery_detector_returns_no_candidate_for_empty_project(tmp_path):
+    import importlib.util
+
+    detector_path = (
+        REPO_ROOT / "core" / "skills" / "orchestration-skill" / "workflows"
+        / "recovery-workflow" / "scripts" / "detect-recovery-state.py"
+    )
+    spec = importlib.util.spec_from_file_location("recovery_detector_empty", detector_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    report = module.build_report(tmp_path)
+
+    assert report["detected"] is False
+    assert report["candidates"] == []
+
+
+def test_recovery_detector_returns_active_checkout_command(tmp_path, monkeypatch):
+    import importlib.util
+
+    detector_path = (
+        REPO_ROOT / "core" / "skills" / "orchestration-skill" / "workflows"
+        / "recovery-workflow" / "scripts" / "detect-recovery-state.py"
+    )
+    spec = importlib.util.spec_from_file_location("recovery_detector_active", detector_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    checkout_path = tmp_path / ".prizmkit" / "state" / "features" / "F-001" / "checkout.json"
+    checkout_path.parent.mkdir(parents=True)
+    checkout_path.write_text(
+        json.dumps({
+            "task_type": "feature",
+            "task_id": "F-001",
+            "state": "active",
+            "active_dev_branch": "dev/F-001-resume",
+            "base_branch": "main",
+            "checkout_mode": "branch",
+        }),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(module, "branch_exists", lambda *_args: True)
+
+    report = module.build_report(tmp_path)
+
+    assert report["detected"] is True
+    assert report["selection_required"] is False
+    assert report["candidates"][0]["continue_command"] == (
+        "python3 ./.prizmkit/dev-pipeline/cli.py feature run F-001"
+    )
+
+
+def test_recovery_detector_ignores_completed_checkout(tmp_path, monkeypatch):
+    import importlib.util
+
+    detector_path = (
+        REPO_ROOT / "core" / "skills" / "orchestration-skill" / "workflows"
+        / "recovery-workflow" / "scripts" / "detect-recovery-state.py"
+    )
+    spec = importlib.util.spec_from_file_location("recovery_detector_completed", detector_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    checkout_path = tmp_path / ".prizmkit" / "state" / "bugfix" / "B-001" / "checkout.json"
+    checkout_path.parent.mkdir(parents=True)
+    checkout_path.write_text(
+        json.dumps({
+            "task_type": "bugfix",
+            "task_id": "B-001",
+            "state": "completed",
+            "active_dev_branch": "bugfix/B-001-done",
+            "base_branch": "main",
+        }),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(module, "branch_exists", lambda *_args: True)
+
+    report = module.build_report(tmp_path)
+
+    assert report["detected"] is False
+
+
+def test_l4_runtime_and_recovery_sources_do_not_depend_on_direct_l1_composite():
+    runtime_root = REPO_ROOT / "dev-pipeline"
+    source_files = list(runtime_root.rglob("*.py"))
+    for source in source_files:
+        if "__pycache__" in source.parts or "tests" in source.parts or not source.is_file():
+            continue
+        assert "prizmkit-workflow" not in source.read_text(encoding="utf-8")
+
+
+def test_recovery_detector_has_no_direct_lifecycle_fallback(tmp_path):
+    import importlib.util
+
+    detector_path = (
+        REPO_ROOT / "core" / "skills" / "orchestration-skill" / "workflows"
+        / "recovery-workflow" / "scripts" / "detect-recovery-state.py"
+    )
+    spec = importlib.util.spec_from_file_location("recovery_detector_contract", detector_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    report = module.build_report(tmp_path)
+
+    assert "continue_command" not in report
+    assert report["detected"] is False

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

@@ -839,8 +839,8 @@ def test_headless_review_guidance_uses_main_agent_review_loop():
         assert "isolation:" not in text, path
 
     skill_text = skill_path.read_text(encoding="utf-8")
-    assert "staged and unstaged tracked changes" in skill_text
-    assert "untracked files" in skill_text
+    assert "the staged diff, and the unstaged diff" in skill_text
+    assert "untracked, deleted, and renamed files" in skill_text
     assert "accepted = 0" in skill_text
     assert "ten completed review rounds" in skill_text
     assert "## Final Result" in skill_text
@@ -1576,7 +1576,7 @@ def test_recovery_sessions_receive_live_heartbeat_configuration(tmp_path, monkey
         "run",
         lambda *_args, **_kwargs: type("Completed", (), {"returncode": 0, "stdout": "0", "stderr": ""})(),
     )
-    monkeypatch.setattr(runner_recovery, "_recovery_outcome", lambda *_args: "no_changes")
+    monkeypatch.setattr(runner_recovery, "_recovery_outcome", lambda *_args, **_kwargs: ("no_changes", {}))
 
     class FakeLauncher:
         def __init__(self, config):