claude-dev-env 8.88.5 → 8.88.6

package/hooks/session/fixtures/compaction_user_messages/long_session.jsonl

@@ -0,0 +1,41 @@
+{"type": "user", "timestamp": "2026-10-19T10:00:18Z", "message": {"role": "user", "content": "we are cleaning up the photo importer in tools/photo_import/. goal: imports under 90 seconds for a 2,000 photo card"}, "origin": {"kind": "human"}}
+{"type": "assistant", "timestamp": "2026-10-19T10:00:19Z", "message": {"role": "assistant", "content": [{"type": "text", "text": "Working on it."}]}}
+{"type": "user", "timestamp": "2026-10-19T10:00:20Z", "message": {"role": "user", "content": [{"type": "tool_result", "tool_use_id": "toolu_1", "content": "ran tests: 41 passed"}]}}
+{"type": "user", "timestamp": "2026-10-19T10:00:21Z", "message": {"role": "user", "content": "sounds good"}, "origin": {"kind": "human"}}
+{"type": "user", "timestamp": "2026-10-19T10:00:22Z", "message": {"role": "user", "content": "the slow part is the EXIF read in exif_reader.py, it opens each file twice"}, "origin": {"kind": "human"}}
+{"type": "user", "timestamp": "2026-10-19T10:00:23Z", "message": {"role": "user", "content": "helper output"}, "isSidechain": true}
+{"type": "assistant", "timestamp": "2026-10-19T10:00:24Z", "message": {"role": "assistant", "content": [{"type": "text", "text": "Working on it."}]}}
+{"type": "user", "timestamp": "2026-10-19T10:00:25Z", "message": {"role": "user", "content": [{"type": "tool_result", "tool_use_id": "toolu_1", "content": "ran tests: 41 passed"}]}}
+{"type": "user", "timestamp": "2026-10-19T10:00:26Z", "message": {"role": "user", "content": "yes go ahead"}, "origin": {"kind": "human"}}
+{"type": "user", "timestamp": "2026-10-19T10:00:27Z", "message": {"role": "user", "content": "do not add new dependencies, pillow is already pinned at 10.4.0"}, "origin": {"kind": "human"}}
+{"type": "user", "timestamp": "2026-10-19T10:00:28Z", "message": {"role": "user", "content": "helper output"}, "isSidechain": true}
+{"type": "assistant", "timestamp": "2026-10-19T10:00:29Z", "message": {"role": "assistant", "content": [{"type": "text", "text": "Working on it."}]}}
+{"type": "user", "timestamp": "2026-10-19T10:00:30Z", "message": {"role": "user", "content": [{"type": "tool_result", "tool_use_id": "toolu_1", "content": "ran tests: 41 passed"}]}}
+{"type": "user", "timestamp": "2026-10-19T10:00:31Z", "message": {"role": "user", "content": "ok"}, "origin": {"kind": "human"}}
+{"type": "user", "timestamp": "2026-10-19T10:00:32Z", "message": {"role": "user", "content": "skip RAW files with the .cr3 extension for now"}, "origin": {"kind": "human"}}
+{"type": "user", "timestamp": "2026-10-19T10:00:33Z", "message": {"role": "user", "content": "helper output"}, "isSidechain": true}
+{"type": "assistant", "timestamp": "2026-10-19T10:00:34Z", "message": {"role": "assistant", "content": [{"type": "text", "text": "Working on it."}]}}
+{"type": "user", "timestamp": "2026-10-19T10:00:35Z", "message": {"role": "user", "content": [{"type": "tool_result", "tool_use_id": "toolu_1", "content": "ran tests: 41 passed"}]}}
+{"type": "user", "timestamp": "2026-10-19T10:00:36Z", "message": {"role": "user", "content": "nice"}, "origin": {"kind": "human"}}
+{"type": "user", "timestamp": "2026-10-19T10:00:37Z", "message": {"role": "user", "content": "the test card lives at /mnt/cards/sample_2000"}, "origin": {"kind": "human"}}
+{"type": "user", "timestamp": "2026-10-19T10:00:38Z", "message": {"role": "user", "content": "helper output"}, "isSidechain": true}
+{"type": "assistant", "timestamp": "2026-10-19T10:00:39Z", "message": {"role": "assistant", "content": [{"type": "text", "text": "Working on it."}]}}
+{"type": "user", "timestamp": "2026-10-19T10:00:40Z", "message": {"role": "user", "content": [{"type": "tool_result", "tool_use_id": "toolu_1", "content": "ran tests: 41 passed"}]}}
+{"type": "user", "timestamp": "2026-10-19T10:00:41Z", "message": {"role": "user", "content": "keep going"}, "origin": {"kind": "human"}}
+{"type": "user", "timestamp": "2026-10-19T10:00:42Z", "message": {"role": "user", "content": "use 6 worker threads, the NAS chokes above that"}, "origin": {"kind": "human"}}
+{"type": "user", "timestamp": "2026-10-19T10:00:43Z", "message": {"role": "user", "content": "helper output"}, "isSidechain": true}
+{"type": "assistant", "timestamp": "2026-10-19T10:00:44Z", "message": {"role": "assistant", "content": [{"type": "text", "text": "Working on it."}]}}
+{"type": "user", "timestamp": "2026-10-19T10:00:45Z", "message": {"role": "user", "content": [{"type": "tool_result", "tool_use_id": "toolu_1", "content": "ran tests: 41 passed"}]}}
+{"type": "user", "timestamp": "2026-10-19T10:00:46Z", "message": {"role": "user", "content": "sure"}, "origin": {"kind": "human"}}
+{"type": "user", "timestamp": "2026-10-19T10:00:47Z", "message": {"role": "user", "content": "write the timing to logs/import_timing.csv with one row per run"}, "origin": {"kind": "human"}}
+{"type": "user", "timestamp": "2026-10-19T10:00:48Z", "message": {"role": "user", "content": "helper output"}, "isSidechain": true}
+{"type": "assistant", "timestamp": "2026-10-19T10:00:49Z", "message": {"role": "assistant", "content": [{"type": "text", "text": "Working on it."}]}}
+{"type": "user", "timestamp": "2026-10-19T10:00:50Z", "message": {"role": "user", "content": [{"type": "tool_result", "tool_use_id": "toolu_1", "content": "ran tests: 41 passed"}]}}
+{"type": "user", "timestamp": "2026-10-19T10:00:51Z", "message": {"role": "user", "content": "great, continue"}, "origin": {"kind": "human"}}
+{"type": "user", "timestamp": "2026-10-19T10:00:52Z", "message": {"role": "user", "content": "change that: make it 4 worker threads, 6 still froze the NAS last night"}, "origin": {"kind": "human"}}
+{"type": "user", "timestamp": "2026-10-19T10:00:53Z", "message": {"role": "user", "content": "helper output"}, "isSidechain": true}
+{"type": "assistant", "timestamp": "2026-10-19T10:00:54Z", "message": {"role": "assistant", "content": [{"type": "text", "text": "Working on it."}]}}
+{"type": "user", "timestamp": "2026-10-19T10:00:55Z", "message": {"role": "user", "content": [{"type": "tool_result", "tool_use_id": "toolu_1", "content": "ran tests: 41 passed"}]}}
+{"type": "user", "timestamp": "2026-10-19T10:00:56Z", "message": {"role": "user", "content": "makes sense"}, "origin": {"kind": "human"}}
+{"type": "user", "timestamp": "2026-10-19T10:00:57Z", "message": {"role": "user", "content": "name the branch photo-import-speed"}, "origin": {"kind": "human"}}
+{"type": "user", "timestamp": "2026-10-19T10:00:58Z", "message": {"role": "user", "content": "helper output"}, "isSidechain": true}

package/hooks/session/fixtures/compaction_user_messages/one_compaction.jsonl

@@ -0,0 +1,7 @@
+{"type": "user", "message": {"role": "user", "content": "Note these facts for later: the deploy path is /srv/alpha/release-42 and the retry limit is 17. Reply only: noted."}, "isSidechain": false, "timestamp": "2026-10-19T14:18:25.345Z"}
+{"type": "assistant", "message": {"role": "assistant", "content": [{"type": "text", "text": "noted."}]}, "isSidechain": false, "timestamp": "2026-10-19T14:18:25.997Z"}
+{"type": "system", "subtype": "compact_boundary", "isMeta": false, "isSidechain": false, "timestamp": "2026-10-19T14:18:41.560Z", "content": "Conversation compacted"}
+{"type": "user", "message": {"role": "user", "content": "This session is being continued from a previous conversation. Summary omitted from fixture."}, "isCompactSummary": true, "isSidechain": false, "timestamp": "2026-10-19T14:18:41.558Z"}
+{"type": "user", "message": {"role": "user", "content": "<local-command-caveat>The command below was run directly in Claude Code, not sent to you as a request, and its output goes straight to the user. It's recorded here as context for later messages.</local-command-caveat>"}, "isMeta": true, "isSidechain": false, "timestamp": "2026-10-19T14:18:38.047Z"}
+{"type": "user", "message": {"role": "user", "content": "<command-name>/compact</command-name>\n            <command-message>compact</command-message>\n            <command-args></command-args>"}, "isSidechain": false, "timestamp": "2026-10-19T14:18:38.047Z"}
+{"type": "user", "message": {"role": "user", "content": "<local-command-stdout>Compacted (ctrl+o to see full summary)</local-command-stdout>"}, "isSidechain": false, "timestamp": "2026-10-19T14:18:41.746Z"}

