prizmkit 1.1.122 → 1.1.124

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

@@ -627,39 +627,194 @@ def test_status_bridge_passes_max_retries_from_invocation_or_environment(monkeyp
     assert second[second.index("--max-retries") + 1] == "6"
 
 
-def test_stop_on_failure_does_not_stop_on_retryable_pending(monkeypatch, tmp_path):
+@pytest.mark.parametrize(
+    ("kind", "item_key"),
+    (("feature", "feature_id"), ("bugfix", "bug_id"), ("refactor", "refactor_id")),
+)
+def test_pipeline_aggregate_replaces_same_item_status_in_first_seen_order(monkeypatch, tmp_path, kind, item_key):
     from prizmkit_runtime import runners
     from prizmkit_runtime.runner_models import family_for, parse_invocation
 
     paths = _make_paths(tmp_path)
-    family = family_for("feature", paths)
+    family = family_for(kind, paths)
     invocation = parse_invocation(family, "run", ())
-    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
+    statuses = iter(("completed", "pending", "completed"))
     queue = [
-        SimpleNamespace(ok=True, stdout=json.dumps({"feature_id": "F-001"}), data={"feature_id": "F-001"}, text=""),
-        SimpleNamespace(ok=True, stdout=json.dumps({"feature_id": "F-002"}), data={"feature_id": "F-002"}, text=""),
+        SimpleNamespace(ok=True, stdout="", data={item_key: "F-049"}, text=""),
+        SimpleNamespace(ok=True, stdout="", data={item_key: "F-050"}, text=""),
+        SimpleNamespace(ok=True, stdout="", data={item_key: "F-050"}, text=""),
         SimpleNamespace(ok=True, stdout="PIPELINE_COMPLETE\n", data=None, text="PIPELINE_COMPLETE"),
     ]
-    processed = []
 
-    monkeypatch.setenv("STOP_ON_FAILURE", "1")
     monkeypatch.setattr(runners, "get_next", lambda *args, **kwargs: queue.pop(0))
+    monkeypatch.setattr(runners, "_process_item", lambda *args, **kwargs: next(statuses))
+    monkeypatch.setattr(runners, "_emit_info", lambda *args, **kwargs: None)
 
-    def fake_process(_family, _invocation, item_id, _paths, *, initial_metadata):
-        processed.append(item_id)
-        return "pending" if item_id == "F-001" else "completed"
+    result = runners._run_pipeline(family, invocation, paths)
 
-    monkeypatch.setattr(runners, "_process_item", fake_process)
+    assert result.processed == 3
+    assert result.completed is True
+    assert result.stopped_reason == "pipeline_complete"
+    assert result.last_status == "completed"
+    assert result.details == ("F-049:completed", "F-050:completed")
+
+
+@pytest.mark.parametrize(
+    ("kind", "item_key"),
+    (("feature", "feature_id"), ("bugfix", "bug_id"), ("refactor", "refactor_id")),
+)
+def test_pipeline_aggregate_keeps_distinct_unresolved_item_blocking(monkeypatch, tmp_path, kind, item_key):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    paths = _make_paths(tmp_path)
+    family = family_for(kind, paths)
+    invocation = parse_invocation(family, "run", ())
+    statuses = iter(("pending", "completed"))
+    queue = [
+        SimpleNamespace(ok=True, stdout="", data={item_key: "F-001"}, text=""),
+        SimpleNamespace(ok=True, stdout="", data={item_key: "F-002"}, text=""),
+        SimpleNamespace(ok=True, stdout="PIPELINE_COMPLETE\n", data=None, text="PIPELINE_COMPLETE"),
+    ]
+
+    monkeypatch.setattr(runners, "get_next", lambda *args, **kwargs: queue.pop(0))
+    monkeypatch.setattr(runners, "_process_item", lambda *args, **kwargs: next(statuses))
+    monkeypatch.setattr(runners, "_emit_info", lambda *args, **kwargs: None)
 
     result = runners._run_pipeline(family, invocation, paths)
 
-    assert processed == ["F-001", "F-002"]
+    assert result.processed == 2
     assert result.completed is False
     assert result.stopped_reason == "pipeline_complete_with_non_terminal_history"
-    assert result.last_status == "completed"
+    assert result.last_status == "pending"
     assert result.details == ("F-001:pending", "F-002:completed")
 
 
+@pytest.mark.parametrize(
+    ("kind", "item_key"),
+    (("feature", "feature_id"), ("bugfix", "bug_id"), ("refactor", "refactor_id")),
+)
+def test_pipeline_aggregate_repeated_terminal_update_remains_unique(monkeypatch, tmp_path, kind, item_key):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    paths = _make_paths(tmp_path)
+    family = family_for(kind, paths)
+    invocation = parse_invocation(family, "run", ())
+    queue = [
+        SimpleNamespace(ok=True, stdout="", data={item_key: "F-001"}, text=""),
+        SimpleNamespace(ok=True, stdout="", data={item_key: "F-001"}, text=""),
+        SimpleNamespace(ok=True, stdout="PIPELINE_COMPLETE\n", data=None, text="PIPELINE_COMPLETE"),
+    ]
+
+    monkeypatch.setattr(runners, "get_next", lambda *args, **kwargs: queue.pop(0))
+    monkeypatch.setattr(runners, "_process_item", lambda *args, **kwargs: "completed")
+    monkeypatch.setattr(runners, "_emit_info", lambda *args, **kwargs: None)
+
+    result = runners._run_pipeline(family, invocation, paths)
+
+    assert result.processed == 2
+    assert result.details == ("F-001:completed",)
+    assert result.last_status == "completed"
+
+
+@pytest.mark.parametrize("kind", ("feature", "bugfix", "refactor"))
+def test_pipeline_aggregate_empty_authoritative_completion(monkeypatch, tmp_path, kind):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    paths = _make_paths(tmp_path)
+    family = family_for(kind, paths)
+    invocation = parse_invocation(family, "run", ())
+    monkeypatch.setattr(
+        runners,
+        "get_next",
+        lambda *args, **kwargs: SimpleNamespace(
+            ok=True,
+            stdout="PIPELINE_COMPLETE\n",
+            data=None,
+            text="PIPELINE_COMPLETE",
+        ),
+    )
+
+    result = runners._run_pipeline(family, invocation, paths)
+
+    assert result.processed == 0
+    assert result.completed is True
+    assert result.stopped_reason == "pipeline_complete"
+    assert result.last_status == ""
+    assert result.details == ()
+
+
+@pytest.mark.parametrize(
+    ("kind", "status", "expected_completed"),
+    (
+        ("feature", "completed", True),
+        ("feature", "skipped", True),
+        ("feature", "auto_skipped", True),
+        ("feature", "split", True),
+        ("bugfix", "completed", True),
+        ("bugfix", "skipped", True),
+        ("bugfix", "auto_skipped", True),
+        ("bugfix", "split", False),
+        ("refactor", "completed", True),
+        ("refactor", "skipped", True),
+        ("refactor", "auto_skipped", True),
+        ("refactor", "split", False),
+    ),
+)
+def test_pipeline_aggregate_completion_compatible_statuses(monkeypatch, tmp_path, kind, status, expected_completed):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    paths = _make_paths(tmp_path)
+    family = family_for(kind, paths)
+    invocation = parse_invocation(family, "run", ())
+    item_key = {"feature": "feature_id", "bugfix": "bug_id", "refactor": "refactor_id"}[kind]
+    queue = [
+        SimpleNamespace(ok=True, stdout="", data={item_key: "X-001"}, text=""),
+        SimpleNamespace(ok=True, stdout="PIPELINE_COMPLETE\n", data=None, text="PIPELINE_COMPLETE"),
+    ]
+
+    monkeypatch.setenv("STOP_ON_FAILURE", "0")
+    monkeypatch.setattr(runners, "get_next", lambda *args, **kwargs: queue.pop(0))
+    monkeypatch.setattr(runners, "_process_item", lambda *args, **kwargs: status)
+
+    result = runners._run_pipeline(family, invocation, paths)
+
+    assert result.completed is expected_completed
+    assert result.stopped_reason == (
+        "pipeline_complete" if expected_completed else "pipeline_complete_with_non_terminal_history"
+    )
+    assert result.last_status == status
+    assert result.details == (f"X-001:{status}",)
+
+
+@pytest.mark.parametrize("kind", ("feature", "bugfix", "refactor"))
+def test_run_pipeline_command_omits_empty_last_status_detail(monkeypatch, tmp_path, kind):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import PipelineRunResult
+
+    paths = _make_paths(tmp_path)
+    plan_path = {
+        "feature": paths.feature_plan,
+        "bugfix": paths.bugfix_plan,
+        "refactor": paths.refactor_plan,
+    }[kind]
+    plan_path.write_text("{}", encoding="utf-8")
+    monkeypatch.setattr(
+        runners,
+        "_run_pipeline",
+        lambda *args, **kwargs: PipelineRunResult(True, 0, "pipeline_complete"),
+    )
+
+    result = runners.run_pipeline_command(kind, "run", (), paths)
+
+    assert result.exit_code == 0
+    assert result.message == "processed=0 completed=True stopped_reason=pipeline_complete"
+    assert result.details == ()
+
+
 def test_pipeline_complete_rejects_retryable_detail(monkeypatch, tmp_path):
     from prizmkit_runtime import runners
     from prizmkit_runtime.runner_models import family_for, parse_invocation
@@ -1680,7 +1835,180 @@ def test_preflight_ready_commit_preserves_staged_unstaged_and_mixed_visible_chan
     assert visible_status == ""
 
 
-def test_preflight_ready_commit_excludes_hidden_support_assets_and_state(tmp_path):
+def test_preflight_ready_commit_handles_exact_special_and_renamed_paths(tmp_path):
+    from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
+
+    _init_bookkeeping_repo(tmp_path)
+    old_path = tmp_path / "old name -> café.txt"
+    old_path.write_text("old\n", encoding="utf-8")
+    subprocess.run(["git", "add", old_path.name], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "track special path"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    new_path = tmp_path / 'new "quoted" \\ 名称.txt'
+    old_path.rename(new_path)
+    untracked_path = tmp_path / "untracked -> line\nbreak.txt"
+    untracked_path.write_text("new\n", encoding="utf-8")
+    colon_path = tmp_path / ":(glob)**.txt"
+    colon_path.write_text("literal pathspec\n", encoding="utf-8")
+
+    result = commit_preflight_ready_changes(tmp_path, "R-001")
+    committed_files = set(
+        filter(
+            None,
+            subprocess.run(
+                ["git", "diff-tree", "--no-commit-id", "--name-only", "-r", "-z", "HEAD"],
+                cwd=tmp_path,
+                check=True,
+                stdout=subprocess.PIPE,
+            ).stdout.decode().split("\0"),
+        )
+    )
+
+    assert result.committed is True
+    assert old_path.name in committed_files
+    assert new_path.name in committed_files
+    assert untracked_path.name in committed_files
+    assert colon_path.name in committed_files
+    assert _head_message(tmp_path) == "chore: ready for R-001"
+
+
+@pytest.mark.parametrize("staged", [False, True])
+def test_preflight_ready_commit_rejects_tracked_local_settings_before_checkout(tmp_path, staged):
+    from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
+
+    _init_bookkeeping_repo(tmp_path)
+    local_settings = tmp_path / ".claude" / "settings.local.json"
+    local_settings.parent.mkdir(parents=True)
+    local_settings.write_text('{"permissions": []}\n', encoding="utf-8")
+    subprocess.run(["git", "add", "-f", ".claude/settings.local.json"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "track local settings"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    local_settings.write_text('{"permissions": ["secret"]}\n', encoding="utf-8")
+    if staged:
+        subprocess.run(["git", "add", ".claude/settings.local.json"], cwd=tmp_path, check=True)
+
+    result = commit_preflight_ready_changes(tmp_path, "B-001")
+
+    assert result.attempted is True
+    assert result.committed is False
+    assert result.result is not None
+    assert "Refusing to auto-commit local-only platform settings" in result.result.stderr
+    assert _head_message(tmp_path) == "track local settings"
+
+
+def test_preflight_ready_commit_excludes_untracked_python_cache_outside_support_dirs(tmp_path):
+    from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
+
+    _init_bookkeeping_repo(tmp_path)
+    (tmp_path / "visible.txt").write_text("visible\n", encoding="utf-8")
+    cache_paths = [
+        tmp_path / "__pycache__" / "top.cpython-312.pyc",
+        tmp_path / "src" / "package" / "__pycache__" / "module.cpython-312.pyc",
+        tmp_path / "src" / "standalone.pyo",
+    ]
+    for path in cache_paths:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text("compiled\n", encoding="utf-8")
+
+    result = commit_preflight_ready_changes(tmp_path, "F-001")
+    committed_files = _head_files(tmp_path)
+
+    assert result.committed is True
+    assert committed_files == {"visible.txt"}
+    assert all(path.is_file() for path in cache_paths)
+
+
+def test_tracked_python_cache_remains_visible_to_task_commit(tmp_path):
+    from prizmkit_runtime.runner_bookkeeping import commit_task_branch_changes
+    from prizmkit_runtime.runner_models import family_for
+
+    paths = _make_paths(tmp_path)
+    _init_bookkeeping_repo(paths.project_root)
+    tracked_cache = paths.project_root / "src" / "__pycache__" / "module.pyc"
+    tracked_cache.parent.mkdir(parents=True)
+    tracked_cache.write_text("baseline\n", encoding="utf-8")
+    subprocess.run(["git", "add", tracked_cache.relative_to(paths.project_root).as_posix()], cwd=paths.project_root, check=True)
+    subprocess.run(["git", "commit", "-m", "track cache"], cwd=paths.project_root, check=True, stdout=subprocess.DEVNULL)
+    tracked_cache.write_text("task change\n", encoding="utf-8")
+
+    result = commit_task_branch_changes(paths.project_root, family_for("bugfix", paths), "B-001", "completed")
+
+    assert result.committed is True
+    assert tracked_cache.relative_to(paths.project_root).as_posix() in _head_files(paths.project_root)
+    assert subprocess.run(
+        ["git", "status", "--short", "--untracked-files=no"],
+        cwd=paths.project_root,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout == ""
+
+
+def test_preflight_ready_commit_includes_tracked_state_but_excludes_untracked_state(tmp_path):
+    from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
+
+    _init_bookkeeping_repo(tmp_path)
+    tracked_state = tmp_path / ".prizmkit" / "state" / "bugfix" / "B-001" / "tracked.json"
+    tracked_state.parent.mkdir(parents=True)
+    tracked_state.write_text("baseline\n", encoding="utf-8")
+    subprocess.run(["git", "add", "-f", tracked_state.relative_to(tmp_path).as_posix()], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "track state"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    tracked_state.write_text("changed\n", encoding="utf-8")
+    untracked_state = tracked_state.parent / "untracked.json"
+    untracked_state.write_text("transient\n", encoding="utf-8")
+
+    result = commit_preflight_ready_changes(tmp_path, "B-001")
+
+    assert result.committed is True
+    assert tracked_state.relative_to(tmp_path).as_posix() in _head_files(tmp_path)
+    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):
+    from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
+
+    _init_bookkeeping_repo(tmp_path)
+    tracked_support_paths = [
+        tmp_path / ".prizmkit" / "manifest.json",
+        tmp_path / ".prizmkit" / "dev-pipeline" / "prizmkit_runtime" / "runners.py",
+        tmp_path / ".claude" / "commands" / "prizmkit.md",
+    ]
+    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)],
+        cwd=tmp_path,
+        check=True,
+    )
+    subprocess.run(["git", "commit", "-m", "track support"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    for path in tracked_support_paths:
+        path.write_text("upgraded\n", encoding="utf-8")
+
+    untracked_support_paths = [
+        tmp_path / ".claude" / "settings.local.json",
+        tmp_path / ".prizmkit" / "dev-pipeline" / "scripts" / "__pycache__" / "runtime.pyc",
+        tmp_path / ".prizmkit" / "state" / "bugfix" / "B-001" / "status.json",
+    ]
+    for path in untracked_support_paths:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        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 subprocess.run(
+        ["git", "status", "--short", "--untracked-files=no"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout == ""
+
+
+def test_preflight_ready_commit_excludes_untracked_support_assets_and_state(tmp_path):
     from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
 
     _init_bookkeeping_repo(tmp_path)
@@ -1727,23 +2055,38 @@ def test_preflight_ready_commit_noops_when_workspace_has_no_visible_dirty_conten
     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):
+@pytest.mark.parametrize(
+    ("kind", "item_id", "branch"),
+    [
+        ("feature", "F-001", "dev/F-001-ready"),
+        ("bugfix", "B-001", "bugfix/B-001-ready"),
+        ("refactor", "R-001", "refactor/R-001-ready"),
+    ],
+)
+def test_process_item_creates_one_ready_commit_before_branch_setup_for_all_families(
+    monkeypatch,
+    tmp_path,
+    kind,
+    item_id,
+    branch,
+):
     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)
+    paths = _make_paths(tmp_path / kind)
     _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")
+    (paths.project_root / "untracked.txt").write_text("untracked 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)
+    monkeypatch.setenv("DEV_BRANCH", branch)
+    family = family_for(kind, paths)
     invocation = parse_invocation(family, "run", ())
-    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": family.plan_path})
     _install_runner_session_fakes(monkeypatch, runners)
     monkeypatch.setattr(runners, "commit_preflight_ready_changes", runner_bookkeeping.commit_preflight_ready_changes)
 
@@ -1766,18 +2109,18 @@ def test_process_item_creates_one_ready_commit_before_branch_setup_for_mixed_vis
 
     monkeypatch.setattr(runners, "run_git_plan", fake_run_git_plan)
 
-    status = runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
+    status = runners._process_item(family, invocation, item_id, paths, initial_metadata={})
 
     assert status == "completed"
     assert branch_events == [
         {
             "commit_count": before_count + 1,
-            "message": "chore: ready for F-001",
+            "message": f"chore: ready for {item_id}",
             "visible_status": "",
         }
     ]
     assert _head_commit_count(paths.project_root) == before_count + 1
-    assert {"staged.txt", "unstaged.txt"}.issubset(_head_files(paths.project_root))
+    assert {"staged.txt", "unstaged.txt", "untracked.txt"}.issubset(_head_files(paths.project_root))
 
 
 

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

@@ -811,14 +811,21 @@ def test_session_preamble_writes_redacted_start_command_for_all_launch_profiles(
             assert str(prompt) not in "\n".join(lines[:6])
 
 
-def test_headless_review_guidance_uses_workspace_equivalence_protocol():
-    guidance_files = [
+def test_headless_review_guidance_uses_workspace_and_execution_protocols():
+    headless_guidance_files = [
         REPO_ROOT / "dev-pipeline" / "templates" / "sections" / "phase-review-full.md",
         REPO_ROOT / "dev-pipeline" / "templates" / "bootstrap-tier3.md",
-        REPO_ROOT / "core" / "skills" / "prizmkit-skill" / "prizmkit-code-review" / "SKILL.md",
     ]
+    skill_path = (
+        REPO_ROOT
+        / "core"
+        / "skills"
+        / "prizmkit-skill"
+        / "prizmkit-code-review"
+        / "SKILL.md"
+    )
 
-    for path in guidance_files:
+    for path in headless_guidance_files:
         text = path.read_text(encoding="utf-8")
         assert "platform-supported" in text, path
         assert "snapshot" in text and "equivalent" in text, path
@@ -828,15 +835,17 @@ def test_headless_review_guidance_uses_workspace_equivalence_protocol():
         assert ".prizmkit/state/worktrees/..." not in text, path
         assert "USE_WORKTREE" not in text, path
         assert "isolation:" not in text, path
+        assert "Read existing source files in the modules this plan touches" not in text, path
 
-    skill_text = guidance_files[-1].read_text(encoding="utf-8")
+    skill_text = skill_path.read_text(encoding="utf-8")
     assert "reviewer-workspace-protocol.md" in skill_text
+    assert "reviewer-execution-protocol.md" in skill_text
     assert "staged, unstaged, untracked, deleted, and renamed" in skill_text
+    assert "content-equivalent" in skill_text
     assert "WORKSPACE_MISMATCH" in skill_text
-
-    for path in guidance_files[:-1]:
-        text = path.read_text(encoding="utf-8")
-        assert "Read existing source files in the modules this plan touches" not in text, path
+    assert "REVIEW_INFRASTRUCTURE_BLOCKED" in skill_text
+    assert "do not substitute Main-Agent self-review" in skill_text
+    assert "platform-specific role" in skill_text
 
 
 def test_progress_parser_adds_required_metadata(tmp_path):
@@ -2109,7 +2118,7 @@ def test_preflight_ready_commit_skips_hidden_support_asset_only_changes(tmp_path
     assert (repo / ".claude" / "settings.local.json").is_file()
 
 
-def test_preflight_ready_commit_excludes_already_staged_hidden_support_assets(tmp_path):
+def test_preflight_ready_commit_includes_explicitly_staged_support_assets(tmp_path):
     from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
 
     repo = tmp_path / "repo"
@@ -2123,8 +2132,8 @@ def test_preflight_ready_commit_excludes_already_staged_hidden_support_assets(tm
 
     assert result.committed
     assert _head_commit_message(repo) == "chore: ready for F-005"
-    assert _head_files(repo) == {"visible.txt"}
-    assert "A  .claude/agent.md" in _short_status(repo)
+    assert _head_files(repo) == {".claude/agent.md", "visible.txt"}
+    assert _short_status(repo) == ""
 
 
 def test_preflight_ready_commit_excludes_ignored_tool_worktree_directories(tmp_path):

package/bundled/skills/_metadata.json

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