prizmkit 1.1.114 → 1.1.116

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

@@ -320,7 +320,7 @@ def test_runner_models_parse_legacy_args_and_environment(tmp_path):
     invocation = parse_invocation(
         family,
         "run",
-        ("custom-list.json", "F-2", "--features", "F-003:F-001", "--max-retries", "7", "--max-infra-retries=5", "--mode", "full", "--critic"),
+        ("custom-list.json", "F-2", "--features", "F-003:F-001", "--max-retries", "7", "--max-infra-retries=5", "--mode", "full"),
     )
     env = RunnerEnvironment.from_env(
         {
@@ -340,7 +340,6 @@ def test_runner_models_parse_legacy_args_and_environment(tmp_path):
     assert invocation.max_retries == 7
     assert invocation.max_infra_retries == 5
     assert invocation.mode == "full"
-    assert invocation.critic is True
     assert env.stop_on_failure is True
     assert env.auto_push is True
     assert env.dev_branch == "dev/custom"
@@ -765,7 +764,6 @@ def test_prompt_generation_result_preserves_per_item_model(monkeypatch, tmp_path
                     "model": "per-item-model",
                     "pipeline_mode": "standard",
                     "agent_count": 3,
-                    "critic_enabled": False,
                 }
             ),
             stderr="",
@@ -815,7 +813,6 @@ def test_prompt_generation_passes_explicit_execution_root_to_generator(monkeypat
                     "model": "",
                     "pipeline_mode": "lite",
                     "agent_count": 1,
-                    "critic_enabled": False,
                 }
             ),
             stderr="",