package/hooks/session/fixtures/compaction_user_messages/recall_request_session.jsonl

@@ -0,0 +1,4 @@
+{"type": "user", "message": {"role": "user", "content": "<command-message>deepen</command-message>\n<command-name>/deepen</command-name>\n<command-args>i'd like my agents to be able to have better post-compaction behavior; i feel that there is a strong potential benefit in having a post-compact hook which runs a tool that -reads- that session's chat transcript, and this tool simply returns the user's messages to that agent. example is attached.\n\ni do believe that we should probably 'lighten the load' by having some other layer - for example perhaps this is a prompt hook that is aligned with it. the prompt hook is simply a caveman style return of the user's messages; so we run our tool, it returns the input to that prompt hook (raw user 'message' input), and then the agent which receives that is instructed to trim it down without losing substance; ie: caveman style messages. and this is the final result that's returned to our agent.</command-args>"}, "isSidechain": false, "origin": {"kind": "human"}, "timestamp": "2026-10-19T14:11:07.044Z"}
+{"type": "user", "message": {"role": "user", "content": [{"type": "text", "text": "Base directory for this skill: ~/.claude/skills/deepen\n\n# deepen\n\nOn a first task, `/deepen` plus a task, or a routine wake that has work, read DeepStack intake and follow it: [intake](https://github.com/jl-cmd-projects/DeepStack/blob/main/plugins/deepstack/skills/deepstack-mode/references/intake.md).\n\nSkip when the prompt already carries `CDE_DEEPEN:v1`, when the text is a thanks or yes/no or status line, when it is a slash command other than `/deepen`, when it is a `/loop` or helper report, or when it is a spawn rewrite that already starts with the poteto-mode prefix.\n\nA prompt that is only `/deepen` with no task is skipped. `/deepen` plus a task deepens the remainder.\n\nThe deepening pass writes the worker prompt and stops. The worker runs that prompt.\n\nWhen you spawn a helper to fill the four answers, that helper's prompt starts with `CDE_DEEPEN_AGENT` so the first-task hook leaves it alone.\n\n## Hosts\n\n- Claude desktop and CLI: a `prompt.submit` mod rewrites the visible text. The Python `UserPromptSubmit` hook is silent when that mod is on outside a cloud session.\n- Claude cloud and Codex local: the Python hook injects `additionalContext`. Command hooks cannot replace the prompt string.\n- Cursor Cloud: run DeepStack intake on the launch prompt. The host adapter for the three lines and the refusal lives with that host. This package keeps the gate.\n- Codex cloud orchestration skips command hooks. Local Codex only.\n\n\nARGUMENTS: i'd like my agents to be able to have better post-compaction behavior; i feel that there is a strong potential benefit in having a post-compact hook which runs a tool that -reads- that session's chat transcript, and this tool simply returns the user's messages to that agent. example is attached.\n\ni do believe that we should probably 'lighten the load' by having some other layer - for example perhaps this is a prompt hook that is aligned with it. the prompt hook is simply a caveman style return of the user's messages; so we run our tool, it returns the input to that prompt hook (raw user 'message' input), and then the agent which receives that is instructed to trim it down without losing substance; ie: caveman style messages. and this is the final result that's returned to our agent."}]}, "isMeta": true, "isSidechain": false, "timestamp": "2026-10-19T14:11:07.044Z"}
+{"type": "user", "message": {"role": "user", "content": [{"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": ""}}, {"text": "here.\n\nand i dont buy it. prompot hooks can definitely return text or values? i'm fairly certain ihave that already in my existing hooks.", "type": "text"}]}, "isSidechain": false, "origin": {"kind": "human"}, "timestamp": "2026-10-19T14:14:31.507Z"}
+{"type": "user", "message": {"role": "user", "content": [{"type": "text", "text": "[Image: source: /tmp/claude-0/-workspace/d1c9e10e-7af1-51e5-8956-15fde41ab886/images/1.png]"}]}, "isMeta": true, "isSidechain": false, "timestamp": "2026-10-19T14:14:31.507Z"}

package/hooks/session/fixtures/compaction_user_messages/trim_cases.json

@@ -0,0 +1,47 @@
+[
+  {
+    "transcript": "deploy_session.jsonl",
+    "facts": [
+      "/deepen",
+      "batch-07.internal",
+      "02:15 UTC",
+      "billing.invoices_v3",
+      "packages/billing/legacy_export.py",
+      "Monday",
+      "SQLite",
+      "Q3",
+      "137",
+      "4 attempts",
+      "30s",
+      "https://github.com/acme/billing/pull/812",
+      "Dana"
+    ],
+    "overruled": [{"earlier": 2, "later": 6}]
+  },
+  {
+    "transcript": "long_session.jsonl",
+    "facts": [
+      "tools/photo_import/",
+      "90 seconds",
+      "2,000",
+      "exif_reader.py",
+      "10.4.0",
+      ".cr3",
+      "/mnt/cards/sample_2000",
+      "logs/import_timing.csv",
+      "4 worker threads",
+      "photo-import-speed"
+    ],
+    "overruled": [{"earlier": 11, "later": 15}]
+  },
+  {
+    "transcript": "recall_request_session.jsonl",
+    "facts": [
+      "/deepen",
+      "transcript",
+      "caveman",
+      "prompt hook"
+    ],
+    "overruled": []
+  }
+]

package/hooks/session/test_compaction_recall_prompt.py

