claude-dev-env 1.39.0 → 1.41.0

package/hooks/config/test_pr_description_enforcer_constants.py

@@ -0,0 +1,82 @@
+"""Behavior tests for pr_description_enforcer_constants module."""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+_HOOKS_ROOT = Path(__file__).resolve().parent.parent
+if str(_HOOKS_ROOT) not in sys.path:
+    sys.path.insert(0, str(_HOOKS_ROOT))
+
+from config import pr_description_enforcer_constants as constants_module
+
+
+def test_plugin_root_is_private_module_attribute() -> None:
+    assert hasattr(constants_module, "_PLUGIN_ROOT")
+    assert isinstance(constants_module._PLUGIN_ROOT, str)
+    assert os.path.isabs(constants_module._PLUGIN_ROOT)
+
+
+def test_plugin_root_public_name_is_not_exported() -> None:
+    assert not hasattr(constants_module, "PLUGIN_ROOT")
+
+
+def test_pr_guide_path_resolves_under_plugin_root_docs() -> None:
+    expected_pr_guide_path = os.path.join(
+        constants_module._PLUGIN_ROOT, "docs", "PR_DESCRIPTION_GUIDE.md"
+    )
+    assert constants_module.PR_GUIDE_PATH == expected_pr_guide_path
+
+
+def test_minimum_substantive_prose_chars_is_positive_integer() -> None:
+    assert isinstance(constants_module.MINIMUM_SUBSTANTIVE_PROSE_CHARS, int)
+    assert constants_module.MINIMUM_SUBSTANTIVE_PROSE_CHARS > 0
+
+
+def test_fenced_code_block_pattern_matches_triple_backtick_block() -> None:
+    sample_markdown = "before ```python\ncode\n``` after"
+    match = constants_module.FENCED_CODE_BLOCK_PATTERN.search(sample_markdown)
+    assert match is not None
+    assert match.group(0).startswith("```")
+    assert match.group(0).endswith("```")
+
+
+def test_inline_code_pattern_matches_single_backtick_span() -> None:
+    match = constants_module.INLINE_CODE_PATTERN.search("see `value` here")
+    assert match is not None
+    assert match.group(0) == "`value`"
+
+
+def test_heading_line_pattern_matches_atx_heading() -> None:
+    match = constants_module.HEADING_LINE_PATTERN.search("## Description\n")
+    assert match is not None
+    assert match.group(0).strip() == "## Description"
+
+
+def test_bold_pair_pattern_captures_inner_text() -> None:
+    match = constants_module.BOLD_PAIR_PATTERN.search("this is **bold** text")
+    assert match is not None
+    assert match.group(1) == "bold"
+
+
+def test_bullet_marker_pattern_strips_dash_bullet_from_line() -> None:
+    stripped_line = constants_module.BULLET_MARKER_PATTERN.sub("", "- first item")
+    assert stripped_line == "first item"
+
+
+def test_blockquote_marker_pattern_strips_quote_marker_from_line() -> None:
+    stripped_line = constants_module.BLOCKQUOTE_MARKER_PATTERN.sub("", "> quoted line")
+    assert stripped_line == "quoted line"
+
+
+def test_link_text_pattern_captures_anchor_text() -> None:
+    match = constants_module.LINK_TEXT_PATTERN.search("See [the docs](https://example.com) now")
+    assert match is not None
+    assert match.group(1) == "the docs"
+
+
+def test_whitespace_run_pattern_collapses_multiple_spaces() -> None:
+    collapsed_text = constants_module.WHITESPACE_RUN_PATTERN.sub(" ", "a   b\t\tc\n\nd")
+    assert collapsed_text == "a b c d"

package/hooks/hooks.json

@@ -124,6 +124,11 @@
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/windows_rmtree_blocker.py",
             "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/gh_pr_author_enforcer.py",
+            "timeout": 30
           }
         ]
       },
@@ -136,6 +141,26 @@
             "timeout": 10
           }
         ]
