claude-dev-env 8.88.5 → 8.88.6

package/.agents/skills/efficient-review/tools/config/test_efficient_review_constants.py

@@ -0,0 +1,23 @@
+from pathlib import Path
+import sys
+
+SKILL_ROOT = Path(__file__).resolve().parents[2]
+if str(SKILL_ROOT) not in sys.path:
+    sys.path.insert(0, str(SKILL_ROOT))
+
+from tools.config import efficient_review_constants as constants
+from tools.efficient_review_plan import plan_review
+
+
+def test_host_markers_select_the_claude_plan_only_on_claude() -> None:
+    claude_plan = plan_review({constants.ALL_CLAUDE_HOST_VARIABLES[0]: "1"})
+    other_plan = plan_review(
+        {
+            constants.ALL_CLAUDE_HOST_VARIABLES[0]: "1",
+            constants.ALL_OTHER_HOST_VARIABLES[0]: "1",
+        }
+    )
+
+    assert claude_plan["runtime"] == "claude"
+    assert claude_plan["model"] == "haiku"
+    assert other_plan == {"runtime": "other", "model": "deferred", "profile": "deferred"}

package/.agents/skills/efficient-review/tools/test_efficient_review.py

@@ -0,0 +1,33 @@
+import io
+import json
+from pathlib import Path
+import sys
+
+import pytest
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+if str(SKILL_ROOT) not in sys.path:
+    sys.path.insert(0, str(SKILL_ROOT))
+
+from tools.efficient_review import main
+
+
+def test_plan_command_prints_one_deferred_plan(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("CLAUDECODE", raising=False)
+    monkeypatch.delenv("CLAUDE_CODE_ENTRYPOINT", raising=False)
+    plan_stream = io.StringIO()
+
+    assert main(["plan"], plan_stream) == 0
+    assert json.loads(plan_stream.getvalue()) == {
+        "runtime": "other",
+        "model": "deferred",
+        "profile": "deferred",
+    }
+    assert plan_stream.getvalue().endswith("\n")
+
+
+def test_unknown_command_is_rejected() -> None:
+    with pytest.raises(SystemExit) as exit_info:
+        main(["unknown"], io.StringIO())
+
+    assert exit_info.value.code == 2

package/.agents/skills/efficient-review/tools/test_efficient_review_plan.py

@@ -0,0 +1,27 @@
+from pathlib import Path
+import sys
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+if str(SKILL_ROOT) not in sys.path:
+    sys.path.insert(0, str(SKILL_ROOT))
+
+from tools.efficient_review_plan import plan_review
+
+
+def test_claude_plan_supplies_the_headless_slim_profile() -> None:
+    plan = plan_review({"CLAUDECODE": "1"})
+
+    assert plan["runtime"] == "claude"
+    assert plan["model"] == "haiku"
+    assert plan["profile"] == "slim"
+    assert plan["command"][:3] == ["claude", "-p", "--model"]
+    assert "--strict-mcp-config" in plan["command"]
+    assert "CLAUDE_CODE_DISABLE_CLAUDE_MDS=1" in plan["environment"]
+
+
+def test_other_host_takes_priority_over_claude_marker() -> None:
+    assert plan_review({"CLAUDECODE": "1", "CODEX_CI": "1"}) == {
+        "runtime": "other",
+        "model": "deferred",
+        "profile": "deferred",
+    }

package/hooks/blocking/test_verify_before_acting.py

@@ -471,7 +471,7 @@ def test_should_register_a_matcher_covering_every_mutating_tool_name() -> None:
         each_entry["matcher"]
         for each_entry in hooks_configuration["hooks"]["PostToolUse"]
         if any(
-            "verify_before_acting.py" in each_hook["command"] for each_hook in each_entry["hooks"]
+            "verify_before_acting.py" in each_hook.get("command", "") for each_hook in each_entry["hooks"]
         )
     ]
     assert len(all_matchers) == 1

package/hooks/features/session-context.md

