prizmkit 1.1.153 → 1.1.155

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",
@@ -306,9 +304,9 @@ def test_preserve_runtime_option_boundaries_and_removed_reset_run_do_not_mutate_
     invalid_cases = [
         (("F-001", "--run"), "no longer accepts --run"),
         (("--preserve-runtime",), "requires --failed"),
-        (("--failed", "--preserve-runtime", "--clean"), "mutually exclusive"),
-        (("F-001", "--failed", "--preserve-runtime"), "cannot target an ID or range"),
-        (("F-001:F-003", "--failed", "--preserve-runtime"), "cannot target an ID or range"),
+        (("--failed", "--preserve-runtime", "--clean"), "Exactly one reset mode"),
+        (("F-001", "--failed", "--preserve-runtime"), "cannot target an ID, range, or --all"),
+        (("F-001:F-003", "--failed", "--preserve-runtime"), "cannot target an ID, range, or --all"),
         (("--failed", "--preserve-runtime", "--stalled"), "Unsupported reset arguments"),
         (("--failed", "--preserve-runtime", "--unknown"), "Unsupported reset arguments"),
     ]
@@ -441,7 +439,7 @@ def test_public_reset_cli_hard_rejects_run_for_every_family_without_state_change
     )
 
     assert completed.returncode == 2
-    assert "Reset no longer accepts --run" in completed.stdout + completed.stderr
+    assert "unrecognized arguments: --run" in completed.stdout + completed.stderr
     assert not (project / ".prizmkit").exists()
 
 
