prizmkit 1.1.130 → 1.1.134

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

@@ -3,6 +3,7 @@
 import json
 import os
 import shutil
+import signal
 import subprocess
 import sys
 from pathlib import Path
@@ -90,6 +91,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 +434,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 +1532,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 +1593,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 = []
 
@@ -1876,26 +1960,29 @@ def test_completed_checkout_blocks_rerun_until_explicit_reset(monkeypatch, tmp_p
         runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
 
 
-def test_no_worktree_interrupt_saves_wip_and_returns_to_base(monkeypatch, tmp_path):
+def test_no_worktree_interrupt_saves_wip_and_returns_to_base(monkeypatch, tmp_path, capsys):
     from prizmkit_runtime import runners
+    from prizmkit_runtime.gitops import current_branch as real_current_branch
+    from prizmkit_runtime.gitops import run_git_command as real_run_git_command
     from prizmkit_runtime.runner_models import family_for, parse_invocation
     from prizmkit_runtime.task_checkout import load_task_checkout
 
     monkeypatch.setenv("DEV_BRANCH", "dev/F-001-interrupt")
     paths = _make_paths(tmp_path)
+    _init_bookkeeping_repo(paths.project_root)
     family = family_for("feature", paths)
     invocation = parse_invocation(family, "run", ())
     invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
     _install_runner_session_fakes(monkeypatch, runners)
-    ensure_calls = []
-    monkeypatch.setattr(runners, "run_git_plan", lambda project_root, plan: SimpleNamespace(ok=True, plan=plan, results=()))
-    monkeypatch.setattr(runners, "branch_ensure_return", lambda project_root, base, branch: ensure_calls.append((base, branch)))
+    monkeypatch.setattr(runners, "current_branch", real_current_branch)
+    monkeypatch.setattr(runners, "run_git_command", real_run_git_command)
 
     class InterruptingLauncher:
         def __init__(self, config):
             self.config = config
 
         def run(self):
+            (self.config.cwd / "interrupted.txt").write_text("preserved\n", encoding="utf-8")
             raise KeyboardInterrupt
 
     monkeypatch.setattr(runners, "AISessionLauncher", InterruptingLauncher)
@@ -1904,11 +1991,158 @@ def test_no_worktree_interrupt_saves_wip_and_returns_to_base(monkeypatch, tmp_pa
         runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
 
     checkout = load_task_checkout(family.state_dir, family.task_type, "F-001")
+    captured = capsys.readouterr()
     assert checkout is not None
     assert checkout.is_active
     assert checkout.active_dev_branch == "dev/F-001-interrupt"
     assert checkout.base_branch == "main"
-    assert ensure_calls == [("main", "dev/F-001-interrupt")]
+    assert real_current_branch(paths.project_root) == "main"
+    assert subprocess.run(
+        ["git", "show", "dev/F-001-interrupt:interrupted.txt"],
+        cwd=paths.project_root,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout == "preserved\n"
+    assert "Interrupted task F-001: work preserved and returned to main" in captured.err
+
+
+def test_interrupt_return_failure_is_reported_without_forcing_checkout(monkeypatch, tmp_path, capsys):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    monkeypatch.setenv("DEV_BRANCH", "dev/F-001-interrupt")
+    paths = _make_paths(tmp_path)
+    family = family_for("feature", paths)
+    invocation = parse_invocation(family, "run", ())
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
+    _install_runner_session_fakes(monkeypatch, runners)
+    monkeypatch.setattr(runners, "run_git_plan", lambda project_root, plan: SimpleNamespace(ok=True, plan=plan, results=()))
+    failure = SimpleNamespace(
+        ok=False,
+        plan=SimpleNamespace(
+            commands=(
+                SimpleNamespace(allow_failure=True),
+                SimpleNamespace(allow_failure=False),
+            )
+        ),
+        results=(
+            SimpleNamespace(
+                args=("commit", "--no-verify", "-m", "wip"),
+                return_code=1,
+                stdout="nothing to commit",
+                stderr="",
+            ),
+            SimpleNamespace(
+                args=("checkout", "main"),
+                return_code=1,
+                stdout="",
+                stderr="untracked files would be overwritten",
+            ),
+        ),
+    )
+    monkeypatch.setattr(runners, "branch_ensure_return", lambda project_root, base, branch: failure)
+
+    class InterruptingLauncher:
+        def __init__(self, config):
+            self.config = config
+
+        def run(self):
+            raise KeyboardInterrupt
+
+    monkeypatch.setattr(runners, "AISessionLauncher", InterruptingLauncher)
+
+    with pytest.raises(KeyboardInterrupt):
+        runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
+
+    captured = capsys.readouterr()
+    assert "Could not safely return to main; leaving dev/F-001-interrupt active" in captured.err
+    assert "git checkout main failed: untracked files would be overwritten" in captured.err
+    assert "After resolving the Git blocker, run: git checkout main" in captured.err
+
+
+def test_worktree_interrupt_preserves_task_worktree_without_returning_caller_checkout(monkeypatch, tmp_path, capsys):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    monkeypatch.setenv("USE_WORKTREE", "1")
+    monkeypatch.setenv("DEV_BRANCH", "dev/F-001-interrupt")
+    paths = _make_paths(tmp_path)
+    family = family_for("feature", paths)
+    invocation = parse_invocation(family, "run", ())
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
+    observed = _install_runner_session_fakes(monkeypatch, runners)
+    monkeypatch.setattr(
+        runners,
+        "ensure_linked_worktree",
+        lambda runtime: SimpleNamespace(ok=True, runtime=runtime, reason=""),
+    )
+    return_calls = []
+    monkeypatch.setattr(
+        runners,
+        "branch_ensure_return",
+        lambda *args: return_calls.append(args),
+    )
+
+    class InterruptingLauncher:
+        def __init__(self, config):
+            self.config = config
+
+        def run(self):
+            raise KeyboardInterrupt
+
+    monkeypatch.setattr(runners, "AISessionLauncher", InterruptingLauncher)
+
+    with pytest.raises(KeyboardInterrupt):
+        runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
+
+    captured = capsys.readouterr()
+    assert observed.wip_calls
+    assert return_calls == []
+    assert "Interrupted task F-001: work preserved in" in captured.err
+    assert "task worktree remains active" in captured.err
+
+
+def test_run_pipeline_command_bridges_sigterm_and_restores_handler(monkeypatch, tmp_path):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import PipelineRunResult
+
+    paths = _make_paths(tmp_path)
+    paths.feature_plan.write_text("{}", encoding="utf-8")
+    previous = signal.getsignal(signal.SIGTERM)
+    observed = []
+
+    def interrupted_pipeline(*args, **kwargs):
+        installed = signal.getsignal(signal.SIGTERM)
+        observed.append(installed)
+        try:
+            installed(signal.SIGTERM, None)
+        except KeyboardInterrupt:
+            return PipelineRunResult(False, 1, "interrupted", "interrupted")
+        raise AssertionError("SIGTERM handler did not interrupt the pipeline")
+
+    monkeypatch.setattr(runners, "_run_pipeline", interrupted_pipeline)
+
+    result = runners.run_pipeline_command("feature", "run", (), paths)
+
+    assert result.exit_code == 1
+    assert result.message == "processed=1 completed=False stopped_reason=interrupted"
+    assert observed and observed[0] not in {previous, signal.SIG_DFL, signal.SIG_IGN}
+    assert signal.getsignal(signal.SIGTERM) is previous
+
+
+def test_interruption_cleanup_shield_ignores_and_restores_signals():
+    from prizmkit_runtime.processes import shield_interruption_signals
+
+    previous_sigint = signal.getsignal(signal.SIGINT)
+    previous_sigterm = signal.getsignal(signal.SIGTERM)
+
+    with shield_interruption_signals():
+        assert signal.getsignal(signal.SIGINT) is signal.SIG_IGN
+        assert signal.getsignal(signal.SIGTERM) is signal.SIG_IGN
+
+    assert signal.getsignal(signal.SIGINT) is previous_sigint
+    assert signal.getsignal(signal.SIGTERM) is previous_sigterm
 
 
 @pytest.mark.parametrize(
@@ -2555,9 +2789,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 +2811,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 +2859,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 +2913,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 +2939,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 +3705,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