prizmkit 1.1.128 → 1.1.129

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

@@ -1408,7 +1408,8 @@ def test_default_no_worktree_preserves_main_worktree_branch_launch(monkeypatch,
             lifecycle_order.append("branch_create")
             branch_events.append(("create", plan.commands[1].args[2]))
         if plan.name == "branch_merge":
-            branch_events.append(("merge", plan.commands[5].args[2]))
+            merge_command = next(command for command in plan.commands if command.args[:2] == ("merge", "--ff-only"))
+            branch_events.append(("merge", merge_command.args[2]))
         return SimpleNamespace(ok=True, plan=plan, results=())
 
     def fake_start_item(*args, **kwargs):
@@ -1603,6 +1604,79 @@ def test_worktree_recovers_completed_pending_branch_from_base_session_history(mo
     assert merge_calls and cleanup_calls[-1][1] is True
 
 
+def test_success_final_commit_failure_preserves_checkout_without_merge(monkeypatch, tmp_path):
+    from prizmkit_runtime import runners
+    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-finalize-fail")
+    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)
+    merge_calls = []
+
+    monkeypatch.setattr(
+        runners,
+        "commit_final_bookkeeping",
+        lambda *args, **kwargs: SimpleNamespace(ok=False, attempted=True, committed=False),
+    )
+    monkeypatch.setattr(
+        runners,
+        "commit_task_branch_changes",
+        lambda *args, **kwargs: SimpleNamespace(ok=True, attempted=False, committed=False),
+    )
+    monkeypatch.setattr(
+        runners,
+        "run_git_plan",
+        lambda root, plan: merge_calls.append(plan.name) or SimpleNamespace(ok=True, plan=plan, results=()),
+    )
+
+    status = runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
+
+    assert status == "completed"
+    assert "branch_merge" not in merge_calls
+    checkout = load_task_checkout(family.state_dir, family.task_type, "F-001")
+    assert checkout is not None and checkout.is_active
+    session_status = paths.feature_state_dir / "F-001" / "sessions" / "F-001-session-1" / "session-status.json"
+    assert json.loads(session_status.read_text(encoding="utf-8"))["status"] == "merge_conflict"
+
+
+def test_wip_commit_failure_skips_base_return(monkeypatch, tmp_path):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    monkeypatch.setenv("DEV_BRANCH", "dev/F-001-wip-fail")
+    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, statuses=("crashed",), update_status="failed")
+    returns = []
+
+    monkeypatch.setattr(
+        runners,
+        "commit_wip_changes",
+        lambda *args, **kwargs: SimpleNamespace(ok=False, attempted=True, committed=False),
+    )
+    monkeypatch.setattr(
+        runners,
+        "branch_ensure_return",
+        lambda *args, **kwargs: returns.append(args) or SimpleNamespace(ok=True),
+    )
+    monkeypatch.setattr(
+        runners,
+        "run_git_plan",
+        lambda root, plan: SimpleNamespace(ok=True, plan=plan, results=()),
+    )
+
+    status = runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
+
+    assert status == "failed"
+    assert returns == []
+
+
 def test_default_branch_names_keep_timestamp_for_each_runner_family(monkeypatch, tmp_path):
     from prizmkit_runtime import runners
     from prizmkit_runtime.runner_models import family_for
@@ -1752,7 +1826,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 (Tier 3 — Orchestrator + Reviewer)" in captured.err
+    assert "Pipeline mode: full (Tier 3 — Main-Agent Full Guardrails)" in captured.err
     assert "Agents: 3" in captured.err
     assert "Spawning AI CLI session: F-001-session-1" in captured.err
     assert "Session result: success" in captured.err
@@ -2098,24 +2172,27 @@ def test_preflight_ready_commit_includes_tracked_state_but_excludes_untracked_st
     assert untracked_state.relative_to(tmp_path).as_posix() not in _head_files(tmp_path)
 
 
