prizmkit 1.1.154 → 1.1.156

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

@@ -76,6 +76,102 @@ def _write_family_plan(paths, kind, items):
     return plan_path
 
 
+@pytest.mark.parametrize(
+    ("kind", "item_id", "filename", "list_key", "schema", "item"),
+    [
+        (
+            "feature", "F-001", "feature-list.json", "features",
+            "dev-pipeline-feature-list-v1",
+            {
+                "id": "F-001", "title": "Preview Feature", "description": "Preview only",
+                "priority": "high", "dependencies": [],
+                "acceptance_criteria": ["Prompt validates"], "status": "pending",
+            },
+        ),
+        (
+            "bugfix", "B-001", "bug-fix-list.json", "bugs",
+            "dev-pipeline-bug-fix-list-v1",
+            {
+                "id": "B-001", "title": "Preview Bug", "description": "Preview only",
+                "severity": "high", "priority": "high", "dependencies": [],
+                "error_source": {"type": "user_report", "reproduction_steps": ["preview"]},
+                "verification_type": "automated",
+                "acceptance_criteria": ["Prompt validates"], "status": "pending",
+            },
+        ),
+        (
+            "refactor", "R-001", "refactor-list.json", "refactors",
+            "dev-pipeline-refactor-list-v1",
+            {
+                "id": "R-001", "title": "Preview Refactor", "description": "Preview only",
+                "scope": {"files": ["src/example.js"], "modules": ["example"]},
+                "type": "simplify", "priority": "high", "complexity": "low",
+                "behavior_preservation": {"strategy": "test-gate", "existing_tests": True},
+                "acceptance_criteria": ["Prompt validates"],
+                "dependencies": [], "status": "pending",
+            },
+        ),
+    ],
+)
+def test_actual_dry_run_is_read_only_and_successful(
+    tmp_path, kind, item_id, filename, list_key, schema, item,
+):
+    from prizmkit_runtime.paths import resolve_runtime_paths
+    from prizmkit_runtime.runners import run_pipeline_command
+
+    project = tmp_path / kind
+    plans = project / ".prizmkit" / "plans"
+    plans.mkdir(parents=True)
+    plan_path = plans / filename
+    plan_path.write_text(
+        json.dumps({"$schema": schema, "project_name": "Dry Run", list_key: [item]}),
+        encoding="utf-8",
+    )
+    fake_cli = project / "fake-ai.py"
+    fake_cli.write_text(
+        "#!/usr/bin/env python3\nfrom pathlib import Path\nPath('AI_WAS_LAUNCHED').write_text('bad')\n",
+        encoding="utf-8",
+    )
+    fake_cli.chmod(0o755)
+    (project / ".prizmkit" / "config.json").write_text(
+        json.dumps({
+            "platform": "pi",
+            "ai_cli": str(fake_cli),
+            "ai_cli_launch": {"profile": "custom", "prompt_arg": "--prompt"},
+        }),
+        encoding="utf-8",
+    )
+    subprocess.run(["git", "init", "-b", "main"], cwd=project, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "config", "user.name", "Dry Run Test"], cwd=project, check=True)
+    subprocess.run(["git", "config", "user.email", "dry-run@example.invalid"], cwd=project, check=True)
+    subprocess.run(["git", "add", "."], cwd=project, check=True)
+    subprocess.run(["git", "commit", "-m", "initial"], cwd=project, check=True, stdout=subprocess.DEVNULL)
+    paths = resolve_runtime_paths(pipeline_root=PIPELINE_ROOT, project_root=project)
+    branch_before = subprocess.check_output(["git", "branch", "--show-current"], cwd=project, text=True).strip()
+    head_before = subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=project, text=True).strip()
+    status_before = subprocess.check_output(["git", "status", "--porcelain=v1", "-uall"], cwd=project, text=True)
+
+    run_args = (
+        (str(plan_path), "--dry-run")
+        if kind == "feature"
+        else (item_id, str(plan_path), "--dry-run")
+    )
+    result = run_pipeline_command(kind, "run", run_args, paths)
+
+    assert result.exit_code == 0
+    assert "processed=1 completed=False stopped_reason=dry_run" in result.render()
+    assert "last_status: dry_run" in result.render()
+    assert json.loads(plan_path.read_text(encoding="utf-8"))[list_key][0]["status"] == "pending"
+    assert subprocess.check_output(["git", "branch", "--show-current"], cwd=project, text=True).strip() == branch_before
+    assert subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=project, text=True).strip() == head_before
+    assert subprocess.check_output(["git", "status", "--porcelain=v1", "-uall"], cwd=project, text=True) == status_before
+    assert not (project / "AI_WAS_LAUNCHED").exists()
+    assert not (project / ".prizmkit" / "state").exists()
+    assert not (project / ".prizmkit" / "specs").exists()
+    assert not (project / ".prizmkit" / "bugfix").exists()
+    assert not (project / ".prizmkit" / "refactor").exists()
+
+
 def _get_next_result(kind, paths):
     from prizmkit_runtime.runner_models import family_for, parse_invocation
     from prizmkit_runtime.runner_status import get_next
