claude-dev-env 8.84.0 → 8.85.0

package/bin/install.prompt-context.test.mjs

@@ -35,11 +35,12 @@ test('reinstall drops the retired style reminder and keeps one skill reminder ho
     mergeHooksIntoSettings(settings, hooksConfig, 'C:/Users/example/.claude', 'python');
 
     const userPromptHooks = settings.hooks.UserPromptSubmit.flatMap(eachGroup => eachGroup.hooks);
-    assert.equal(userPromptHooks.length, 4);
+    assert.equal(userPromptHooks.length, 5);
     assert.equal(userPromptHooks[0].command, userCommand);
     assert.match(userPromptHooks[1].command, /session\/skill_loaded_reminder\.py$/);
     assert.match(userPromptHooks[2].command, /session\/deepen_first_prompt\.py$/);
     assert.match(userPromptHooks[3].command, /lifecycle\/nested_project_hooks\.py$/);
+    assert.match(userPromptHooks[4].command, /blocking\/chat_reply_gate\.py$/);
     assert.ok(userPromptHooks.every(eachHook => !eachHook.command.includes('style_reminder_prompt')));
 
     const firstMerge = JSON.stringify(settings);

package/hooks/blocking/chat_reply_gate.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+"""Hook that shows the user one short chat reply per message.
+
+``reply_length_gate.py`` checks only the chat tools that post to Slack.
+A reply typed straight into the chat is no tool call, so this hook runs
+the same checks on it::
+
+    UserPromptSubmit                       -> additionalContext states the rules
+    MessageDisplay, batch before the last  -> hold the text, show nothing yet
+    MessageDisplay, last batch, passes     -> show the whole message
+    MessageDisplay, last batch, fails      -> show a draft from a small model that passes
+
+A Stop hook would see the reply only after it is on screen, so each block
+would add a second reply under the first. MessageDisplay changes the text
+before it renders. The transcript keeps the original, so the next
+UserPromptSubmit tells the agent the text the user saw.
+
+The draft comes from ``claude -p`` on DEFAULT_DRAFTER_MODEL with no setting
+sources and no tools. The draft must pass ``reply_violation``; after
+MAXIMUM_DRAFT_ATTEMPTS failed drafts, the original shows.
+
+The checks come from ``reply_length_gate.reply_violation``: at most
+MAXIMUM_SENTENCE_COUNT sentences of at most MAXIMUM_WORDS_PER_SENTENCE
+words, no mid-sentence colon, no em dash, linked pull requests, a source
+for each causal claim, and no banned word.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import uuid
+from pathlib import Path
+
+hooks_root_directory = str(Path(__file__).resolve().parent.parent)
+if hooks_root_directory not in sys.path:
+    sys.path.insert(0, hooks_root_directory)
+blocking_directory = str(Path(__file__).resolve().parent)
+if blocking_directory not in sys.path:
+    sys.path.insert(0, blocking_directory)
+
+from reply_length_gate import reply_violation
+from hooks_constants.chat_reply_gate_constants import (
+    CLAUDE_SESSION_ID_ENV_VAR,
+    DEFAULT_DRAFTER_MODEL,
+    DELTA_KEY,
+    DISPLAY_CONTENT_KEY,
+    DRAFTER_GUARD_ENV_VAR,
+    DRAFTER_MODEL_ENV_VAR,
+    DRAFTER_REQUEST_TEMPLATE,
+    DRAFTER_ERROR_KEY,
+    DRAFTER_EXECUTABLE_NAME,
+    DRAFTER_RESULT_KEY,
+    DRAFTER_RULES,
+    DRAFTER_TIMEOUT_SECONDS,
+    FINAL_KEY,
+    HELD_TEXT_FILE_PREFIX,
+    HOOK_EVENT_NAME_INPUT_KEY,
+    MAXIMUM_DRAFT_ATTEMPTS,
+    MESSAGE_DISPLAY_EVENT_NAME,
+    MESSAGE_ID_KEY,
+    REPLY_LIMIT_REMINDER,
+    SESSION_END_EVENT_NAME,
+    SESSION_ID_KEY,
+    SHOWN_DRAFT_FILE_PREFIX,
+    SHOWN_DRAFT_PREFIX,
+    STATE_FILE_ENCODING,
+    STATE_FILE_SUFFIX,
+    USER_PROMPT_SUBMIT_EVENT_NAME,
+)
+from hooks_constants.hook_block_logger import log_hook_block
+from hooks_constants.hook_specific_output_keys import (
+    HOOK_EVENT_NAME_KEY,
+    HOOK_SPECIFIC_OUTPUT_KEY,
+)
+from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
+from hooks_constants.reply_length_gate_constants import (
+    ADDITIONAL_CONTEXT_KEY,
+    ALLOW_EXIT_CODE,
+)
+from hooks_constants.session_file_id import session_file_id
+
+
+def state_file_path(file_prefix: str, state_key: object) -> Path:
+    """Return the temp file that holds one message's held text or one session's shown draft."""
+    file_name = f"{file_prefix}{session_file_id(state_key)}{STATE_FILE_SUFFIX}"
+    return Path(tempfile.gettempdir()) / file_name
+
+
+def read_state_text(state_path: Path) -> str:
+    """Return the stored text, or an empty string when the file is absent or unreadable."""
+    try:
+        return state_path.read_text(encoding=STATE_FILE_ENCODING)
+    except OSError:
+        return ""
+
+
+def write_state_text(state_path: Path, state_text: str) -> None:
+    """Store the text; a failed write leaves the shown text unchanged."""
+    try:
+        state_path.write_text(state_text, encoding=STATE_FILE_ENCODING)
+    except OSError:
+        return
+
+
+def drafter_command() -> list[str]:
+    """Return the headless claude command that drafts with no settings and no tools."""
+    return [
+        shutil.which(DRAFTER_EXECUTABLE_NAME) or DRAFTER_EXECUTABLE_NAME,
+        "-p",
+        "--model",
+        os.environ.get(DRAFTER_MODEL_ENV_VAR, DEFAULT_DRAFTER_MODEL),
+        "--setting-sources",
+        "",
+        "--tools",
+        "",
+        "--no-session-persistence",
+        "--session-id",
+        str(uuid.uuid4()),
+        "--output-format",
+        "json",
+        "--system-prompt",
+        DRAFTER_RULES,
+    ]
+
+
+def drafter_environment() -> dict[str, str]:
+    """Return the drafter's environment, marked so this hook exits inside it."""
+    environment = dict(os.environ)
+    environment[DRAFTER_GUARD_ENV_VAR] = "1"
+    environment.pop(CLAUDE_SESSION_ID_ENV_VAR, None)
+    return environment
+
+
+def ask_drafter(reply_text: str, violation: str) -> str | None:
+    """Return one draft from the small model, or None when the call fails."""
+    try:
+        completed = subprocess.run(
+            drafter_command(),
+            input=DRAFTER_REQUEST_TEMPLATE.format(violation=violation, reply_text=reply_text),
+            capture_output=True,
+            text=True,
+            timeout=DRAFTER_TIMEOUT_SECONDS,
+            env=drafter_environment(),
+            check=False,
+        )
+        drafter_output = json.loads(completed.stdout)
+        draft_text = drafter_output.get(DRAFTER_RESULT_KEY)
+    except (OSError, subprocess.TimeoutExpired, json.JSONDecodeError, AttributeError):
+        return None
+    if drafter_output.get(DRAFTER_ERROR_KEY) is True:
+        return None
+    if not isinstance(draft_text, str) or not draft_text.strip():
+        return None
+    return draft_text.strip()
+
+
+def compliant_draft(reply_text: str, violation: str) -> str | None:
+    """Return a draft that passes ``reply_violation``, or None after MAXIMUM_DRAFT_ATTEMPTS."""
+    current_violation = violation
+    for _ in range(MAXIMUM_DRAFT_ATTEMPTS):
+        draft_text = ask_drafter(reply_text, current_violation)
+        if draft_text is None:
+            continue
+        draft_violation = reply_violation(draft_text, None, None)
+        if draft_violation is None:
+            return draft_text
+        current_violation = draft_violation
+    return None
+
+
+def shown_text(all_hook_input: dict[str, object]) -> str | None:
+    """Return the text to show for this batch, or None to show the batch as it is."""
+    message_id = all_hook_input.get(MESSAGE_ID_KEY)
+    if not isinstance(message_id, str) or not message_id:
+        return None
+    held_path = state_file_path(HELD_TEXT_FILE_PREFIX, message_id)
+    held_text = read_state_text(held_path)
+    message_text = held_text + str(all_hook_input.get(DELTA_KEY) or "")
+    if not all_hook_input.get(FINAL_KEY):
+        write_state_text(held_path, message_text)
+        return ""
+    held_path.unlink(missing_ok=True)
+    shown_draft_path = state_file_path(SHOWN_DRAFT_FILE_PREFIX, all_hook_input.get(SESSION_ID_KEY))
+    violation = reply_violation(message_text, None, None)
+    draft_text = None if violation is None else compliant_draft(message_text, violation)
+    if violation is None or draft_text is None:
+        shown_draft_path.unlink(missing_ok=True)
+        return message_text if held_text else None
+    write_state_text(shown_draft_path, draft_text)
+    log_hook_block(
+        Path(__file__).name,
+        MESSAGE_DISPLAY_EVENT_NAME,
+        violation,
+        offending_input_preview=message_text,
+    )
+    return draft_text
+
+
+def write_hook_output(event_name: str, output_key: str, output_text: str) -> None:
+    """Print one hookSpecificOutput field for the event."""
+    hook_event_output = {HOOK_EVENT_NAME_KEY: event_name, output_key: output_text}
+    sys.stdout.write(json.dumps({HOOK_SPECIFIC_OUTPUT_KEY: hook_event_output}))
+
+
+def reply_limit_reminder(session_id: object) -> str:
+    """Return the reply rules, plus the draft the user saw in place of the last reply."""
+    shown_draft_path = state_file_path(SHOWN_DRAFT_FILE_PREFIX, session_id)
+    shown_draft = read_state_text(shown_draft_path)
+    if not shown_draft:
+        return REPLY_LIMIT_REMINDER
+    shown_draft_path.unlink(missing_ok=True)
+    return REPLY_LIMIT_REMINDER + SHOWN_DRAFT_PREFIX + shown_draft
+
+
+def main() -> int:
+    if os.environ.get(DRAFTER_GUARD_ENV_VAR):
+        return ALLOW_EXIT_CODE
+    hook_input = read_hook_input_dictionary_from_stdin()
+    if hook_input is None:
+        return ALLOW_EXIT_CODE
+    event_name = hook_input.get(HOOK_EVENT_NAME_INPUT_KEY)
+    if event_name == USER_PROMPT_SUBMIT_EVENT_NAME:
+        write_hook_output(
+            USER_PROMPT_SUBMIT_EVENT_NAME,
+            ADDITIONAL_CONTEXT_KEY,
+            reply_limit_reminder(hook_input.get(SESSION_ID_KEY)),
+        )
+        return ALLOW_EXIT_CODE
+    if event_name == SESSION_END_EVENT_NAME:
+        state_file_path(SHOWN_DRAFT_FILE_PREFIX, hook_input.get(SESSION_ID_KEY)).unlink(missing_ok=True)
+        return ALLOW_EXIT_CODE
+    if event_name != MESSAGE_DISPLAY_EVENT_NAME:
+        return ALLOW_EXIT_CODE
+    display_text = shown_text(hook_input)
+    if display_text is not None:
+        write_hook_output(MESSAGE_DISPLAY_EVENT_NAME, DISPLAY_CONTENT_KEY, display_text)
+    return ALLOW_EXIT_CODE
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/hooks/blocking/inventory_intent_records/records.py

@@ -33,11 +33,10 @@ from inventory_intent_records.config.intent_records_constants import (
 )
 
 from hooks_constants.session_edit_stage_gate_constants import (
-    SESSION_ID_UNSAFE_CHARACTERS_PATTERN,
     STATE_FILE_ATOMIC_WRITE_SUFFIX,
-    STATE_FILE_DEFAULT_SESSION_ID,
     STATE_FILE_JSON_INDENT_SPACES,
 )
+from hooks_constants.session_file_id import session_file_id
 
 
 def _intent_file_path(session_id: str) -> Path:
@@ -50,9 +49,7 @@ def _intent_file_path(session_id: str) -> Path:
     Returns:
         The absolute path of this session's intent-records file.
     """
-    sanitized_session_id = SESSION_ID_UNSAFE_CHARACTERS_PATTERN.sub("", session_id)
-    effective_session_id = sanitized_session_id or STATE_FILE_DEFAULT_SESSION_ID
-    file_name = f"{INTENT_FILE_PREFIX}{effective_session_id}{INTENT_FILE_SUFFIX}"
+    file_name = f"{INTENT_FILE_PREFIX}{session_file_id(session_id)}{INTENT_FILE_SUFFIX}"
     return Path(tempfile.gettempdir()) / file_name
 
 

package/hooks/blocking/pull_request_proof.py

@@ -21,10 +21,20 @@ from hooks_constants.pull_request_proof_constants import (
     ALL_VISIBLE_FILE_SUFFIXES,
     CHANGED_FILES_SEPARATOR,
     COMMAND_MARKER,
+    ALL_BASE_FLAGS,
     ALL_DEFAULT_BRANCH_REFERENCES,
     ALL_HEAD_FLAGS,
+    ALL_REPOSITORY_FLAGS,
+    BASE_FLAG_ASSIGNMENT_PREFIX,
+    COMPARE_ENDPOINT_TEMPLATE,
+    COMPARE_FILE_LIST_LIMIT,
+    COMPARE_FILE_NAMES_QUERY,
+    DEFAULT_BRANCH_QUERY,
+    GH_TIMEOUT_SECONDS,
     HEAD_FLAG_ASSIGNMENT_PREFIX,
     REMOTE_BRANCH_PREFIX,
+    REPOSITORY_ENDPOINT_TEMPLATE,
+    REPOSITORY_FLAG_ASSIGNMENT_PREFIX,
     UNREADABLE_CHANGES_REASON,
     EVAL_HEADING_PATTERN,
     EXISTING_WORK_HEADING_PATTERN,
@@ -174,28 +184,55 @@ def _shell_create_calls(command: str, working_directory: str) -> list[CreateCall
     ]
 
 
-def _head_flag_value(all_create_arguments: list[str]) -> str | None:
+def _flag_value(all_create_arguments: list[str], all_flags: frozenset[str], assignment_prefix: str) -> str | None:
     for each_position, each_argument in enumerate(all_create_arguments):
-        if each_argument in ALL_HEAD_FLAGS and each_position + 1 < len(all_create_arguments):
-            return all_create_arguments[each_position + 1]
-        if each_argument.startswith(HEAD_FLAG_ASSIGNMENT_PREFIX):
-            return each_argument[len(HEAD_FLAG_ASSIGNMENT_PREFIX) :]
+        if each_argument in all_flags and each_position + 1 < len(all_create_arguments):
+            return unquoted_token(all_create_arguments[each_position + 1])
+        if each_argument.startswith(assignment_prefix):
+            return unquoted_token(each_argument[len(assignment_prefix) :])
     return None
 
 
-def _named_head_branch(all_payload_fields: Mapping[str, object]) -> str | None:
-    create_fields = create_tool_fields(all_payload_fields)
-    head_branch = None if create_fields is None else create_fields.get("head")
-    if isinstance(head_branch, str):
-        return head_branch
+def _shell_flag_value(
+    all_payload_fields: Mapping[str, object], all_flags: frozenset[str], assignment_prefix: str
+) -> str | None:
     command = _shell_command(all_payload_fields)
     if command is None:
         return None
-    all_head_flag_values = [
-        _head_flag_value(all_create_arguments)
+    all_flag_values = [
+        _flag_value(all_create_arguments, all_flags, assignment_prefix)
         for all_create_arguments in _all_create_argument_lists(command)
     ]
-    return next((each_value for each_value in all_head_flag_values if each_value), None)
+    return next((each_value for each_value in all_flag_values if each_value), None)
+
+
+def _named_create_field(
+    all_payload_fields: Mapping[str, object], field_name: str, all_flags: frozenset[str], assignment_prefix: str
+) -> str | None:
+    create_fields = create_tool_fields(all_payload_fields)
+    field_value = None if create_fields is None else create_fields.get(field_name)
+    if isinstance(field_value, str) and field_value:
+        return field_value
+    return _shell_flag_value(all_payload_fields, all_flags, assignment_prefix)
+
+
+def _named_head_branch(all_payload_fields: Mapping[str, object]) -> str | None:
+    return _named_create_field(all_payload_fields, "head", ALL_HEAD_FLAGS, HEAD_FLAG_ASSIGNMENT_PREFIX)
+
+
+def _named_base_branch(all_payload_fields: Mapping[str, object]) -> str | None:
+    return _named_create_field(all_payload_fields, "base", ALL_BASE_FLAGS, BASE_FLAG_ASSIGNMENT_PREFIX)
+
+
+def _named_repository(all_payload_fields: Mapping[str, object]) -> str | None:
+    create_fields = create_tool_fields(all_payload_fields)
+    if create_fields is not None:
+        owner = create_fields.get("owner")
+        repository_name = create_fields.get("repo")
+        if isinstance(owner, str) and owner and isinstance(repository_name, str) and repository_name:
+            return f"{owner}/{repository_name}"
+        return None
+    return _shell_flag_value(all_payload_fields, ALL_REPOSITORY_FLAGS, REPOSITORY_FLAG_ASSIGNMENT_PREFIX)
 
 
 def _create_calls(all_payload_fields: Mapping[str, object]) -> list[CreateCall]:
@@ -485,9 +522,83 @@ def visible_changed_files(working_directory: str, head_branch: object) -> list[s
     all_changed_paths = _git_lines(working_directory, "diff", "--name-only", merge_base, head_reference)
     if all_changed_paths is None:
         return None
+    return _visible_paths(all_changed_paths)
+
+
+def _visible_paths(all_changed_paths: list[str]) -> list[str]:
     return [each_path for each_path in all_changed_paths if each_path.lower().endswith(ALL_VISIBLE_FILE_SUFFIXES)]
 
 
+def _gh_api_lines(endpoint: str, query: str) -> list[str] | None:
+    try:
+        completed = subprocess.run(
+            ["gh", "api", endpoint, "--jq", query],
+            capture_output=True,
+            text=True,
+            timeout=GH_TIMEOUT_SECONDS,
+            check=False,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    return completed.stdout.splitlines() if completed.returncode == 0 else None
+
+
+def _compare_base_branch(repository: str, base_branch: str | None) -> str | None:
+    if base_branch:
+        return base_branch
+    all_default_branch_lines = _gh_api_lines(
+        REPOSITORY_ENDPOINT_TEMPLATE.format(repository=repository), DEFAULT_BRANCH_QUERY
+    )
+    if not all_default_branch_lines:
+        return None
+    return all_default_branch_lines[0]
+
+
+def _visible_compare_paths(repository: str, base_branch: str, head_branch: str) -> list[str] | None:
+    all_changed_paths = _gh_api_lines(
+        COMPARE_ENDPOINT_TEMPLATE.format(
+            repository=repository, base_branch=base_branch, head_branch=head_branch
+        ),
+        COMPARE_FILE_NAMES_QUERY,
+    )
+    if all_changed_paths is None:
+        return None
+    all_visible_paths = _visible_paths(all_changed_paths)
+    if all_visible_paths or len(all_changed_paths) < COMPARE_FILE_LIST_LIMIT:
+        return all_visible_paths
+    return None
+
+
+def remote_visible_changed_files(
+    repository: str | None, base_branch: str | None, head_branch: str | None
+) -> list[str] | None:
+    """Return the changed files people see, read from the GitHub compare API, or None when it cannot tell.
+
+    ::
+
+        compare lists tool.py                          -> []
+        compare lists web/page.html                    -> ["web/page.html"]
+        compare returns 300 paths and none are visible -> None
+        repository or head missing                     -> None
+
+    The base is the named base branch, else the repository's default branch.
+    A page of 300 paths is the compare API's file cap. A visible file on that
+    page is returned. A full page with none is None, because a later file can
+    still be one people see.
+
+    Args:
+        repository: The owner/name the create call names, or None.
+        base_branch: The base branch the create call names, or None.
+        head_branch: The head branch the create call names, or None.
+    """
+    if not repository or not head_branch:
+        return None
+    resolved_base_branch = _compare_base_branch(repository, base_branch)
+    if resolved_base_branch is None:
+        return None
+    return _visible_compare_paths(repository, resolved_base_branch, head_branch)
+
+
 def missing_look_reason(all_payload_fields: Mapping[str, object]) -> str | None:
     """Return a deny reason when a pull request changing visible files shows no picture, else None.
 
@@ -496,7 +607,9 @@ def missing_look_reason(all_payload_fields: Mapping[str, object]) -> str | None:
         branch changes page.html, proof has ![after](https://x/after.png) -> None
         branch changes page.html, proof quotes only command output        -> MISSING_LOOK_REASON
         branch changes only .py files                                     -> None
-        git cannot read the branch, proof shows no picture                -> UNREADABLE_CHANGES_REASON
+        git cannot read the branch, compare API lists only .py files      -> None
+        git cannot read the branch, compare API returns 300 .py files     -> UNREADABLE_CHANGES_REASON
+        neither git nor the compare API can read it, no picture           -> UNREADABLE_CHANGES_REASON
 
     Args:
         all_payload_fields: The parsed PreToolUse input.
@@ -505,9 +618,12 @@ def missing_look_reason(all_payload_fields: Mapping[str, object]) -> str | None:
     if not all_bodies:
         return None
     working_directory = all_payload_fields.get("cwd")
-    all_visible_files = visible_changed_files(
-        str(working_directory or ""), _named_head_branch(all_payload_fields)
-    )
+    head_branch = _named_head_branch(all_payload_fields)
+    all_visible_files = visible_changed_files(str(working_directory or ""), head_branch)
+    if all_visible_files is None:
+        all_visible_files = remote_visible_changed_files(
+            _named_repository(all_payload_fields), _named_base_branch(all_payload_fields), head_branch
+        )
     if all_visible_files == []:
         return None
     for each_body in all_bodies: