claude-dev-env 8.90.0 → 8.91.0

package/hooks/session/test_compaction_trim.py

@@ -0,0 +1,169 @@
+"""Tests for compaction_trim: the caveman trim, the overruled marks, and the recall budget."""
+
+import sys
+from pathlib import Path
+
+_SESSION_DIR = Path(__file__).resolve().parent
+_HOOKS_ROOT = _SESSION_DIR.parent
+for each_sys_path_entry in (str(_SESSION_DIR), str(_HOOKS_ROOT)):
+    if each_sys_path_entry not in sys.path:
+        sys.path.insert(0, each_sys_path_entry)
+
+import compaction_trim as trim
+from compaction_user_messages import TypedMessage
+from hooks_constants.compaction_user_messages_constants import (
+    MAXIMUM_MESSAGE_CHARACTERS,
+    MAXIMUM_RECALL_CHARACTERS,
+)
+
+
+def message(position: int, text: str) -> TypedMessage:
+    return TypedMessage(position=position, timestamp="t", text=text)
+
+
+def test_caveman_text_should_drop_filler_and_articles() -> None:
+    assert (
+        trim.caveman_text("Could you please just add the retry to a deploy script , basically.")
+        == "just add retry to deploy script."
+    )
+
+
+def test_caveman_text_should_keep_a_restrictive_just() -> None:
+    assert trim.caveman_text("use just the staging db") == "use just staging db"
+
+
+def test_caveman_text_should_keep_backtick_spans_and_path_tokens_as_typed() -> None:
+    assert (
+        trim.caveman_text("run `the just a tool` on just/the.py and the-a.md")
+        == "run `the just a tool` on just/the.py and the-a.md"
+    )
+
+
+def test_caveman_text_should_keep_a_hedge() -> None:
+    assert trim.caveman_text("I think the cache is stale") == "I think cache is stale"
+
+
+def test_caveman_text_should_keep_a_capital_letter_label() -> None:
+    assert trim.caveman_text("The plan A is good, an Option A or B") == "plan A is good, Option A or B"
+
+
+def test_trimmed_lines_should_not_mark_a_line_a_reminder_repeats() -> None:
+    all_messages = [
+        message(1, "Set up the linter in CI"),
+        message(2, "Don't forget the linter config too"),
+    ]
+    assert trim.trimmed_lines(all_messages) == [
+        "#1 Set up linter in CI",
+        "#2 Don't forget linter config too",
+    ]
+
+
+def test_trimmed_lines_should_not_read_a_cue_inside_a_longer_word() -> None:
+    all_messages = [
+        message(1, "Add docs for the API"),
+        message(2, "Document the undocumented parts of the API"),
+    ]
+    assert trim.trimmed_lines(all_messages) == [
+        "#1 Add docs for API",
+        "#2 Document undocumented parts of API",
+    ]
+
+
+def test_trimmed_lines_should_drop_gratitude_and_interrupts_and_keep_approvals() -> None:
+    all_messages = [
+        message(1, "ship it to staging"),
+        message(2, "thanks"),
+        message(3, "[Request interrupted by user]"),
+        message(4, "yes, go ahead"),
+        message(5, "ok but use port 8443"),
+    ]
+    assert trim.trimmed_lines(all_messages) == [
+        "#1 ship it to staging",
+        "#4 yes, go ahead",
+        "#5 ok but use port 8443",
+    ]
+
+
+def test_trimmed_lines_should_mark_the_earlier_message_a_reversal_overrules() -> None:
+    all_messages = [
+        message(1, "Store the uploads in S3."),
+        message(2, "Log every retry to logs/retry.csv"),
+        message(3, "Change of plan, keep the uploads on local disk, not S3."),
+    ]
+    assert trim.trimmed_lines(all_messages) == [
+        "#1 Store uploads in S3. (overruled by #3)",
+        "#2 Log every retry to logs/retry.csv",
+        "#3 Change of plan, keep uploads on local disk, not S3.",
+    ]
+
+
+ARTIFACT_COMMENT_TEXT = """[Artifact comment sent to Claude]
+Artifact: https://claude.ai/code/artifact/e5f0
+Comment thread: 02ec
+I sent you this comment from the artifact's comment thread. Handle it in this session.
+=== BEGIN ARTIFACT COMMENT df7f ===
+> Can you show me this?
+> How is the agent spawned?
+=== END ARTIFACT COMMENT df7f ===
+<comment-anchor-context source="artifact content">
+Location: What happens when a session compacts
+Element: rect
+</comment-anchor-context>
+Answer this comment in its thread, not here."""
+
+
+def test_trimmed_lines_should_keep_only_the_link_anchor_and_quote_of_an_artifact_comment() -> None:
+    assert trim.trimmed_lines([message(1, ARTIFACT_COMMENT_TEXT)]) == [
+        "#1 Artifact comment on https://claude.ai/code/artifact/e5f0 at What happens when "
+        "session compacts: show me this? How is agent spawned?"
+    ]
+
+
+def test_trimmed_lines_should_drop_html_comments_and_a_message_left_empty() -> None:
+    assert trim.trimmed_lines(
+        [message(1, "<!-- reply 1 --> use port 8443"), message(2, "<!-- draft -->")]
+    ) == ["#1 use port 8443"]
+
+
+def test_trimmed_lines_should_cut_a_long_message_and_say_how_much() -> None:
+    long_text = "y" * (MAXIMUM_MESSAGE_CHARACTERS + 25)
+    assert trim.trimmed_lines([message(1, long_text)]) == [
+        "#1 " + "y" * MAXIMUM_MESSAGE_CHARACTERS + " [25 more characters left out]"
+    ]
+
+
+def test_recall_text_should_keep_the_first_and_the_newest_lines_within_budget() -> None:
+    message_count = 3 * MAXIMUM_RECALL_CHARACTERS // MAXIMUM_MESSAGE_CHARACTERS
+    all_messages = [
+        message(each, f"m{each} " + "x" * (MAXIMUM_MESSAGE_CHARACTERS - 100))
+        for each in range(1, message_count + 1)
+    ]
+    all_recall_lines = (trim.recall_text(all_messages) or "").splitlines()
+    assert all_recall_lines[0].startswith("#1 m1 ")
+    assert all_recall_lines[-1].startswith(f"#{message_count} m{message_count} ")
+    kept_line_count = len(all_recall_lines) - 2
+    left_out_count = message_count - 1 - kept_line_count
+    assert left_out_count > 0
+    assert all_recall_lines[1] == f"[{left_out_count} earlier messages left out to fit the budget]"
+    recall_without_note = "\n".join([all_recall_lines[0], *all_recall_lines[2:]])
+    assert len(recall_without_note) <= MAXIMUM_RECALL_CHARACTERS
+
+
+def test_recall_text_should_return_none_when_nothing_carries_content() -> None:
+    assert trim.recall_text([]) is None
+    assert trim.recall_text([message(1, "thank you"), message(2, "thanks")]) is None
+
+
+def test_recall_text_should_keep_approval_and_continuation_messages() -> None:
+    for approval in (
+        "yes, go ahead",
+        "yes",
+        "ok",
+        "sure",
+        "sounds good",
+        "continue",
+        "proceed",
+        "you",
+        "thanks 8443",
+    ):
+        assert trim.recall_text([message(1, approval)]) == f"#1 {approval}"

package/hooks/session/test_compaction_trim_eval.py

@@ -1,9 +1,11 @@
-"""Tests for compaction_trim_eval: the grader, the hook settings, and the reason parsers."""
+"""Tests for compaction_trim_eval: the grader and the fixture cases it scores."""
 
 import json
 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)):
@@ -11,105 +13,50 @@ for each_sys_path_entry in (str(_SESSION_DIR), str(_HOOKS_ROOT)):
         sys.path.insert(0, each_sys_path_entry)
 
 import compaction_trim_eval as trim_eval
-from compaction_user_messages import rendered_extract, typed_user_messages
 
+FIXTURE_DIRECTORY = _SESSION_DIR / "fixtures" / "compaction_user_messages"
 DEPLOY_CASE = {
     "transcript": "deploy_session.jsonl",
     "facts": ["batch-07.internal", "137", "SQLite"],
     "overruled": [{"earlier": 2, "later": 6}],
 }
-EXTRACT_TEXT = "# User messages, oldest first\n\n" + "m" * 400
+RAW_MESSAGES = "m" * 400
 
 
 def test_score_condensed_should_count_every_fact_and_the_marked_reversal() -> None:
-    condensed_text = (
+    recall = (
         "#1 deploy to BATCH-07.internal\n#2 keep Postgres (overruled by #6)\n"
         "#5 exit code 137\n#6 switch to SQLite\n"
     )
-    case_score = trim_eval.score_condensed(condensed_text, DEPLOY_CASE, EXTRACT_TEXT)
+    case_score = trim_eval.score_condensed(recall, DEPLOY_CASE, RAW_MESSAGES)
     assert (case_score.facts_kept, case_score.facts_total) == (3, 3)
     assert (case_score.overruled_marked, case_score.overruled_total) == (1, 1)
-    assert case_score.compression_ratio == len("m" * 400) / len(condensed_text)
+    assert case_score.compression_ratio == len(RAW_MESSAGES) / len(recall)
+    assert case_score.is_lossless
 
 
-def test_score_condensed_should_score_a_copy_that_drops_facts_lower() -> None:
-    lossy_text = "#1 deploy\n#2 keep Postgres\n#6 switch db\n"
-    case_score = trim_eval.score_condensed(lossy_text, DEPLOY_CASE, EXTRACT_TEXT)
+def test_score_condensed_should_score_a_recall_that_drops_facts_lower() -> None:
+    lossy_recall = "#1 deploy\n#2 keep Postgres\n#6 switch db\n"
+    case_score = trim_eval.score_condensed(lossy_recall, DEPLOY_CASE, RAW_MESSAGES)
     assert case_score.facts_kept == 0
     assert case_score.overruled_marked == 0
-
-
-def test_score_condensed_should_give_the_raw_extract_every_fact_and_an_empty_copy_none() -> None:
-    fixture_directory = _SESSION_DIR / "fixtures" / "compaction_user_messages"
-    all_cases = json.loads((fixture_directory / "trim_cases.json").read_text(encoding="utf-8"))
-    for each_case in all_cases:
-        transcript_lines = (fixture_directory / each_case["transcript"]).read_text().splitlines()
-        extract_text = rendered_extract(typed_user_messages(transcript_lines))
-        oracle_score = trim_eval.score_condensed(extract_text, each_case, extract_text)
-        null_score = trim_eval.score_condensed("", each_case, extract_text)
-        assert oracle_score.facts_kept == oracle_score.facts_total
-        assert null_score.facts_kept == 0
-
-
-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": {
-                "PostToolUse": [
-                    {"matcher": "Bash", "hooks": [{"type": "command", "command": "x"}]},
-                    {
-                        "matcher": "Bash",
-                        "hooks": [{"type": "command", "command": "y"}, CONDENSING_HOOK],
-                    },
-                ]
-            }
-        }
-    )
-    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:
-    model_reply = (
-        'Draft {"ok": false, "reason": "first"} then {"note": 1} and '
-        '{"ok": false, "reason": "#1 use {braces} here"}'
-    )
-    assert trim_eval.hook_reason(model_reply) == "#1 use {braces} here"
-
-
-def test_hook_reason_should_return_none_when_the_reply_has_no_decision() -> None:
-    assert trim_eval.hook_reason("I could not read the file {broken") is None
+    assert not case_score.is_lossless
+
+
+def test_scored_cases_should_keep_every_fact_and_reversal_in_each_fixture() -> None:
+    all_cases = json.loads((FIXTURE_DIRECTORY / "trim_cases.json").read_text(encoding="utf-8"))
+    all_rows = trim_eval.scored_cases(FIXTURE_DIRECTORY)
+    assert [each_row[0] for each_row in all_rows] == [
+        each_case["transcript"] for each_case in all_cases
+    ]
+    for each_name, trim_score, oracle_score, null_score in all_rows:
+        assert trim_score.is_lossless, each_name
+        assert oracle_score.facts_kept == oracle_score.facts_total, each_name
+        assert null_score.facts_kept == 0, each_name
+
+
+def test_main_should_exit_zero_when_the_trim_keeps_every_fact(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    assert trim_eval.main() == 0
+    assert "trim: facts 1.00  overruled 1.00" in capsys.readouterr().out

package/hooks/session/test_compaction_user_messages.py

@@ -1,13 +1,9 @@
-"""Tests for compaction_user_messages: which transcript entries count as typed, and the file it writes."""
+"""Tests for compaction_user_messages: which Claude Code and Codex transcript entries count as typed."""
 
 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,13 +11,7 @@ for each_sys_path_entry in (str(_SESSION_DIR), str(_HOOKS_ROOT)):
         sys.path.insert(0, each_sys_path_entry)
 
 import compaction_user_messages as extractor
-from hooks_constants.compaction_user_messages_constants import (
-    MAXIMUM_EXTRACT_CHARACTERS,
-    MAXIMUM_MESSAGE_CHARACTERS,
-    MESSAGES_HEADING,
-)
 
-EXTRACTOR_PATH = _SESSION_DIR / "compaction_user_messages.py"
 FIXTURE_DIRECTORY = _SESSION_DIR / "fixtures" / "compaction_user_messages"
 
 
@@ -137,92 +127,44 @@ def test_should_converge_when_a_second_compaction_appends_to_the_transcript() ->
     ]
 
 
