claude-dev-env 8.88.6 → 8.89.0

package/hooks/session/compaction_trim_eval.py

@@ -10,11 +10,14 @@
     oracle (raw extract): facts 1.00 ...   null (empty reply): facts 0.00 ...
 
 Each case is a fixture transcript with planted facts: paths, numbers, a
-link, and a decision the user later reversed. The runner writes the
-extract with ``compaction_user_messages.py``, then sends the agent hook's
-own prompt from ``hooks.json`` to ``claude -p`` with the Read tool, the way
-Claude Code runs the hook. The grader checks that each fact survives and
-that the reversed line says ``overruled``.
+link, and a decision the user later reversed.
+
+Each run starts a headless ``claude -p`` session whose settings hold the
+condensing hook from ``hooks.json`` and the Read allow rules from the
+package ``settings.json``. The session runs the extractor on the fixture, so
+Claude Code fires the hook as it would after a compaction. The runner reads
+the hook's returned reason from the session's debug log. The grader checks
+that each fact survives and that the reversed line says ``overruled``.
 
 The oracle grades the raw extract and the null grades an empty reply, so a
 broken grader shows before any model score is trusted. A failed call goes
@@ -26,11 +29,11 @@ from __future__ import annotations
 import argparse
 import json
 import re
+import shlex
 import shutil
 import subprocess
 import sys
 import tempfile
-import uuid
 from dataclasses import dataclass, field
 from pathlib import Path
 
@@ -41,22 +44,29 @@ _session_directory = str(Path(__file__).resolve().parent)
 if _session_directory not in sys.path:
     sys.path.insert(0, _session_directory)
 