@@ -97,22 +193,22 @@ def _write_semantic_completion_checkpoint(project_root, artifact_dir, workflow_t
             "feature_state",
             [
                 "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
-                "prizmkit-retrospective", "prizmkit-committer", "completion-summary",
+                "completion-summary", "prizmkit-retrospective", "prizmkit-committer",
             ],
         ),
         "bugfix-pipeline": (
             "bugfix_state",
             [
                 "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
-                "prizmkit-retrospective", "prizmkit-committer", "bug-report",
+                "bug-report", "prizmkit-retrospective", "prizmkit-committer",
             ],
         ),
         "refactor-pipeline": (
             "refactor_state",
             [
                 "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
-                "prizmkit-retrospective", "prizmkit-committer", "refactor-report",
-                "completion-summary",
+                "refactor-report", "completion-summary", "prizmkit-retrospective",
+                "prizmkit-committer",
             ],
         ),
     }
@@ -128,6 +224,8 @@ def _write_semantic_completion_checkpoint(project_root, artifact_dir, workflow_t
             "required_artifacts": [],
             "depends_on": previous,
         }
+        if skill == "prizmkit-implement":
+            step["stage_result"] = "IMPLEMENTED"
         if skill == "prizmkit-code-review":
             step["stage_result"] = "REVIEW_PASS"
         if skill == "prizmkit-test":
@@ -137,6 +235,10 @@ def _write_semantic_completion_checkpoint(project_root, artifact_dir, workflow_t
                 str(relative_artifact / "test-report.md"),
                 str(relative_artifact / "test-result.json"),
             ]
+        if skill == "prizmkit-retrospective":
+            step["stage_result"] = "RETRO_COMPLETE"
+        if skill == "prizmkit-committer":
+            step["stage_result"] = "COMMITTED"
         steps.append(step)
         previous = step["id"]
     artifact_dir.mkdir(parents=True, exist_ok=True)
@@ -158,12 +260,31 @@ def _write_semantic_completion_checkpoint(project_root, artifact_dir, workflow_t
             },
             "repair_rounds": 0,
             "production_changed": False,
-            "review_required": False,
-            "review_scope": None,
             "unresolved_items": [],
         }),
         encoding="utf-8",
     )
