claude-dev-env 2.11.0 → 2.13.0

package/hooks/blocking/verified_commit_message_accuracy_blocker.py

@@ -1,167 +0,0 @@
-#!/usr/bin/env python3
-"""PreToolUse hook: keep verified-commit exemption messages accurate.
-
-The verified-commit gate exempts a branch surface only when every changed path
-matches one of two narrow rules, implemented in ``is_verification_exempt_diff``:
-
-1. file extension in ``DOCS_ONLY_EXTENSIONS`` (docs and image extensions), or
-2. a ``.py`` file whose docstring/comment-stripped AST is unchanged.
-
-A comment-only change to a non-Python, non-doc file (for example ``.sh``,
-``.json``, ``.yaml``) is therefore NOT exempt: comments are ignored for
-exemption purposes only inside Python files via the AST path. A corrective or
-guard message that claims comment-only or docs-only surfaces are blanket exempt
-overstates the rule and misleads users into expecting such a change to skip
-verification.
-
-This hook fires on Write/Edit of any verified-commit constants module and denies
-content whose exemption-claim wording asserts a blanket comment-only or docs-only
-exemption. It guards the message constants at authoring time, before the change
-reaches review.
-"""
-
-import json
-import os
-import re
-import sys
-from pathlib import Path
-
-_hooks_dir = str(Path(__file__).resolve().parent.parent)
-if _hooks_dir not in sys.path:
-    sys.path.insert(0, _hooks_dir)
-
-from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
-
-
-def is_guarded_file(file_path: str) -> bool:
-    """Return True for any verified-commit constants module carrying messages."""
-    all_guarded_file_names = frozenset({"verified_commit_constants.py"})
-    return os.path.basename(file_path) in all_guarded_file_names
-
-
-def join_adjacent_string_literals(written_text: str) -> str:
-    """Collapse a closing quote, inter-literal whitespace, and an opening quote.
-
-    Write/Edit content carries the message constant as it appears in source: a
-    long sentence split across adjacent Python string literals. Between two
-    literals sit a closing quote, a newline, indentation, and an opening quote.
-    Replacing that run with a single space rejoins the prose so a phrase wrapped
-    across a literal boundary — for example ``exempt "`` then ``"automatically``
-    — reads as one continuous clause for matching.
-    """
-    inter_literal_noise_pattern = re.compile(r"[\"']\s*[\"']")
-    return inter_literal_noise_pattern.sub(" ", written_text)
-
-
-def claims_blanket_comment_exemption(written_text: str) -> bool:
-    """Return True when the text claims comment surfaces are blanket-exempt.
-
-    Rejoins source-wrapped string literals first, then matches only a genuine
-    blanket form in which a comment surface is the grammatical subject of
-    "exempt automatically". A comment surface is the bare noun ``comments`` or
-    the ``comment-only`` category — never the ``comment`` stem inside an
-    unrelated word such as ``commentary`` or the ``comment-stripped`` AST
-    qualifier.
-
-    Two blanket shapes match. The direct shape names a comment surface as the
-    immediate subject of "(are|is) exempt automatically" across a bridge that
-    crosses no period, semicolon, or comma, so an intervening predicate (for
-    example "Comments are handled, and docs are exempt automatically") leaves
-    docs, not comments, as the exemption subject and does not match. The
-    enumerated shape names a comment item inside an "...-only surfaces are
-    exempt automatically" list (for example "Docs-, comment-, and test-only
-    surfaces are exempt automatically").
-
-    An accurate sentence whose true exemption subject is docs, or that qualifies
-    comments as the stripped input to the AST comparison, does not match. This
-    isolates the overstated form the verified-commit gate does not honor for
-    non-Python files.
-    """
-    comment_surface = r"comments?-only|comments?\b(?!-)"
-    blanket_direct_claim = (
-        "(?:" + comment_surface + r")(?:[^.;,]*?\b)?(?:are|is)\s+exempt\s+automatically"
-    )
-    blanket_enumerated_claim = (
-        "(?:" + comment_surface + "|comment-)"
-        r"[^.;]*?-only\s+surfaces\s+are\s+exempt\s+automatically"
-    )
-    blanket_exemption_claim_pattern = re.compile(
-        "(?:" + blanket_direct_claim + ")|(?:" + blanket_enumerated_claim + ")",
-        re.IGNORECASE,
-    )
-    joined_text = join_adjacent_string_literals(written_text)
-    return bool(blanket_exemption_claim_pattern.search(joined_text))
-
-
-def build_corrective_message() -> str:
-    """Return the deny reason explaining the real, narrower exemption rules."""
-    accurate_exemption_phrasing = (
-        "Docs and images are exempt by extension, and Python files whose "
-        "docstring- and comment-stripped AST is unchanged; a comment-only "
-        "change to a non-Python file still needs a verdict."
-    )
-    return (
-        "BLOCKED [verified-commit-message-accuracy]: this exemption message "
-        "claims comment-only surfaces are exempt automatically, but the "
-        "verified-commit gate exempts comments only inside Python files (via the "
-        "docstring/comment stripped AST path). A comment-only change to a "
-        "non-Python file is NOT exempt and still needs a verifier verdict, so "
-        "the blanket wording misleads users.\n\nDescribe the real exemption "
-        "rules instead, for example:\n  " + accurate_exemption_phrasing
-    )
-
-
-def extract_written_text(all_written_fields: dict[str, str]) -> str:
-    """Return the Write ``content`` and Edit ``new_string`` joined for scanning."""
-    return (
-        all_written_fields.get("content", "")
-        + "\n"
-        + all_written_fields.get("new_string", "")
-    )
-
-
-def main() -> None:
-    all_write_edit_tools = frozenset({"Write", "Edit"})
-    try:
-        hook_input = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        sys.exit(0)
-
-    tool_name = hook_input.get("tool_name", "")
-    if tool_name not in all_write_edit_tools:
-        sys.exit(0)
-
-    tool_input = hook_input.get("tool_input", {})
-    file_path = tool_input.get("file_path", "")
-    if not file_path:
-        sys.exit(0)
-
-    if not is_guarded_file(file_path):
-        sys.exit(0)
-
-    written_text = extract_written_text(tool_input)
-    if not claims_blanket_comment_exemption(written_text):
-        sys.exit(0)
-
-    corrective_message = build_corrective_message()
-    deny_response = {
-        "hookSpecificOutput": {
-            "hookEventName": "PreToolUse",
-            "permissionDecision": "deny",
-            "permissionDecisionReason": corrective_message,
-        }
-    }
-    log_hook_block(
-        calling_hook_name="verified_commit_message_accuracy_blocker.py",
-        hook_event="PreToolUse",
-        block_reason=corrective_message,
-        tool_name=tool_name,
-        offending_input_preview=file_path,
-    )
-    print(json.dumps(deny_response))
-    sys.stdout.flush()
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/hooks/blocking/verifier_verdict_minter.py