-def test_preflight_ready_commit_includes_tracked_framework_support_but_excludes_untracked_support_and_state(tmp_path):
+def test_preflight_ready_commit_excludes_tracked_framework_manifest_but_preserves_other_tracked_support(tmp_path):
     from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
 
     _init_bookkeeping_repo(tmp_path)
+    manifest_path = tmp_path / ".prizmkit" / "manifest.json"
     tracked_support_paths = [
-        tmp_path / ".prizmkit" / "manifest.json",
         tmp_path / ".prizmkit" / "dev-pipeline" / "prizmkit_runtime" / "runners.py",
         tmp_path / ".claude" / "commands" / "prizmkit.md",
     ]
+    manifest_path.parent.mkdir(parents=True, exist_ok=True)
+    manifest_path.write_text('{"version":"1.1.127"}\n', encoding="utf-8")
     for path in tracked_support_paths:
         path.parent.mkdir(parents=True, exist_ok=True)
         path.write_text("installed\n", encoding="utf-8")
     subprocess.run(
-        ["git", "add", *(path.relative_to(tmp_path).as_posix() for path in tracked_support_paths)],
+        ["git", "add", manifest_path.relative_to(tmp_path).as_posix(), *(path.relative_to(tmp_path).as_posix() for path in tracked_support_paths)],
         cwd=tmp_path,
         check=True,
     )
     subprocess.run(["git", "commit", "-m", "track support"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    manifest_path.write_text('{"version":"1.1.128"}\n', encoding="utf-8")
     for path in tracked_support_paths:
         path.write_text("upgraded\n", encoding="utf-8")
 
@@ -2129,19 +2206,23 @@ def test_preflight_ready_commit_includes_tracked_framework_support_but_excludes_
         path.write_text("transient\n", encoding="utf-8")
 
     result = commit_preflight_ready_changes(tmp_path, "B-001")
-    committed_files = _head_files(tmp_path)
 
-    assert result.committed is True
-    assert {path.relative_to(tmp_path).as_posix() for path in tracked_support_paths}.issubset(committed_files)
-    assert not {path.relative_to(tmp_path).as_posix() for path in untracked_support_paths}.intersection(committed_files)
-    assert _head_message(tmp_path) == "chore: ready for B-001"
+    assert result.attempted is True
+    assert result.committed is False
+    assert result.result is not None
+    assert "installer-owned .prizmkit/manifest.json" in result.result.stderr
+    assert _head_message(tmp_path) == "track support"
     assert subprocess.run(
         ["git", "status", "--short", "--untracked-files=no"],
         cwd=tmp_path,
         check=True,
         stdout=subprocess.PIPE,
         text=True,
-    ).stdout == ""
+    ).stdout.splitlines() == [
+        " M .claude/commands/prizmkit.md",
+        " M .prizmkit/dev-pipeline/prizmkit_runtime/runners.py",
+        " M .prizmkit/manifest.json",
+    ]
 
 
 def test_preflight_ready_commit_excludes_untracked_support_assets_and_state(tmp_path):
@@ -2176,6 +2257,53 @@ def test_preflight_ready_commit_excludes_untracked_support_assets_and_state(tmp_
     assert ".claude" in hidden_status or ".prizmkit/state" in hidden_status
 
 
+def test_preflight_ready_commit_rejects_unmerged_index(tmp_path):
+    from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
+
+    _init_bookkeeping_repo(tmp_path)
+    subprocess.run(["git", "checkout", "-b", "other"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "staged.txt").write_text("other\n", encoding="utf-8")
+    subprocess.run(["git", "commit", "-am", "other"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "checkout", "main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "staged.txt").write_text("main\n", encoding="utf-8")
+    subprocess.run(["git", "commit", "-am", "main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "merge", "other"], cwd=tmp_path, check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    before_count = _head_commit_count(tmp_path)
+
+    result = commit_preflight_ready_changes(tmp_path, "F-126")
+
+    assert result.attempted is True
+    assert result.committed is False
+    assert result.result is not None
+    assert "unmerged Git paths" in result.result.stderr
+    assert _head_commit_count(tmp_path) == before_count
+
+
+def test_preflight_ready_commit_rejects_conflict_markers_and_malformed_manifest(tmp_path):
+    from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
+
+    _init_bookkeeping_repo(tmp_path)
+    (tmp_path / "unstaged.txt").write_text("<<<<<<< Updated upstream\ncurrent\n=======\nstashed\n>>>>>>> Stashed changes\n", encoding="utf-8")
+
+    marker_result = commit_preflight_ready_changes(tmp_path, "F-127")
+
+    assert marker_result.committed is False
+    assert marker_result.result is not None
+    assert "unresolved conflict markers" in marker_result.result.stderr
+
+    (tmp_path / "unstaged.txt").write_text("safe\n", encoding="utf-8")
+    manifest = tmp_path / ".prizmkit" / "manifest.json"
+    manifest.parent.mkdir(parents=True, exist_ok=True)
+    manifest.write_text("<<<<<<< Updated upstream\n{}\n", encoding="utf-8")
+
+    manifest_result = commit_preflight_ready_changes(tmp_path, "F-128")
+
+    assert manifest_result.committed is False
+    assert manifest_result.result is not None
+    assert ".prizmkit/manifest.json" in manifest_result.result.stderr
+    assert "valid JSON" in manifest_result.result.stderr
+
+
 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
 

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

@@ -2,6 +2,7 @@
 
 import json
 import os
+import re
 import shutil
 import subprocess
 import sys
@@ -830,7 +831,8 @@ def test_headless_review_guidance_uses_main_agent_review_loop():
         assert "Main-Agent review loop" in text, path
         assert "up to ten completed rounds" in text, path
         assert "text final-verdict" in text, path
-        assert "code-review-specific subagent" in text, path
+        assert "The current Main Agent is the only Code Review executor" in text, path
+        assert "Do not invoke another review skill or review workflow" in text, path
         assert "low=0" not in text and "Reviewer 3" not in text, path
         assert "REVIEW_BLOCKED" not in text, path
         assert "forced-worktree changed-content fallback" not in text, path
@@ -947,10 +949,11 @@ def test_progress_parser_normalizes_codebuddy_agent_tools_with_deduplication():
 
     assert data["cb_session_id"] == "cb-session"
     assert data["subagent_provider"] == "codebuddy"
-    assert data["subagent_spawn_count"] == 2
-    assert data["active_subagent_count"] == 2
+    assert data["subagent_spawn_count"] == 1
+    assert data["active_subagent_count"] == 1
     assert {item["status"] for item in data["subagent_states"]} == {"running"}
-    assert len(data["subagent_statistics"]["records"]) == 2
+    assert len(data["subagent_statistics"]["records"]) == 1
+    assert data["subagent_statistics"]["records"][0]["metadata"]["tool"] == "Agent"
 
 
 def test_progress_parser_normalizes_codex_collab_metadata_with_missing_fields():
@@ -1827,14 +1830,18 @@ def test_git_branch_worktree_plans_preserve_shell_invariants(tmp_path):
 
     assert create.name == "branch_create"
     assert any(command.args[:2] == ("checkout", "-b") for command in create.commands)
-    assert any(command.args[:2] == ("stash", "push") for command in merge.commands)
+    assert not any(command.args and command.args[0] == "stash" for command in merge.commands)
+    assert any(command.args[:2] == ("status", "--porcelain") for command in merge.commands)
     assert any(command.args[:2] == ("merge", "--ff-only") for command in merge.commands)
-    assert any(command.args == ("push",) for command in merge.commands)
-    assert save_wip.never_fails is True
-    assert ensure.never_fails is True
+    push_index = next(index for index, command in enumerate(merge.commands) if command.args == ("push",))
+    merge_index = next(index for index, command in enumerate(merge.commands) if command.args[:2] == ("merge", "--ff-only"))
+    assert merge_index < push_index
+    assert save_wip.never_fails is False
+    assert ensure.never_fails is False
     assert any(command.args[:2] == ("rebase", "--abort") for command in ensure.commands)
     assert any(command.args[:2] == ("add", "-A") for command in ensure.commands)
-    assert not any(command.args[:2] == ("stash", "pop") for command in ensure.commands)
+    assert not any(command.args and command.args[0] == "stash" for command in ensure.commands)
+    assert ensure.never_fails is False
     assert any(".*/worktrees/**" in " ".join(command.args) for command in save_wip.commands)
     assert worktree.commands[0].args[:2] == ("worktree", "add")
 
@@ -1862,6 +1869,205 @@ def test_git_branch_worktree_plans_preserve_shell_invariants(tmp_path):
     assert skipped_wip.results == ()
 
 
+def test_runtime_source_constructs_no_git_stash_commands():
+    runtime = Path("dev-pipeline/prizmkit_runtime")
+    matches = []
+    for path in runtime.glob("*.py"):
+        text = path.read_text(encoding="utf-8")
+        if re.search(r'["\']stash["\']', text):
+            matches.append(path.as_posix())
+
+    assert matches == []
+
+
+def _init_merge_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)
+    manifest = project_root / ".prizmkit" / "manifest.json"
+    manifest.parent.mkdir(parents=True)
+    manifest.write_text('{"version":"current"}\n', encoding="utf-8")
+    (project_root / "app.txt").write_text("base\n", encoding="utf-8")
+    subprocess.run(["git", "add", "."], cwd=project_root, check=True)
+    subprocess.run(["git", "commit", "-m", "base"], cwd=project_root, check=True, stdout=subprocess.DEVNULL)
+
+
+def _stash_oids(project_root):
+    output = subprocess.run(
+        ["git", "stash", "list", "--format=%H"],
+        cwd=project_root,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout
+    return tuple(line for line in output.splitlines() if line)
+
+
+def test_branch_merge_preserves_preexisting_stash_when_workspace_is_clean(tmp_path):
+    from prizmkit_runtime.gitops import BranchContext, branch_merge_plan, run_git_plan
+
+    _init_merge_repo(tmp_path)
+    manifest = tmp_path / ".prizmkit" / "manifest.json"
+    manifest.write_text('{"version":"stale"}\n', encoding="utf-8")
+    subprocess.run(["git", "stash", "push", "-m", "stale-install", "--", ".prizmkit/manifest.json"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    stale_stashes = _stash_oids(tmp_path)
+    subprocess.run(["git", "checkout", "-b", "dev/example"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "feature.txt").write_text("done\n", encoding="utf-8")
+    subprocess.run(["git", "add", "feature.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "feature"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+
+    result = run_git_plan(
+        tmp_path,
+        branch_merge_plan(BranchContext("main", "dev/example", tmp_path)),
+    )
+
+    assert result.ok is True
+    assert _stash_oids(tmp_path) == stale_stashes
+    assert json.loads(manifest.read_text(encoding="utf-8"))["version"] == "current"
+    assert (tmp_path / "feature.txt").read_text(encoding="utf-8") == "done\n"
+
+
+def test_branch_merge_rejects_dirty_task_checkout_without_touching_stashes(tmp_path):
+    from prizmkit_runtime.gitops import BranchContext, branch_merge_plan, run_git_plan
+
+    _init_merge_repo(tmp_path)
+    manifest = tmp_path / ".prizmkit" / "manifest.json"
+    manifest.write_text('{"version":"stale"}\n', encoding="utf-8")
+    subprocess.run(["git", "stash", "push", "-m", "user-stash", "--", ".prizmkit/manifest.json"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    stale_stashes = _stash_oids(tmp_path)
+    subprocess.run(["git", "checkout", "-b", "dev/example"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "feature.txt").write_text("done\n", encoding="utf-8")
+    subprocess.run(["git", "add", "feature.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "feature"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "app.txt").write_text("local visible change\n", encoding="utf-8")
+
+    result = run_git_plan(
+        tmp_path,
+        branch_merge_plan(BranchContext("main", "dev/example", tmp_path)),
+    )
+
+    assert result.ok is False
+    assert _stash_oids(tmp_path) == stale_stashes
+    assert (tmp_path / "app.txt").read_text(encoding="utf-8") == "local visible change\n"
+    assert json.loads(manifest.read_text(encoding="utf-8"))["version"] == "current"
+    assert subprocess.run(
+        ["git", "branch", "--show-current"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.strip() == "dev/example"
+
+
+def test_branch_merge_rebases_committed_task_without_stash_restore_conflict(tmp_path):
+    from prizmkit_runtime.gitops import BranchContext, branch_merge_plan, run_git_plan
+
+    _init_merge_repo(tmp_path)
+    subprocess.run(["git", "checkout", "-b", "dev/example"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "feature.txt").write_text("done\n", encoding="utf-8")
+    subprocess.run(["git", "add", "feature.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "feature"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "checkout", "main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "app.txt").write_text("main changed\n", encoding="utf-8")
+    subprocess.run(["git", "commit", "-am", "advance main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "checkout", "dev/example"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+
+    result = run_git_plan(
+        tmp_path,
+        branch_merge_plan(BranchContext("main", "dev/example", tmp_path)),
+    )
+
+    assert result.ok is True
+    assert _stash_oids(tmp_path) == ()
+    assert (tmp_path / "app.txt").read_text(encoding="utf-8") == "main changed\n"
+    assert subprocess.run(
+        ["git", "branch", "--show-current"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.strip() == "main"
+
+
+def test_branch_return_commits_wip_without_touching_user_stashes(tmp_path):
+    from prizmkit_runtime.gitops import branch_ensure_return
+
+    _init_merge_repo(tmp_path)
+    manifest = tmp_path / ".prizmkit" / "manifest.json"
+    manifest.write_text('{"version":"stale"}\n', encoding="utf-8")
+    subprocess.run(["git", "stash", "push", "-m", "user-stash", "--", ".prizmkit/manifest.json"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    user_stashes = _stash_oids(tmp_path)
+    subprocess.run(["git", "checkout", "-b", "dev/interrupted"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "app.txt").write_text("interrupted work\n", encoding="utf-8")
+
+    result = branch_ensure_return(tmp_path, "main", "dev/interrupted")
+
+    assert result.ok is True
+    assert _stash_oids(tmp_path) == user_stashes
+    assert subprocess.run(
+        ["git", "branch", "--show-current"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True,
+    ).stdout.strip() == "main"
+    assert subprocess.run(
+        ["git", "show", "dev/interrupted:app.txt"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True,
+    ).stdout == "interrupted work\n"
+
+
+def test_branch_return_commit_failure_does_not_checkout_base(monkeypatch, tmp_path):
+    from prizmkit_runtime import gitops
+
+    calls = []
+
+    def fake_run(_root, args):
+        args = tuple(args)
+        calls.append(args)
+        if args[:3] == ("rev-parse", "--abbrev-ref", "HEAD"):
+            return gitops.GitCommandResult(args, 0, "dev/interrupted\n", "")
+        if args and args[0] == "commit":
+            return gitops.GitCommandResult(args, 1, "", "commit failed")
+        if args[:2] == ("status", "--porcelain"):
+            return gitops.GitCommandResult(args, 0, " M app.txt\n", "")
+        return gitops.GitCommandResult(args, 0, "", "")
+
+    monkeypatch.setattr(gitops, "run_git_command", fake_run)
+
+    result = gitops.branch_ensure_return(tmp_path, "main", "dev/interrupted")
+
+    assert result.ok is False
+    assert not any(args[:2] == ("checkout", "main") for args in calls)
+    assert not any(args and args[0] == "stash" for args in calls)
+
+
+def test_non_current_reset_preserves_dirty_workspace_and_user_stashes(tmp_path):
+    from prizmkit_runtime.gitops import reset_cleanup_branch
+
+    _init_merge_repo(tmp_path)
+    subprocess.run(["git", "branch", "dev/other"], cwd=tmp_path, check=True)
+    manifest = tmp_path / ".prizmkit" / "manifest.json"
+    manifest.write_text('{"version":"stale"}\n', encoding="utf-8")
+    subprocess.run(["git", "stash", "push", "-m", "user-stash", "--", ".prizmkit/manifest.json"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    user_stashes = _stash_oids(tmp_path)
+    (tmp_path / "app.txt").write_text("unstaged\n", encoding="utf-8")
+    (tmp_path / "staged.txt").write_text("staged\n", encoding="utf-8")
+    subprocess.run(["git", "add", "staged.txt"], cwd=tmp_path, check=True)
+    (tmp_path / "untracked.txt").write_text("untracked\n", encoding="utf-8")
+    before = subprocess.run(["git", "status", "--porcelain"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True).stdout
+
+    reset_result = reset_cleanup_branch(tmp_path, "dev/other", return_branch="main", delete=False)
+
+    assert reset_result.branch_preserved is True
+    assert reset_result.checkout_discarded is False
+    assert subprocess.run(["git", "branch", "--show-current"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True).stdout.strip() == "main"
+    assert subprocess.run(["git", "status", "--porcelain"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True).stdout == before
+    assert _stash_oids(tmp_path) == user_stashes
+    assert subprocess.run(["git", "show-ref", "--verify", "refs/heads/dev/other"], cwd=tmp_path, check=False).returncode == 0
+
+    clean_result = reset_cleanup_branch(tmp_path, "dev/other", return_branch="main", delete=True)
+
+    assert clean_result.deleted is True
+    assert subprocess.run(["git", "status", "--porcelain"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True).stdout == before
+    assert _stash_oids(tmp_path) == user_stashes
+
+
 def test_worktree_runtime_context_uses_safe_deterministic_path(tmp_path):
     from prizmkit_runtime.gitops import BranchContext, WorktreePolicy, worktree_runtime_context
 

package/bundled/skills/_metadata.json

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

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

@@ -361,8 +361,8 @@ Key requirements:
 - descriptions: minimum 15 words (error), recommended minimum 30/50/80/100+ for low/medium/high/critical (warning). No upper limit — more detail prevents AI guessing
 - `estimated_complexity` determines pipeline execution tier:
   - `low` / `medium` → **lite** (single agent, no subagents)
-  - `high` → **standard** (orchestrator + reviewer guardrails, 3-agent metadata)
-  - `critical` → **full** (strongest orchestrator/reviewer guardrails). Use for: architectural changes touching 10+ files, cross-module refactoring with API surface changes, or safety/security/data-loss risk
+  - `high` → **standard** (Main-Agent review guardrails, 3-agent compatibility metadata)
+  - `critical` → **full** (strongest Main-Agent review guardrails). Use for: architectural changes touching 10+ files, cross-module refactoring with API surface changes, or safety/security/data-loss risk
 
 **IMPORTANT: Do NOT hand-write the final JSON file.** Instead:
 1. Write a draft JSON to a temporary path (e.g., `.prizmkit/plans/feature-list.draft.json`)

package/bundled/skills/prizmkit/SKILL.md

@@ -110,7 +110,7 @@ PrizmKit supports any development scenario through the same skill chain. `/prizm
 | `/prizmkit-plan` | First implementation planning step: run ahead of `/prizmkit-implement` to turn natural language into `spec.md` + `plan.md` with executable tasks. | "specify", "plan", "new task", "architect", "break it down" |
 | `/prizmkit-implement` | Implementation step: use after `/prizmkit-plan` to execute `plan.md` tasks with TDD where applicable, task order, and checkpoints. | "implement", "build", "code it", "start coding" |
 | `/prizmkit-test` | Risk-triggered quality gate: run after implementation when behavior, interfaces, data, security, or deploy risk requires tests and boundary coverage. | "test", "run tests", "verify", "quality check", "boundary tests" |
-| `/prizmkit-code-review` | Full path quality gate: run after implementation; requires the dedicated reviewer agent in the active checkout and stops if that launch mode is unavailable. | "review", "check code", "code review", "is it ready to commit" |
+| `/prizmkit-code-review` | Full path quality gate: the current Main Agent reviews and repairs the complete change in the active checkout without direct or indirect review delegation. | "review", "check code", "code review", "is it ready to commit" |
 | `/prizmkit-retrospective` | Docs maintenance step: run after review/implementation when structure, interfaces, dependencies, behavior, or durable knowledge changed. | "retrospective", "retro", "update docs", "sync docs", "wrap up" |
 | `/prizmkit-committer` | Final lifecycle commit step: use after required gates are satisfied; safely stages and creates a Conventional Commit without changing changelog by default. | "commit", "submit", "finish", "done" |
 | `/prizmkit-prizm-docs` | Documentation system entry point: use for init/status/rebuild/validate/migrate or out-of-band repair, not normal development sync. | "initialize docs", "check docs", "rebuild docs", "validate docs", "docs drifted" |

package/bundled/skills/prizmkit-code-review/SKILL.md

@@ -5,7 +5,16 @@ description: "Review the complete current change in a bounded Main-Agent loop. A
 
 # PrizmKit Code Review
 
-Use one Main-Agent review loop. The Main Agent performs the complete review, filters candidate findings, repairs accepted findings, verifies the repairs, and decides the final result without delegating code review.
+Use one Main-Agent review loop. The current Main Agent is the only Code Review executor: it performs the complete review, filters candidate findings, repairs accepted findings, verifies the repairs, and decides the final result.
+
+## Execution Boundary
+
+- Do not delegate any part of Code Review directly or indirectly.
+- Do not invoke another review skill or review workflow from inside this skill.
+- Do not launch review work through a general-purpose execution unit or relabel it as a finder, verifier, audit, compatibility review, verification, or gap sweep.
+- These restrictions apply for the entire review phase, including candidate discovery, evidence checks, repair verification, and final gap analysis.
+- The Main Agent may directly use non-delegating read, search, edit, and test capabilities in the active workspace.
+- `{artifact_dir}/review-report.md` is the only persisted review artifact. Do not append separate Review Notes to `context-snapshot.md`.
 
 ## When to Use
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prizmkit",
-  "version": "1.1.128",
+  "version": "1.1.129",
   "description": "Create a new PrizmKit-powered project with clean initialization — no framework dev files, just what you need.",
   "type": "module",
   "bin": {

package/src/manifest.js

@@ -19,6 +19,7 @@ const MANIFEST_DIR = '.prizmkit';
  * Read the manifest from a project directory.
  * @param {string} projectRoot
  * @returns {Promise<Object|null>} parsed manifest or null if not found
+ * @throws {Error} when a present manifest cannot be read or parsed
  */
 export async function readManifest(projectRoot) {
   const manifestPath = path.join(projectRoot, MANIFEST_DIR, MANIFEST_FILE);
@@ -26,9 +27,13 @@ export async function readManifest(projectRoot) {
     return null;
   }
   try {
-    return await fs.readJSON(manifestPath);
-  } catch {
-    return null;
+    const manifest = await fs.readJSON(manifestPath);
+    if (manifest === null || Array.isArray(manifest) || typeof manifest !== 'object') {
+      throw new TypeError('manifest root must be a JSON object');
+    }
+    return manifest;
+  } catch (error) {
+    throw new Error(`Failed to read PrizmKit manifest at ${manifestPath}: ${error.message}`, { cause: error });
   }
 }