claude-dev-env 8.90.1 → 8.92.0

package/hooks/hooks_constants/compaction_user_messages_constants.py

@@ -1,8 +1,8 @@
-"""Names, limits, and texts for the compaction user-message recall hooks.
+"""Names, limits, and texts for the compaction user-message recall hook.
 
-Groups: the transcript entry shapes the extractor reads, the bounds and
-location of the file it writes, the SessionStart context that tells the agent
-to run the extractor, and the eval that runs the condensing hook live.
+Groups: the Claude Code and Codex transcript entry shapes the extractor reads,
+the trim rules that condense each message, the bounds of the recall text, the
+SessionStart context that carries it, and the offline eval of the trim.
 """
 
 from __future__ import annotations
@@ -34,20 +34,129 @@ HARNESS_TAG_OPENING_PATTERN = re.compile(r"<[a-z]+(?:-[a-z]+)+[\s>]")
 SLASH_COMMAND_NAME_PATTERN = re.compile(r"<command-name>\s*(.*?)\s*</command-name>", re.DOTALL)
 SLASH_COMMAND_ARGS_PATTERN = re.compile(r"<command-args>(.*?)</command-args>", re.DOTALL)
 
-MAXIMUM_MESSAGE_CHARACTERS = 4000
-MAXIMUM_EXTRACT_CHARACTERS = 60000
-CUT_MESSAGE_SUFFIX_TEMPLATE = "\n[{cut_count} more characters left out]"
-LEFT_OUT_MESSAGES_TEMPLATE = "[{left_out_count} earlier messages left out to fit the budget]\n\n"
-NO_MESSAGES_TEXT = "No typed user messages were found in this transcript.\n"
-MESSAGE_HEADING_TEMPLATE = "## {position} | {timestamp}\n{text}\n\n"
-MESSAGES_HEADING = "# User messages, oldest first\n\n"
+CODEX_EVENT_ENTRY_TYPE = "event_msg"
+CODEX_PAYLOAD_KEY = "payload"
+CODEX_USER_MESSAGE_TYPE = "user_message"
+CODEX_AGENT_MESSAGE_TYPE = "agent_message"
+CODEX_IMAGES_KEY = "images"
 
-ALL_RECALL_DIRECTORY_PARTS = (".claude", "compaction-recall")
-OUTPUT_FILE_SUFFIX = ".md"
-OUTPUT_ENCODING = "utf-8"
-TRANSCRIPT_ARGUMENT_COUNT = 2
-USAGE_TEXT = "usage: compaction_user_messages.py <transcript.jsonl>\n"
-USAGE_EXIT_CODE = 2
+GRATITUDE_PATTERN = re.compile(r"(?:thanks|thank\s+you|thx|ty)[.!]*", re.IGNORECASE)
+INTERRUPT_PATTERN = re.compile(r"^\[request interrupted by user[^\]]*\]$", re.IGNORECASE)
+PATH_CHARACTERS = r"\w/.:`-"
+PATH_FOLLOWING_CHARACTERS = r"\w/:`-"
+ALL_FILLER_PHRASES = (
+    "so basically",
+    "basically",
+    "just to be clear",
+    "honestly",
+    "I would like it if",
+    "could you please make sure that",
+    "could you please",
+    "can you please",
+    "could you",
+    "can you",
+    "please",
+    "when you get a chance",
+    "kind of",
+    "sort of",
+    "I mean",
+)
+FILLER_PATTERN = re.compile(
+    rf"(?<![{PATH_CHARACTERS}])(?:"
+    + "|".join(re.escape(each_phrase) for each_phrase in ALL_FILLER_PHRASES)
+    + rf")(?![{PATH_FOLLOWING_CHARACTERS}]|\.\w),?",
+    re.IGNORECASE,
+)
+ARTICLE_PATTERN = re.compile(
+    rf"(?<![{PATH_CHARACTERS}])(?:[Tt]he|THE|a|[Aa]n|AN)\s+(?=\w)"
+)
+ARTIFACT_COMMENT_MARKER = "[Artifact comment sent to Claude]"
+ARTIFACT_URL_PATTERN = re.compile(r"^Artifact: (\S+)", re.MULTILINE)
+ARTIFACT_LOCATION_PATTERN = re.compile(r"^Location: (.+)$", re.MULTILINE)
+ARTIFACT_QUOTE_PATTERN = re.compile(
+    r"=== BEGIN ARTIFACT COMMENT (?P<marker>\w+) ===\n(?P<comment>.*?)\n"
+    r"=== END ARTIFACT COMMENT (?P=marker) ===",
+    re.DOTALL,
+)
+QUOTE_PREFIX_PATTERN = re.compile(r"^> ?", re.MULTILINE)
+ARTIFACT_COMMENT_TEMPLATE = "Artifact comment on {url}{location}: {comment}"
+ARTIFACT_LOCATION_TEMPLATE = " at {location}"
+ARTIFACT_QUOTE_GROUP = "comment"
+HTML_COMMENT_PATTERN = re.compile(r"<!--.*?-->", re.DOTALL)
+CODE_SPAN_PATTERN = re.compile(r"(`[^`]*`)")
+WHITESPACE_RUN_PATTERN = re.compile(r"\s+")
+SPACE_BEFORE_PUNCTUATION_PATTERN = re.compile(r"\s+([,.;:])(?=\s|$)")
+DANGLING_COMMA_PATTERN = re.compile(r",\s*(?=[,.;:](?:\s|$))")
+TRIMMED_EDGE_CHARACTERS = " ,"
+REVERSAL_PATTERN = re.compile(
+    r"change of plan|change that|on second thought|scratch (?:that|the)|"
+    r"(?<!n't )(?<!nt )forget\b|after all|"
+    r"instead|\bswitch(?:ed)? to\b|vetoed|no longer|not anymore|\boverride\b|\brevert\b|\bundo\b|"
+    r"don'?t (?:use|do)|stop using",
+    re.IGNORECASE,
+)
+CONTENT_WORD_PATTERN = re.compile(r"[A-Za-z][\w./:-]+")
+CONTENT_WORD_EDGE_PUNCTUATION = ".,:;"
+ALL_STOP_WORDS = frozenset(
+    {
+        "to",
+        "it",
+        "is",
+        "we",
+        "of",
+        "on",
+        "in",
+        "be",
+        "so",
+        "do",
+        "no",
+        "as",
+        "at",
+        "by",
+        "or",
+        "us",
+        "me",
+        "if",
+        "an",
+        "the",
+        "and",
+        "for",
+        "use",
+        "not",
+        "with",
+        "this",
+        "that",
+        "its",
+        "from",
+        "should",
+        "instead",
+        "drop",
+        "after",
+        "all",
+        "change",
+        "plan",
+        "switch",
+        "forget",
+        "let's",
+        "second",
+        "thought",
+        "scratch",
+        "idea",
+        "call",
+        "update",
+        "ops",
+        "vetoed",
+        "go",
+    }
+)
+TRIMMED_LINE_TEMPLATE = "#{position} {text}"
+OVERRULED_SUFFIX_TEMPLATE = " (overruled by #{later_position})"
+
+MAXIMUM_MESSAGE_CHARACTERS = 1500
+MAXIMUM_RECALL_CHARACTERS = 6000
+CUT_MESSAGE_SUFFIX_TEMPLATE = " [{cut_count} more characters left out]"
+LEFT_OUT_LINES_TEMPLATE = "[{left_out_count} earlier messages left out to fit the budget]"
+LINE_SEPARATOR = "\n"
 
 SESSION_START_EVENT_NAME = "SessionStart"
 COMPACTION_SOURCE = "compact"
@@ -55,39 +164,24 @@ HOOK_EVENT_NAME_INPUT_KEY = "hook_event_name"
 SOURCE_INPUT_KEY = "source"
 TRANSCRIPT_PATH_INPUT_KEY = "transcript_path"
 ADDITIONAL_CONTEXT_KEY = "additionalContext"
-EXTRACTOR_SCRIPT_NAME = "compaction_user_messages.py"
 RECALL_CONTEXT_TEMPLATE = (
     "The context was just compacted, so the user's own words are gone from it. "
-    "Run this Bash command first, before you reply and before any other tool call:\n\n"
-    "{command}\n\n"
-    "It prints a file path. A PostToolUse hook then reads that file and returns every "
-    "message the user typed in this session, condensed, as a hook blocking error. That "
-    "block is no error. It is the user's requests in order, and a later message overrides "
-    "an earlier one. Hold them as the user's instructions next to the summary, then "
-    "continue the work. Read the printed file only when no condensed block arrives."
+    "These are the messages the user typed in this session, oldest first, trimmed "
+    "to their substance. A later message overrides an earlier one. A line that "
+    "ends with (overruled by #N) is one that message N changes, so read the two "
+    "together and follow message N where they differ. When message N was left "
+    "out to fit the budget, treat the marked line as replaced. Hold them as the user's "
+    "instructions next to the summary, then continue the work.\n\n{lines}"
 )
 
-EVAL_SESSION_DIRECTORY = Path(__file__).resolve().parent.parent / "session"
-EVAL_FIXTURE_DIRECTORY = EVAL_SESSION_DIRECTORY / "fixtures" / "compaction_user_messages"
-EVAL_HOOKS_JSON_PATH = EVAL_SESSION_DIRECTORY.parent / "hooks.json"
-EVAL_RESULTS_FILE_NAME = "results.json"
-EVAL_RESULTS_JSON_INDENT = 2
-EVAL_SERVED_MODEL_SEPARATOR = ","
+EVAL_FIXTURE_DIRECTORY = Path(__file__).resolve().parent.parent / "session" / "fixtures" / (
+    "compaction_user_messages"
+)
+EVAL_CASES_FILE_NAME = "trim_cases.json"
+EVAL_CASE_TRANSCRIPT_KEY = "transcript"
+EVAL_CASE_FACTS_KEY = "facts"
+EVAL_CASE_OVERRULED_KEY = "overruled"
+EVAL_CASE_EARLIER_KEY = "earlier"
 EVAL_MESSAGE_LINE_PATTERN_TEMPLATE = r"^\W*#?{position}\b.*$"
 EVAL_OVERRULED_MARKER = "overruled"
-EVAL_CASES_FILE_NAME = "trim_cases.json"
-EVAL_CLAUDE_EXECUTABLE = "claude"
-EVAL_DEFAULT_MODEL = "haiku"
-EVAL_HOOK_TYPE = "agent"
-EVAL_TIMEOUT_SECONDS = 240
-EVAL_JSON_OBJECT_START = "{"
-EVAL_PACKAGE_SETTINGS_PATH = EVAL_SESSION_DIRECTORY.parent.parent / "settings.json"
-EVAL_RUN_SETTINGS_FILE_NAME = "hook-settings.json"
-EVAL_DEBUG_FILE_NAME = "debug.log"
-EVAL_STRUCTURED_OUTPUT_MARKER = "Hooks: Got structured output: "
-EVAL_DECISION_SEPARATOR = "\n"
-EVAL_ALLOWED_TOOLS = "Bash(python3:*)"
-EVAL_EMPTY_MCP_CONFIG = '{"mcpServers": {}}'
-EVAL_RUN_PROMPT_TEMPLATE = (
-    "Run this exact Bash command once, then reply with one word, done:\n\n{command}"
-)
+EVAL_FILE_ENCODING = "utf-8"

package/hooks/hooks_constants/owned_pr_merge_stop_gate_constants.py

@@ -0,0 +1,37 @@
+"""Constants for the owned pull request merge Stop gate."""
+
+import re
+
+HOOK_EVENT_NAME = "Stop"
+SESSION_ID_KEY = "session_id"
+LAST_ASSISTANT_MESSAGE_KEY = "last_assistant_message"
+DECISION_KEY = "decision"
+BLOCK_DECISION = "block"
+REASON_KEY = "reason"
+ALLOW_EXIT_CODE = 0
+GH_PROGRAM_NAME = "gh"
+GH_API_SUBCOMMAND = "api"
+GH_JQ_OPTION = "--jq"
+PULL_REQUEST_ENDPOINT_TEMPLATE = "repos/{owner}/{repository}/pulls/{number}"
+PULL_REQUEST_STATE_QUERY = ".state"
+OPEN_PULL_REQUEST_STATE = "open"
+STATE_QUERY_TIMEOUT_SECONDS = 10
+LOOKUP_FAILURE_TEMPLATE = "owned_pr_merge_stop_gate: could not read {endpoint}: {detail}\n"
+BLOCKED_LINE_PATTERN: re.Pattern[str] = re.compile(
+    r"^\s*(?:[-*]\s*)?blocked\s*:(.*)$", re.IGNORECASE
+)
+BLOCKED_TEXT_GROUP_INDEX = 1
+BOLD_MARKER = "**"
+NAME_START_PATTERN = r"(?<![0-9A-Za-z_./-])"
+NAME_END_PATTERN = r"(?![0-9A-Za-z/])"
+PULL_REQUEST_REFERENCE_TEMPLATE = "{owner}/{repository}#{number}"
+PULL_REQUEST_LINE_TEMPLATE = "\n- {url}"
+BLOCK_REASON_PREFIX = "You opened these owned pull requests and they are still open:"
+BLOCK_REASON_SUFFIX = (
+    "\nThe repository owner approves the whole owned PR loop, the merge included."
+    " Keep working now: run /efficient-review until a pass is clean, mark the PR ready,"
+    " babysit CI and review threads, then merge it and read it back as merged."
+    " End the turn early only with one line per pull request:"
+    " 'Blocked: <owner>/<repository>#<number> - <what only the owner can give>'."
+    " A user who asked to hold the PR or to read it first is such a blocker."
+)

package/hooks/hooks_constants/owned_pr_review_loop_constants.py

@@ -48,6 +48,9 @@ __all__ = [
     "ALL_DECLARED_URL_KEYS",
     "JSON_OBJECT_OPENER",
     "REVIEW_LOOP_CONTEXT_TEMPLATE",
+    "SESSION_RECORD_FILE_TEMPLATE",
+    "SESSION_RECORD_TEMPORARY_PREFIX",
+    "ALL_PULL_REQUEST_FIELD_NAMES",
 ]
 
 NAME_DIGEST_TEXT_ENCODING: str = "utf-8"
@@ -99,10 +102,16 @@ ALREADY_EXISTS_MARKER: str = "already exists"
 ALL_DECLARED_URL_KEYS: tuple[str, ...] = ("html_url", "url")
 JSON_OBJECT_OPENER: str = "{"
 
+SESSION_RECORD_FILE_TEMPLATE: str = "owned-pr-loop-{session_file_id}.json"
+SESSION_RECORD_TEMPORARY_PREFIX: str = "owned-pr-loop-"
+ALL_PULL_REQUEST_FIELD_NAMES: tuple[str, ...] = ("owner", "repository", "number", "url")
+
 REVIEW_LOOP_CONTEXT_TEMPLATE: str = (
     "=== OWNED PR REVIEW LOOP (context reminder, never a block) ===\n"
     "You opened {owner}/{repository}#{number}  {url}\n"
     "This repository has no automated review, so you own the review and the merge.\n"
+    "Your task now runs past opening this PR to its merge, also when your brief\n"
+    "asked for a draft or stopped at opening it.\n"
     "1. Review loop. Load the efficient-review skill (/efficient-review). Review the\n"
     "   branch, check each finding against the code, fix every one that holds, push,\n"
     "   and review again. Repeat until a pass reports no findings.\n"
@@ -116,5 +125,9 @@ REVIEW_LOOP_CONTEXT_TEMPLATE: str = (
     "4. Ship. Follow the pstack shipping playbook (poteto-mode/playbooks/shipping.md)\n"
     "   to land the PR, or the pr-lifecycle skill outside poteto-mode. Read the PR\n"
     "   back and confirm it reads merged.\n"
-    "Run each step yourself. The task ends at a merged PR or a named blocker."
+    "The repository owner installed this hook and\n"
+    "approves every step above, the merge included. Run each step yourself\n"
+    "without asking first. The task ends at a merged PR or a named blocker.\n"
+    "When the user asked to hold this PR or to read it before it merges, stop\n"
+    "after step 3 and end with: Blocked: {owner}/{repository}#{number} - the user holds the merge."
 )

package/hooks/owned_pr_session_record.py

@@ -0,0 +1,104 @@
+"""Session record of the owned pull requests an agent opened.
+
+The owned pull request review-loop hook writes each pull request it reports
+into one JSON file per session in the system temp folder. The owned pull
+request Stop gate reads the same file back::
+
+    owned-pr-loop-<session id>.json
+    [{"owner": "acme", "repository": "widgets", "number": "42",
+      "url": "https://github.com/acme/widgets/pull/42"}]
+
+Both Claude Code and Codex send ``session_id`` to PostToolUse and Stop hooks,
+so the file links the two hooks on either host.
+"""
+
+from __future__ import annotations
+
+import json
+import tempfile
+from pathlib import Path
+
+from atomic_file_writer import write_text_atomically
+from hooks_constants.atomic_file_writer_constants import ATOMIC_WRITE_TEMPORARY_SUFFIX
+from hooks_constants.owned_pr_review_loop_constants import (
+    ALL_PULL_REQUEST_FIELD_NAMES,
+    NAME_DIGEST_TEXT_ENCODING,
+    SESSION_RECORD_FILE_TEMPLATE,
+    SESSION_RECORD_TEMPORARY_PREFIX,
+)
+from hooks_constants.session_file_id import session_file_id
+
+__all__ = ["session_record_path", "all_recorded_pull_requests", "record_pull_request"]
+
+
+def session_record_path(session_id: object) -> Path:
+    """Return the record file path for one session.
+
+    Args:
+        session_id: The ``session_id`` field of the hook payload.
+    """
+    file_name = SESSION_RECORD_FILE_TEMPLATE.format(session_file_id=session_file_id(session_id))
+    return Path(tempfile.gettempdir()) / file_name
+
+
+def _is_session_id(session_id: object) -> bool:
+    return isinstance(session_id, str) and bool(session_id)
+
+
+def _is_pull_request_entry(entry: object) -> bool:
+    return isinstance(entry, dict) and all(
+        isinstance(entry.get(each_field), str) for each_field in ALL_PULL_REQUEST_FIELD_NAMES
+    )
+
+
+def all_recorded_pull_requests(session_id: object) -> list[dict[str, str]]:
+    """Return the pull requests recorded for the session, oldest first.
+
+    A payload with no session id, or a missing, unreadable, or malformed
+    file, reads as an empty record.
+
+    Args:
+        session_id: The ``session_id`` field of the hook payload.
+    """
+    if not _is_session_id(session_id):
+        return []
+    try:
+        record_text = session_record_path(session_id).read_text(encoding=NAME_DIGEST_TEXT_ENCODING)
+        all_entries = json.loads(record_text)
+    except (OSError, ValueError):
+        return []
+    if not isinstance(all_entries, list):
+        return []
+    return [each_entry for each_entry in all_entries if _is_pull_request_entry(each_entry)]
+
+
+def record_pull_request(session_id: object, all_pull_request_fields: dict[str, str]) -> None:
+    """Add one pull request to the session record, once per url.
+
+    A payload with no session id records nothing. A write that fails leaves
+    the record as it was, so the PostToolUse hook still adds its context.
+
+    Args:
+        session_id: The ``session_id`` field of the hook payload.
+        all_pull_request_fields: The owner, repository, number, and url fields.
+    """
+    if not _is_session_id(session_id):
+        return
+    all_entries = all_recorded_pull_requests(session_id)
+    if any(each_entry["url"] == all_pull_request_fields["url"] for each_entry in all_entries):
+        return
+    new_entry = {
+        each_field: all_pull_request_fields[each_field]
+        for each_field in ALL_PULL_REQUEST_FIELD_NAMES
+    }
+    try:
+        write_text_atomically(
+            session_record_path(session_id),
+            json.dumps([*all_entries, new_entry]),
+            NAME_DIGEST_TEXT_ENCODING,
+            SESSION_RECORD_TEMPORARY_PREFIX,
+            ATOMIC_WRITE_TEMPORARY_SUFFIX,
+            False,
+        )
+    except (OSError, UnicodeError):
+        return

package/hooks/session/compaction_recall_prompt.py

@@ -1,31 +1,35 @@
 #!/usr/bin/env python3
-"""SessionStart hook: after a compaction, tell the agent to recall the user's messages.
+"""SessionStart hook: after a compaction, return the user's typed messages, trimmed.
 
 ::
 
-    SessionStart, source compact, transcript_path set -> run the extractor command
-    any other source, or no transcript_path           -> nothing
+    SessionStart, source compact, transcript_path set -> the trimmed messages
+    any other source, no transcript_path, no messages -> nothing
 
-The context names one Bash command that runs ``compaction_user_messages.py``
-on this session's transcript. A PostToolUse agent hook in ``hooks.json``
-matches that command and returns the user's messages, condensed.
+The hook reads the session transcript, keeps the messages a person typed,
+trims each one to its substance in Python, and returns the lines as
+additionalContext. It runs as a command hook, so Claude Code and Codex both
+run it, and it calls no model.
 """
 
 from __future__ import annotations
 
 import json