@@ -1,280 +0,0 @@
-"""SubagentStop hook: mint a commit-gate verdict when code-verifier finishes.
-
-Only this hook writes verdict files — the main session is denied writes to
-the verdict directory, so a session cannot fabricate a passing verdict. The
-SubagentStop payload names the stopping subagent's own transcript
-(``agent_transcript_path``), which sits beside a harness-written
-``agent-<id>.meta.json`` sidecar naming the spawning ``agentType``. The hook
-reads that type from the sidecar, so it resolves identically in interactive,
-background, and worktree-switched sessions; only the harness writes the
-sidecar, so the type it records cannot be forged. When that type is
-``code-verifier``, the hook pulls the verdict block out of the agent's own
-transcript (``agent_transcript_path``), recomputes the live change-surface
-hash for the session repository, and writes the verdict bound to that hash.
-The companion ``verified_commit_gate.py`` (PreToolUse) then allows ``git
-commit`` / ``git push`` only while the work tree still matches the verified
-state.
-
-The verifier's final message must end with a fenced block::
-
-    ```verdict
-    {"all_pass": true, "findings": []}
-    ```
-
-A missing or unparseable block mints nothing, which leaves the gate closed.
-"""
-
-from __future__ import annotations
-
-import json
-import re
-import sys
-from pathlib import Path
-
-blocking_directory = str(Path(__file__).resolve().parent)
-if blocking_directory not in sys.path:
-    sys.path.insert(0, blocking_directory)
-
-from verified_commit_config_bootstrap import (  # noqa: E402
-    register_verified_commit_constants,
-)
-
-register_verified_commit_constants()
-
-from config.verified_commit_constants import (
-    MINTING_AGENT_TYPE,
-    VERDICT_KEY_MANIFEST_SHA256,
-)
-from verification_verdict_store import (
-    branch_surface_manifest,
-    empty_surface_hash,
-    manifest_sha256,
-    resolve_merge_base,
-    resolve_repo_root,
-    write_verdict,
-)
-
-
-def assistant_text_blocks(transcript_path: str) -> list[str]:
-    """Collect every assistant text block from a transcript JSONL file.
-
-    Args:
-        transcript_path: Path to the subagent's transcript.
-
-    Returns:
-        The text of each assistant content block, in transcript order;
-        empty when the file is missing or holds no assistant text.
-    """
-    collected_blocks: list[str] = []
-    try:
-        transcript_lines = (
-            Path(transcript_path).read_text(encoding="utf-8", errors="replace").splitlines()
-        )
-    except OSError:
-        return collected_blocks
-    for each_line in transcript_lines:
-        try:
-            transcript_entry = json.loads(each_line)
-        except json.JSONDecodeError:
-            continue
-        if not isinstance(transcript_entry, dict):
-            continue
-        if transcript_entry.get("type") != "assistant":
-            continue
-        message_body = transcript_entry.get("message")
-        if not isinstance(message_body, dict):
-            continue
-        content_blocks = message_body.get("content")
-        if not isinstance(content_blocks, list):
-            continue
-        for each_block in content_blocks:
-            if isinstance(each_block, dict) and each_block.get("type") == "text":
-                block_text = each_block.get("text")
-                if isinstance(block_text, str):
-                    collected_blocks.append(block_text)
-    return collected_blocks
-
-
-def last_verdict_in_blocks(all_text_blocks: list[str]) -> dict | None:
-    """Extract the final verdict fence from assistant text blocks.
-
-    Args:
-        all_text_blocks: Assistant text blocks in transcript order.
-
-    Returns:
-        The parsed verdict mapping carrying a boolean ``all_pass`` and a
-        list ``findings``, or None when no block holds a wellformed fence.
-    """
-    verdict_fence_pattern = re.compile(r"```verdict\s*\n(.*?)```", re.DOTALL)
-    fence_bodies: list[str] = []
-    for each_block in all_text_blocks:
-        fence_bodies.extend(verdict_fence_pattern.findall(each_block))
-    for each_fence_body in reversed(fence_bodies):
-        try:
-            verdict_record = json.loads(each_fence_body)
-        except json.JSONDecodeError:
-            continue
-        if not isinstance(verdict_record, dict):
-            continue
-        if not isinstance(verdict_record.get("all_pass"), bool):
-            continue
-        if not isinstance(verdict_record.get("findings"), list):
-            continue
-        return verdict_record
-    return None
-
-
-def _agent_type_from_meta_sidecar(agent_transcript_path: str) -> str | None:
-    """Read the spawning agentType from a subagent transcript's sidecar.
-
-    Each subagent transcript ``agent-<id>.jsonl`` sits beside a harness-written
-    ``agent-<id>.meta.json`` naming the spawning ``agentType``. Reading the type
-    from this sidecar binds it to the stopping subagent itself, so it resolves
-    identically in interactive, background, and worktree-switched sessions and
-    needs no parent-transcript scan or flush retry. Only the harness writes this
-    sidecar, so a session cannot forge the type it reports.
-
-    Args:
-        agent_transcript_path: The stopping subagent's own transcript path from
-            the SubagentStop payload.
-
-    Returns:
-        The recorded ``agentType``, or None when the path is empty, the sidecar
-        is absent, unreadable, or unparseable, it does not hold a JSON object,
-        or it names no string ``agentType``.
-    """
-    if not agent_transcript_path:
-        return None
-    transcript_file = Path(agent_transcript_path)
-    sidecar_file = transcript_file.with_name(f"{transcript_file.stem}.meta.json")
-    try:
-        sidecar_record = json.loads(sidecar_file.read_text(encoding="utf-8"))
-    except (OSError, UnicodeDecodeError, json.JSONDecodeError):
-        return None
-    if not isinstance(sidecar_record, dict):
-        return None
-    recorded_type = sidecar_record.get("agentType")
-    return recorded_type if isinstance(recorded_type, str) else None
-
-
-def resolved_subagent_type(subagent_stop_payload: dict) -> str | None:
-    """Recover the spawning agent type for a SubagentStop payload.
-
-    The stopping subagent's own transcript (``agent_transcript_path``) sits
-    beside a harness-written ``agent-<id>.meta.json`` sidecar naming its
-    ``agentType``. The type comes solely from that sidecar, which only the
-    harness writes — the main session can neither write the sidecar nor forge
-    the agentType it records. A verdict fence in the transcript is never used to
-    infer the type, because the main session controls the prompt of any
-    Agent-tool subagent it spawns and could instruct one to print such a fence.
-
-    Args:
-        subagent_stop_payload: The SubagentStop hook payload.
-
-    Returns:
-        The agent type the sidecar records, or None when the
-        ``agent_transcript_path`` is empty, the sidecar is absent, unreadable,
-        or unparseable, it does not hold a JSON object, or it names no string
-        ``agentType``.
-    """
-    return _agent_type_from_meta_sidecar(
-        subagent_stop_payload.get("agent_transcript_path", "")
-    )
-
-
-def _attested_or_recomputed_hash(verdict_record: dict, repo_root: str) -> str | None:
-    """Choose the surface hash the minted verdict binds to.
-
-    A code-verifier that verifies a work tree other than the stop event's cwd
-    attests the surface it checked by emitting ``manifest_sha256`` in its
-    verdict fence (computed against the verified work tree via the
-    ``--manifest-hash`` CLI). Binding the minted verdict to that attested hash
-    keeps the verdict tied to the code actually verified rather than the
-    subagent's cwd, so a verdict earned for one work tree clears a commit in a
-    sibling work tree of the same surface. When the fence attests no hash, the
-    minter recomputes one from the cwd work tree, which is correct whenever the
-    verifier ran in the work tree it verified.
-
-    Returns None (mints nothing) in two empty-surface cases:
-
-    - The attested hash equals ``empty_surface_hash()`` — the verifier called
-      the store CLI on a wrong (empty) work tree and the hash it got back
-      represents nothing.
-    - The recompute branch produces an empty manifest — the cwd work tree also
-      has no changed or untracked files versus the merge base.
-
-    Args:
-        verdict_record: The parsed verdict fence from the verifier transcript.
-        repo_root: The work-tree root resolved from the stop event's cwd, used
-            for the recompute fallback.
-
-    Returns:
-        The attested ``manifest_sha256`` when the fence carries a non-empty
-        string one that is not the empty-surface sentinel; the cwd work tree's
-        recomputed surface hash when the fence attests nothing and the surface
-        is non-empty; or None when the attested hash is the empty-surface
-        sentinel, the surface manifest is empty, or no upstream base resolves.
-    """
-    attested_manifest_sha256 = verdict_record.get(VERDICT_KEY_MANIFEST_SHA256)
-    if isinstance(attested_manifest_sha256, str) and attested_manifest_sha256:
-        if attested_manifest_sha256 == empty_surface_hash():
-            return None
-        return attested_manifest_sha256
-    merge_base_sha = resolve_merge_base(repo_root)
-    if merge_base_sha is None:
-        return None
-    surface_manifest_text = branch_surface_manifest(repo_root, merge_base_sha)
-    if not surface_manifest_text:
-        return None
-    return manifest_sha256(surface_manifest_text)
-
-
-def mint_for_payload(subagent_stop_payload: dict) -> Path | None:
-    """Mint a verdict file for a code-verifier stop event.
-
-    Args:
-        subagent_stop_payload: The SubagentStop hook payload.
-
-    Returns:
-        The verdict file path when minted; None when the payload is not a
-        code-verifier stop, the transcript holds no verdict, the cwd is not a
-        work tree, or — for a verdict that attests no ``manifest_sha256`` of
-        its own — that work tree has no upstream base to recompute the surface
-        hash from.
-    """
-    if resolved_subagent_type(subagent_stop_payload) != MINTING_AGENT_TYPE:
-        return None
-    agent_transcript_path = subagent_stop_payload.get("agent_transcript_path", "")
-    if not agent_transcript_path:
-        return None
-    verdict_record = last_verdict_in_blocks(assistant_text_blocks(agent_transcript_path))
-    if verdict_record is None:
-        return None
-    repo_root = resolve_repo_root(subagent_stop_payload.get("cwd", "."))
-    if repo_root is None:
-        return None
-    bound_manifest_sha256 = _attested_or_recomputed_hash(verdict_record, repo_root)
-    if bound_manifest_sha256 is None:
-        return None
-    return write_verdict(
-        repo_root,
-        bound_manifest_sha256,
-        verdict_record["all_pass"],
-        verdict_record["findings"],
-        str(subagent_stop_payload.get("agent_id", "")),
-    )
-
-
-def main() -> None:
-    """Read the SubagentStop payload and mint a verdict when one applies."""
-    try:
-        subagent_stop_payload = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        return
-    if not isinstance(subagent_stop_payload, dict):
-        return
-    mint_for_payload(subagent_stop_payload)
-
-
-if __name__ == "__main__":
-    main()