+    runtime_commit_hash = "b" * 40
+    runtime_base_head = "a" * 40
+    head = subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        cwd=project_root,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.DEVNULL,
+        text=True,
+        check=False,
+    )
+    parent = subprocess.run(
+        ["git", "rev-parse", "HEAD^"],
+        cwd=project_root,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.DEVNULL,
+        text=True,
+        check=False,
+    )
+    if head.returncode == 0 and parent.returncode == 0:
+        runtime_commit_hash = head.stdout.strip()
+        runtime_base_head = parent.stdout.strip()
     checkpoint = artifact_dir / "workflow-checkpoint.json"
     checkpoint.write_text(
         json.dumps({
@@ -173,6 +294,8 @@ def _write_semantic_completion_checkpoint(project_root, artifact_dir, workflow_t
             state_key: {
                 "repair_round": 0,
                 "terminal_status": "WORKFLOW_COMPLETED",
+                "runtime_base_head": runtime_base_head,
+                "runtime_commit_hash": runtime_commit_hash,
             },
         }),
         encoding="utf-8",
@@ -403,7 +526,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"),
+        ("custom-list.json", "F-2", "--features", "F-003:F-001", "--max-retries", "7", "--max-infra-retries=5"),
     )
     env = RunnerEnvironment.from_env(
         {
@@ -422,7 +545,7 @@ def test_runner_models_parse_legacy_args_and_environment(tmp_path):
     assert invocation.item_filter == "F-003:F-001"
     assert invocation.max_retries == 7
     assert invocation.max_infra_retries == 5
-    assert invocation.mode == "full"
+    assert not hasattr(invocation, "mode")
     assert env.stop_on_failure is True
     assert env.auto_push is True
     assert env.dev_branch == "dev/custom"
@@ -1082,7 +1205,6 @@ def test_prompt_generation_result_preserves_per_item_model(monkeypatch, tmp_path
                     "output_path": str(session_paths.prompt_path),
                     "checkpoint_path": str(paths.project_root / ".prizmkit" / "bugfix" / "B-001" / "workflow-checkpoint.json"),
                     "model": "per-item-model",
-                    "pipeline_mode": "standard",
                 }
             ),
             stderr="",
@@ -1130,7 +1252,6 @@ def test_prompt_generation_passes_explicit_execution_root_to_generator(monkeypat
                     "output_path": str(session_paths.prompt_path),
                     "checkpoint_path": str(execution_root / ".prizmkit" / "specs" / "001-low" / "workflow-checkpoint.json"),
                     "model": "",
-                    "pipeline_mode": "full",
                 }
             ),
             stderr="",
@@ -1195,7 +1316,6 @@ def _install_runner_session_fakes(monkeypatch, runners, *, statuses=("success",)
         return PromptGenerationResult(
             output_path=session_paths.prompt_path,
             model="per-item-model",
-            pipeline_mode="full",
             checkpoint_path=execution_root / ".prizmkit" / "specs" / "001-low" / "workflow-checkpoint.json",
             artifact_path=execution_root / ".prizmkit" / "specs" / "001-low",
             raw={},
@@ -1528,7 +1648,6 @@ def test_explicit_worktree_materializes_ignored_support_assets_before_prompt_and
         return PromptGenerationResult(
             output_path=session_paths.prompt_path,
             model="",
-            pipeline_mode="full",
             checkpoint_path=execution_root / ".prizmkit" / "specs" / "001-support" / "workflow-checkpoint.json",
             artifact_path=execution_root / ".prizmkit" / "specs" / "001-support",
             raw={},
@@ -1615,7 +1734,6 @@ 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"
-    _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)
@@ -1623,6 +1741,7 @@ def test_has_branch_completion_evidence_requires_task_branch_ahead_of_base(tmp_p
     (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)
+    _write_semantic_completion_checkpoint(tmp_path, artifact_dir)
 
     assert has_branch_completion_evidence(tmp_path, "main", "dev/F-001", artifact_dir) is True
 
@@ -1994,7 +2113,7 @@ def test_foreground_runner_emits_structured_feature_progress(monkeypatch, tmp_pa
     assert "Feature: F-001 — Readable output" in captured.err
     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: full (Full Guidance)" in captured.err
+    assert "Pipeline mode:" not in captured.err
     assert "Spawning AI CLI session: F-001-session-1" in captured.err
     assert "Session result: success" in captured.err
 
@@ -3166,6 +3285,14 @@ def test_classification_accepts_final_success_after_internal_stream_retry(tmp_pa
         stdout=subprocess.PIPE,
         text=True,
     ).stdout.strip()
+    (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" / "bugfix" / "B-004"
     checkpoint = _write_semantic_completion_checkpoint(tmp_path, artifact_dir, "bugfix-pipeline")
 
@@ -3313,7 +3440,7 @@ def test_classification_keeps_pre_completion_provider_error_as_infra_error(tmp_p
     assert classification.reason == "ai_runtime_or_provider_error"
 
 
-def test_classification_accepts_terminal_success_with_completed_checkpoint_without_git_delta(tmp_path):
+def test_classification_rejects_completed_checkpoint_without_runtime_git_receipt(tmp_path):
     from prizmkit_runtime.runner_classification import classify_session
     from prizmkit_runtime.runner_models import PromptGenerationResult
     from prizmkit_runtime.sessions import AISessionCommand, AISessionResult
@@ -3353,8 +3480,8 @@ 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_semantic_checkpoint"
+    assert classification.session_status == "commit_missing"
+    assert classification.reason == "runtime_commit_receipt_mismatch"
 
 
 def test_classification_preserves_success_before_context_overflow(tmp_path):
@@ -3915,6 +4042,14 @@ def test_pi_length_stop_does_not_override_completed_checkpoint(tmp_path):
     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-length-complete"
     checkpoint = _write_semantic_completion_checkpoint(tmp_path, artifact_dir)
     prompt = PromptGenerationResult(
@@ -4361,6 +4496,21 @@ def test_semantic_completion_classification_has_cross_family_parity(tmp_path, wo
     (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)
+    base_head = subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.strip()
+    (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 = tmp_path / ".prizmkit" / "artifacts" / workflow_type
     checkpoint = _write_semantic_completion_checkpoint(tmp_path, artifact, workflow_type)
     log = tmp_path / f"{workflow_type}.log"
@@ -4383,7 +4533,7 @@ def test_semantic_completion_classification_has_cross_family_parity(tmp_path, wo
     classification = classify_session(
         raw,
         project_root=tmp_path,
-        base_head="",
+        base_head=base_head,
         prompt=PromptGenerationResult(
             output_path=tmp_path / "prompt.md",
             checkpoint_path=checkpoint,

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

@@ -86,6 +86,25 @@ def _write_checkout(
     return checkout
 
 
+def _write_raw_checkout(
+    project: Path,
+    family: str,
+    directory_id: str,
+    payload: dict[str, object],
+) -> Path:
+    checkout = (
+        project
+        / ".prizmkit"
+        / "state"
+        / STATE_DIRS[family]
+        / directory_id
+        / "checkout.json"
+    )
+    checkout.parent.mkdir(parents=True, exist_ok=True)
+    checkout.write_text(json.dumps(payload) + "\n", encoding="utf-8")
+    return checkout
+
+
 def _repository_snapshot(project: Path) -> tuple[str, str, str]:
     return (
         _git(project, "branch", "--show-current"),
@@ -209,3 +228,95 @@ def test_zero_candidates_filters_invalid_records_without_history_fallback_or_ses
     assert _repository_snapshot(project) == repository_before
     assert _historical_snapshot(historical) == history_before
     assert sorted(path.name for path in historical.parent.iterdir()) == ["historical-only"]
+
+
+def test_detector_rejects_malformed_or_mismatched_checkout_identity(tmp_path):
+    project = tmp_path / "project"
+    _init_repository(project)
+    invalid_records = (
+        (
+            "feature",
+            "F-not-an-id",
+            "dev/F-not-an-id",
+            {
+                "task_type": "feature",
+                "task_id": "F-not-an-id",
+                "state": "active",
+                "active_dev_branch": "dev/F-not-an-id",
+                "base_branch": "main",
+                "checkout_mode": "branch",
+            },
+        ),
+        (
+            "bugfix",
+            "B-004",
+            "bugfix/B-004-missing-id",
+            {
+                "task_type": "bugfix",
+                "state": "active",
+                "active_dev_branch": "bugfix/B-004-missing-id",
+                "base_branch": "main",
+                "checkout_mode": "branch",
+            },
+        ),
+        (
+            "refactor",
+            "R-005",
+            "refactor/R-005-wrong-type",
+            {
+                "task_type": "feature",
+                "task_id": "R-005",
+                "state": "active",
+                "active_dev_branch": "refactor/R-005-wrong-type",
+                "base_branch": "main",
+                "checkout_mode": "branch",
+            },
+        ),
+        (
+            "feature",
+            "F-006",
+            "dev/F-006-path-mismatch",
+            {
+                "task_type": "feature",
+                "task_id": "F-007",
+                "state": "active",
+                "active_dev_branch": "dev/F-006-path-mismatch",
+                "base_branch": "main",
+                "checkout_mode": "branch",
+            },
+        ),
+    )
+    for family, directory_id, branch, payload in invalid_records:
+        _git(project, "branch", branch)
+        _write_raw_checkout(project, family, directory_id, payload)
+
+    detector = _load_detector("recovery_workflow_invalid_identity")
+
+    assert detector.detect_candidates(project) == []
+
+
+def test_recovery_workflow_metadata_matches_detector_only_contract():
+    metadata = json.loads((REPO_ROOT / "core" / "skills" / "_metadata.json").read_text())
+    recovery = metadata["skills"]["recovery-workflow"]
+    description = recovery["description"].lower()
+
+    assert recovery["hasScripts"] is True
+    assert "active feature, bugfix, or refactor checkout records" in description
+    assert "operation-first" in description
+    assert "direct requirement" not in description
+
+
+def test_canonical_recovery_and_cli_guidance_has_no_retired_contracts():
+    env_example = (REPO_ROOT / "dev-pipeline" / ".env.example").read_text(encoding="utf-8")
+    readme = (REPO_ROOT / "README.md").read_text(encoding="utf-8")
+    readme_en = (REPO_ROOT / "README_EN.md").read_text(encoding="utf-8")
+
+    assert "cli.py feature run" not in env_example
+    assert "cli.py run feature" in env_example
+    assert "从断点继续" not in readme
+    assert "reset/clean/unskip/complete" not in readme
+    assert "reset/clean/reset_state/complete" in readme
+    assert "Auto-detect + resume from breakpoint" not in readme_en
+    assert "interrupted at Phase 4" not in readme_en
+    assert "Resumes from Phase 5" not in readme_en
+    assert "Does not execute the command or infer a lifecycle phase" in readme_en

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

@@ -110,8 +110,6 @@ def _write_semantic_completion_checkpoint(project_root, artifact_dir, workflow_t
             },
             "repair_rounds": 0,
             "production_changed": False,
-            "review_required": False,
-            "review_scope": None,
             "unresolved_items": [],
         }),
         encoding="utf-8",