prizmkit 1.1.128 → 1.1.130

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.130",
   "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.130",
   "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 });
   }
 }