@@ -0,0 +1,117 @@
+"""Tests for compaction_recall_prompt and the hooks.json entries that carry its recall."""
+
+import fnmatch
+import json
+import shlex
+import subprocess
+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_recall_prompt as recall
+
+HOOK_PATH = _SESSION_DIR / "compaction_recall_prompt.py"
+ALL_HOOK_REGISTRATIONS = json.loads((_HOOKS_ROOT / "hooks.json").read_text(encoding="utf-8"))[
+    "hooks"
+]
+
+
+def compact_input(transcript_path: str) -> dict[str, object]:
+    return {
+        "hook_event_name": "SessionStart",
+        "source": "compact",
+        "transcript_path": transcript_path,
+    }
+
+
+def recall_command(transcript_path: str) -> str:
+    context_text = recall.recall_context(compact_input(transcript_path))
+    assert context_text is not None
+    return next(line for line in context_text.splitlines() if "compaction_user_messages.py" in line)
+
+
+def test_recall_context_should_name_a_command_that_writes_the_users_messages(
+    tmp_path: Path,
+) -> None:
+    transcript_path = tmp_path / "it's a session.jsonl"
+    transcript_path.write_text(
+        json.dumps({"type": "user", "message": {"content": "keep port 8443"}}) + "\n",
+        encoding="utf-8",
+    )
+    completed = subprocess.run(
+        shlex.split(recall_command(str(transcript_path))),
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    assert "keep port 8443" in Path(completed.stdout.strip()).read_text(encoding="utf-8")
+
+
+def test_recall_context_should_stay_quiet_outside_a_compaction() -> None:
+    assert recall.recall_context({**compact_input("/t.jsonl"), "source": "startup"}) is None
+    assert recall.recall_context({**compact_input("/t.jsonl"), "hook_event_name": "Stop"}) is None
+    assert recall.recall_context({"hook_event_name": "SessionStart", "source": "compact"}) is None
+
+
+def test_main_should_print_the_context_as_session_start_output() -> None:
+    completed = subprocess.run(
+        [sys.executable, str(HOOK_PATH)],
+        input=json.dumps(compact_input("/t/abc.jsonl")),
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    hook_output = json.loads(completed.stdout)["hookSpecificOutput"]
+    assert hook_output["hookEventName"] == "SessionStart"
+    assert "compaction_user_messages.py" in hook_output["additionalContext"]
+
+
+def test_hooks_json_should_run_the_recall_prompt_after_every_compaction() -> None:
+    all_compact_commands = [
+        each_hook.get("command", "")
+        for each_group in ALL_HOOK_REGISTRATIONS["SessionStart"]
+        if each_group.get("matcher") == "compact"
+        for each_hook in each_group["hooks"]
+    ]
+    assert any(
+        each_command.endswith("/hooks/session/compaction_recall_prompt.py")
+        for each_command in all_compact_commands
+    )
+
+
+def condensing_hooks() -> list[dict[str, object]]:
+    return [
+        each_hook
+        for each_group in ALL_HOOK_REGISTRATIONS["PostToolUse"]
+        if each_group.get("matcher") == "Bash"
+        for each_hook in each_group["hooks"]
+        if each_hook.get("type") == "agent"
+    ]
+
+
+def test_hooks_json_condensing_hook_should_match_the_command_the_recall_names() -> None:
+    all_hooks = condensing_hooks()
+    assert len(all_hooks) == 1
+    if_rule = str(all_hooks[0]["if"])
+    assert if_rule.startswith("Bash(") and if_rule.endswith(")")
+    command_pattern = if_rule[len("Bash(") : -1]
+    assert fnmatch.fnmatchcase(
+        recall_command("/home/u/.claude/projects/p/s.jsonl"), command_pattern
+    )
+    spaced_home_command = shlex.join(
+        [sys.executable, "/home/a b/.claude/hooks/session/compaction_user_messages.py", "/t.jsonl"]
+    )
+    assert fnmatch.fnmatchcase(spaced_home_command, command_pattern)
+    assert not fnmatch.fnmatchcase("python3 other_script.py /t.jsonl", command_pattern)
+
+
+def test_hooks_json_condensing_hook_should_always_return_its_text_as_the_block_reason() -> None:
+    condensing_hook = condensing_hooks()[0]
+    assert '"ok": false' in str(condensing_hook["prompt"])
+    assert "$ARGUMENTS" in str(condensing_hook["prompt"])
+    assert str(condensing_hook["statusMessage"]).startswith("claude-dev-env: ")

package/hooks/session/test_compaction_trim_eval.py

@@ -0,0 +1,86 @@
+"""Tests for compaction_trim_eval: the grader, the hook prompt lookup, and the reply parser."""
+
+import json
+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_eval as trim_eval
+from compaction_user_messages import rendered_extract, typed_user_messages
+
+DEPLOY_CASE = {
+    "transcript": "deploy_session.jsonl",
+    "facts": ["batch-07.internal", "137", "SQLite"],
+    "overruled": [{"earlier": 2, "later": 6}],
+}
+EXTRACT_TEXT = "rules\n\n# User messages, oldest first\n\n" + "m" * 400
+
+
+def test_score_condensed_should_count_every_fact_and_the_marked_reversal() -> None:
+    condensed_text = (
+        "#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)
+    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)
+
+
+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)
+    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
+
+
+def test_condensing_hook_prompt_should_return_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": "agent",
+                                "if": "Bash(*compaction_user_messages.py *)",
+                                "prompt": "condense $ARGUMENTS",
+                            }
+                        ],
+                    },
+                ]
+            }
+        }
+    )
+    assert trim_eval.condensing_hook_prompt(hooks_json_text) == "condense $ARGUMENTS"
+
+
+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

package/hooks/session/test_compaction_user_messages.py