+      },
+      {
+        "matcher": "Agent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/pr_converge_bugteam_enforcer.py",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "Skill",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/lifecycle/pr_converge_bugteam_skill_tracker.py",
+            "timeout": 10
+          }
+        ]
       }
     ],
     "SessionStart": [
@@ -156,6 +181,11 @@
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/untracked_repo_detector.py",
             "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/gh_pr_author_session_cleanup.py",
+            "timeout": 30
           }
         ]
       }
@@ -241,6 +271,16 @@
             "timeout": 10
           }
         ]
+      },
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/gh_pr_author_restore.py",
+            "timeout": 20
+          }
+        ]
       }
     ],
     "InstructionsLoaded": [

package/hooks/lifecycle/pr_converge_bugteam_skill_tracker.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+"""PreToolUse hook: record formal bugteam Skill invocations into pr-converge state.
+
+Companion to ``pr_converge_bugteam_enforcer``. On every
+``Skill({skill: "bugteam"})`` invocation, this hook stamps
+``$CLAUDE_JOB_DIR/pr-converge-state.json`` with
+``bugteam_skill_invoked_at_head = current_head`` and
+``bugteam_skill_invoked_at_tick = tick_count`` so the enforcer can confirm
+the formal Skill fired this tick at the current HEAD before allowing any
+follow-on clean-coder audit-shaped Agent spawn.
+
+``qbug`` invocations are deliberately ignored — qbug is not an accepted
+substitute for the formal bugteam Skill at Step 5.
+
+The hook never blocks: it returns exit 0 in every branch so the Skill call
+proceeds unchanged.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import tempfile
+from pathlib import Path
+from typing import TextIO
+
+
+def _insert_hooks_tree_for_imports() -> None:
+    hooks_tree = Path(__file__).resolve().parent.parent
+    hooks_tree_string = str(hooks_tree)
+    if hooks_tree_string not in sys.path:
+        sys.path.insert(0, hooks_tree_string)
+
+
+_insert_hooks_tree_for_imports()
+
+from config.pr_converge_bugteam_enforcer_constants import (
+    BUGTEAM_SKILL_NAME,
+    SKILL_TOOL_NAME,
+    STATE_FIELD_BUGTEAM_SKILL_INVOKED_AT_HEAD,
+    STATE_FIELD_BUGTEAM_SKILL_INVOKED_AT_TICK,
+    STATE_FIELD_CURRENT_HEAD,
+    STATE_FIELD_TICK_COUNT,
+    STATE_FILE_ATOMIC_WRITE_SUFFIX,
+    STATE_FILE_JSON_INDENT_SPACES,
+)
+from config.pr_converge_bugteam_enforcer_state import (
+    load_state_dictionary,
+    resolve_state_path,
+)
+
+
+def _atomic_write_state(state_path: Path, state_by_field: dict[str, object]) -> None:
+    """Serialize state to disk atomically via tempfile + rename.
+
+    Args:
+        state_path: Destination ``pr-converge-state.json`` path.
+        state_by_field: Updated state mapping each field name to its value.
+    """
+    parent_directory = state_path.parent
+    parent_directory.mkdir(parents=True, exist_ok=True)
+    encoded_text = json.dumps(state_by_field, indent=STATE_FILE_JSON_INDENT_SPACES, sort_keys=True)
+    with tempfile.NamedTemporaryFile(
+        mode="w",
+        encoding="utf-8",
+        dir=str(parent_directory),
+        delete=False,
+        suffix=STATE_FILE_ATOMIC_WRITE_SUFFIX,
+    ) as temporary_handle:
+        temporary_handle.write(encoded_text)
+        temporary_path = Path(temporary_handle.name)
+    try:
+        os.replace(str(temporary_path), str(state_path))
+    except OSError:
+        Path(temporary_path).unlink(missing_ok=True)
+        raise
+
+
+def _emit_missing_state_warning(output_stream: TextIO) -> None:
+    """Write the missing-state warning to the provided stream.
+
+    Args:
+        output_stream: Writable text stream — production code passes
+            ``sys.stderr``; tests pass a ``StringIO`` to capture the message.
+    """
+    output_stream.write(
+        "pr_converge_bugteam_skill_tracker: state file lacks current_head or "
+        "tick_count; bugteam invocation NOT recorded\n"
+    )
+    output_stream.flush()
+
+
+def _record_bugteam_skill_invocation(
+    state_by_field: dict[str, object],
+) -> dict[str, object] | None:
+    """Return a copy of state with bugteam-Skill invocation fields stamped, or None on no-op.
+
+    The two stamp fields are owned exclusively by this tracker. Concurrent
+    writes from the orchestrator never touch them, so the read-modify-write
+    window cannot lose an orchestrator update on these specific keys.
+
+    When ``current_head`` (str) or ``tick_count`` (int) is missing or wrong-typed,
+    the function emits a stderr warning via ``_emit_missing_state_warning`` and
+    returns ``None`` so the caller skips the disk write entirely. Skipping the
+    no-op write narrows the read-modify-write window against the orchestrator —
+    concurrent updates to non-stamp fields (``phase``, ``tick_count``, etc.)
+    cannot be silently lost by a tracker rewrite that changes nothing.
+
+    Args:
+        state_by_field: Existing pr-converge state mapping each field name to
+            its value.
+
+    Returns:
+        New dictionary identical to ``state_by_field`` plus
+        ``bugteam_skill_invoked_at_head`` set to ``current_head`` and
+        ``bugteam_skill_invoked_at_tick`` set to ``tick_count`` when both
+        source fields are present and well-typed; ``None`` when either source
+        field is missing or wrong-typed, signaling the caller to skip the
+        atomic write.
+    """
+    current_head = state_by_field.get(STATE_FIELD_CURRENT_HEAD)
+    current_tick = state_by_field.get(STATE_FIELD_TICK_COUNT)
+    if not isinstance(current_head, str) or not isinstance(current_tick, int):
+        _emit_missing_state_warning(sys.stderr)
+        return None
+    updated_state: dict[str, object] = dict(state_by_field)
+    updated_state[STATE_FIELD_BUGTEAM_SKILL_INVOKED_AT_HEAD] = current_head
+    updated_state[STATE_FIELD_BUGTEAM_SKILL_INVOKED_AT_TICK] = current_tick
+    return updated_state
+
+
+def _is_formal_bugteam_skill_invocation(payload_by_field: dict[str, object]) -> bool:
+    """Return True when this hook invocation matches the formal bugteam Skill.
+
+    Args:
+        payload_by_field: The full PreToolUse hook payload (already JSON-parsed),
+            keyed by top-level field name.
+
+    Returns:
+        True when ``tool_name == "Skill"`` and ``tool_input["skill"]
+        == "bugteam"``. Returns False for qbug and every other skill.
+    """
+    if payload_by_field.get("tool_name", "") != SKILL_TOOL_NAME:
+        return False
+    tool_input = payload_by_field.get("tool_input", {})
+    if not isinstance(tool_input, dict):
+        return False
+    return tool_input.get("skill", "") == BUGTEAM_SKILL_NAME
+
+
+def _emit_state_write_error(state_write_error: OSError, output_stream: TextIO) -> None:
+    """Write the state-write failure message to the provided stream.
+
+    Args:
+        state_write_error: The OSError raised by ``_atomic_write_state``.
+        output_stream: Writable text stream — production code passes
+            ``sys.stderr``; tests pass a ``StringIO`` to capture the message.
+    """
+    output_stream.write(
+        f"pr_converge_bugteam_skill_tracker: state write failed; "
+        f"stamp not recorded: {state_write_error}\n"
+    )
+    output_stream.flush()
+
+
+def main() -> None:
+    """Tracker entry point for the PreToolUse:Skill hook.
+
+    Reads the PreToolUse payload from stdin, records a formal
+    ``Skill({skill: "bugteam"})`` invocation in the pr-converge state file,
+    and always returns 0 — including on a state-write failure, since a
+    non-zero PreToolUse exit would block the very Skill invocation this
+    hook exists to record. State-write failures are surfaced via
+    ``_emit_state_write_error`` to stderr so the operator still sees the
+    protocol-corruption signal.
+    """
+    try:
+        hook_payload = json.load(sys.stdin)
+    except json.JSONDecodeError:
+        return
+    if not isinstance(hook_payload, dict):
+        return
+    if not _is_formal_bugteam_skill_invocation(hook_payload):
+        return
+    state_path = resolve_state_path()
+    if state_path is None:
+        return
+    parsed_state = load_state_dictionary(state_path)
+    if parsed_state is None:
+        return
+    updated_state = _record_bugteam_skill_invocation(parsed_state)
+    if updated_state is None:
+        return
+    try:
+        _atomic_write_state(state_path, updated_state)
+    except OSError as state_write_error:
+        _emit_state_write_error(state_write_error, sys.stderr)
+        return
+    return
+
+
+if __name__ == "__main__":
+    main()

package/hooks/lifecycle/test_pr_converge_bugteam_skill_tracker.py

@@ -0,0 +1,283 @@
+"""Unit tests for the pr_converge_bugteam_skill_tracker PreToolUse hook.
+
+Covers the bugteam-only update path: only Skill({skill: "bugteam"}) updates
+the invocation fields in $CLAUDE_JOB_DIR/pr-converge-state.json (the file
+named by PR_CONVERGE_STATE_FILENAME). qbug, other skills, and missing-state
+cases all return exit 0 without modifying state.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import io
+import json
+import pathlib
+import sys
+from typing import Any
+from unittest import mock
+
+import pytest
+
+_HOOK_DIR = pathlib.Path(__file__).parent
+_HOOKS_TREE = _HOOK_DIR.parent
+for each_path in (str(_HOOK_DIR), str(_HOOKS_TREE)):
+    if each_path not in sys.path:
+        sys.path.insert(0, each_path)
+
+hook_spec = importlib.util.spec_from_file_location(
+    "pr_converge_bugteam_skill_tracker",
+    _HOOK_DIR / "pr_converge_bugteam_skill_tracker.py",
+)
+assert hook_spec is not None
+assert hook_spec.loader is not None
+hook_module = importlib.util.module_from_spec(hook_spec)
+hook_spec.loader.exec_module(hook_module)
+
+from config.pr_converge_bugteam_enforcer_constants import (
+    CLAUDE_JOB_DIR_ENV_VAR,
+    PR_CONVERGE_STATE_FILENAME,
+)
+
+_HEAD_SHA = "abc123def456abc123def456abc123def456abcd"
+_TICK_COUNT = 4
+
+
+def _write_state(state_directory: pathlib.Path, state: dict[str, Any]) -> pathlib.Path:
+    state_path = state_directory / PR_CONVERGE_STATE_FILENAME
+    state_path.write_text(json.dumps(state), encoding="utf-8")
+    return state_path
+
+
+def _baseline_state() -> dict[str, Any]:
+    return {
+        "phase": "BUGTEAM",
+        "current_head": _HEAD_SHA,
+        "tick_count": _TICK_COUNT,
+        "bugteam_skill_invoked_at_head": None,
+        "bugteam_skill_invoked_at_tick": None,
+    }
+
+
+def _read_state(state_directory: pathlib.Path) -> dict[str, Any]:
+    state_path = state_directory / PR_CONVERGE_STATE_FILENAME
+    return json.loads(state_path.read_text(encoding="utf-8"))
+
+
+def _run_main_with_io(input_text: str) -> None:
+    with mock.patch("sys.stdin", io.StringIO(input_text)):
+        with mock.patch("sys.stdout", new_callable=io.StringIO):
+            try:
+                hook_module.main()
+            except SystemExit:
+                pass
+
+
+def _run_main_capturing_stderr(input_text: str) -> str:
+    with mock.patch("sys.stdin", io.StringIO(input_text)):
+        with mock.patch("sys.stdout", new_callable=io.StringIO):
+            with mock.patch("sys.stderr", new_callable=io.StringIO) as captured_stderr:
+                try:
+                    hook_module.main()
+                except SystemExit:
+                    pass
+                return captured_stderr.getvalue()
+
+
+@pytest.fixture()
+def claude_job_directory(tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch) -> pathlib.Path:
+    monkeypatch.setenv(CLAUDE_JOB_DIR_ENV_VAR, str(tmp_path))
+    return tmp_path
+
+
+def test_should_record_invocation_when_bugteam_skill_fires(
+    claude_job_directory: pathlib.Path,
+) -> None:
+    _write_state(claude_job_directory, _baseline_state())
+    skill_payload: dict[str, Any] = {
+        "tool_name": "Skill",
+        "tool_input": {"skill": "bugteam", "args": "https://github.com/o/r/pull/1"},
+    }
+    _run_main_with_io(json.dumps(skill_payload))
+    updated_state = _read_state(claude_job_directory)
+    assert updated_state["bugteam_skill_invoked_at_head"] == _HEAD_SHA
+    assert updated_state["bugteam_skill_invoked_at_tick"] == _TICK_COUNT
+
+
+def test_should_not_record_invocation_when_qbug_skill_fires(
+    claude_job_directory: pathlib.Path,
+) -> None:
+    _write_state(claude_job_directory, _baseline_state())
+    qbug_payload: dict[str, Any] = {
+        "tool_name": "Skill",
+        "tool_input": {"skill": "qbug"},
+    }
+    _run_main_with_io(json.dumps(qbug_payload))
+    updated_state = _read_state(claude_job_directory)
+    assert updated_state["bugteam_skill_invoked_at_head"] is None
+    assert updated_state["bugteam_skill_invoked_at_tick"] is None
+
+
+def test_should_ignore_unrelated_skills(
+    claude_job_directory: pathlib.Path,
+) -> None:
+    _write_state(claude_job_directory, _baseline_state())
+    other_payload: dict[str, Any] = {
+        "tool_name": "Skill",
+        "tool_input": {"skill": "agent-prompt"},
+    }
+    _run_main_with_io(json.dumps(other_payload))
+    updated_state = _read_state(claude_job_directory)
+    assert updated_state["bugteam_skill_invoked_at_head"] is None
+
+
+def test_should_ignore_non_skill_tools(
+    claude_job_directory: pathlib.Path,
+) -> None:
+    _write_state(claude_job_directory, _baseline_state())
+    agent_payload: dict[str, Any] = {
+        "tool_name": "Agent",
+        "tool_input": {"subagent_type": "clean-coder", "prompt": "fix this"},
+    }
+    _run_main_with_io(json.dumps(agent_payload))
+    updated_state = _read_state(claude_job_directory)
+    assert updated_state["bugteam_skill_invoked_at_head"] is None
+
+
+def test_should_no_op_when_state_file_absent(
+    claude_job_directory: pathlib.Path,
+) -> None:
+    skill_payload: dict[str, Any] = {
+        "tool_name": "Skill",
+        "tool_input": {"skill": "bugteam"},
+    }
+    _run_main_with_io(json.dumps(skill_payload))
+    assert not (claude_job_directory / PR_CONVERGE_STATE_FILENAME).exists()
+
+
+def test_should_no_op_when_state_json_is_malformed(
+    claude_job_directory: pathlib.Path,
+) -> None:
+    state_path = claude_job_directory / PR_CONVERGE_STATE_FILENAME
+    state_path.write_text("{not valid json", encoding="utf-8")
+    skill_payload: dict[str, Any] = {
+        "tool_name": "Skill",
+        "tool_input": {"skill": "bugteam"},
+    }
+    _run_main_with_io(json.dumps(skill_payload))
+    assert state_path.read_text(encoding="utf-8") == "{not valid json"
+
+
+def test_should_preserve_other_state_fields_on_update(
+    claude_job_directory: pathlib.Path,
+) -> None:
+    baseline_state = _baseline_state()
+    baseline_state["bugbot_clean_at"] = _HEAD_SHA
+    baseline_state["copilot_wait_count"] = 2
+    _write_state(claude_job_directory, baseline_state)
+    skill_payload: dict[str, Any] = {
+        "tool_name": "Skill",
+        "tool_input": {"skill": "bugteam"},
+    }
+    _run_main_with_io(json.dumps(skill_payload))
+    updated_state = _read_state(claude_job_directory)
+    assert updated_state["bugbot_clean_at"] == _HEAD_SHA
+    assert updated_state["copilot_wait_count"] == 2
+    assert updated_state["bugteam_skill_invoked_at_head"] == _HEAD_SHA
+
+
+def test_should_no_op_when_claude_job_dir_env_var_absent(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv(CLAUDE_JOB_DIR_ENV_VAR, raising=False)
+    skill_payload: dict[str, Any] = {
+        "tool_name": "Skill",
+        "tool_input": {"skill": "bugteam"},
+    }
+    _run_main_with_io(json.dumps(skill_payload))
+
+
+def test_should_no_op_when_payload_is_malformed_json(
+    claude_job_directory: pathlib.Path,
+) -> None:
+    baseline_state = _baseline_state()
+    _write_state(claude_job_directory, baseline_state)
+    _run_main_with_io("not valid json {{{")
+    updated_state = _read_state(claude_job_directory)
+    assert updated_state["bugteam_skill_invoked_at_head"] is None
+
+
+def test_should_leave_state_unchanged_when_current_head_is_missing(
+    claude_job_directory: pathlib.Path,
+) -> None:
+    state_without_head = _baseline_state()
+    del state_without_head["current_head"]
+    _write_state(claude_job_directory, state_without_head)
+    skill_payload: dict[str, Any] = {
+        "tool_name": "Skill",
+        "tool_input": {"skill": "bugteam"},
+    }
+    captured_stderr = _run_main_capturing_stderr(json.dumps(skill_payload))
+    updated_state = _read_state(claude_job_directory)
+    assert "current_head" not in updated_state
+    assert updated_state.get("bugteam_skill_invoked_at_head") is None
+    assert updated_state.get("bugteam_skill_invoked_at_tick") is None
+    assert "current_head or tick_count" in captured_stderr
+
+
+def test_should_leave_state_unchanged_when_tick_count_is_missing(
+    claude_job_directory: pathlib.Path,
+) -> None:
+    state_without_tick = _baseline_state()
+    del state_without_tick["tick_count"]
+    _write_state(claude_job_directory, state_without_tick)
+    skill_payload: dict[str, Any] = {
+        "tool_name": "Skill",
+        "tool_input": {"skill": "bugteam"},
+    }
+    captured_stderr = _run_main_capturing_stderr(json.dumps(skill_payload))
+    updated_state = _read_state(claude_job_directory)
+    assert "tick_count" not in updated_state
+    assert updated_state.get("bugteam_skill_invoked_at_head") is None
+    assert updated_state.get("bugteam_skill_invoked_at_tick") is None
+    assert "current_head or tick_count" in captured_stderr
+
+
+def test_should_preserve_prior_stamp_when_current_head_becomes_missing(
+    claude_job_directory: pathlib.Path,
+) -> None:
+    prior_head = "feedface0000feedface0000feedface0000feed"
+    prior_tick = 3
+    state_with_prior_stamp = _baseline_state()
+    state_with_prior_stamp["bugteam_skill_invoked_at_head"] = prior_head
+    state_with_prior_stamp["bugteam_skill_invoked_at_tick"] = prior_tick
+    del state_with_prior_stamp["current_head"]
+    _write_state(claude_job_directory, state_with_prior_stamp)
+    skill_payload: dict[str, Any] = {
+        "tool_name": "Skill",
+        "tool_input": {"skill": "bugteam"},
+    }
+    _run_main_capturing_stderr(json.dumps(skill_payload))
+    updated_state = _read_state(claude_job_directory)
+    assert updated_state["bugteam_skill_invoked_at_head"] == prior_head
+    assert updated_state["bugteam_skill_invoked_at_tick"] == prior_tick
+
+
+def test_should_skip_atomic_write_when_state_missing_required_fields(
+    claude_job_directory: pathlib.Path,
+) -> None:
+    state_without_head = _baseline_state()
+    del state_without_head["current_head"]
+    _write_state(claude_job_directory, state_without_head)
+    skill_payload: dict[str, Any] = {
+        "tool_name": "Skill",
+        "tool_input": {"skill": "bugteam"},
+    }
+    with mock.patch.object(hook_module, "_atomic_write_state") as patched_atomic_write:
+        with mock.patch("sys.stdin", io.StringIO(json.dumps(skill_payload))):
+            with mock.patch("sys.stdout", new_callable=io.StringIO):
+                with mock.patch("sys.stderr", new_callable=io.StringIO):
+                    try:
+                        hook_module.main()
+                    except SystemExit:
+                        pass
+        assert patched_atomic_write.call_count == 0