-def message(position: int, text: str) -> extractor.TypedMessage:
-    return extractor.TypedMessage(position=position, timestamp="t", text=text)
-
-
-def test_bounded_messages_should_keep_everything_that_fits() -> None:
-    all_messages = [message(1, "a"), message(2, "b"), message(3, "c")]
-    assert extractor.bounded_messages(all_messages) == all_messages
-
-
-def test_bounded_messages_should_keep_the_first_and_the_newest_when_over_budget() -> None:
-    long_text = "x" * (MAXIMUM_MESSAGE_CHARACTERS - 100)
-    message_count = 2 * MAXIMUM_EXTRACT_CHARACTERS // MAXIMUM_MESSAGE_CHARACTERS
-    all_messages = [message(each, long_text) for each in range(1, message_count + 1)]
-    all_kept = extractor.bounded_messages(all_messages)
-    kept_positions = [each.position for each in all_kept]
-    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 + 200
-
-
-def test_bounded_messages_should_return_nothing_for_no_messages() -> None:
-    assert extractor.bounded_messages([]) == []
-
-
-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(MESSAGES_HEADING)
-    assert "caveman" not in rendered
-    assert "## 1 | t\nfix login\n" in rendered
-    assert "## 2 | t\nuse /srv\n" in rendered
-
-
-def test_rendered_extract_should_cut_a_long_message_and_say_how_much() -> None:
-    rendered = extractor.rendered_extract([message(1, "y" * (MAXIMUM_MESSAGE_CHARACTERS + 25))])
-    assert "[25 more characters left out]" in rendered
-
-
-def test_rendered_extract_should_name_how_many_messages_were_left_out() -> None:
-    long_text = "x" * (MAXIMUM_MESSAGE_CHARACTERS - 100)
-    message_count = 2 * MAXIMUM_EXTRACT_CHARACTERS // MAXIMUM_MESSAGE_CHARACTERS
-    all_messages = [message(each, long_text) for each in range(1, message_count + 1)]
-    left_out_count = message_count - len(extractor.bounded_messages(all_messages))
-    assert left_out_count > 0
-    assert f"[{left_out_count} earlier messages left out" in extractor.rendered_extract(
-        all_messages
+def codex_line(payload: dict[str, object]) -> str:
+    return json.dumps(
+        {"timestamp": "2026-10-19T11:00:00Z", "type": "event_msg", "payload": payload}
     )
 
 
-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_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 == tmp_path / ".claude" / "compaction-recall" / "abc-123.md"
+def test_should_keep_codex_user_messages_and_leave_out_injected_items() -> None:
+    all_lines = [
+        json.dumps({"type": "session_meta", "payload": {"cwd": "/w"}}),
+        json.dumps(
+            {
+                "type": "response_item",
+                "payload": {
+                    "type": "message",
+                    "role": "user",
+                    "content": [{"type": "input_text", "text": "<environment_context>"}],
+                },
+            }
+        ),
+        codex_line({"type": "user_message", "message": "port the hook to codex", "kind": "plain"}),
+        codex_line({"type": "agent_message", "message": "on it"}),
+        codex_line({"type": "user_message", "message": "see this", "images": ["data:image/png"]}),
+        codex_line({"type": "user_message", "message": "", "images": ["data:image/png"]}),
+    ]
+    all_messages = extractor.typed_user_messages(all_lines)
+    assert [each_message.text for each_message in all_messages] == [
+        "port the hook to codex",
+        "see this [image]",
+        "[image]",
+    ]
+    assert all_messages[0].timestamp == "2026-10-19T11:00:00Z"
 
 
-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 == 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()
-
-
-def test_main_should_exit_with_usage_when_the_transcript_is_missing(tmp_path: Path) -> None:
-    for all_arguments in ([], [str(tmp_path / "absent.jsonl")]):
-        completed = subprocess.run(
-            [sys.executable, str(EXTRACTOR_PATH), *all_arguments],
-            capture_output=True,
-            text=True,
-            check=False,
-        )
-        assert completed.returncode == 2
-        assert completed.stdout == ""
+def test_should_keep_a_codex_message_typed_again_after_the_agent_replied() -> None:
+    all_lines = [
+        codex_line({"type": "user_message", "message": "go"}),
+        codex_line({"type": "user_message", "message": "go"}),
+        codex_line({"type": "agent_message", "message": "done"}),
+        codex_line({"type": "user_message", "message": "go"}),
+    ]
+    assert texts_of(all_lines) == ["go", "go"]

package/package.json

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

package/settings.json

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