@@ -0,0 +1,220 @@
+"""Tests for compaction_user_messages: which transcript entries count as typed, and the file it writes."""
+
+import json
+import subprocess
+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_user_messages as extractor
+from hooks_constants.compaction_user_messages_constants import (
+    MAXIMUM_EXTRACT_CHARACTERS,
+    MAXIMUM_MESSAGE_CHARACTERS,
+    TRIM_INSTRUCTIONS,
+)
+
+EXTRACTOR_PATH = _SESSION_DIR / "compaction_user_messages.py"
+FIXTURE_DIRECTORY = _SESSION_DIR / "fixtures" / "compaction_user_messages"
+
+
+def user_line(content: object, **all_extra_fields: object) -> str:
+    return json.dumps(
+        {
+            "type": "user",
+            "timestamp": "2026-10-19T10:00:00Z",
+            "message": {"role": "user", "content": content},
+            **all_extra_fields,
+        }
+    )
+
+
+def texts_of(all_lines: list[str]) -> list[str]:
+    return [each_message.text for each_message in extractor.typed_user_messages(all_lines)]
+
+
+def test_should_keep_plain_typed_text_with_position_and_timestamp() -> None:
+    all_messages = extractor.typed_user_messages(
+        [user_line("fix the login bug"), user_line("  use /srv/app  ")]
+    )
+    assert [
+        (each_message.position, each_message.timestamp, each_message.text)
+        for each_message in all_messages
+    ] == [
+        (1, "2026-10-19T10:00:00Z", "fix the login bug"),
+        (2, "2026-10-19T10:00:00Z", "use /srv/app"),
+    ]
+
+
+def test_should_show_a_slash_command_as_name_and_typed_arguments() -> None:
+    command_text = (
+        "<command-message>deepen</command-message>\n<command-name>/deepen</command-name>\n"
+        "<command-args>make it faster</command-args>"
+    )
+    assert texts_of([user_line(command_text)]) == ["/deepen make it faster"]
+
+
+def test_should_leave_out_harness_and_agent_entries() -> None:
+    all_lines = [
+        user_line("skill body", isMeta=True),
+        user_line("summary", isCompactSummary=True),
+        user_line("helper prompt", isSidechain=True),
+        user_line("report", origin={"kind": "peer"}),
+        user_line([{"type": "tool_result", "tool_use_id": "t1", "content": "ok"}]),
+        user_line("<system-reminder>rules</system-reminder>"),
+        user_line("<local-command-stdout>Compacted</local-command-stdout>"),
+        json.dumps({"type": "assistant", "message": {"content": [{"type": "text", "text": "hi"}]}}),
+        "not json",
+        user_line("typed", origin={"kind": "human"}),
+    ]
+    assert texts_of(all_lines) == ["typed"]
+
+
+def test_should_keep_typed_text_that_opens_with_markup() -> None:
+    all_lines = [
+        user_line("<Button> does not render"),
+        user_line("<task-notification>done</task-notification>"),
+    ]
+    assert texts_of(all_lines) == ["<Button> does not render"]
+
+
+def test_should_keep_an_interrupt_and_mark_an_image() -> None:
+    all_lines = [
+        user_line([{"type": "text", "text": "[Request interrupted by user]"}]),
+        user_line([{"type": "image", "source": {}}, {"type": "text", "text": "here."}]),
+    ]
+    assert texts_of(all_lines) == ["[Request interrupted by user]", "[image] here."]
+
+
+def test_should_count_a_queued_prompt_once_when_it_also_lands_as_a_user_entry() -> None:
+    queued_line = json.dumps(
+        {"type": "attachment", "attachment": {"type": "queued_command", "prompt": "check logs"}}
+    )
+    relay_line = json.dumps(
+        {
+            "type": "attachment",
+            "attachment": {"type": "queued_command", "prompt": "<agent-message>x"},
+        }
+    )
+    assert texts_of([queued_line, user_line("check logs"), relay_line]) == ["check logs"]
+
+
+def test_should_keep_a_message_typed_again_after_the_assistant_replied() -> None:
+    assistant_line = json.dumps({"type": "assistant", "message": {"content": "done"}})
+    assert texts_of([user_line("yes"), assistant_line, user_line("yes")]) == ["yes", "yes"]
+
+
+def test_should_read_a_claude_code_transcript_across_a_compaction() -> None:
+    fixture_lines = (FIXTURE_DIRECTORY / "one_compaction.jsonl").read_text().splitlines()
+    assert texts_of(fixture_lines) == [
+        "Note these facts for later: the deploy path is /srv/alpha/release-42 and the "
+        "retry limit is 17. Reply only: noted.",
+        "/compact",
+    ]
+
+
+def test_should_converge_when_a_second_compaction_appends_to_the_transcript() -> None:
+    first_lines = (FIXTURE_DIRECTORY / "one_compaction.jsonl").read_text().splitlines()
+    second_lines = first_lines + [
+        user_line("now set the retry limit to 9"),
+        json.dumps({"type": "system", "subtype": "compact_boundary"}),
+        user_line("summary two", isCompactSummary=True),
+        user_line("<command-name>/compact</command-name>"),
+    ]
+    first_messages = extractor.typed_user_messages(first_lines)
+    second_messages = extractor.typed_user_messages(second_lines)
+    assert second_messages[: len(first_messages)] == first_messages
+    assert [each_message.text for each_message in second_messages[len(first_messages) :]] == [
+        "now set the retry limit to 9",
+        "/compact",
+    ]
+
+
+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 + len(TRIM_INSTRUCTIONS) + 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:
+    rendered = extractor.rendered_extract([message(1, "fix login"), message(2, "use /srv")])
+    assert rendered.startswith(TRIM_INSTRUCTIONS)
+    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 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:
+    output_path = extractor.output_path_for(Path("/p/abc-123.jsonl"))
+    assert output_path.name == "compaction-user-messages-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")
+    completed = subprocess.run(
+        [sys.executable, str(EXTRACTOR_PATH), str(transcript_path)],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    printed_path = Path(completed.stdout.strip())
+    assert printed_path == extractor.output_path_for(transcript_path)
+    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 == ""

package/package.json

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

package/scripts/ci/scratch-home-install.mjs

@@ -2,8 +2,8 @@
 /**
  * Install this package into a scratch home directory.
  *
- * The installer writes into `$HOME/.claude` and rewrites the global git
- * configuration. Both are redirected here so a run leaves the caller's own home
+ * The installer writes into `$HOME/.claude`, rewrites the global git
+ * configuration, and edits `$CODEX_HOME/config.toml`. All three are redirected here so a run leaves the caller's own home
  * untouched.
  */
 
@@ -44,6 +44,7 @@ export function scratchHomeEnvironment(scratchHome) {
         HOME: scratchHome,
         USERPROFILE: scratchHome,
         GIT_CONFIG_GLOBAL: join(scratchHome, SANDBOX_GIT_CONFIG_NAME),
+        CODEX_HOME: join(scratchHome, '.codex'),
     };
 }
 