package/hooks/hooks_constants/code_verifier_spawn_preflight_gate_constants.py

@@ -1,64 +0,0 @@
-"""Configuration constants for the code_verifier_spawn_preflight_gate hook.
-
-The gate denies an ``Agent`` or ``Task`` spawn whose ``subagent_type`` is
-``code-verifier`` when the branch carries a merge conflict against its base
-ref, a CODE_RULES violation on a line added in the working tree since the merge
-base (committed on the branch or uncommitted), or a CODE_RULES engine
-import/load failure. It runs those pre-flight checks before the expensive
-verification spawn and addresses its deny reason to the spawning agent so that
-agent fixes the named issues and re-spawns. Environmental git failures stay
-fail-open; engine import/load failure is fail-closed. Every literal the hook
-body reads lives here; ``AGENT_TOOL_NAME`` comes from
-``pr_converge_bugteam_enforcer_constants`` and joins ``TASK_TOOL_NAME`` in
-``ALL_CODE_VERIFIER_SPAWN_TOOL_NAMES`` so both spawn tool names share one source.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-from hooks_constants.pr_converge_bugteam_enforcer_constants import AGENT_TOOL_NAME
-
-CODE_VERIFIER_SUBAGENT_TYPE: str = "code-verifier"
-TASK_TOOL_NAME: str = "Task"
-ALL_CODE_VERIFIER_SPAWN_TOOL_NAMES: frozenset[str] = frozenset(
-    {AGENT_TOOL_NAME, TASK_TOOL_NAME}
-)
-
-ALL_MERGE_TREE_COMMAND_FLAGS: tuple[str, ...] = (
-    "merge-tree",
-    "--write-tree",
-    "--name-only",
-)
-MERGE_TREE_CONFLICT_EXIT_CODE: int = 1
-MERGE_TREE_CLEAN_EXIT_CODE: int = 0
-MERGE_TREE_TIMEOUT_SECONDS: int = 30
-
-ALL_MERGE_HEAD_PROBE_FLAGS: tuple[str, ...] = ("rev-parse", "--verify", "--quiet", "MERGE_HEAD")
-ALL_UNMERGED_PATHS_DIFF_FLAGS: tuple[str, ...] = ("diff", "--name-only", "--diff-filter=U")
-
-ALL_NAME_ONLY_WORKTREE_DIFF_FLAGS: tuple[str, ...] = (
-    "-c",
-    "core.quotePath=false",
-    "diff",
-    "--name-only",
-    "--no-renames",
-)
-ALL_UNIFIED_ZERO_DIFF_FLAGS: tuple[str, ...] = ("diff", "--unified=0")
-
-DENY_REASON_LEAD: str = (
-    "BLOCKED [code-verifier-spawn-preflight]: a code-verifier spawn "
-    "(Agent or Task tool, subagent_type code-verifier) is blocked because "
-    "the branch is not in a committable state. "
-    "Fix these, then re-spawn the code-verifier:"
-)
-MERGE_CONFLICT_SECTION_HEADER: str = "Merge conflicts vs {base_ref}:"
-CODE_RULES_SECTION_HEADER: str = "CODE_RULES violations on changed lines:"
-ENGINE_LOAD_FAILURE_SECTION: str = (
-    "CODE_RULES engine failed to load:\n"
-    "  The CODE_RULES validate_content engine could not be imported or loaded "
-    "(package import/load failure). Repair the enforcer so load_validate_content "
-    "succeeds, then re-spawn code-verifier."
-)
-
-GATE_SCRIPTS_RELATIVE_PATH: Path = Path("_shared") / "pr-loop" / "scripts"

package/hooks/hooks_constants/convergence_gate_blocker_constants.py

@@ -1,53 +0,0 @@
-"""Command-parse patterns for the convergence gate's repo binding.
-
-The convergence gate keys its evidence lookup to the PR that the
-``gh pr ready`` command names. These patterns pull an explicit owner/repo
-out of the command — and, for a full PR URL, the PR number too — so the
-gate binds to the repository the command targets rather than the
-session working directory's repository when the two differ.
-
-The owner/repo and URL patterns run only over the ``gh pr ready`` segment,
-clipped at the first command separator, so a flag or URL that belongs to a
-chained command does not bind the gate to the wrong PR::
-
-    gh pr ready 161 && gh pr comment 999 --repo other-owner/other-repo
-    ^^^^^^^^^^^^^^^^                                    clipped here ^
-    -> ready segment scanned; the chained --repo is out of scope
-
-    gh pr ready 161 --repo sample-owner/target-repo
-                    ^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^
-                    flag   owner        repo         -> REPO_OVERRIDE_FLAG_PATTERN
-    gh pr ready https://github.com/sample-owner/target-repo/pull/161
-                                   ^^^^^^^^^^^^ ^^^^^^^^^^^      ^^^
-                                   owner        repo            number
-                                                -> PR_URL_OWNER_REPO_NUMBER_PATTERN
-"""
-
-GH_PR_READY_ANCHOR_PATTERN: str = r"\bgh\s+pr\s+ready\b(?![^&|;\n]*--undo)"
-
-COMMAND_SEPARATOR_PATTERN: str = r"&&|\|\||;|\||\n|(?<![>&])&(?![>&])"
-
-BASH_LINE_CONTINUATION_PATTERN: str = r"\\\r?\n[ \t]*"
-
-PR_URL_OWNER_REPO_NUMBER_PATTERN: str = (
-    r"https?://[^/]+/(?P<owner>[\w.-]+)/(?P<repo>[\w.-]+)/pull/(?P<number>\d+)"
-)
-
-REPO_OVERRIDE_FLAG_PATTERN: str = (
-    r"(?:^|\s)(?:--repo(?:=|\s+)|-R(?:=|\s+)?)"
-    r"(?:https?://[^/\s]+/|git@[^:\s]+:|(?:[\w.-]+/)*)"
-    r"(?P<owner>[\w.-]+)/(?P<repo>[\w.-]+)"
-)
-
-ALL_GH_PR_VIEW_NUMBER_COMMAND: tuple[str, ...] = (
-    "gh",
-    "pr",
-    "view",
-    "--json",
-    "number",
-    "--jq",
-    ".number",
-)
-GH_REPO_FLAG: str = "--repo"
-REPO_SLUG_TEMPLATE: str = "{owner}/{repo}"
-GIT_URL_SUFFIX: str = ".git"

package/hooks/hooks_constants/pr_converge_bugteam_enforcer_constants.py

@@ -1,55 +0,0 @@
-"""Configuration constants for the pr_converge_bugteam_enforcer hook pair.
-
-The enforcer denies ``Agent({subagent_type: "clean-coder"})`` invocations that
-substitute audit-shaped work for the formal ``Skill({skill: "bugteam"})`` call
-during Step 5 BUGTEAM of the pr-converge loop. The tracker records every
-formal ``Skill({skill: "bugteam"})`` invocation so the enforcer can confirm
-the Skill fired this tick at the current HEAD before allowing follow-on
-clean-coder spawns.
-"""
-
-from __future__ import annotations
-
-AGENT_TOOL_NAME: str = "Agent"
-SKILL_TOOL_NAME: str = "Skill"
-
-CLEAN_CODER_SUBAGENT_TYPE: str = "clean-coder"
-BUGTEAM_SKILL_NAME: str = "bugteam"
-
-PR_CONVERGE_STATE_FILENAME: str = "pr-converge-state.json"
-CLAUDE_JOB_DIR_ENV_VAR: str = "CLAUDE_JOB_DIR"
-
-BUGTEAM_PHASE: str = "BUGTEAM"
-
-STATE_FIELD_PHASE: str = "phase"
-STATE_FIELD_CURRENT_HEAD: str = "current_head"
-STATE_FIELD_TICK_COUNT: str = "tick_count"
-STATE_FIELD_BUGTEAM_SKILL_INVOKED_AT_HEAD: str = "bugteam_skill_invoked_at_head"
-STATE_FIELD_BUGTEAM_SKILL_INVOKED_AT_TICK: str = "bugteam_skill_invoked_at_tick"
-
-ALL_AUDIT_PROMPT_SUBSTRINGS: tuple[str, ...] = (
-    "audit",
-    "findings",
-    "bugteam",
-    "a-j categor",
-    "code-quality",
-    "verify_clean",
-    "converge",
-)
-
-ENFORCER_CORRECTIVE_MESSAGE: str = (
-    "BLOCKED [pr-converge-bugteam-enforcer]: Step 5 BUGTEAM advances ONLY after "
-    '`Skill({skill: "bugteam", args: "<PR URL>"})` fires this tick at the '
-    'current HEAD. Substituting an `Agent({subagent_type: "clean-coder"})` '
-    "audit call for the formal Skill invocation is a protocol violation — the "
-    "formal Skill writes the artifact `check_convergence.py`'s `bugteam_clean_at` "
-    "gate looks for, and a substituted audit silently bypasses that gate.\n\n"
-    "`qbug` is NOT an accepted substitute — `bugteam` is the only allowed skill "
-    "at this step.\n\n"
-    'Run `Skill({skill: "bugteam", args: "<PR URL>"})` first. Follow-on '
-    "clean-coder fix spawns are allowed once the formal Skill has registered at "
-    "the current HEAD and tick."
-)
-
-STATE_FILE_ATOMIC_WRITE_SUFFIX: str = ".tmp"
-STATE_FILE_JSON_INDENT_SPACES: int = 2

package/hooks/hooks_constants/pr_converge_bugteam_enforcer_state.py

@@ -1,67 +0,0 @@
-"""Shared state-loading helpers for the pr_converge_bugteam_enforcer hook pair.
-
-Both the enforcer (``pr_converge_bugteam_enforcer.py``) and the tracker
-(``pr_converge_bugteam_skill_tracker.py``) read the per-job
-``$CLAUDE_JOB_DIR/pr-converge-state.json`` file from the same per-job
-directory. This module hosts the byte-identical ``load_state_dictionary``
-and ``resolve_state_path`` helpers so each hook imports a single canonical
-definition.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-from pathlib import Path
-
-from hooks_constants.pr_converge_bugteam_enforcer_constants import (
-    CLAUDE_JOB_DIR_ENV_VAR,
-    PR_CONVERGE_STATE_FILENAME,
-)
-
-
-def load_state_dictionary(state_path: Path) -> dict[str, object] | None:
-    """Return the parsed pr-converge state, or None when absent or unparseable.
-
-    Args:
-        state_path: Absolute path to ``pr-converge-state.json``.
-
-    Returns:
-        The decoded state dictionary, or None when the file is missing,
-        malformed, empty, or not a JSON object at the root.
-    """
-    if not state_path.is_file():
-        return None
-    try:
-        raw_text = state_path.read_text(encoding="utf-8")
-    except OSError:
-        return None
-    if not raw_text.strip():
-        return None
-    try:
-        parsed_state = json.loads(raw_text)
-    except json.JSONDecodeError:
-        return None
-    if not isinstance(parsed_state, dict):
-        return None
-    return parsed_state
-
-
-def resolve_state_path() -> Path | None:
-    """Return the absolute path to the per-job ``pr-converge-state.json``.
-
-    Reads ``$CLAUDE_JOB_DIR`` from the environment and joins
-    ``PR_CONVERGE_STATE_FILENAME`` onto it. The path is returned even when
-    the file does not yet exist on disk; callers are expected to call
-    ``load_state_dictionary`` (or ``state_path.is_file()``) to check for
-    presence.
-
-    Returns:
-        Absolute path to ``$CLAUDE_JOB_DIR/pr-converge-state.json``, or
-        ``None`` when the ``CLAUDE_JOB_DIR`` environment variable is unset
-        or empty (no single-PR pr-converge job is currently active).
-    """
-    job_directory = os.environ.get(CLAUDE_JOB_DIR_ENV_VAR, "")
-    if not job_directory:
-        return None
-    return Path(job_directory) / PR_CONVERGE_STATE_FILENAME