-from compaction_user_messages import output_path_for, rendered_extract, typed_user_messages
+from compaction_user_messages import rendered_extract, typed_user_messages
 from hooks_constants.compaction_user_messages_constants import (
-    EVAL_ARGUMENTS_PLACEHOLDER,
+    EVAL_ALLOWED_TOOLS,
     EVAL_CASES_FILE_NAME,
     EVAL_CLAUDE_EXECUTABLE,
+    EVAL_DEBUG_FILE_NAME,
+    EVAL_DECISION_SEPARATOR,
     EVAL_DEFAULT_MODEL,
+    EVAL_EMPTY_MCP_CONFIG,
     EVAL_FIXTURE_DIRECTORY,
     EVAL_HOOK_TYPE,
     EVAL_HOOKS_JSON_PATH,
     EVAL_JSON_OBJECT_START,
     EVAL_MESSAGE_LINE_PATTERN_TEMPLATE,
     EVAL_OVERRULED_MARKER,
+    EVAL_PACKAGE_SETTINGS_PATH,
     EVAL_RESULTS_FILE_NAME,
     EVAL_RESULTS_JSON_INDENT,
+    EVAL_RUN_PROMPT_TEMPLATE,
+    EVAL_RUN_SETTINGS_FILE_NAME,
     EVAL_SERVED_MODEL_SEPARATOR,
     EVAL_SESSION_DIRECTORY,
+    EVAL_STRUCTURED_OUTPUT_MARKER,
     EVAL_TIMEOUT_SECONDS,
     EXTRACTOR_SCRIPT_NAME,
     MESSAGES_HEADING,
@@ -145,11 +155,11 @@ def score_condensed(
     )
 
 
-def condensing_hook_prompt(hooks_json_text: str) -> str:
-    """Return the prompt of the PostToolUse agent hook that condenses the messages."""
+def condensing_hook_group(hooks_json_text: str) -> dict[str, object]:
+    """Return the PostToolUse group of ``hooks.json`` cut down to the condensing agent hook."""
     all_registrations = json.loads(hooks_json_text)["hooks"]["PostToolUse"]
     return next(
-        str(each_hook["prompt"])
+        {"matcher": each_group["matcher"], "hooks": [each_hook]}
         for each_group in all_registrations
         for each_hook in each_group["hooks"]
         if each_hook.get("type") == EVAL_HOOK_TYPE
@@ -157,6 +167,17 @@ def condensing_hook_prompt(hooks_json_text: str) -> str:
     )
 
 
+def run_settings(
+    all_group_fields: dict[str, object], all_allow_rules: list[str], model_name: str
+) -> dict[str, object]:
+    """Return headless session settings that register the hook on the given model."""
+    all_hooks = [{**each_hook, "model": model_name} for each_hook in all_group_fields["hooks"]]
+    return {
+        "permissions": {"allow": all_allow_rules},
+        "hooks": {"PostToolUse": [{**all_group_fields, "hooks": all_hooks}]},
+    }
+
+
 def hook_reason(model_reply: str) -> str | None:
     """Return the ``reason`` of the last JSON decision in the reply, or None when there is none."""
     decoder = json.JSONDecoder()
@@ -173,53 +194,74 @@ def hook_reason(model_reply: str) -> str | None:
     return found_reason
 
 
-def _write_extract(transcript_path: Path) -> tuple[Path, str]:
-    all_lines = transcript_path.read_text(encoding=OUTPUT_ENCODING).splitlines()
-    extract_text = rendered_extract(typed_user_messages(all_lines))
-    extract_path = output_path_for(transcript_path)
-    extract_path.write_text(extract_text, encoding=OUTPUT_ENCODING)
-    return extract_path, extract_text
+def debug_log_reason(debug_text: str) -> str | None:
+    """Return the reason of the last hook decision a debug log records, or None.
 
+    ::
 
-def _hook_input(transcript_path: Path, extract_path: Path) -> str:
-    command = f"python3 {EVAL_SESSION_DIRECTORY / EXTRACTOR_SCRIPT_NAME} {transcript_path}"
-    return json.dumps(
-        {
-            "hook_event_name": "PostToolUse",
-            "tool_name": "Bash",
-            "tool_input": {"command": command},
-            "tool_response": {"stdout": f"{extract_path}\n", "stderr": "", "interrupted": False},
-        }
-    )
+        "... Hooks: Got structured output: {\"ok\":false,\"reason\":\"#1 deploy\"}"
+        -> "#1 deploy"
 
+    Args:
+        debug_text: The ``--debug-file`` log of one headless session.
 
-def _ask_model(prompt_text: str, model_name: str) -> dict[str, object]:
-    command = [
+    Returns:
+        The text Claude Code handed the main agent, or None when no hook answered.
+    """
+    all_decisions = [
+        each_line.split(EVAL_STRUCTURED_OUTPUT_MARKER, 1)[1]
+        for each_line in debug_text.splitlines()
+        if EVAL_STRUCTURED_OUTPUT_MARKER in each_line
+    ]
+    return hook_reason(EVAL_DECISION_SEPARATOR.join(all_decisions))
+
+
+def _session_command(
+    transcript_path: Path, settings_path: Path, model_name: str, debug_path: Path
+) -> list[str]:
+    extractor_command = shlex.join(
+        ["python3", str(EVAL_SESSION_DIRECTORY / EXTRACTOR_SCRIPT_NAME), str(transcript_path)]
+    )
+    return [
         shutil.which(EVAL_CLAUDE_EXECUTABLE) or EVAL_CLAUDE_EXECUTABLE,
         "-p",
         "--model",
         model_name,
         "--setting-sources",
         "",
-        "--tools",
-        "Read",
-        "--allowedTools=Read",
+        "--settings",
+        str(settings_path),
+        "--strict-mcp-config",
+        "--mcp-config",
+        EVAL_EMPTY_MCP_CONFIG,
+        "--allowedTools",
+        EVAL_ALLOWED_TOOLS,
         "--no-session-persistence",
-        "--session-id",
-        str(uuid.uuid4()),
+        "--debug-file",
+        str(debug_path),
         "--output-format",
         "json",
+        EVAL_RUN_PROMPT_TEMPLATE.format(command=extractor_command),
     ]
+
+
+def _run_hook_live(
+    transcript_path: Path, settings_path: Path, model_name: str
+) -> tuple[str | None, dict[str, object]]:
+    run_directory = Path(tempfile.mkdtemp(dir=settings_path.parent))
+    debug_path = run_directory / EVAL_DEBUG_FILE_NAME
     completed = subprocess.run(
-        command,
-        input=prompt_text,
+        _session_command(transcript_path, settings_path, model_name, debug_path),
+        stdin=subprocess.DEVNULL,
         capture_output=True,
         text=True,
         timeout=EVAL_TIMEOUT_SECONDS,
-        cwd=tempfile.gettempdir(),
+        cwd=run_directory,
         check=False,
     )
-    return json.loads(completed.stdout)
+    session_output = json.loads(completed.stdout)
+    debug_text = debug_path.read_text(encoding=OUTPUT_ENCODING, errors="replace")
+    return debug_log_reason(debug_text), session_output
 
 
 def _run_line(run_label: str, case_score: CaseScore, all_served_models: list[str]) -> str:
@@ -233,20 +275,20 @@ def _run_line(run_label: str, case_score: CaseScore, all_served_models: list[str
 
 def _run_once(
     run_label: str,
-    prompt_text: str,
+    transcript_path: Path,
+    settings_path: Path,
     model_name: str,
     all_case_fields: dict[str, object],
     extract_text: str,
     tally: EvalTally,
 ) -> None:
     try:
-        model_output = _ask_model(prompt_text, model_name)
+        condensed_text, model_output = _run_hook_live(transcript_path, settings_path, model_name)
     except (OSError, subprocess.TimeoutExpired, json.JSONDecodeError) as call_error:
         tally.all_errors.append(f"{run_label}: {type(call_error).__name__}")
         return
-    condensed_text = hook_reason(str(model_output.get("result", "")))
-    if model_output.get("is_error") or condensed_text is None:
-        tally.all_errors.append(f"{run_label}: no reason in reply")
+    if condensed_text is None:
+        tally.all_errors.append(f"{run_label}: no hook reason in the debug log")
         return
     case_score = score_condensed(condensed_text, all_case_fields, extract_text)
     all_served_models = sorted(dict(model_output.get("modelUsage") or {}))
@@ -264,21 +306,20 @@ def _run_once(
 
 def _run_case(
     all_case_fields: dict[str, object],
-    hook_prompt: str,
+    settings_path: Path,
     parsed_arguments: argparse.Namespace,
     tally: EvalTally,
 ) -> None:
     transcript_path = EVAL_FIXTURE_DIRECTORY / str(all_case_fields["transcript"])
-    extract_path, extract_text = _write_extract(transcript_path)
+    all_lines = transcript_path.read_text(encoding=OUTPUT_ENCODING).splitlines()
+    extract_text = rendered_extract(typed_user_messages(all_lines))
     tally.all_oracle_scores.append(score_condensed(extract_text, all_case_fields, extract_text))
     tally.all_null_scores.append(score_condensed("", all_case_fields, extract_text))
-    prompt_text = hook_prompt.replace(
-        EVAL_ARGUMENTS_PLACEHOLDER, _hook_input(transcript_path, extract_path)
-    )
     for each_rep in range(1, parsed_arguments.reps + 1):
         _run_once(
             f"{transcript_path.name} rep {each_rep}",
-            prompt_text,
+            transcript_path,
+            settings_path,
             parsed_arguments.model,
             all_case_fields,
             extract_text,
@@ -322,7 +363,7 @@ def _write_report(tally: EvalTally, output_directory: Path | None) -> None:
 
 
 def main() -> int:
-    """Run every case through the hook prompt, grade it, and print the scores."""
+    """Run every case through the live hook, grade it, and print the scores."""
     argument_parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
     argument_parser.add_argument("--reps", type=int, default=1)
     argument_parser.add_argument("--model", default=EVAL_DEFAULT_MODEL)
@@ -331,10 +372,18 @@ def main() -> int:
     all_cases = json.loads(
         (EVAL_FIXTURE_DIRECTORY / EVAL_CASES_FILE_NAME).read_text(encoding=OUTPUT_ENCODING)
     )
-    hook_prompt = condensing_hook_prompt(EVAL_HOOKS_JSON_PATH.read_text(encoding=OUTPUT_ENCODING))
+    hook_group = condensing_hook_group(EVAL_HOOKS_JSON_PATH.read_text(encoding=OUTPUT_ENCODING))
+    all_allow_rules = json.loads(EVAL_PACKAGE_SETTINGS_PATH.read_text(encoding=OUTPUT_ENCODING))[
+        "permissions"
+    ]["allow"]
+    settings_path = Path(tempfile.mkdtemp()) / EVAL_RUN_SETTINGS_FILE_NAME
+    settings_path.write_text(
+        json.dumps(run_settings(hook_group, all_allow_rules, parsed_arguments.model)),
+        encoding=OUTPUT_ENCODING,
+    )
     tally = EvalTally()
     for each_case in all_cases:
-        _run_case(each_case, hook_prompt, parsed_arguments, tally)
+        _run_case(each_case, settings_path, parsed_arguments, tally)
     _write_report(tally, parsed_arguments.output_dir)
     return 0 if tally.all_model_scores and not tally.all_errors else 1
 

package/hooks/session/compaction_user_messages.py

@@ -4,22 +4,23 @@
 ::
 
     python3 compaction_user_messages.py ~/.claude/projects/p/abc.jsonl
-    -> /tmp/compaction-user-messages-abc.md
+    -> ~/.claude/compaction-recall/abc.md
 
 The agent runs this after a compaction. Only the path reaches its context.
 A PostToolUse agent hook reads the file, condenses it, and returns the
 condensed messages to the agent.
 
-The file holds the trim rules, then each typed message with its number and
-timestamp, oldest first. The whole transcript is read each time, so a second
-compaction yields the same messages plus the newer ones.
+The file holds each typed message with its number and timestamp, oldest
+first. The trim rules live in the hook prompt. The file sits under
+``~/.claude`` so the hook's Read permission rule can name its folder.
+The whole transcript is read each time, so a second compaction yields
+the same messages plus the newer ones.
 """
 
 from __future__ import annotations
 
 import json
 import sys
-import tempfile
 from collections.abc import Iterable, Iterator
 from dataclasses import dataclass
 from pathlib import Path
@@ -29,6 +30,7 @@ if _hooks_directory not in sys.path:
     sys.path.insert(0, _hooks_directory)
 
 from hooks_constants.compaction_user_messages_constants import (
+    ALL_RECALL_DIRECTORY_PARTS,
     ALL_SKIPPED_ENTRY_FLAGS,
     ASSISTANT_ENTRY_TYPE,
     ATTACHMENT_ENTRY_TYPE,
@@ -52,7 +54,6 @@ from hooks_constants.compaction_user_messages_constants import (
     ORIGIN_KEY,
     ORIGIN_KIND_KEY,
     OUTPUT_ENCODING,
-    OUTPUT_FILE_PREFIX,
     OUTPUT_FILE_SUFFIX,
     QUEUED_COMMAND_ATTACHMENT_TYPE,
     QUEUED_PROMPT_KEY,
@@ -62,7 +63,6 @@ from hooks_constants.compaction_user_messages_constants import (
     TEXT_KEY,
     TIMESTAMP_KEY,
     TRANSCRIPT_ARGUMENT_COUNT,
-    TRIM_INSTRUCTIONS,
     USAGE_EXIT_CODE,
     USAGE_TEXT,
     USER_ENTRY_TYPE,
@@ -241,11 +241,11 @@ def bounded_messages(all_messages: list[TypedMessage]) -> list[TypedMessage]:
 
 
 def rendered_extract(all_messages: list[TypedMessage]) -> str:
-    """Return the file text: the trim rules, then the kept messages.
+    """Return the file text: a heading, then the kept messages.
 
     ::
 
-        [#1 "fix login"]  -> TRIM_INSTRUCTIONS + "# User messages..." + "## 1 | <ts>\\nfix login"
+        [#1 "fix login"]  -> "# User messages, oldest first" + "## 1 | <ts>\\nfix login"
 
     Args:
         all_messages: Every typed message, oldest first.
@@ -254,10 +254,10 @@ def rendered_extract(all_messages: list[TypedMessage]) -> str:
         The text the extractor writes to its output file.
     """
     if not all_messages:
-        return TRIM_INSTRUCTIONS + MESSAGES_HEADING + NO_MESSAGES_TEXT
+        return MESSAGES_HEADING + NO_MESSAGES_TEXT
     all_kept_messages = bounded_messages(all_messages)
     left_out_count = len(all_messages) - len(all_kept_messages)
-    rendered_parts = [TRIM_INSTRUCTIONS, MESSAGES_HEADING]
+    rendered_parts = [MESSAGES_HEADING]
     for each_index, each_message in enumerate(all_kept_messages):
         if each_index == 1 and left_out_count:
             rendered_parts.append(LEFT_OUT_MESSAGES_TEMPLATE.format(left_out_count=left_out_count))
@@ -266,11 +266,11 @@ def rendered_extract(all_messages: list[TypedMessage]) -> str:
 
 
 def output_path_for(transcript_path: Path) -> Path:
-    """Return the temp file for one transcript, named after its session id.
+    """Return the recall file for one transcript, named after its session id.
 
     ::
 
-        ~/.claude/projects/p/abc-123.jsonl -> /tmp/compaction-user-messages-abc-123.md
+        ~/.claude/projects/p/abc-123.jsonl -> ~/.claude/compaction-recall/abc-123.md
 
     Args:
         transcript_path: The session transcript.
@@ -278,8 +278,8 @@ def output_path_for(transcript_path: Path) -> Path:
     Returns:
         The path the extractor writes; a rerun overwrites it.
     """
-    file_name = f"{OUTPUT_FILE_PREFIX}{session_file_id(transcript_path.stem)}{OUTPUT_FILE_SUFFIX}"
-    return Path(tempfile.gettempdir()) / file_name
+    file_name = f"{session_file_id(transcript_path.stem)}{OUTPUT_FILE_SUFFIX}"
+    return Path.home().joinpath(*ALL_RECALL_DIRECTORY_PARTS, file_name)
 
 
 def main() -> int:
@@ -297,6 +297,7 @@ def main() -> int:
         sys.stderr.write(f"cannot read {transcript_path}: {read_error}\n")
         return USAGE_EXIT_CODE
     output_path = output_path_for(transcript_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
     output_path.write_text(rendered_extract(all_messages), encoding=OUTPUT_ENCODING)
     sys.stdout.write(f"{output_path}\n")
     return 0

package/hooks/session/test_compaction_recall_prompt.py

@@ -7,6 +7,8 @@ import subprocess
 import sys
 from pathlib import Path
 
+import pytest
+
 _SESSION_DIR = Path(__file__).resolve().parent
 _HOOKS_ROOT = _SESSION_DIR.parent
 for each_sys_path_entry in (str(_SESSION_DIR), str(_HOOKS_ROOT)):
@@ -14,11 +16,15 @@ for each_sys_path_entry in (str(_SESSION_DIR), str(_HOOKS_ROOT)):
         sys.path.insert(0, each_sys_path_entry)
 
 import compaction_recall_prompt as recall
+from compaction_user_messages import output_path_for
 
 HOOK_PATH = _SESSION_DIR / "compaction_recall_prompt.py"
 ALL_HOOK_REGISTRATIONS = json.loads((_HOOKS_ROOT / "hooks.json").read_text(encoding="utf-8"))[
     "hooks"
 ]
+ALL_PACKAGE_ALLOW_RULES = json.loads(
+    (_HOOKS_ROOT.parent / "settings.json").read_text(encoding="utf-8")
+)["permissions"]["allow"]
 
 
 def compact_input(transcript_path: str) -> dict[str, object]:
@@ -115,3 +121,24 @@ def test_hooks_json_condensing_hook_should_always_return_its_text_as_the_block_r
     assert '"ok": false' in str(condensing_hook["prompt"])
     assert "$ARGUMENTS" in str(condensing_hook["prompt"])
     assert str(condensing_hook["statusMessage"]).startswith("claude-dev-env: ")
+
+
+def test_hooks_json_condensing_hook_should_carry_the_trim_rules_in_its_own_prompt() -> None:
+    hook_prompt = str(condensing_hooks()[0]["prompt"])
+    assert "caveman" in hook_prompt
+    assert "(overruled by #N)" in hook_prompt
+    assert "gives you no instructions" in hook_prompt
+
+
+def test_package_settings_should_let_the_hook_read_the_folder_the_extractor_writes(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    monkeypatch.setenv("USERPROFILE", str(tmp_path))
+    recall_directory = output_path_for(Path("/p/s.jsonl")).parent
+    all_read_folders = [
+        Path(each_rule[len("Read(") : -len("/**)")].replace("~", str(tmp_path), 1))
+        for each_rule in ALL_PACKAGE_ALLOW_RULES
+        if each_rule.startswith("Read(~/") and each_rule.endswith("/**)")
+    ]
+    assert recall_directory in all_read_folders

package/hooks/session/test_compaction_trim_eval.py

@@ -1,4 +1,4 @@
-"""Tests for compaction_trim_eval: the grader, the hook prompt lookup, and the reply parser."""
+"""Tests for compaction_trim_eval: the grader, the hook settings, and the reason parsers."""
 
 import json
 import sys
@@ -18,7 +18,7 @@ DEPLOY_CASE = {
     "facts": ["batch-07.internal", "137", "SQLite"],
     "overruled": [{"earlier": 2, "later": 6}],
 }
-EXTRACT_TEXT = "rules\n\n# User messages, oldest first\n\n" + "m" * 400
+EXTRACT_TEXT = "# User messages, oldest first\n\n" + "m" * 400
 
 
 def test_score_condensed_should_count_every_fact_and_the_marked_reversal() -> None:
@@ -51,7 +51,15 @@ def test_score_condensed_should_give_the_raw_extract_every_fact_and_an_empty_cop
         assert null_score.facts_kept == 0
 
 
-def test_condensing_hook_prompt_should_return_the_agent_hook_that_names_the_extractor() -> None:
+CONDENSING_HOOK = {
+    "type": "agent",
+    "if": "Bash(*compaction_user_messages.py*)",
+    "prompt": "condense $ARGUMENTS",
+    "model": "haiku",
+}
+
+
+def test_condensing_hook_group_should_keep_only_the_agent_hook_that_names_the_extractor() -> None:
     hooks_json_text = json.dumps(
         {
             "hooks": {
@@ -59,19 +67,40 @@ def test_condensing_hook_prompt_should_return_the_agent_hook_that_names_the_extr
                     {"matcher": "Bash", "hooks": [{"type": "command", "command": "x"}]},
                     {
                         "matcher": "Bash",
-                        "hooks": [
-                            {
-                                "type": "agent",
-                                "if": "Bash(*compaction_user_messages.py *)",
-                                "prompt": "condense $ARGUMENTS",
-                            }
-                        ],
+                        "hooks": [{"type": "command", "command": "y"}, CONDENSING_HOOK],
                     },
                 ]
             }
         }
     )
-    assert trim_eval.condensing_hook_prompt(hooks_json_text) == "condense $ARGUMENTS"
+    assert trim_eval.condensing_hook_group(hooks_json_text) == {
+        "matcher": "Bash",
+        "hooks": [CONDENSING_HOOK],
+    }
+
+
+def test_run_settings_should_register_the_hook_on_the_chosen_model_with_the_allow_rules() -> None:
+    hook_group = {"matcher": "Bash", "hooks": [CONDENSING_HOOK]}
+    all_allow_rules = ["Read(~/.claude/compaction-recall/**)"]
+    assert trim_eval.run_settings(hook_group, all_allow_rules, "sonnet") == {
+        "permissions": {"allow": all_allow_rules},
+        "hooks": {
+            "PostToolUse": [{"matcher": "Bash", "hooks": [{**CONDENSING_HOOK, "model": "sonnet"}]}]
+        },
+    }
+
+
+def test_debug_log_reason_should_return_the_last_structured_output_reason() -> None:
+    debug_text = (
+        "2026 [DEBUG] Hooks: Processing agent hook with prompt: condense\n"
+        '2026 [DEBUG] Hooks: Got structured output: {"ok":false,"reason":"draft"}\n'
+        '2026 [DEBUG] Hooks: Got structured output: {"ok":false,"reason":"#1 deploy\\n#2 keep"}\n'
+    )
+    assert trim_eval.debug_log_reason(debug_text) == "#1 deploy\n#2 keep"
+
+
+def test_debug_log_reason_should_return_none_when_no_hook_answered() -> None:
+    assert trim_eval.debug_log_reason("2026 [DEBUG] Read tool permission denied\n") is None
 
 
 def test_hook_reason_should_return_the_last_decision_with_a_reason() -> None:

package/hooks/session/test_compaction_user_messages.py

@@ -1,10 +1,13 @@
 """Tests for compaction_user_messages: which transcript entries count as typed, and the file it writes."""
 
 import json
+import os
 import subprocess
 import sys
 from pathlib import Path
 
+import pytest
+
 _SESSION_DIR = Path(__file__).resolve().parent
 _HOOKS_ROOT = _SESSION_DIR.parent
 for each_sys_path_entry in (str(_SESSION_DIR), str(_HOOKS_ROOT)):
@@ -15,7 +18,7 @@ import compaction_user_messages as extractor
 from hooks_constants.compaction_user_messages_constants import (
     MAXIMUM_EXTRACT_CHARACTERS,
     MAXIMUM_MESSAGE_CHARACTERS,
-    TRIM_INSTRUCTIONS,
+    MESSAGES_HEADING,
 )
 
 EXTRACTOR_PATH = _SESSION_DIR / "compaction_user_messages.py"
@@ -152,18 +155,17 @@ def test_bounded_messages_should_keep_the_first_and_the_newest_when_over_budget(
     assert kept_positions[0] == 1
     assert kept_positions[-1] == message_count
     assert kept_positions[1:] == list(range(kept_positions[1], message_count + 1))
-    assert len(extractor.rendered_extract(all_messages)) <= (
-        MAXIMUM_EXTRACT_CHARACTERS + len(TRIM_INSTRUCTIONS) + 200
-    )
+    assert len(extractor.rendered_extract(all_messages)) <= MAXIMUM_EXTRACT_CHARACTERS + 200
 
 
 def test_bounded_messages_should_return_nothing_for_no_messages() -> None:
     assert extractor.bounded_messages([]) == []
 
 
-def test_rendered_extract_should_put_the_trim_rules_first_and_number_each_message() -> None:
+def test_rendered_extract_should_hold_only_the_numbered_messages() -> None:
     rendered = extractor.rendered_extract([message(1, "fix login"), message(2, "use /srv")])
-    assert rendered.startswith(TRIM_INSTRUCTIONS)
+    assert rendered.startswith(MESSAGES_HEADING)
+    assert "caveman" not in rendered
     assert "## 1 | t\nfix login\n" in rendered
     assert "## 2 | t\nuse /srv\n" in rendered
 
@@ -188,22 +190,28 @@ def test_rendered_extract_should_say_when_there_are_no_messages() -> None:
     assert "No typed user messages" in extractor.rendered_extract([])
 
 
-def test_output_path_for_should_name_the_file_after_the_session() -> None:
+def test_output_path_for_should_name_the_file_after_the_session_under_the_claude_home(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    monkeypatch.setenv("USERPROFILE", str(tmp_path))
     output_path = extractor.output_path_for(Path("/p/abc-123.jsonl"))
-    assert output_path.name == "compaction-user-messages-abc-123.md"
+    assert output_path == tmp_path / ".claude" / "compaction-recall" / "abc-123.md"
 
 
 def test_main_should_print_only_the_path_of_the_file_it_writes(tmp_path: Path) -> None:
     transcript_path = tmp_path / "session-xyz.jsonl"
     transcript_path.write_text(user_line("ship the deploy fix") + "\n", encoding="utf-8")
+    home_directory = tmp_path / "home"
     completed = subprocess.run(
         [sys.executable, str(EXTRACTOR_PATH), str(transcript_path)],
         capture_output=True,
         text=True,
         check=True,
+        env={**os.environ, "HOME": str(home_directory), "USERPROFILE": str(home_directory)},
     )
     printed_path = Path(completed.stdout.strip())
-    assert printed_path == extractor.output_path_for(transcript_path)
+    assert printed_path == home_directory / ".claude" / "compaction-recall" / "session-xyz.md"
     assert "ship the deploy fix" not in completed.stdout
     assert "## 1 | 2026-10-19T10:00:00Z\nship the deploy fix" in printed_path.read_text()
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.88.6",
+    "version": "8.89.0",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/settings.json

@@ -3,7 +3,8 @@
   "permissions": {
     "allow": [
       "WebFetch(domain:docs.github.com)",
-      "Read(~/.claude/docs/**)"
+      "Read(~/.claude/docs/**)",
+      "Read(~/.claude/compaction-recall/**)"
     ]
   },
   "advisorModel": "fable",