@@ -503,7 +501,7 @@ def test_preserve_runtime_success_quotes_list_path_in_separate_run_instruction(t
     result = run_reset_command("feature", ("--failed", "--preserve-runtime"), paths)
 
     assert result.exit_code == 0
-    assert f"feature run {shlex.quote(str(plan.resolve()))}" in result.render()
+    assert f"run feature {shlex.quote(str(plan.resolve()))}" in result.render()
 
 
 def test_preserve_runtime_requires_recorded_base_to_be_a_local_branch(tmp_path):

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

@@ -0,0 +1,608 @@
+"""Tests for runtime-owned local commit execution and finalization."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from prizmkit_runtime.checkpoint_state import load_checkpoint_state
+from prizmkit_runtime.runtime_commit import finalize_runtime_commit
+
+
+def _git(root: Path, *args: str) -> str:
+    completed = subprocess.run(
+        ["git", *args],
+        cwd=root,
+        check=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+    )
+    return completed.stdout.strip()
+
+
+def _init_repo(root: Path) -> str:
+    _git(root, "init")
+    _git(root, "config", "user.email", "runtime@example.invalid")
+    _git(root, "config", "user.name", "Runtime Test")
+    (root / "tracked.txt").write_text("before\n", encoding="utf-8")
+    (root / ".gitignore").write_text(".prizmkit/\n", encoding="utf-8")
+    _git(root, "add", "tracked.txt", ".gitignore")
+    _git(root, "commit", "-m", "initial")
+    return _git(root, "rev-parse", "HEAD")
+
+
+def _write_test_artifacts(artifact_dir: Path) -> None:
+    artifact_dir.mkdir(parents=True, exist_ok=True)
+    for filename in ("context-snapshot.md", "spec.md", "plan.md"):
+        (artifact_dir / filename).write_text(f"# {filename}\n", encoding="utf-8")
+    (artifact_dir / "review-report.md").write_text(
+        "# Review Report\n\n## Final Result\n\n- Verdict: PASS\n",
+        encoding="utf-8",
+    )
+    (artifact_dir / "test-report.md").write_text(
+        "# Test Report\n\n## Final Result\n\n- Result: TEST_PASS\n",
+        encoding="utf-8",
+    )
+    (artifact_dir / "test-result.json").write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "result": "TEST_PASS",
+                "report": "test-report.md",
+                "main_review_rounds": 1,
+                "independent_review": {
+                    "status": "downgraded",
+                    "responses": 0,
+                    "downgrade_reason": "no eligible reviewer",
+                    "final_state_rechecked": False,
+                },
+                "repair_rounds": 0,
+                "production_changed": False,
+                        "unresolved_items": [],
+            }
+        ),
+        encoding="utf-8",
+    )
+    (artifact_dir / "completion-summary.json").write_text(
+        '{"completion_notes":["Runtime commit fixture"]}\n', encoding="utf-8"
+    )
+    (artifact_dir / "retrospective-result.json").write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "outcome": "RETRO_COMPLETE",
+                "result": "NO_DOC_CHANGE",
+                "reason": "No durable documentation change in fixture",
+                "change_paths": ["tracked.txt"],
+                "documentation_paths": [],
+                "validation": [],
+            }
+        ),
+        encoding="utf-8",
+    )
+
+
+def _write_commit_ready_checkpoint(root: Path) -> tuple[Path, Path]:
+    artifact_dir = root / ".prizmkit" / "specs" / "001-runtime-commit"
+    _write_test_artifacts(artifact_dir)
+    skills = [
+        "context-snapshot-and-plan",
+        "prizmkit-implement",
+        "prizmkit-code-review",
+        "prizmkit-test",
+        "completion-summary",
+        "prizmkit-retrospective",
+        "prizmkit-committer",
+    ]
+    steps = []
+    previous = None
+    for index, skill in enumerate(skills, start=1):
+        status = "in_progress" if skill == "prizmkit-committer" else "completed"
+        step = {
+            "id": f"S{index:02d}",
+            "skill": skill,
+            "name": skill,
+            "status": status,
+            "required_artifacts": [],
+            "depends_on": previous,
+        }
+        if skill == "context-snapshot-and-plan":
+            step["stage_result"] = "PLAN_READY"
+            step["required_artifacts"] = [
+                ".prizmkit/specs/001-runtime-commit/context-snapshot.md",
+                ".prizmkit/specs/001-runtime-commit/spec.md",
+                ".prizmkit/specs/001-runtime-commit/plan.md",
+            ]
+        elif skill == "prizmkit-implement":
+            step["stage_result"] = "IMPLEMENTED"
+        elif skill == "prizmkit-code-review":
+            step["stage_result"] = "REVIEW_PASS"
+            step["required_artifacts"] = [
+                ".prizmkit/specs/001-runtime-commit/review-report.md"
+            ]
+        elif skill == "prizmkit-test":
+            step["stage_result"] = "TEST_PASS"
+            step["required_artifacts"] = [
+                ".prizmkit/specs/001-runtime-commit/test-report.md",
+                ".prizmkit/specs/001-runtime-commit/test-result.json",
+            ]
+        elif skill == "completion-summary":
+            step["required_artifacts"] = [
+                ".prizmkit/specs/001-runtime-commit/completion-summary.json"
+            ]
+        elif skill == "prizmkit-retrospective":
+            step["stage_result"] = "RETRO_COMPLETE"
+            step["required_artifacts"] = [
+                ".prizmkit/specs/001-runtime-commit/retrospective-result.json"
+            ]
+        elif skill == "prizmkit-committer":
+            step["stage_result"] = "COMMIT_PENDING"
+            step["required_artifacts"] = [
+                ".prizmkit/specs/001-runtime-commit/runtime-commit-request.json"
+            ]
+        steps.append(step)
+        previous = step["id"]
+    checkpoint = {
+        "version": 1,
+        "workflow_type": "feature-pipeline",
+        "item_id": "F-001",
+        "item_slug": "001-runtime-commit",
+        "session_id": "session-1",
+        "steps": steps,
+        "feature_state": {
+            "schema_version": 1,
+            "artifact_dir": ".prizmkit/specs/001-runtime-commit",
+            "orchestrator": "pipeline-runtime",
+            "stage": "committer",
+            "current_stage": "prizmkit-committer",
+            "status": "in_progress",
+            "stage_result": "COMMIT_PENDING",
+            "repair_round": 0,
+            "next_stage": "prizmkit-committer",
+            "terminal_status": None,
+        },
+    }
+    checkpoint_path = artifact_dir / "workflow-checkpoint.json"
+    checkpoint_path.write_text(json.dumps(checkpoint), encoding="utf-8")
+    return artifact_dir, checkpoint_path
+
+
+def _write_request(root: Path, artifact_dir: Path, base_head: str, paths: list[str]) -> Path:
+    request_path = artifact_dir / "runtime-commit-request.json"
+    request_path.write_text(
+        json.dumps(
+            {
+                "schema_version": 1,
+                "artifact_dir": artifact_dir.relative_to(root).as_posix(),
+                "base_head": base_head,
+                "commit_message": "fix(runtime): finalize prepared task",
+                "intended_paths": paths,
+            }
+        ),
+        encoding="utf-8",
+    )
+    return request_path
+
+
+def test_runtime_commit_executes_exact_request_and_finalizes_only_checkpoint(tmp_path):
+    base_head = _init_repo(tmp_path)
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    caller_state = tmp_path / ".prizmkit" / "state" / "workflows" / "caller.json"
+    caller_state.parent.mkdir(parents=True, exist_ok=True)
+    caller_state.write_text('{"owner":"external-coordinator"}\n', encoding="utf-8")
+    expected_caller_state = caller_state.read_bytes()
+    (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
+    _write_request(tmp_path, artifact_dir, base_head, ["tracked.txt"])
+
+    result = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert result.status == "committed"
+    assert result.commit_hash == _git(tmp_path, "rev-parse", "HEAD")
+    assert _git(tmp_path, "log", "-1", "--pretty=%s") == "fix(runtime): finalize prepared task"
+    checkpoint = json.loads(checkpoint_path.read_text(encoding="utf-8"))
+    committer = next(step for step in checkpoint["steps"] if step["skill"] == "prizmkit-committer")
+    assert committer["status"] == "completed"
+    assert committer["stage_result"] == "COMMITTED"
+    assert checkpoint["feature_state"]["terminal_status"] == "WORKFLOW_COMPLETED"
+    assert checkpoint["feature_state"]["runtime_base_head"] == base_head
+    assert checkpoint["feature_state"]["runtime_commit_hash"] == result.commit_hash
+    assert caller_state.read_bytes() == expected_caller_state
+    assert not (artifact_dir / "runtime-commit-request.json").exists()
+    assert load_checkpoint_state(
+        checkpoint_path,
+        project_root=tmp_path,
+    ).semantic_complete is True
+
+
+@pytest.mark.parametrize(
+    "durable_path",
+    [
+        ".prizmkit/config.json",
+        ".prizmkit/prizm-docs/src/counter.prizm",
+    ],
+)
+def test_runtime_commit_excludes_tracked_prizmkit_internal_paths(tmp_path, durable_path):
+    _init_repo(tmp_path)
+    durable = tmp_path / durable_path
+    durable.parent.mkdir(parents=True, exist_ok=True)
+    durable.write_text("before\n", encoding="utf-8")
+    _git(tmp_path, "add", "-f", durable_path)
+    _git(tmp_path, "commit", "-m", "track durable PrizmKit project data")
+    base_head = _git(tmp_path, "rev-parse", "HEAD")
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
+    durable.write_text("after\n", encoding="utf-8")
+    _write_request(tmp_path, artifact_dir, base_head, ["tracked.txt"])
+
+    result = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert result.status == "committed", result
+    assert _git(
+        tmp_path,
+        "diff-tree",
+        "--no-commit-id",
+        "--name-only",
+        "-r",
+        "HEAD",
+    ) == "tracked.txt"
+    assert durable.read_text(encoding="utf-8") == "after\n"
+    assert durable_path in _git(
+        tmp_path,
+        "status",
+        "--short",
+        "--untracked-files=all",
+    )
+
+
+def test_runtime_commit_ignores_runner_support_paths_but_leaves_them_unmodified(tmp_path):
+    base_head = _init_repo(tmp_path)
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
+    (tmp_path / "AGENTS.md").write_text("@./AGENTS.private.md\n", encoding="utf-8")
+    codex_config = tmp_path / ".codex" / "config.toml"
+    codex_config.parent.mkdir()
+    codex_config.write_text("[project]\ntrusted = true\n", encoding="utf-8")
+    _write_request(tmp_path, artifact_dir, base_head, ["tracked.txt"])
+
+    result = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert result.status == "committed"
+    assert _git(tmp_path, "diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD") == "tracked.txt"
+    assert (tmp_path / "AGENTS.md").read_text(encoding="utf-8") == "@./AGENTS.private.md\n"
+    assert codex_config.read_text(encoding="utf-8") == "[project]\ntrusted = true\n"
+    untracked = set(_git(tmp_path, "ls-files", "--others", "--exclude-standard").splitlines())
+    assert {"AGENTS.md", ".codex/config.toml"}.issubset(untracked)
+
+
+def test_runtime_commit_allows_task_path_adjacent_to_internal_namespace(tmp_path):
+    base_head = _init_repo(tmp_path)
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    adjacent_path = tmp_path / ".prizmkitx" / "task.txt"
+    adjacent_path.parent.mkdir()
+    adjacent_path.write_text("task-owned\n", encoding="utf-8")
+    _write_request(tmp_path, artifact_dir, base_head, [".prizmkitx/task.txt"])
+
+    result = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert result.status == "committed"
+    assert _git(tmp_path, "diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD") == ".prizmkitx/task.txt"
+
+
+def test_runtime_commit_ignores_project_gitignored_transient_data(tmp_path):
+    _init_repo(tmp_path)
+    gitignore = tmp_path / ".gitignore"
+    gitignore.write_text(gitignore.read_text(encoding="utf-8") + "tmp/\n", encoding="utf-8")
+    _git(tmp_path, "add", ".gitignore")
+    _git(tmp_path, "commit", "-m", "ignore project transient data")
+    base_head = _git(tmp_path, "rev-parse", "HEAD")
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
+    transient = tmp_path / "tmp" / "tool-cache.json"
+    transient.parent.mkdir()
+    transient.write_text('{"cache":true}\n', encoding="utf-8")
+    _write_request(tmp_path, artifact_dir, base_head, ["tracked.txt"])
+
+    result = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert result.status == "committed"
+    assert _git(tmp_path, "diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD") == "tracked.txt"
+    assert transient.read_text(encoding="utf-8") == '{"cache":true}\n'
+
+
+def test_runtime_commit_rejects_unlisted_git_visible_change(tmp_path):
+    base_head = _init_repo(tmp_path)
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
+    (tmp_path / "unexpected.txt").write_text("unexpected\n", encoding="utf-8")
+    _write_request(tmp_path, artifact_dir, base_head, ["tracked.txt"])
+
+    result = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert result.status == "failed"
+    assert result.reason == "intended_paths_mismatch"
+    assert _git(tmp_path, "rev-parse", "HEAD") == base_head
+
+
+def test_runtime_commit_recovers_commit_created_before_state_finalization(tmp_path):
+    base_head = _init_repo(tmp_path)
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
+    _write_request(tmp_path, artifact_dir, base_head, ["tracked.txt"])
+    _git(tmp_path, "add", "tracked.txt")
+    _git(tmp_path, "commit", "-m", "fix(runtime): finalize prepared task")
+    committed_head = _git(tmp_path, "rev-parse", "HEAD")
+
+    result = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert result.status == "committed"
+    assert result.commit_hash == committed_head
+    assert result.recovered is True
+    assert _git(tmp_path, "rev-list", "--count", f"{base_head}..HEAD") == "1"
+
+
+def test_runtime_commit_recovers_after_checkpoint_finalization_failure(tmp_path, monkeypatch):
+    import prizmkit_runtime.runtime_commit as runtime_commit
+
+    base_head = _init_repo(tmp_path)
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
+    request_path = _write_request(
+        tmp_path, artifact_dir, base_head, ["tracked.txt"]
+    )
+
+    original_finalize = runtime_commit._finalize_checkpoint
+    monkeypatch.setattr(
+        runtime_commit,
+        "_finalize_checkpoint",
+        lambda _path, **_kwargs: "checkpoint_commit_finalization_failed",
+    )
+    first = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert first.status == "failed"
+    assert first.reason == "checkpoint_commit_finalization_failed"
+    committed_head = _git(tmp_path, "rev-parse", "HEAD")
+    request = json.loads(request_path.read_text(encoding="utf-8"))
+    assert request["runtime_commit_hash"] == committed_head
+
+    monkeypatch.setattr(runtime_commit, "_finalize_checkpoint", original_finalize)
+    second = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert second.status == "committed"
+    assert second.recovered is True
+    assert second.commit_hash == committed_head
+    assert _git(tmp_path, "rev-list", "--count", f"{base_head}..HEAD") == "1"
+
+
+def test_runtime_commit_recovers_cleanup_after_completed_checkpoint(tmp_path, monkeypatch):
+    base_head = _init_repo(tmp_path)
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
+    request_path = _write_request(
+        tmp_path, artifact_dir, base_head, ["tracked.txt"]
+    )
+
+    original_unlink = Path.unlink
+
+    def fail_request_cleanup(path, *args, **kwargs):
+        if path == request_path:
+            raise OSError("simulated cleanup failure")
+        return original_unlink(path, *args, **kwargs)
+
+    monkeypatch.setattr(Path, "unlink", fail_request_cleanup)
+    first = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert first.status == "failed"
+    assert first.reason == "commit_request_cleanup_failed"
+    assert request_path.is_file()
+
+    monkeypatch.setattr(Path, "unlink", original_unlink)
+    second = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert second.status == "committed"
+    assert second.recovered is True
+    assert not request_path.exists()
+    assert _git(tmp_path, "rev-list", "--count", f"{base_head}..HEAD") == "1"
+
+
+def test_runtime_commit_disables_repository_hooks(tmp_path):
+    base_head = _init_repo(tmp_path)
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    hook = tmp_path / ".git" / "hooks" / "pre-commit"
+    hook.write_text(
+        "#!/bin/sh\nprintf 'hook mutation\\n' > hook-output.txt\ngit add hook-output.txt\n",
+        encoding="utf-8",
+    )
+    hook.chmod(0o755)
+    (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
+    _write_request(tmp_path, artifact_dir, base_head, ["tracked.txt"])
+
+    result = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert result.status == "committed"
+    assert not (tmp_path / "hook-output.txt").exists()
+    assert _git(tmp_path, "diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD") == "tracked.txt"
+
+
+def test_runtime_commit_handles_rename_as_exact_delete_and_add(tmp_path):
+    _init_repo(tmp_path)
+    old_path = tmp_path / "old-name.txt"
+    old_path.write_text("rename me\n", encoding="utf-8")
+    _git(tmp_path, "add", "old-name.txt")
+    _git(tmp_path, "commit", "-m", "add rename source")
+    base_head = _git(tmp_path, "rev-parse", "HEAD")
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    old_path.rename(tmp_path / "new-name.txt")
+    _write_request(
+        tmp_path,
+        artifact_dir,
+        base_head,
+        ["old-name.txt", "new-name.txt"],
+    )
+
+    result = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert result.status == "committed"
+    changed = _git(
+        tmp_path,
+        "diff-tree",
+        "--no-commit-id",
+        "--name-only",
+        "--no-renames",
+        "-r",
+        "HEAD",
+    ).splitlines()
+    assert set(changed) == {"old-name.txt", "new-name.txt"}
+
+
+@pytest.mark.parametrize(
+    "unsafe_path",
+    [
+        "../escape.txt",
+        ".git/config",
+        ".env",
+        "AGENTS.md",
+        "skills-lock.json",
+        ".codex/config.toml",
+        ".CLAUDE/settings.local.json",
+        ".prizmkit/config.json",
+        ".prizmkit/prizm-docs/src/counter.prizm",
+        ".prizmkit/state/runtime.json",
+        ".prizmkit/dev-pipeline/cli.py",
+        ".prizmkit/scripts/helper.py",
+        ".prizmkit/manifest.json",
+        ".prizmkit/specs/001-runtime-commit/workflow-checkpoint.json",
+        ".prizmkit/specs/001-runtime-commit/runtime-commit-request.json",
+    ],
+)
+def test_runtime_commit_rejects_unsafe_intended_paths(tmp_path, unsafe_path):
+    base_head = _init_repo(tmp_path)
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
+    _write_request(tmp_path, artifact_dir, base_head, [unsafe_path])
+
+    result = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert result.status == "failed"
+    assert result.reason == "commit_request_path_unsafe"
+    assert _git(tmp_path, "rev-parse", "HEAD") == base_head
+
+
+def test_runtime_commit_rejects_caller_orchestration_fields(tmp_path):
+    base_head = _init_repo(tmp_path)
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
+    request_path = _write_request(
+        tmp_path, artifact_dir, base_head, ["tracked.txt"]
+    )
+    request = json.loads(request_path.read_text(encoding="utf-8"))
+    request["caller_state_path"] = ".runtime/caller-state.json"
+    request_path.write_text(json.dumps(request), encoding="utf-8")
+
+    result = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert result.status == "failed"
+    assert result.reason == "commit_request_invalid_schema"
+    assert _git(tmp_path, "rev-parse", "HEAD") == base_head
+
+
+def test_runtime_commit_rejects_ai_supplied_premature_runtime_hash(tmp_path):
+    base_head = _init_repo(tmp_path)
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
+    request_path = _write_request(
+        tmp_path, artifact_dir, base_head, ["tracked.txt"]
+    )
+    request = json.loads(request_path.read_text(encoding="utf-8"))
+    request["runtime_commit_hash"] = "a" * 40
+    request_path.write_text(json.dumps(request), encoding="utf-8")
+
+    result = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert result.status == "failed"
+    assert result.reason == "premature_runtime_commit_hash"
+    assert _git(tmp_path, "rev-parse", "HEAD") == base_head
+
+
+def test_runtime_commit_rejects_stale_base_head(tmp_path):
+    base_head = _init_repo(tmp_path)
+    artifact_dir, checkpoint_path = _write_commit_ready_checkpoint(tmp_path)
+    (tmp_path / "tracked.txt").write_text("after\n", encoding="utf-8")
+    _write_request(tmp_path, artifact_dir, "a" * 40, ["tracked.txt"])
+
+    result = finalize_runtime_commit(
+        tmp_path,
+        artifact_dir=artifact_dir,
+        checkpoint_path=checkpoint_path,
+    )
+
+    assert result.status == "failed"
+    assert result.reason == "base_head_mismatch"
+    assert _git(tmp_path, "rev-parse", "HEAD") == base_head