-import shlex
 import sys
 from pathlib import Path
 
 _hooks_directory = str(Path(__file__).resolve().parent.parent)
 if _hooks_directory not in sys.path:
     sys.path.insert(0, _hooks_directory)
+_session_directory = str(Path(__file__).resolve().parent)
+if _session_directory not in sys.path:
+    sys.path.insert(0, _session_directory)
 
+from compaction_trim import recall_text
+from compaction_user_messages import typed_user_messages
 from hooks_constants.compaction_user_messages_constants import (
     ADDITIONAL_CONTEXT_KEY,
     COMPACTION_SOURCE,
-    EXTRACTOR_SCRIPT_NAME,
     HOOK_EVENT_NAME_INPUT_KEY,
     RECALL_CONTEXT_TEMPLATE,
     SESSION_START_EVENT_NAME,
@@ -37,25 +41,24 @@ from hooks_constants.hook_specific_output_keys import (
     HOOK_SPECIFIC_OUTPUT_KEY,
 )
 from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
+from hooks_constants.setup_project_paths_constants import DECODE_ERRORS_POLICY, UTF8_ENCODING
 
 
 def recall_context(all_hook_fields: dict[str, object]) -> str | None:
-    """Return the recall instruction for a compaction, or None for any other start.
+    """Return the trimmed messages for a compaction, or None for any other start.
 
     ::
 
         {"hook_event_name": "SessionStart", "source": "compact",
          "transcript_path": "/t/abc.jsonl"}
-        -> "...run this Bash command:\\n\\n'/usr/bin/python3' '.../compaction_user_messages.py' /t/abc.jsonl..."
-
-    The command names the interpreter running this hook, so it works where
-    ``python3`` is not on PATH.
+        -> "The context was just compacted, ...\\n\\n#1 fix login bug\\n#3 ..."
 
     Args:
         all_hook_fields: The parsed hook input.
 
     Returns:
-        The additionalContext text, or None.
+        The additionalContext text, or None when the start is no compaction,
+        the transcript cannot be read, or it holds no typed message.
     """
     if all_hook_fields.get(HOOK_EVENT_NAME_INPUT_KEY) != SESSION_START_EVENT_NAME:
         return None
@@ -64,13 +67,21 @@ def recall_context(all_hook_fields: dict[str, object]) -> str | None:
     transcript_path = all_hook_fields.get(TRANSCRIPT_PATH_INPUT_KEY)
     if not isinstance(transcript_path, str) or not transcript_path:
         return None
-    extractor_path = Path(__file__).resolve().parent / EXTRACTOR_SCRIPT_NAME
-    command = shlex.join([sys.executable, str(extractor_path), transcript_path])
-    return RECALL_CONTEXT_TEMPLATE.format(command=command)
+    try:
+        with Path(transcript_path).open(
+            encoding=UTF8_ENCODING, errors=DECODE_ERRORS_POLICY
+        ) as transcript:
+            all_messages = typed_user_messages(transcript)
+    except OSError:
+        return None
+    trimmed_messages = recall_text(all_messages)
+    if trimmed_messages is None:
+        return None
+    return RECALL_CONTEXT_TEMPLATE.format(lines=trimmed_messages)
 
 
 def main() -> None:
-    """Print the recall instruction as SessionStart additionalContext, or stay quiet."""
+    """Print the trimmed messages as SessionStart additionalContext, or stay quiet."""
     hook_input = read_hook_input_dictionary_from_stdin()
     if hook_input is None:
         return