prizmkit 1.1.115 → 1.1.116

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.115",
-  "bundledAt": "2026-07-09T10:20:47.948Z",
-  "bundledFrom": "5d2c9f0"
+  "frameworkVersion": "1.1.116",
+  "bundledAt": "2026-07-09T12:20:56.645Z",
+  "bundledFrom": "5def1a0"
 }

package/bundled/dev-pipeline/prizmkit_runtime/gitops.py

@@ -31,6 +31,8 @@ HIDDEN_TOOL_WORKTREE_EXCLUDES = (
     ":(top,exclude,glob).prizmkit/prizm-docs/**",
     ":(top,exclude).prizmkit/config.json",
     ":(top,exclude).prizmkit/manifest.json",
+    ":(top,exclude).prizmkit/state",
+    ":(top,exclude,glob).prizmkit/state/**",
     ":(top,exclude).prizmkit/dev-pipeline/scripts",
     ":(top,exclude,glob).prizmkit/dev-pipeline/scripts/**",
     ":(top,exclude).prizmkit/dev-pipeline/prizmkit_runtime",

package/bundled/dev-pipeline/prizmkit_runtime/runner_bookkeeping.py

@@ -42,6 +42,10 @@ def _repo_path(project_root: Path, path: Path) -> str:
         return path.as_posix()
 
 
+def _visible_status_result(project_root: Path) -> GitCommandResult:
+    return run_git_command(project_root, ("status", "--porcelain", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES))
+
+
 def _changed_paths_in(project_root: Path, paths: Sequence[str]) -> tuple[str, ...]:
     result = run_git_command(project_root, ("status", "--porcelain", "--", *paths))
     if result.return_code != 0:
@@ -73,7 +77,10 @@ def commit_bookkeeping_changes(
 
 def commit_preflight_ready_changes(project_root: Path, item_id: str) -> BookkeepingResult:
     """Preserve visible pre-existing changes before task branch setup."""
-    if not git_status_safe(project_root).strip():
+    visible_status = _visible_status_result(project_root)
+    if visible_status.return_code != 0:
+        return BookkeepingResult(attempted=True, committed=False, result=visible_status)
+    if not visible_status.stdout.strip():
         return BookkeepingResult(attempted=False, committed=False)
     add_result = run_git_command(project_root, ("add", "-A", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES))
     if add_result.return_code != 0:
@@ -82,7 +89,12 @@ def commit_preflight_ready_changes(project_root: Path, item_id: str) -> Bookkeep
         project_root,
         ("commit", "--no-verify", "-m", f"chore: ready for {item_id}", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES),
     )
-    return BookkeepingResult(attempted=True, committed=result.return_code == 0, result=result)
+    if result.return_code != 0:
+        return BookkeepingResult(attempted=True, committed=False, result=result)
+    clean_result = _visible_status_result(project_root)
+    if clean_result.return_code != 0 or clean_result.stdout.strip():
+        return BookkeepingResult(attempted=True, committed=False, result=clean_result)
+    return BookkeepingResult(attempted=True, committed=True, result=result)
 
 
 def commit_task_branch_changes(

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

@@ -1471,15 +1471,25 @@ def test_no_worktree_runner_ignores_recovery_side_effect_branch(monkeypatch, tmp
     assert observed.updates[-1][2]["base_branch"] == "main"
 
 
-def test_no_worktree_preflight_commit_failure_aborts_before_branch_or_status(monkeypatch, tmp_path):
+@pytest.mark.parametrize(
+    ("kind", "item_id", "branch"),
+    [
+        ("feature", "F-001", "dev/F-001-preflight-fail"),
+        ("bugfix", "B-001", "bugfix/B-001-preflight-fail"),
+        ("refactor", "R-001", "refactor/R-001-preflight-fail"),
+    ],
+)
+def test_preflight_commit_failure_aborts_before_branch_worktree_or_status_for_all_families(monkeypatch, tmp_path, kind, item_id, branch):
     from prizmkit_runtime import runners
     from prizmkit_runtime.runner_models import family_for, parse_invocation
 
-    monkeypatch.setenv("DEV_BRANCH", "dev/F-001-preflight-fail")
-    paths = _make_paths(tmp_path)
-    family = family_for("feature", paths)
+    monkeypatch.setenv("DEV_BRANCH", branch)
+    monkeypatch.setenv("USE_WORKTREE", "1")
+    paths = _make_paths(tmp_path / kind)
+    family = family_for(kind, paths)
     invocation = parse_invocation(family, "run", ())
-    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
+    plan_path = {"feature": paths.feature_plan, "bugfix": paths.bugfix_plan, "refactor": paths.refactor_plan}[kind]
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": plan_path})
     events = []
 
     monkeypatch.setattr(
@@ -1490,10 +1500,11 @@ def test_no_worktree_preflight_commit_failure_aborts_before_branch_or_status(mon
     monkeypatch.setattr(runners, "current_branch", lambda _root: "main")
     monkeypatch.setattr(runners, "commit_preflight_ready_changes", lambda *args, **kwargs: SimpleNamespace(attempted=True, committed=False, result=SimpleNamespace(stderr="commit failed\n", stdout="")))
     monkeypatch.setattr(runners, "run_git_plan", lambda *args, **kwargs: events.append("branch_create"))
+    monkeypatch.setattr(runners, "ensure_linked_worktree", lambda *args, **kwargs: events.append("worktree_create"), raising=False)
     monkeypatch.setattr(runners, "start_item", lambda *args, **kwargs: events.append("start_item"))
 
     with pytest.raises(RuntimeError, match="Preflight dirty workspace preservation failed"):
-        runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
+        runners._process_item(family, invocation, item_id, paths, initial_metadata={})
 
     assert events == []
 
@@ -1559,6 +1570,190 @@ def test_no_worktree_interrupt_saves_wip_and_returns_to_base(monkeypatch, tmp_pa
     assert ensure_calls == [("main", "dev/F-001-interrupt")]
 
 
+def _init_bookkeeping_repo(project_root):
+    subprocess.run(["git", "init", "-b", "main"], cwd=project_root, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=project_root, check=True)
+    subprocess.run(["git", "config", "user.name", "Test"], cwd=project_root, check=True)
+    (project_root / "staged.txt").write_text("base staged\n", encoding="utf-8")
+    (project_root / "unstaged.txt").write_text("base unstaged\n", encoding="utf-8")
+    subprocess.run(["git", "add", "staged.txt", "unstaged.txt"], cwd=project_root, check=True)
+    subprocess.run(["git", "commit", "-m", "base"], cwd=project_root, check=True, stdout=subprocess.DEVNULL)
+
+
+def _head_commit_count(project_root):
+    return int(
+        subprocess.run(
+            ["git", "rev-list", "--count", "HEAD"],
+            cwd=project_root,
+            check=True,
+            stdout=subprocess.PIPE,
+            text=True,
+        ).stdout.strip()
+    )
+
+
+def _head_message(project_root):
+    return subprocess.run(
+        ["git", "log", "-1", "--format=%s"],
+        cwd=project_root,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.strip()
+
+
+def _head_files(project_root):
+    return set(
+        subprocess.run(
+            ["git", "show", "--name-only", "--format=", "HEAD"],
+            cwd=project_root,
+            check=True,
+            stdout=subprocess.PIPE,
+            text=True,
+        ).stdout.splitlines()
+    )
+
+
+@pytest.mark.parametrize(
+    ("scenario", "expected_files"),
+    [
+        ("staged_only", {"staged.txt"}),
+        ("unstaged_only", {"unstaged.txt"}),
+        ("mixed", {"staged.txt", "unstaged.txt", "new-visible.txt"}),
+    ],
+)
+def test_preflight_ready_commit_preserves_staged_unstaged_and_mixed_visible_changes(tmp_path, scenario, expected_files):
+    from prizmkit_runtime.gitops import HIDDEN_TOOL_WORKTREE_EXCLUDES
+    from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
+
+    _init_bookkeeping_repo(tmp_path)
+    if scenario in {"staged_only", "mixed"}:
+        (tmp_path / "staged.txt").write_text("staged change\n", encoding="utf-8")
+        subprocess.run(["git", "add", "staged.txt"], cwd=tmp_path, check=True)
+    if scenario in {"unstaged_only", "mixed"}:
+        (tmp_path / "unstaged.txt").write_text("unstaged change\n", encoding="utf-8")
+    if scenario == "mixed":
+        (tmp_path / "new-visible.txt").write_text("new visible\n", encoding="utf-8")
+
+    before_count = _head_commit_count(tmp_path)
+    result = commit_preflight_ready_changes(tmp_path, "F-123")
+    visible_status = subprocess.run(
+        ["git", "status", "--porcelain", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout
+
+    assert result.attempted is True
+    assert result.committed is True
+    assert _head_commit_count(tmp_path) == before_count + 1
+    assert _head_message(tmp_path) == "chore: ready for F-123"
+    assert expected_files.issubset(_head_files(tmp_path))
+    assert visible_status == ""
+
+
+def test_preflight_ready_commit_excludes_hidden_support_assets_and_state(tmp_path):
+    from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
+
+    _init_bookkeeping_repo(tmp_path)
+    (tmp_path / "unstaged.txt").write_text("visible change\n", encoding="utf-8")
+    hidden_paths = [
+        tmp_path / ".claude" / "settings.json",
+        tmp_path / ".codebuddy" / "skills" / "local.md",
+        tmp_path / ".agents" / "skills" / "local.md",
+        tmp_path / ".codex" / "config.toml",
+        tmp_path / ".prizmkit" / "state" / "features" / "F-001" / "status.json",
+        tmp_path / ".claude" / "worktrees" / "agent" / "scratch.txt",
+    ]
+    for path in hidden_paths:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text("hidden support\n", encoding="utf-8")
+
+    result = commit_preflight_ready_changes(tmp_path, "F-124")
+    committed_files = _head_files(tmp_path)
+    hidden_status = subprocess.run(
+        ["git", "status", "--porcelain", "--", ".claude", ".codebuddy", ".agents", ".codex", ".prizmkit/state"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout
+
+    assert result.committed is True
+    assert committed_files == {"unstaged.txt"}
+    assert ".claude" in hidden_status or ".prizmkit/state" in hidden_status
+
+
+def test_preflight_ready_commit_noops_when_workspace_has_no_visible_dirty_content(tmp_path):
+    from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
+
+    _init_bookkeeping_repo(tmp_path)
+    (tmp_path / ".claude" / "worktrees" / "agent").mkdir(parents=True)
+    (tmp_path / ".claude" / "worktrees" / "agent" / "scratch.txt").write_text("hidden only\n", encoding="utf-8")
+    before_count = _head_commit_count(tmp_path)
+
+    result = commit_preflight_ready_changes(tmp_path, "F-125")
+
+    assert result.attempted is False
+    assert result.committed is False
+    assert _head_commit_count(tmp_path) == before_count
+
+
+def test_process_item_creates_one_ready_commit_before_branch_setup_for_mixed_visible_changes(monkeypatch, tmp_path):
+    from prizmkit_runtime import runner_bookkeeping, runners
+    from prizmkit_runtime.gitops import HIDDEN_TOOL_WORKTREE_EXCLUDES
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    paths = _make_paths(tmp_path)
+    _init_bookkeeping_repo(paths.project_root)
+    (paths.project_root / "staged.txt").write_text("staged before run\n", encoding="utf-8")
+    subprocess.run(["git", "add", "staged.txt"], cwd=paths.project_root, check=True)
+    (paths.project_root / "unstaged.txt").write_text("unstaged before run\n", encoding="utf-8")
+    before_count = _head_commit_count(paths.project_root)
+    branch_events = []
+
+    monkeypatch.setenv("DEV_BRANCH", "dev/F-001-ready")
+    family = family_for("feature", paths)
+    invocation = parse_invocation(family, "run", ())
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
+    _install_runner_session_fakes(monkeypatch, runners)
+    monkeypatch.setattr(runners, "commit_preflight_ready_changes", runner_bookkeeping.commit_preflight_ready_changes)
+
+    def fake_run_git_plan(project_root, plan):
+        if plan.name == "branch_create":
+            branch_events.append(
+                {
+                    "commit_count": _head_commit_count(project_root),
+                    "message": _head_message(project_root),
+                    "visible_status": subprocess.run(
+                        ["git", "status", "--porcelain", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES],
+                        cwd=project_root,
+                        check=True,
+                        stdout=subprocess.PIPE,
+                        text=True,
+                    ).stdout,
+                }
+            )
+        return SimpleNamespace(ok=True, plan=plan, results=())
+
+    monkeypatch.setattr(runners, "run_git_plan", fake_run_git_plan)
+
+    status = runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
+
+    assert status == "completed"
+    assert branch_events == [
+        {
+            "commit_count": before_count + 1,
+            "message": "chore: ready for F-001",
+            "visible_status": "",
+        }
+    ]
+    assert _head_commit_count(paths.project_root) == before_count + 1
+    assert {"staged.txt", "unstaged.txt"}.issubset(_head_files(paths.project_root))
+
+
+
 def test_bookkeeping_commits_only_runner_owned_paths(tmp_path):
     from prizmkit_runtime.runner_bookkeeping import commit_final_bookkeeping
     from prizmkit_runtime.runner_models import RunnerFamily

package/bundled/skills/_metadata.json

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

package/package.json

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