package/scripts/ci/scratch-home-install.test.mjs

@@ -1,5 +1,6 @@
 import assert from 'node:assert/strict';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
 
@@ -30,6 +31,7 @@ test('a scratch home starts with an isolated global git configuration and is rem
         assert.equal(environment.HOME, scratchHome);
         assert.equal(environment.USERPROFILE, scratchHome);
         assert.equal(environment.GIT_CONFIG_GLOBAL, gitConfigPath);
+        assert.equal(environment.CODEX_HOME, join(scratchHome, '.codex'));
     } finally {
         removeScratchHome(scratchHome);
     }
@@ -47,3 +49,23 @@ test('the installer runs against a scratch home and leaves the caller home alone
         removeScratchHome(scratchHome);
     }
 });
+
+test('an install into a scratch home leaves the caller Codex home config alone', () => {
+    const callerCodexHome = mkdtempSync(join(tmpdir(), 'cde-caller-codex-'));
+    const callerConfigPath = join(callerCodexHome, 'config.toml');
+    const callerConfigBody = 'model = "caller"\n';
+    writeFileSync(callerConfigPath, callerConfigBody);
+    const priorCodexHome = process.env.CODEX_HOME;
+    process.env.CODEX_HOME = callerCodexHome;
+    const scratchHome = createScratchHome();
+    try {
+        const install = runInstaller(scratchHome, []);
+        assert.equal(install.status, 0, `${install.stdout}\n${install.stderr}`);
+        assert.equal(readFileSync(callerConfigPath, 'utf8'), callerConfigBody);
+    } finally {
+        if (priorCodexHome === undefined) delete process.env.CODEX_HOME;
+        else process.env.CODEX_HOME = priorCodexHome;
+        removeScratchHome(scratchHome);
+        rmSync(callerCodexHome, { recursive: true, force: true });
+    }
+});