@@ -881,7 +878,6 @@ def _install_runner_session_fakes(monkeypatch, runners, *, statuses=("success",)
             model="per-item-model",
             pipeline_mode="lite",
             agent_count=1,
-            critic_enabled=False,
             checkpoint_path=execution_root / ".prizmkit" / "specs" / "001-low" / "workflow-checkpoint.json",
             artifact_path=execution_root / ".prizmkit" / "specs" / "001-low",
             raw={},
@@ -1144,7 +1140,6 @@ def test_explicit_worktree_materializes_ignored_support_assets_before_prompt_and
             model="",
             pipeline_mode="lite",
             agent_count=1,
-            critic_enabled=False,
             checkpoint_path=execution_root / ".prizmkit" / "specs" / "001-support" / "workflow-checkpoint.json",
             artifact_path=execution_root / ".prizmkit" / "specs" / "001-support",
             raw={},
@@ -1294,7 +1289,7 @@ def test_no_worktree_recovers_completed_pending_branch_before_new_session(monkey
     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", "status": "completed"}]}),
+        json.dumps({"steps": [{"id": "S01", "skill": "done", "name": "Done", "status": "completed"}]}),
         encoding="utf-8",
     )
     updates = []
@@ -1476,15 +1471,25 @@ def test_no_worktree_runner_ignores_recovery_side_effect_branch(monkeypatch, tmp
     assert observed.updates[-1][2]["base_branch"] == "main"
 
 
-def test_no_worktree_preflight_commit_failure_aborts_before_branch_or_status(monkeypatch, tmp_path):
+@pytest.mark.parametrize(
+    ("kind", "item_id", "branch"),
+    [
+        ("feature", "F-001", "dev/F-001-preflight-fail"),
+        ("bugfix", "B-001", "bugfix/B-001-preflight-fail"),
+        ("refactor", "R-001", "refactor/R-001-preflight-fail"),
+    ],
+)
+def test_preflight_commit_failure_aborts_before_branch_worktree_or_status_for_all_families(monkeypatch, tmp_path, kind, item_id, branch):
     from prizmkit_runtime import runners
     from prizmkit_runtime.runner_models import family_for, parse_invocation
 
-    monkeypatch.setenv("DEV_BRANCH", "dev/F-001-preflight-fail")
-    paths = _make_paths(tmp_path)
-    family = family_for("feature", paths)
+    monkeypatch.setenv("DEV_BRANCH", branch)
+    monkeypatch.setenv("USE_WORKTREE", "1")
+    paths = _make_paths(tmp_path / kind)
+    family = family_for(kind, paths)
     invocation = parse_invocation(family, "run", ())
-    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
+    plan_path = {"feature": paths.feature_plan, "bugfix": paths.bugfix_plan, "refactor": paths.refactor_plan}[kind]
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": plan_path})
     events = []
 
     monkeypatch.setattr(
@@ -1495,10 +1500,11 @@ def test_no_worktree_preflight_commit_failure_aborts_before_branch_or_status(mon
     monkeypatch.setattr(runners, "current_branch", lambda _root: "main")
     monkeypatch.setattr(runners, "commit_preflight_ready_changes", lambda *args, **kwargs: SimpleNamespace(attempted=True, committed=False, result=SimpleNamespace(stderr="commit failed\n", stdout="")))
     monkeypatch.setattr(runners, "run_git_plan", lambda *args, **kwargs: events.append("branch_create"))
+    monkeypatch.setattr(runners, "ensure_linked_worktree", lambda *args, **kwargs: events.append("worktree_create"), raising=False)
     monkeypatch.setattr(runners, "start_item", lambda *args, **kwargs: events.append("start_item"))
 
     with pytest.raises(RuntimeError, match="Preflight dirty workspace preservation failed"):
-        runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
+        runners._process_item(family, invocation, item_id, paths, initial_metadata={})
 
     assert events == []
 
@@ -1530,7 +1536,7 @@ def test_foreground_runner_emits_structured_feature_progress(monkeypatch, tmp_pa
     assert "Code retry: 1 / 3" in captured.err
     assert "Preflight: no user-visible changes to preserve before feature task F-001" in captured.err
     assert "Pipeline mode: lite (Tier 1 — Single Agent)" in captured.err
-    assert "Agents: 1 (critic: disabled)" in captured.err
+    assert "Agents: 1" in captured.err
     assert "Spawning AI CLI session: F-001-session-1" in captured.err
     assert "Session result: success" in captured.err
 
@@ -1564,6 +1570,190 @@ def test_no_worktree_interrupt_saves_wip_and_returns_to_base(monkeypatch, tmp_pa
     assert ensure_calls == [("main", "dev/F-001-interrupt")]
 
 
+def _init_bookkeeping_repo(project_root):
+    subprocess.run(["git", "init", "-b", "main"], cwd=project_root, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=project_root, check=True)
+    subprocess.run(["git", "config", "user.name", "Test"], cwd=project_root, check=True)
+    (project_root / "staged.txt").write_text("base staged\n", encoding="utf-8")
+    (project_root / "unstaged.txt").write_text("base unstaged\n", encoding="utf-8")
+    subprocess.run(["git", "add", "staged.txt", "unstaged.txt"], cwd=project_root, check=True)
+    subprocess.run(["git", "commit", "-m", "base"], cwd=project_root, check=True, stdout=subprocess.DEVNULL)
+
+
+def _head_commit_count(project_root):
+    return int(
+        subprocess.run(
+            ["git", "rev-list", "--count", "HEAD"],
+            cwd=project_root,
+            check=True,
+            stdout=subprocess.PIPE,
+            text=True,
+        ).stdout.strip()
+    )
+
+
+def _head_message(project_root):
+    return subprocess.run(
+        ["git", "log", "-1", "--format=%s"],
+        cwd=project_root,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.strip()
+
+
+def _head_files(project_root):
+    return set(
+        subprocess.run(
+            ["git", "show", "--name-only", "--format=", "HEAD"],
+            cwd=project_root,
+            check=True,
+            stdout=subprocess.PIPE,
+            text=True,
+        ).stdout.splitlines()
+    )
+
+
+@pytest.mark.parametrize(
+    ("scenario", "expected_files"),
+    [
+        ("staged_only", {"staged.txt"}),
+        ("unstaged_only", {"unstaged.txt"}),
+        ("mixed", {"staged.txt", "unstaged.txt", "new-visible.txt"}),
+    ],
+)
+def test_preflight_ready_commit_preserves_staged_unstaged_and_mixed_visible_changes(tmp_path, scenario, expected_files):
+    from prizmkit_runtime.gitops import HIDDEN_TOOL_WORKTREE_EXCLUDES
+    from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
+
+    _init_bookkeeping_repo(tmp_path)
+    if scenario in {"staged_only", "mixed"}:
+        (tmp_path / "staged.txt").write_text("staged change\n", encoding="utf-8")
+        subprocess.run(["git", "add", "staged.txt"], cwd=tmp_path, check=True)
+    if scenario in {"unstaged_only", "mixed"}:
+        (tmp_path / "unstaged.txt").write_text("unstaged change\n", encoding="utf-8")
+    if scenario == "mixed":
+        (tmp_path / "new-visible.txt").write_text("new visible\n", encoding="utf-8")
+
+    before_count = _head_commit_count(tmp_path)
+    result = commit_preflight_ready_changes(tmp_path, "F-123")
+    visible_status = subprocess.run(
+        ["git", "status", "--porcelain", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout
+
+    assert result.attempted is True
+    assert result.committed is True
+    assert _head_commit_count(tmp_path) == before_count + 1
+    assert _head_message(tmp_path) == "chore: ready for F-123"
+    assert expected_files.issubset(_head_files(tmp_path))
+    assert visible_status == ""
+
+
+def test_preflight_ready_commit_excludes_hidden_support_assets_and_state(tmp_path):
+    from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
+
+    _init_bookkeeping_repo(tmp_path)
+    (tmp_path / "unstaged.txt").write_text("visible change\n", encoding="utf-8")
+    hidden_paths = [
+        tmp_path / ".claude" / "settings.json",
+        tmp_path / ".codebuddy" / "skills" / "local.md",
+        tmp_path / ".agents" / "skills" / "local.md",
+        tmp_path / ".codex" / "config.toml",
+        tmp_path / ".prizmkit" / "state" / "features" / "F-001" / "status.json",
+        tmp_path / ".claude" / "worktrees" / "agent" / "scratch.txt",
+    ]
+    for path in hidden_paths:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text("hidden support\n", encoding="utf-8")
+
+    result = commit_preflight_ready_changes(tmp_path, "F-124")
+    committed_files = _head_files(tmp_path)
+    hidden_status = subprocess.run(
+        ["git", "status", "--porcelain", "--", ".claude", ".codebuddy", ".agents", ".codex", ".prizmkit/state"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout
+
+    assert result.committed is True
+    assert committed_files == {"unstaged.txt"}
+    assert ".claude" in hidden_status or ".prizmkit/state" in hidden_status
+
+
+def test_preflight_ready_commit_noops_when_workspace_has_no_visible_dirty_content(tmp_path):
+    from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
+
+    _init_bookkeeping_repo(tmp_path)
+    (tmp_path / ".claude" / "worktrees" / "agent").mkdir(parents=True)
+    (tmp_path / ".claude" / "worktrees" / "agent" / "scratch.txt").write_text("hidden only\n", encoding="utf-8")
+    before_count = _head_commit_count(tmp_path)
+
+    result = commit_preflight_ready_changes(tmp_path, "F-125")
+
+    assert result.attempted is False
+    assert result.committed is False
+    assert _head_commit_count(tmp_path) == before_count
+
+
+def test_process_item_creates_one_ready_commit_before_branch_setup_for_mixed_visible_changes(monkeypatch, tmp_path):
+    from prizmkit_runtime import runner_bookkeeping, runners
+    from prizmkit_runtime.gitops import HIDDEN_TOOL_WORKTREE_EXCLUDES
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    paths = _make_paths(tmp_path)
+    _init_bookkeeping_repo(paths.project_root)
+    (paths.project_root / "staged.txt").write_text("staged before run\n", encoding="utf-8")
+    subprocess.run(["git", "add", "staged.txt"], cwd=paths.project_root, check=True)
+    (paths.project_root / "unstaged.txt").write_text("unstaged before run\n", encoding="utf-8")
+    before_count = _head_commit_count(paths.project_root)
+    branch_events = []
+
+    monkeypatch.setenv("DEV_BRANCH", "dev/F-001-ready")
+    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, "commit_preflight_ready_changes", runner_bookkeeping.commit_preflight_ready_changes)
+
+    def fake_run_git_plan(project_root, plan):
+        if plan.name == "branch_create":
+            branch_events.append(
+                {
+                    "commit_count": _head_commit_count(project_root),
+                    "message": _head_message(project_root),
+                    "visible_status": subprocess.run(
+                        ["git", "status", "--porcelain", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES],
+                        cwd=project_root,
+                        check=True,
+                        stdout=subprocess.PIPE,
+                        text=True,
+                    ).stdout,
+                }
+            )
+        return SimpleNamespace(ok=True, plan=plan, results=())
+
+    monkeypatch.setattr(runners, "run_git_plan", fake_run_git_plan)
+
+    status = runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
+
+    assert status == "completed"
+    assert branch_events == [
+        {
+            "commit_count": before_count + 1,
+            "message": "chore: ready for F-001",
+            "visible_status": "",
+        }
+    ]
+    assert _head_commit_count(paths.project_root) == before_count + 1
+    assert {"staged.txt", "unstaged.txt"}.issubset(_head_files(paths.project_root))
+
+
+
 def test_bookkeeping_commits_only_runner_owned_paths(tmp_path):
     from prizmkit_runtime.runner_bookkeeping import commit_final_bookkeeping
     from prizmkit_runtime.runner_models import RunnerFamily
@@ -1667,7 +1857,7 @@ def test_classification_accepts_late_infra_error_with_completed_checkpoint_and_c
     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", "status": "completed"}]}), encoding="utf-8")
+    checkpoint.write_text(json.dumps({"steps": [{"id": "S01", "skill": "done", "name": "Done", "status": "completed"}]}), encoding="utf-8")
     log = tmp_path / "session.log"
     log.write_text("model quota exceeded; API error after commit", encoding="utf-8")
     raw = AISessionResult(
@@ -1792,7 +1982,7 @@ def test_classification_accepts_terminal_success_with_completed_checkpoint_witho
     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", "status": "completed"}]}), encoding="utf-8")
+    checkpoint.write_text(json.dumps({"steps": [{"id": "S01", "skill": "done", "name": "Done", "status": "completed"}]}), encoding="utf-8")
     (artifact_dir / "completion-summary.json").write_text("{}", encoding="utf-8")
     log = tmp_path / "session.log"
     log.write_text("terminal success", encoding="utf-8")
@@ -2207,3 +2397,126 @@ def test_python_daemon_progress_uses_list_status_without_runtime_files(tmp_path)
         else:
             assert summary["auto_skipped"] == 1
 
+
+
+def _init_git_repo_for_invalid_checkpoint_test(tmp_path):
+    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)
+    return subprocess.run(["git", "rev-parse", "HEAD"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True).stdout.strip()
+
+
+def _terminal_success_result(tmp_path):
+    from prizmkit_runtime.sessions import AISessionCommand, AISessionResult
+    from prizmkit_runtime.status import ProgressSummary
+
+    log = tmp_path / "session.log"
+    log.write_text("terminal success", encoding="utf-8")
+    return 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", terminal_result_text="Completed"),
+        session_log=log,
+        backup_log=tmp_path / "backup.log",
+        log_recovery=None,
+        started_epoch=0,
+        ended_epoch=1,
+    )
+
+
+def test_invalid_existing_checkpoint_blocks_terminal_success_with_completion_summary(tmp_path):
+    from prizmkit_runtime.runner_classification import classify_session
+    from prizmkit_runtime.runner_models import PromptGenerationResult
+
+    base_head = _init_git_repo_for_invalid_checkpoint_test(tmp_path)
+    artifact_dir = tmp_path / ".prizmkit" / "specs" / "001-invalid"
+    artifact_dir.mkdir(parents=True)
+    checkpoint = artifact_dir / "workflow-checkpoint.json"
+    checkpoint.write_text(json.dumps({"steps": [{"id": "S01", "skill": "done", "name": "Done", "status": "not-valid"}]}), encoding="utf-8")
+    (artifact_dir / "completion-summary.json").write_text("{}", encoding="utf-8")
+    prompt = PromptGenerationResult(output_path=tmp_path / "prompt.md", checkpoint_path=checkpoint, artifact_path=artifact_dir)
+
+    classification = classify_session(_terminal_success_result(tmp_path), project_root=tmp_path, base_head=base_head, prompt=prompt)
+
+    assert classification.session_status == "crashed"
+    assert classification.reason == "invalid_workflow_checkpoint:invalid_status"
+
+
+def test_invalid_existing_checkpoint_blocks_head_change_success(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
+
+    base_head = _init_git_repo_for_invalid_checkpoint_test(tmp_path)
+    (tmp_path / "done.txt").write_text("done", encoding="utf-8")
+    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-invalid"
+    artifact_dir.mkdir(parents=True)
+    checkpoint = artifact_dir / "workflow-checkpoint.json"
+    checkpoint.write_text(json.dumps({"steps": [{"id": "bad", "skill": "done", "name": "Done", "status": "completed"}]}), encoding="utf-8")
+    raw = AISessionResult(
+        command=AISessionCommand(("fake",), None, "claude", "stdin"),
+        exit_code=1,
+        timed_out=False,
+        termination_reason=None,
+        stale_marker=None,
+        fatal_error_code="context_overflow",
+        progress_summary=ProgressSummary(fatal_error_code="context_overflow"),
+        session_log=tmp_path / "session.log",
+        backup_log=tmp_path / "backup.log",
+        log_recovery=None,
+        started_epoch=0,
+        ended_epoch=1,
+    )
+    raw.session_log.write_text("context overflow", encoding="utf-8")
+    prompt = PromptGenerationResult(output_path=tmp_path / "prompt.md", checkpoint_path=checkpoint, artifact_path=artifact_dir)
+
+    classification = classify_session(raw, project_root=tmp_path, base_head=base_head, prompt=prompt)
+
+    assert classification.session_status == "crashed"
+    assert classification.reason == "invalid_workflow_checkpoint:malformed_step_id"
+
+
+def test_invalid_existing_checkpoint_blocks_workspace_auto_commit_success(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
+
+    base_head = _init_git_repo_for_invalid_checkpoint_test(tmp_path)
+    artifact_dir = tmp_path / ".prizmkit" / "specs" / "001-invalid"
+    artifact_dir.mkdir(parents=True)
+    checkpoint = artifact_dir / "workflow-checkpoint.json"
+    checkpoint.write_text(json.dumps({"steps": []}), encoding="utf-8")
+    (tmp_path / "dirty.txt").write_text("dirty", encoding="utf-8")
+    log = tmp_path / "session.log"
+    log.write_text("clean exit but dirty workspace", 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="", terminal_result_text=""),
+        session_log=log,
+        backup_log=tmp_path / "backup.log",
+        log_recovery=None,
+        started_epoch=0,
+        ended_epoch=1,
+    )
+    prompt = PromptGenerationResult(output_path=tmp_path / "prompt.md", checkpoint_path=checkpoint, artifact_path=artifact_dir)
+
+    classification = classify_session(raw, project_root=tmp_path, base_head=base_head, prompt=prompt)
+
+    assert classification.session_status == "crashed"
+    assert classification.reason == "invalid_workflow_checkpoint:empty_steps"

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

@@ -793,9 +793,6 @@ def test_session_preamble_writes_redacted_start_command_for_all_launch_profiles(
 
 def test_headless_subagent_prompt_guidance_keeps_no_worktree_boundary_visible():
     guidance_files = [
-        REPO_ROOT / "dev-pipeline" / "templates" / "sections" / "phase-critic-plan.md",
-        REPO_ROOT / "dev-pipeline" / "templates" / "sections" / "phase-critic-plan-full.md",
-        REPO_ROOT / "dev-pipeline" / "templates" / "agent-prompts" / "critic-plan-challenge.md",
         REPO_ROOT / "dev-pipeline" / "templates" / "bootstrap-tier2.md",
         REPO_ROOT / "dev-pipeline" / "templates" / "bootstrap-tier3.md",
         REPO_ROOT / "core" / "skills" / "prizmkit-skill" / "prizmkit-code-review" / "SKILL.md",
@@ -1029,12 +1026,13 @@ def test_compact_progress_line_hides_stale_until_no_progress(tmp_path):
 
     session_log = tmp_path / "session.log"
     progress = tmp_path / "progress.json"
+    checkpoint = tmp_path / "workflow-checkpoint.json"
     progress.write_text(
         json.dumps(
             {
                 "child_total_bytes": 2 * 1024 * 1024,
                 "subagent_spawn_count": 5,
-                "current_phase": "retrospective",
+                "current_phase": "stream-derived-phase",
                 "current_tool": "Read",
                 "message_count": 465,
                 "total_tool_calls": 412,
@@ -1042,20 +1040,28 @@ def test_compact_progress_line_hides_stale_until_no_progress(tmp_path):
         ),
         encoding="utf-8",
     )
+    checkpoint.write_text(
+        json.dumps({"steps": [
+            {"id": "S01", "skill": "plan", "name": "Plan", "status": "completed"},
+            {"id": "S02", "skill": "retro", "name": "Retrospective", "status": "pending", "depends_on": "S01"},
+        ]}),
+        encoding="utf-8",
+    )
     running = HeartbeatState(last_seen_epoch=1.0, stale=False, details="progress", stale_seconds=0, log_size=4 * 1024 * 1024)
     brief_pause = HeartbeatState(last_seen_epoch=1.0, stale=False, details="no progress", stale_seconds=125, log_size=4 * 1024 * 1024)
     paused = HeartbeatState(last_seen_epoch=1.0, stale=True, details="no progress", stale_seconds=15 * 60, log_size=4 * 1024 * 1024)
     resumed = HeartbeatState(last_seen_epoch=3.0, stale=False, details="progress", stale_seconds=0, log_size=5 * 1024 * 1024)
 
-    running_line = _compact_progress_line(0, session_log, progress, running, stale_threshold_seconds=15 * 60)
-    brief_pause_line = _compact_progress_line(0, session_log, progress, brief_pause, stale_threshold_seconds=15 * 60)
-    paused_line = _compact_progress_line(0, session_log, progress, paused, stale_threshold_seconds=15 * 60)
-    resumed_line = _compact_progress_line(0, session_log, progress, resumed, stale_threshold_seconds=15 * 60)
+    running_line = _compact_progress_line(0, session_log, progress, running, checkpoint_path=checkpoint, stale_threshold_seconds=15 * 60)
+    brief_pause_line = _compact_progress_line(0, session_log, progress, brief_pause, checkpoint_path=checkpoint, stale_threshold_seconds=15 * 60)
+    paused_line = _compact_progress_line(0, session_log, progress, paused, checkpoint_path=checkpoint, stale_threshold_seconds=15 * 60)
+    resumed_line = _compact_progress_line(0, session_log, progress, resumed, checkpoint_path=checkpoint, stale_threshold_seconds=15 * 60)
 
     assert "▶ [HEARTBEAT]" in running_line
     assert "log: 4MB" in running_line
     assert "child: 2MB/5" in running_line
-    assert "phase: retrospective" in running_line
+    assert "phase: Retrospective" in running_line
+    assert "stream-derived-phase" not in running_line
     assert "tool: Read" in running_line
     assert "msgs: 465" in running_line
     assert "412 tool calls" in running_line
@@ -1068,6 +1074,31 @@ def test_compact_progress_line_hides_stale_until_no_progress(tmp_path):
     assert "log: 5MB" in resumed_line
     assert "stale:" not in resumed_line
 
+def test_compact_progress_line_omits_phase_without_valid_checkpoint(tmp_path):
+    from prizmkit_runtime.heartbeat import HeartbeatState
+    from prizmkit_runtime.sessions import _compact_progress_line
+
+    session_log = tmp_path / "session.log"
+    progress = tmp_path / "progress.json"
+    malformed = tmp_path / "bad-checkpoint.json"
+    invalid = tmp_path / "invalid-checkpoint.json"
+    progress.write_text(
+        json.dumps({"current_phase": "legacy-plan", "current_tool": "Edit"}),
+        encoding="utf-8",
+    )
+    malformed.write_text("{bad", encoding="utf-8")
+    invalid.write_text(json.dumps({"steps": [{"id": "S01", "skill": "x", "name": "X", "status": "done"}]}), encoding="utf-8")
+    state = HeartbeatState(last_seen_epoch=1.0, stale=False, details="progress", stale_seconds=0, log_size=12)
+
+    missing_line = _compact_progress_line(0, session_log, progress, state, checkpoint_path=tmp_path / "missing.json")
+    malformed_line = _compact_progress_line(0, session_log, progress, state, checkpoint_path=malformed)
+    invalid_line = _compact_progress_line(0, session_log, progress, state, checkpoint_path=invalid)
+
+    for line in (missing_line, malformed_line, invalid_line):
+        assert "phase:" not in line
+        assert "legacy-plan" not in line
+        assert "tool: Edit" in line
+
 
 def test_heartbeat_observation_stale_accumulates_by_elapsed_time_and_resets_on_progress(tmp_path, monkeypatch):
     import prizmkit_runtime.heartbeat as heartbeat

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.114",
+  "version": "1.1.116",
   "skills": {
     "prizmkit": {
       "description": "Full-lifecycle dev toolkit. Covers spec-driven development, Prizm context docs, code quality, debugging, deployment, and knowledge management.",

package/bundled/skills/bug-planner/SKILL.md

@@ -414,14 +414,15 @@ Bug List (by priority):
 
 ---
 
-## Adversarial Critic & Browser Verification
+## Verification Defaults
 
-When configuring critic settings or browser verification for bugs, read `${SKILL_DIR}/references/critic-and-verification.md` for default behavior tables and verification type guidance.
+When configuring bug verification, read `${SKILL_DIR}/references/verification.md` for verification type and browser verification guidance.
 
 Key points:
-- Critic is enabled by default for critical/high severity, disabled for medium/low
-- Users can override critic settings per-bug during Phase 2 or Phase 3
+- Critical/high severity bugs require clear automated, manual, or hybrid verification evidence.
+- Medium/low severity bugs use the smallest verification that proves the fix and guards against regression.
 - `browser_interaction` is supported for UI-reproducible bugs; `verification_type` still declares whether verification is automated, manual, or hybrid.
+- Do not generate `critic` or `critic_count`; those fields are fully removed and validators reject them.
 
 ---
 

package/bundled/skills/bug-planner/references/verification.md

@@ -0,0 +1,29 @@
+# Bug Verification Guidance
+
+## Verification Defaults
+
+All bug fixes need verification that matches severity, reproduction clarity, and risk.
+
+| Severity | Default verification expectation | Rationale |
+|---|---|---|
+| critical | Automated or hybrid verification with explicit regression coverage | Crash/data-loss/security bugs need durable proof. |
+| high | Automated or hybrid verification for the broken core path | Core-feature failures need regression protection. |
+| medium | Focused automated or manual verification | Workaround cases need proof without over-scoping. |
+| low | Smallest meaningful check | Cosmetic or minor edge cases should stay lightweight. |
+
+## Verification Type
+
+- `automated`: use when a unit, integration, or E2E test can reliably reproduce the bug and prove the fix.
+- `manual`: use when reproduction needs external state or human judgment and no stable automated check is practical.
+- `hybrid`: use when automated regression coverage is possible but final confidence needs manual/browser confirmation.
+
+## Browser Verification
+
+Use `browser_interaction` for UI-reproducible bugs.
+
+- `tool: auto` lets the runtime choose the best browser tool.
+- `tool: playwright-cli` is best for local dev-server verification in an isolated browser.
+- `tool: opencli` is best when an existing Chrome login/session or third-party integration cookies are needed.
+- `verify_steps` should describe what to prove, not low-level click scripts.
+
+Do not emit `critic` or `critic_count`; those fields are retired and validators reject them.

package/bundled/skills/bug-planner/scripts/validate-bug-list.py

@@ -139,6 +139,14 @@ def validate(data, feature_ids=None):
     for i, bug in enumerate(bugs):
         prefix = "bugs[{}]".format(i)
 
+        for retired_field in ("critic", "critic_count"):
+            if retired_field in bug:
+                errors.append(
+                    "{}: '{}' field is retired; remove it from bug-fix-list data".format(
+                        prefix, retired_field
+                    )
+                )
+
         # Required fields
         bug_id = bug.get("id", "")
         if not bug_id:

package/bundled/skills/bugfix-pipeline-launcher/SKILL.md

@@ -123,7 +123,7 @@ Detect user intent from their message, then follow the corresponding workflow:
    ```
    Selected-options example:
    ```bash
-   VERBOSE=1 ENABLE_CRITIC=1 MAX_RETRIES=5 STOP_ON_FAILURE=1 ENABLE_DEPLOY=1 PRIZMKIT_EFFORT=high \
+   VERBOSE=1 MAX_RETRIES=5 STOP_ON_FAILURE=1 ENABLE_DEPLOY=1 PRIZMKIT_EFFORT=high \
      python3 ./.prizmkit/dev-pipeline/cli.py bugfix run .prizmkit/plans/bug-fix-list.json
    ```
 
@@ -134,7 +134,7 @@ Detect user intent from their message, then follow the corresponding workflow:
    Selected-options example:
    ```bash
    python3 ./.prizmkit/dev-pipeline/cli.py daemon bugfix start .prizmkit/plans/bug-fix-list.json \
-     --env "VERBOSE=1 ENABLE_CRITIC=1 MAX_RETRIES=5 STOP_ON_FAILURE=1 ENABLE_DEPLOY=1 PRIZMKIT_EFFORT=high"
+     --env "VERBOSE=1 MAX_RETRIES=5 STOP_ON_FAILURE=1 ENABLE_DEPLOY=1 PRIZMKIT_EFFORT=high"
    ```
 
    **Manual mode**: Print the assembled command(s) and **stop here**. Do not execute anything. Do not proceed to step 7.

package/bundled/skills/bugfix-pipeline-launcher/references/configuration.md

@@ -11,7 +11,6 @@ Translating user responses to env vars:
 | Verbose: Off | `VERBOSE=0` |
 | Verbose: On | `VERBOSE=1` |
 | Max retries: N | `MAX_RETRIES=N` |
-| Critic: On | `ENABLE_CRITIC=1` |
 | Stop on failure: On | `STOP_ON_FAILURE=1` |
 | Deploy: Yes | `ENABLE_DEPLOY=1` |
 | Effort: value | `PRIZMKIT_EFFORT=<value>` |
@@ -43,15 +42,11 @@ Present these via `AskUserQuestion` in step 5. Round 1 is one `AskUserQuestion`
 - 1
 - 5
 
-**Question 3 — Critic review** (multiSelect: false):
-- Off (default) — Skip adversarial review (`ENABLE_CRITIC=0`)
-- On — Enable adversarial critic review (`ENABLE_CRITIC=1`): an independent AI agent reviews the diagnosis/plan for completeness and the fix for defects, edge cases, and regression risks. Adds ~5-10 min per bug.
-
 **Question 4 — Advanced config?** (multiSelect: false):
 - No (default) — Use defaults for failure behavior
 - Yes — Configure stop-on-failure, deploy, and reasoning effort options
 
-Note: Bug filter defaults to all bugs. Runtime selects eligible bugs in stable list order after dependencies are completed; planners should order unrelated bugs by severity/priority before launch. Default Critic to Off unless bugs have `severity: "critical"` or `severity: "high"` (in which case default to On). If the user selects "Other" on any option, handle their custom input.
+Note: Bug filter defaults to all bugs. Runtime selects eligible bugs in stable list order after dependencies are completed; planners should order unrelated bugs by severity/priority before launch. If the user selects "Other" on any option, handle their custom input.
 
 ### Round 2 (only if Advanced config = Yes)