@@ -5,6 +5,7 @@ This family injects reminders and task guidance when an agent starts, resumes, s
 ## Checks
 
 - `session/skill_loaded_reminder.py` injects a poteto-mode reminder when the skill needs loading or reloading.
+- `session/compaction_recall_prompt.py` tells the agent after a compaction to run `session/compaction_user_messages.py` on its transcript. That command writes every message the user typed to a temp file and prints only the path. A PostToolUse agent hook reads the file and returns the messages in caveman style as its block reason.
 - `session/task_tool_prompt.py` injects a task tracking directive at session start.
 - `session/working_style_prompt.py` injects the session's working style at session start.
 - `session/advisor_rules_prompt.py` injects advisor guidance when the built-in advisor is enabled.
@@ -16,6 +17,7 @@ This family injects reminders and task guidance when an agent starts, resumes, s
 ## When it fires
 
 - `session/skill_loaded_reminder.py` runs on `PreToolUse` matcher `Agent|Task` at `10` seconds, `UserPromptSubmit` matcher empty at `10` seconds, `SessionStart` matcher `compact` at `10` seconds, and `SubagentStart` matcher `workflow-subagent` at `10` seconds in `hooks.json`.
+- `session/compaction_recall_prompt.py` runs on `SessionStart` matcher `compact` at `10` seconds in `hooks.json`. The condensing hook is a `type: "agent"` hook on `PostToolUse` matcher `Bash`, with `if` set to `Bash(*compaction_user_messages.py*)`, model `haiku`, and a `180` second timeout.
 - `session/task_tool_prompt.py`, `session/working_style_prompt.py`, `session/advisor_rules_prompt.py`, and `session/orchestrator_auto_starter.py` run on `SessionStart`, matcher empty, timeout `10` seconds each in `hooks.json`.
 - `session/deepen_first_prompt.py` runs on `UserPromptSubmit`, matcher empty, timeout `10` seconds in `hooks.json`.
 - In Cursor, `session/deepen_first_prompt.py` also runs on `beforeSubmitPrompt`. Cursor passes that event name to the `UserPromptSubmit` copy it imports from the Claude Code settings too. When both copies run, `session/deepen_turn_marker.py` creates the turn marker only when it does not exist yet, so one copy injects. A later prompt skips when either the transcript marker or the session marker exists, or when the transcript already has a user line in Claude Code's or Cursor's shape.
@@ -29,6 +31,7 @@ Preconditions:
 - Run each command from the repository root with Python and pytest available. Enable opt-in flags only inside the tests.
 
 - **Skill reminder.** Input is a helper spawn whose prompt lacks poteto-mode. Run `python -m pytest packages/claude-dev-env/hooks/session/test_skill_loaded_reminder.py -q`. The adjacent test observes the reminder and leaves an already prepared prompt unchanged.
+- **Compaction recall.** Input is a transcript with typed, meta, sidechain, peer, and harness entries across a compaction. Run `python -m pytest packages/claude-dev-env/hooks/session/test_compaction_user_messages.py packages/claude-dev-env/hooks/session/test_compaction_recall_prompt.py -q`. The tests observe only typed messages in the file, a stable result across a second compaction, only the path on stdout, and an `if` rule that matches the command the recall names. `python packages/claude-dev-env/hooks/session/compaction_trim_eval.py` runs the agent hook prompt through `claude -p` on fixture transcripts with planted facts and prints the share of facts that survive and the compression ratio.
 - **Task tracking.** Input is a SessionStart event. Run `python -m pytest packages/claude-dev-env/hooks/session/test_task_tool_prompt.py -q`. The adjacent test observes a `SessionStart` context directive that names the task tool.
 - **Working style.** Input is a SessionStart event. Run `python -m pytest packages/claude-dev-env/hooks/session/test_working_style_prompt.py -q`. The adjacent test observes the fixed context text.
 - **Advisor guidance.** Input is SessionStart with `advisorModel` set. Run `python -m pytest packages/claude-dev-env/hooks/session/test_advisor_rules_prompt.py -q`. The adjacent test observes guidance only when the advisor setting is enabled.
@@ -39,6 +42,7 @@ Preconditions:
 
 ## Gotchas
 
+- A SessionStart hook cannot run a prompt or agent hook, so the condensing step waits for the agent's Bash call. The agent hook reaches the agent only through `ok: false`, and Claude Code shows the reason as a PostToolUse hook blocking error. The Claude Code docs mark agent hooks experimental. When the agent hook fails or times out, the agent reads the printed file itself. The recall command is a plain Bash call, so a session that does not pre-approve Bash asks before it runs, and a headless `claude -p` run without Bash in `--allowedTools` denies it and keeps only the compaction summary.
 - `session/skill_loaded_reminder.py` has four registration points. Its tests cover helper prompt rewriting and repeated prompt suppression.
 - The advisor prompt depends on settings and an environment disable flag. The two starter scripts each use separate opt-in checks.
 - The issue tracker starter requires the checkout to appear in the project path registry.

package/hooks/hooks.json

@@ -356,6 +356,11 @@
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/skill_loaded_reminder.py",
             "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/compaction_recall_prompt.py",
+            "timeout": 10
           }
         ]
       }
@@ -451,6 +456,19 @@
           }
         ]
       },
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "agent",
+            "if": "Bash(*compaction_user_messages.py*)",
+            "prompt": "The Bash command in this PostToolUse input printed one file path in tool_response.stdout. Read that file with the Read tool and follow the rules at its top. Return {\"ok\": false, \"reason\": \"<the condensed lines>\"}. Always return ok false, because the reason is how the condensed messages reach the agent. When the file cannot be read, return {\"ok\": false, \"reason\": \"Read the printed file yourself; the condensing hook could not.\"}\n\n$ARGUMENTS",
+            "model": "haiku",
+            "timeout": 180,
+            "statusMessage": "claude-dev-env: condensing the user's messages after compaction"
+          }
+        ]
+      },
       {
         "matcher": "Write|Edit|MultiEdit|NotebookEdit|Agent|Task|apply_patch|Bash|PowerShell|mcp__.*",
         "hooks": [

package/hooks/hooks_constants/compaction_user_messages_constants.py

@@ -0,0 +1,101 @@
+"""Names, limits, and texts for the compaction user-message recall hooks.
+
+Groups: the transcript entry shapes the extractor reads, the bounds on the
+file it writes, the trim rules at the top of that file, and the SessionStart
+context that tells the agent to run the extractor.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+ENTRY_TYPE_KEY = "type"
+USER_ENTRY_TYPE = "user"
+ATTACHMENT_ENTRY_TYPE = "attachment"
+ASSISTANT_ENTRY_TYPE = "assistant"
+ATTACHMENT_KEY = "attachment"
+QUEUED_COMMAND_ATTACHMENT_TYPE = "queued_command"
+QUEUED_PROMPT_KEY = "prompt"
+MESSAGE_KEY = "message"
+CONTENT_KEY = "content"
+TIMESTAMP_KEY = "timestamp"
+ORIGIN_KEY = "origin"
+ORIGIN_KIND_KEY = "kind"
+HUMAN_ORIGIN_KIND = "human"
+ALL_SKIPPED_ENTRY_FLAGS = ("isMeta", "isCompactSummary", "isSidechain")
+BLOCK_TYPE_KEY = "type"
+TEXT_BLOCK_TYPE = "text"
+TEXT_KEY = "text"
+IMAGE_BLOCK_TYPE = "image"
+IMAGE_PLACEHOLDER = "[image]"
+BLOCK_SEPARATOR = " "
+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"
+
+OUTPUT_FILE_PREFIX = "compaction-user-messages-"
+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
+
+TRIM_WORD_LIMIT = 1500
+TRIM_INSTRUCTIONS = (
+    "# How to condense this file\n\n"
+    "These are the messages the user typed in one Claude Code session, oldest first. "
+    "The session's context was just compacted, and the agent reads your condensed copy "
+    "in place of the user's lost words.\n\n"
+    "Rewrite them in caveman style: drop articles, filler, greetings, and politeness, "
+    "and keep the substance. Write one line per message, in order, starting with its "
+    "number, such as `#3`. Copy every request, constraint, correction, decision, "
+    "preference, question, name, file path, command, number, date, and link exactly as "
+    "the user wrote it. When a later message corrects or reverses an earlier one, keep "
+    "both and end the earlier line with `(overruled by #N)`. Drop a message only when it "
+    "carries nothing, such as `ok` or `thanks`. Keep the user's own words for anything "
+    "you are unsure how to shorten. "
+    f"Stay under {TRIM_WORD_LIMIT} words.\n\n"
+)
+
+SESSION_START_EVENT_NAME = "SessionStart"
+COMPACTION_SOURCE = "compact"
+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."
+)
+
+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_MESSAGE_LINE_PATTERN_TEMPLATE = r"^\W*#?{position}\b.*$"
+EVAL_OVERRULED_MARKER = "overruled"
+EVAL_ARGUMENTS_PLACEHOLDER = "$ARGUMENTS"
+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 = "{"

package/hooks/hooks_constants/test_haiku_spawn_slim_gate_constants.py

@@ -0,0 +1,18 @@
+import json
+import shlex
+
+from hooks_constants import haiku_spawn_slim_gate_constants as constants
+
+
+def test_slim_profile_command_passes_settings_and_mcp_config() -> None:
+    command = shlex.split(constants.SLIM_PROFILE_SHELL_COMMAND)
+
+    assert command == [constants.SLIM_PROFILE_EXECUTABLE, *constants.ALL_SLIM_PROFILE_ARGUMENTS]
+    assert command[command.index("--model") + 1] == "haiku"
+    assert json.loads(command[command.index("--settings") + 1])["autoMemoryEnabled"] is False
+    assert json.loads(command[command.index("--mcp-config") + 1]) == {"mcpServers": {}}
+
+
+def test_deny_reason_includes_the_command_and_environment() -> None:
+    assert constants.SLIM_PROFILE_SHELL_COMMAND in constants.SLIM_PROFILE_DENY_REASON
+    assert constants.SLIM_PROFILE_ENVIRONMENT_TEXT in constants.SLIM_PROFILE_DENY_REASON

package/hooks/session/compaction_recall_prompt.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""SessionStart hook: after a compaction, tell the agent to recall the user's messages.
+
+::
+
+    SessionStart, source compact, transcript_path set -> run the extractor command
+    any other source, or no transcript_path           -> 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.
+"""
+
+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)
+
+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,
+    SOURCE_INPUT_KEY,
+    TRANSCRIPT_PATH_INPUT_KEY,
+)
+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
+
+
+def recall_context(all_hook_fields: dict[str, object]) -> str | None:
+    """Return the recall instruction 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.
+
+    Args:
+        all_hook_fields: The parsed hook input.
+
+    Returns:
+        The additionalContext text, or None.
+    """
+    if all_hook_fields.get(HOOK_EVENT_NAME_INPUT_KEY) != SESSION_START_EVENT_NAME:
+        return None
+    if all_hook_fields.get(SOURCE_INPUT_KEY) != COMPACTION_SOURCE:
+        return 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)
+
+
+def main() -> None:
+    """Print the recall instruction as SessionStart additionalContext, or stay quiet."""
+    hook_input = read_hook_input_dictionary_from_stdin()
+    if hook_input is None:
+        return
+    context_text = recall_context(hook_input)
+    if context_text is None:
+        return
+    hook_output = {
+        HOOK_SPECIFIC_OUTPUT_KEY: {
+            HOOK_EVENT_NAME_KEY: SESSION_START_EVENT_NAME,
+            ADDITIONAL_CONTEXT_KEY: context_text,
+        }
+    }
+    sys.stdout.write(json.dumps(hook_output) + "\n")
+
+
+if __name__ == "__main__":
+    main()