claude-dev-env 8.73.2 → 8.74.0

package/bin/cde.mjs

@@ -45,6 +45,7 @@ export function createHelpText() {
         "  cde followup brief        Write the task an agent fixes them from",
         "  cde followup count        Report the backlog against the threshold",
         "  cde followup clear        Empty the ledger",
+        "  cde followup dedupe       Remove exact repeated ledger lines",
         "",
         "Python may also be selected with CDE_PYTHON.",
     ].join("\n");

package/bin/cde.test.mjs

@@ -292,4 +292,5 @@ test("dispatches followup to the follow-up ledger command", async () => {
 test("help names the followup command", () => {
     assert.match(createHelpText(), /cde <lint\|verify\|followup>/);
     assert.match(createHelpText(), /cde followup count/);
+    assert.match(createHelpText(), /cde followup dedupe/);
 });

package/bin/install.settings-defaults.test.mjs

@@ -263,10 +263,18 @@ test('sandbox uninstall removes only package-owned permission entries and keeps
     }
 });
 
-test('package settings.json publishes the session agent, advisor model and auto mode defaults', () => {
+test('package settings.json publishes the session agent, advisor model, auto-compact and auto mode defaults', () => {
     const packageSettings = JSON.parse(readFileSync(PACKAGE_SETTINGS_PATH, 'utf8'));
     const settingsDefaults = settingsDefaultsFromPackageSettings(packageSettings);
-    assert.deepEqual(Object.keys(settingsDefaults).sort(), ['advisorModel', 'agent', 'autoMode']);
+    assert.deepEqual(
+        Object.keys(settingsDefaults).sort(),
+        ['advisorModel', 'agent', 'autoCompactWindow', 'autoMode', 'modelSettings'],
+    );
+    assert.equal(settingsDefaults.autoCompactWindow, 350000);
+    assert.deepEqual(settingsDefaults.modelSettings, {
+        'claude-haiku-5-5': { autoCompactWindow: 100000 },
+        'claude-haiku-4-5': { autoCompactWindow: 100000 },
+    });
     assert.equal(settingsDefaults.agent, 'dev-env-session');
     assert.ok(
         existsSync(join(PACKAGE_ROOT, '.agents', 'agents', `${settingsDefaults.agent}.md`)),

package/bin/merge_settings_defaults.mjs

@@ -4,9 +4,35 @@
  * Every top-level key in the package settings.json other than the managed
  * lists (`permissions`) is a default. Install adds a default only when the
  * user settings lack that key, so a value the user already set stays as is.
+ *
+ * A per-model key (`modelSettings`) merges one level deeper: install adds each
+ * model entry, and each field inside an entry, that the user settings lack.
  */
 
 export const MANAGED_LIST_SETTING_KEYS = Object.freeze(['permissions']);
+export const PER_MODEL_SETTING_KEYS = Object.freeze(['modelSettings']);
+
+function isPlainObject(candidate) {
+    return Boolean(candidate) && typeof candidate === 'object' && !Array.isArray(candidate);
+}
+
+function mergeMissingPerModelFields(targetPerModel, defaultPerModel, settingKey) {
+    const addedKeys = [];
+    for (const [modelName, defaultFields] of Object.entries(defaultPerModel)) {
+        if (!Object.hasOwn(targetPerModel, modelName)) {
+            targetPerModel[modelName] = { ...defaultFields };
+            addedKeys.push(`${settingKey}.${modelName}`);
+            continue;
+        }
+        if (!isPlainObject(targetPerModel[modelName])) continue;
+        for (const [fieldName, fieldDefault] of Object.entries(defaultFields)) {
+            if (Object.hasOwn(targetPerModel[modelName], fieldName)) continue;
+            targetPerModel[modelName][fieldName] = fieldDefault;
+            addedKeys.push(`${settingKey}.${modelName}.${fieldName}`);
+        }
+    }
+    return addedKeys;
+}
 
 /**
  * Read the setting defaults from a package settings source object.
@@ -35,8 +61,15 @@ export function settingsDefaultsFromPackageSettings(packageSettings) {
 export function mergeMissingSettingsDefaults(targetSettings, settingsDefaults) {
     const addedKeys = [];
     for (const [settingKey, defaultValue] of Object.entries(settingsDefaults)) {
+        const isPerModelMerge = PER_MODEL_SETTING_KEYS.includes(settingKey)
+            && isPlainObject(targetSettings[settingKey])
+            && isPlainObject(defaultValue);
+        if (isPerModelMerge) {
+            addedKeys.push(...mergeMissingPerModelFields(targetSettings[settingKey], defaultValue, settingKey));
+            continue;
+        }
         if (Object.hasOwn(targetSettings, settingKey)) continue;
-        targetSettings[settingKey] = defaultValue;
+        targetSettings[settingKey] = structuredClone(defaultValue);
         addedKeys.push(settingKey);
     }
     return { addedKeys };

package/bin/merge_settings_defaults.test.mjs

@@ -41,3 +41,56 @@ test('mergeMissingSettingsDefaults adds absent keys and keeps present values', (
         theme: 'dark',
     });
 });
+
+test('mergeMissingSettingsDefaults should add a missing model entry and a missing field inside a present one', () => {
+    const targetSettings = {
+        modelSettings: {
+            'claude-opus-5-5': { effortLevel: 'medium' },
+            'claude-haiku-4-5': { effortLevel: 'low' },
+        },
+    };
+
+    assert.deepEqual(
+        mergeMissingSettingsDefaults(targetSettings, {
+            modelSettings: {
+                'claude-haiku-5-5': { autoCompactWindow: 100000 },
+                'claude-haiku-4-5': { autoCompactWindow: 100000 },
+            },
+        }),
+        {
+            addedKeys: [
+                'modelSettings.claude-haiku-5-5',
+                'modelSettings.claude-haiku-4-5.autoCompactWindow',
+            ],
+        },
+    );
+    assert.deepEqual(targetSettings.modelSettings, {
+        'claude-opus-5-5': { effortLevel: 'medium' },
+        'claude-haiku-4-5': { effortLevel: 'low', autoCompactWindow: 100000 },
+        'claude-haiku-5-5': { autoCompactWindow: 100000 },
+    });
+});
+
+test('mergeMissingSettingsDefaults should give each target its own copy of an added default', () => {
+    const settingsDefaults = { modelSettings: { 'claude-haiku-5-5': { autoCompactWindow: 100000 } } };
+    const firstTarget = {};
+    const secondTarget = {};
+
+    mergeMissingSettingsDefaults(firstTarget, settingsDefaults);
+    firstTarget.modelSettings['claude-haiku-5-5'].autoCompactWindow = 200000;
+    mergeMissingSettingsDefaults(secondTarget, settingsDefaults);
+
+    assert.deepEqual(secondTarget.modelSettings, { 'claude-haiku-5-5': { autoCompactWindow: 100000 } });
+});
+
+test('mergeMissingSettingsDefaults should keep a per-model value the user already set', () => {
+    const targetSettings = { modelSettings: { 'claude-haiku-5-5': { autoCompactWindow: 150000 } } };
+
+    assert.deepEqual(
+        mergeMissingSettingsDefaults(targetSettings, {
+            modelSettings: { 'claude-haiku-5-5': { autoCompactWindow: 100000 } },
+        }),
+        { addedKeys: [] },
+    );
+    assert.deepEqual(targetSettings.modelSettings, { 'claude-haiku-5-5': { autoCompactWindow: 150000 } });
+});

package/docs/rule-guides/flag-non-breaking-findings.md

@@ -38,9 +38,12 @@ A message with no catalog entry resolves to `<rule>/unclassified`, which a parti
 | `cde followup brief` | Writes the task an agent fixes them from |
 | `cde followup clear` | Empties the ledger |
 | `cde followup count` | Reports the backlog against the threshold |
+| `cde followup dedupe` | Removes exact repeated lines and keeps the first of each |
 
 `count` exits non-zero once the backlog passes `FOLLOWUP_BACKLOG_THRESHOLD` in `scripts/dev_env_scripts_constants/followup_constants.py`, so a scheduled job escalates. The number is the repository's setting.
 
+`.gitattributes` marks the ledger `merge=union`, so a local `git merge` keeps both sides' appended lines without a conflict. GitHub's server-side merge ignores the attribute. Every ledger write drops exact repeated lines, and the `followup-ledger-duplicates` repository check fails a tree that still holds one.
+
 The `/fix-followups` command reads the brief, fixes each rule group, opens a pull request, and clears the ledger.
 
 ## Worked example

package/hooks/blocking/haiku_spawn_slim_gate.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""PreToolUse gate: deny a Haiku agent spawned inside this session.
+
+Registered on ``Agent|Task`` and ``mcp__hearthbot__start_thread_session``. An
+in-session spawn shares this session's settings, plugins, MCP servers, and
+CLAUDE.md files, so a Haiku agent started that way cannot run on the slim
+profile. The deny reason gives the headless command that loads the profile.
+
+::
+
+    model "haiku"                       -> deny with the headless command
+    model "claude-haiku-5-5"            -> deny with the headless command
+    model "opus", "sonnet", or omitted  -> no output; the call runs unchanged
+
+A spawn that names no model passes, even when the subagent's definition or
+``CLAUDE_CODE_SUBAGENT_MODEL`` resolves it to Haiku.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+hooks_root_directory = str(Path(__file__).resolve().parent.parent)
+if hooks_root_directory not in sys.path:
+    sys.path.insert(0, hooks_root_directory)
+
+from hooks_constants.haiku_spawn_slim_gate_constants import (
+    DENY_DECISION,
+    HAIKU_MODEL_FAMILY,
+    HOOK_EVENT_NAME,
+    MODEL_INPUT_KEY,
+    PERMISSION_DECISION_REASON_KEY,
+    SLIM_PROFILE_DENY_REASON,
+    TOOL_INPUT_KEY,
+)
+from hooks_constants.hook_specific_output_keys import (
+    HOOK_EVENT_NAME_KEY,
+    HOOK_SPECIFIC_OUTPUT_KEY,
+    PERMISSION_DECISION_KEY,
+)
+from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
+
+
+def is_haiku_model(model: object) -> bool:
+    """Return True when the spawn's model field names the Haiku family.
+
+    ::
+
+        "haiku" -> True     "claude-haiku-4-5-20251001" -> True
+        "opus" -> False     None -> False
+
+    Args:
+        model: The ``model`` field of the spawn input.
+    """
+    return isinstance(model, str) and HAIKU_MODEL_FAMILY in model.lower()
+
+
+def decide_hook_output(tool_input: object) -> dict[str, object] | None:
+    """Choose the hook's output for one spawn.
+
+    Args:
+        tool_input: The ``tool_input`` of the PreToolUse payload.
+
+    Returns:
+        None to pass the call through unchanged, else the deny output.
+    """
+    if not isinstance(tool_input, dict) or not is_haiku_model(tool_input.get(MODEL_INPUT_KEY)):
+        return None
+    return {
+        HOOK_SPECIFIC_OUTPUT_KEY: {
+            HOOK_EVENT_NAME_KEY: HOOK_EVENT_NAME,
+            PERMISSION_DECISION_KEY: DENY_DECISION,
+            PERMISSION_DECISION_REASON_KEY: SLIM_PROFILE_DENY_REASON,
+        }
+    }
+
+
+def main() -> int:
+    """Read the PreToolUse payload and print the decision.
+
+    Returns:
+        0 in every case.
+    """
+    hook_payload = read_hook_input_dictionary_from_stdin()
+    tool_input = hook_payload.get(TOOL_INPUT_KEY) if hook_payload is not None else None
+    hook_output = decide_hook_output(tool_input)
+    if hook_output is not None:
+        sys.stdout.write(json.dumps(hook_output))
+        sys.stdout.flush()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/hooks/blocking/test_haiku_spawn_slim_gate.py

@@ -0,0 +1,65 @@
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+import haiku_spawn_slim_gate
+from hooks_constants.haiku_spawn_slim_gate_constants import SLIM_PROFILE_DENY_REASON
+
+HOOK_SCRIPT = Path(__file__).resolve().parent / "haiku_spawn_slim_gate.py"
+
+
+def _run_hook(payload: dict[str, object]) -> str:
+    completed = subprocess.run(
+        [sys.executable, str(HOOK_SCRIPT)],
+        input=json.dumps(payload),
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    return completed.stdout
+
+
+@pytest.mark.parametrize(
+    ("tool_name", "model"),
+    [
+        ("Agent", "haiku"),
+        ("Task", "Haiku"),
+        ("Agent", "claude-haiku-5-5"),
+        ("Agent", "claude-haiku-4-5-20251001"),
+        ("mcp__hearthbot__start_thread_session", "claude-haiku-5-5"),
+    ],
+)
+def test_should_deny_a_haiku_spawn_with_the_headless_command(tool_name: str, model: str) -> None:
+    payload = {"tool_name": tool_name, "tool_input": {"prompt": "Review.", "model": model}}
+    hook_output = json.loads(_run_hook(payload))["hookSpecificOutput"]
+    assert hook_output["hookEventName"] == "PreToolUse"
+    assert hook_output["permissionDecision"] == "deny"
+    assert hook_output["permissionDecisionReason"] == SLIM_PROFILE_DENY_REASON
+
+
+@pytest.mark.parametrize("model", ["opus", "sonnet", "claude-opus-5-5", "fable", None, "", 7])
+def test_should_pass_a_spawn_that_names_no_haiku_model(model: object) -> None:
+    tool_input = {"prompt": "Review."}
+    if model is not None:
+        tool_input["model"] = model
+    assert _run_hook({"tool_name": "Agent", "tool_input": tool_input}) == ""
+
+
+def test_should_pass_a_payload_without_tool_input() -> None:
+    assert haiku_spawn_slim_gate.decide_hook_output(None) is None
+
+
+def test_should_name_every_slim_profile_flag_in_the_deny_reason() -> None:
+    for each_flag in (
+        "account_broker.py",
+        "--model haiku",
+        "--setting-sources local",
+        "--strict-mcp-config",
+        "--autocompact 100k",
+        "CLAUDE_CODE_DISABLE_CLAUDE_MDS=1",
+        "POSIX shell",
+    ):
+        assert each_flag in SLIM_PROFILE_DENY_REASON

package/hooks/features/spawn-routing.md

@@ -1,6 +1,6 @@
 # Spawn routing
 
-This family reminds the agent to gather context before a spawn, tells it that it owns the spawned work, adjusts thread requests when usage exceeds pace, and selects an allowed subagent model.
+This family reminds the agent to gather context before a spawn, tells it that it owns the spawned work, adjusts thread requests when usage exceeds pace, selects an allowed subagent model, and sends a Haiku spawn to a headless slim-profile run.
 
 ## Checks
 
@@ -8,6 +8,7 @@ This family reminds the agent to gather context before a spawn, tells it that it
 - `routing/spawn_oversight_hook.py` adds the orchestrator oversight directive to every spawn: watch the agent, check its output against the user's words and standards, and correct it before the output reaches the user. The spawn still runs.
 - `routing/thread_spawn_pace_hook.py` reshapes a thread request when usage is over pace or unreadable.
 - `routing/subagent_model_routing.mjs` allows a selected Luna model, remaps eligible requests, and denies unsupported model routing.
+- `blocking/haiku_spawn_slim_gate.py` denies an Agent, Task, or thread spawn whose `model` names Haiku. The deny reason gives the headless `claude -p` command that loads the slim profile through the account broker.
 
 ## When it fires
 
@@ -15,6 +16,7 @@ This family reminds the agent to gather context before a spawn, tells it that it
 - `routing/spawn_oversight_hook.py` runs on `PreToolUse` with matchers `Agent|Task`, `multi_agent_v1__spawn_agent`, `Workflow|mcp__github__actions_run_trigger`, `mcp__hearthbot__start_thread_session`, and `mcp__hearthbot__start_rc_session`, each at `10` seconds in `hooks.json`. A workflow dispatch counts only when its inputs carry a `prompt`.
 - `routing/thread_spawn_pace_hook.py` runs on `PreToolUse`, matcher `mcp__hearthbot__start_thread_session`, timeout `30` seconds in `hooks.json`.
 - `routing/subagent_model_routing.mjs` runs on `PreToolUse`, matcher `multi_agent_v1__spawn_agent`, timeout `10` seconds through the quoted Node command in `hooks.json`.
+- `blocking/haiku_spawn_slim_gate.py` runs on `PreToolUse` with matchers `Agent|Task` and `mcp__hearthbot__start_thread_session`, each at `10` seconds in `hooks.json`.
 
 ## Proving it
 
@@ -25,6 +27,7 @@ Preconditions:
 - **Spawn readiness.** Input is a spawn after a read, a question, and its answer. Run `python -m pytest packages/claude-dev-env/hooks/routing/test_spawn_readiness_hook.py -q`. The adjacent test observes no output for a ready spawn and reminder context for each missing step.
 - **Spawn oversight.** Input is a spawn from each registered tool, a subagent's own spawn, and a non-spawn call. Run `python -m pytest packages/claude-dev-env/hooks/routing/test_spawn_oversight_hook.py -q`. The adjacent test observes the directive for every spawn and no output for the other calls.
 - **Thread pace.** Input is a thread spawn with usage over pace. Run `python -m pytest packages/claude-dev-env/hooks/routing/test_thread_spawn_pace_hook.py -q`. The adjacent test observes updated tool input with the selected model, effort, and advisor line.
+- **Haiku slim gate.** Input is a spawn with a Haiku alias or model ID, and spawns on other models or with no model. Run `python -m pytest packages/claude-dev-env/hooks/blocking/test_haiku_spawn_slim_gate.py -q`. The adjacent test observes a deny with the headless command for each Haiku spawn and no output for the rest.
 - **Model routing.** Input is a `multi_agent_v1__spawn_agent` payload with a model choice. Run `node --test packages/claude-dev-env/hooks/routing/subagent_model_routing.test.mjs`. The adjacent test observes an allow or deny decision with the routed model.
 
 ## Gotchas
@@ -32,4 +35,5 @@ Preconditions:
 - `routing/spawn_readiness_hook.py` also runs after the pace hook on thread spawns. A reshaped request still gets the readiness check.
 - The oversight hook fires inside subagents too, so each level of the tree oversees the level below it. It emits `additionalContext` only and never blocks.
 - The readiness hook emits `additionalContext` only, so it never blocks. It passes subagent calls, read-only helper types, a non-object tool input, and unreadable transcripts.
+- The Haiku slim gate reads only the spawn's `model` field. A spawn that names no model passes, even when its agent definition or `CLAUDE_CODE_SUBAGENT_MODEL` resolves it to Haiku.
 - The model router allows an advisor flag to bypass the Luna restriction. Its ordinary path denies unresolved or unsupported models.

package/hooks/followup_ledger.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 
 import json
 import sys
+from collections.abc import Sequence
 from pathlib import Path
 from typing import NamedTuple
 
@@ -74,6 +75,52 @@ class FollowupFinding(NamedTuple):
         return (self.check_id or self.rule_id, self.file_path, self.message)
 
 
+def deduplicated_lines(all_lines: Sequence[str]) -> list[str]:
+    """Return the lines with every exact repeat removed.
+
+    The first occurrence of each line keeps its place, so the ledger keeps its
+    record order after a ``merge=union`` merge writes both sides' lines.
+
+    Args:
+        all_lines: The ledger lines, in file order.
+
+    Returns:
+        The lines in file order, each exact line once.
+    """
+    return list(dict.fromkeys(all_lines))
+
+
+def deduplicate_ledger(repository_root: Path) -> int:
+    """Rewrite the repository's ledger without exact repeated lines.
+
+    An absent or unreadable ledger, and a ledger that cannot be rewritten, are
+    left as they are, so a ledger failure never becomes a gate failure.
+
+    Args:
+        repository_root: The repository whose ledger to clean.
+
+    Returns:
+        How many lines the rewrite removed.
+    """
+    ledger_path = followup_ledger_path(repository_root)
+    try:
+        all_ledger_lines = ledger_path.read_text(encoding=LEDGER_ENCODING).splitlines()
+    except (OSError, UnicodeError):
+        return 0
+    all_unique_lines = deduplicated_lines(all_ledger_lines)
+    removed_line_count = len(all_ledger_lines) - len(all_unique_lines)
+    if not removed_line_count:
+        return 0
+    try:
+        ledger_path.write_text(
+            "".join(each_line + "\n" for each_line in all_unique_lines),
+            encoding=LEDGER_ENCODING,
+        )
+    except OSError:
+        return 0
+    return removed_line_count
+
+
 def followup_ledger_path(repository_root: Path) -> Path:
     """Return the ledger path for one repository.
 
@@ -89,8 +136,10 @@ def followup_ledger_path(repository_root: Path) -> Path:
 def record_followup_finding(repository_root: Path, finding: FollowupFinding) -> None:
     """Append one finding to the repository's ledger, once.
 
-    A finding already present in the ledger is left alone, so a gate that runs
-    on every commit records a standing smell a single time. The ledger
+    The ledger first loses every exact repeated line, so lines a
+    ``merge=union`` merge wrote twice leave on the next write. A finding
+    already present in the ledger is left alone, so a gate that runs on every
+    commit records a standing smell a single time. The ledger
     directory carries a ``.gitignore`` matching every file in it, so the
     ledger stays out of ``git status`` in any repository. Every filesystem
     error is swallowed, so a ledger failure leaves the caller's gate decision
@@ -100,6 +149,7 @@ def record_followup_finding(repository_root: Path, finding: FollowupFinding) ->
         repository_root: The repository whose ledger receives the finding.
         finding: The non-breaking finding to record.
     """
+    deduplicate_ledger(repository_root)
     all_recorded_keys = {
         each_finding.tracking_key()
         for each_finding in all_recorded_findings(repository_root)

package/hooks/hooks.json

@@ -10,6 +10,11 @@
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/skill_loaded_reminder.py",
             "timeout": 10
           },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/haiku_spawn_slim_gate.py",
+            "timeout": 10
+          },
           {
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/routing/spawn_readiness_hook.py",
@@ -180,6 +185,11 @@
       {
         "matcher": "mcp__hearthbot__start_thread_session",
         "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/haiku_spawn_slim_gate.py",
+            "timeout": 10
+          },
           {
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/routing/thread_spawn_pace_hook.py",

package/hooks/hooks_constants/haiku_spawn_slim_gate_constants.py

@@ -0,0 +1,29 @@
+"""Constants for the Haiku spawn slim-profile PreToolUse gate.
+
+Groups: the model family the gate denies, the hook event name, the hook input and output keys, and
+the deny reason that gives the headless slim-profile command.
+"""
+
+from __future__ import annotations
+
+HAIKU_MODEL_FAMILY = "haiku"
+HOOK_EVENT_NAME = "PreToolUse"
+TOOL_INPUT_KEY = "tool_input"
+MODEL_INPUT_KEY = "model"
+DENY_DECISION = "deny"
+PERMISSION_DECISION_REASON_KEY = "permissionDecisionReason"
+SLIM_PROFILE_DENY_REASON = (
+    "BLOCKED: A Haiku agent started from this session runs with this session's settings, plugins, "
+    "MCP servers, and CLAUDE.md files. An Agent, Task, or thread spawn has no field for setting sources, "
+    "a plugin directory, or an MCP config, so it cannot load the slim profile. "
+    "Start Haiku as a headless run with the slim profile. Set CLAUDE_CODE_DISABLE_CLAUDE_MDS=1 and "
+    "CLAUDE_CODE_DISABLE_AUTO_MEMORY=1 in the environment, then run this from Bash or another POSIX shell, "
+    "because PowerShell strips the double quotes inside the single-quoted JSON: "
+    'python "$HOME/.claude/scripts/account_broker.py" run --product claude --report <report.json> -- '
+    "claude -p --model haiku --setting-sources local "
+    '--settings \'{"enabledPlugins": {}, "autoMemoryEnabled": false, "autoCompactWindow": 100000}\' '
+    "--strict-mcp-config --mcp-config '{\"mcpServers\": {}}' --autocompact 100k. "
+    "Send the task on standard input. In a cloud session, run the same claude -p command without the broker. "
+    "Where the efficient-review skill is installed, /efficient-review headless or /efficient-review auto builds "
+    "this profile. To keep the agent in this session, spawn it on opus or sonnet."
+)

package/hooks/test_followup_ledger.py

@@ -12,6 +12,8 @@ if _hooks_directory not in sys.path:
 from followup_ledger import (
     FollowupFinding,
     all_recorded_findings,
+    deduplicate_ledger,
+    deduplicated_lines,
     followup_ledger_path,
     head_commit,
     record_followup_finding,
@@ -187,3 +189,59 @@ def test_head_commit_reads_a_detached_revision(tmp_path: Path) -> None:
 
 def test_head_commit_is_empty_outside_a_repository(tmp_path: Path) -> None:
     assert head_commit(tmp_path) == ""
+
+
+def test_deduplicated_lines_keeps_the_first_of_each_exact_line_in_order() -> None:
+    assert deduplicated_lines(["a", "b", "a", "c", "b"]) == ["a", "b", "c"]
+
+
+def test_record_followup_finding_removes_lines_a_union_merge_repeated(
+    tmp_path: Path,
+) -> None:
+    ledger_path = followup_ledger_path(tmp_path)
+    ledger_path.parent.mkdir(parents=True)
+    first_line = '{"rule_id": "r1", "file_path": "a.py", "message": "m1"}'
+    second_line = '{"rule_id": "r2", "file_path": "b.py", "message": "m2"}'
+    ledger_path.write_text(
+        f"{first_line}\n{second_line}\n{first_line}\n", encoding="utf-8"
+    )
+
+    record_followup_finding(tmp_path, FollowupFinding("r3", "c.py", "m3", "r3"))
+
+    all_ledger_lines = ledger_path.read_text(encoding="utf-8").splitlines()
+    assert all_ledger_lines[:2] == [first_line, second_line]
+    assert [json.loads(each_line)["rule_id"] for each_line in all_ledger_lines] == [
+        "r1",
+        "r2",
+        "r3",
+    ]
+
+
+def test_record_followup_finding_removes_a_repeat_of_an_already_recorded_finding(
+    tmp_path: Path,
+) -> None:
+    finding = FollowupFinding("r1", "a.py", "m1", "r1")
+    record_followup_finding(tmp_path, finding)
+    ledger_path = followup_ledger_path(tmp_path)
+    recorded_text = ledger_path.read_text(encoding="utf-8")
+    ledger_path.write_text(recorded_text * 2, encoding="utf-8")
+
+    record_followup_finding(tmp_path, finding)
+
+    assert ledger_path.read_text(encoding="utf-8") == recorded_text
+
+
+def test_deduplicate_ledger_reports_how_many_lines_it_removed(tmp_path: Path) -> None:
+    ledger_path = followup_ledger_path(tmp_path)
+    ledger_path.parent.mkdir(parents=True)
+    ledger_path.write_text("x\ny\nx\nx\n", encoding="utf-8")
+
+    removed_count = deduplicate_ledger(tmp_path)
+
+    assert removed_count == 2
+    assert ledger_path.read_text(encoding="utf-8") == "x\ny\n"
+
+
+def test_deduplicate_ledger_leaves_an_absent_ledger_absent(tmp_path: Path) -> None:
+    assert deduplicate_ledger(tmp_path) == 0
+    assert not followup_ledger_path(tmp_path).exists()

package/package.json

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

package/scripts/dev_env_scripts_constants/followup_constants.py

@@ -31,12 +31,14 @@ INGEST_COMMAND_NAME: str = "ingest"
 BRIEF_COMMAND_NAME: str = "brief"
 CLEAR_COMMAND_NAME: str = "clear"
 COUNT_COMMAND_NAME: str = "count"
+DEDUPE_COMMAND_NAME: str = "dedupe"
 ALL_COMMAND_NAMES: tuple[str, ...] = (
     LIST_COMMAND_NAME,
     INGEST_COMMAND_NAME,
     BRIEF_COMMAND_NAME,
     CLEAR_COMMAND_NAME,
     COUNT_COMMAND_NAME,
+    DEDUPE_COMMAND_NAME,
 )
 
 SUCCESS_EXIT_CODE: int = 0
@@ -61,8 +63,9 @@ ABSENT_LOCATION_PATH: str = ""
 LINE_SEPARATOR: str = "\n"
 EMPTY_LEDGER_MESSAGE: str = "no follow-ups recorded"
 UNREADABLE_REPORT_TEMPLATE: str = "cannot read the lint report: {report_path}"
+DEDUPE_RESULT_TEMPLATE: str = "removed {removed_count} duplicate ledger lines"
 USAGE_TEXT: str = (
-    "Usage: followup_cli.py <list|ingest|brief|clear|count> "
+    "Usage: followup_cli.py <list|ingest|brief|clear|count|dedupe> "
     "[--repository-root PATH]\n"
     "  list              Name every recorded follow-up\n"
     "  ingest REPORT     Record every diagnostic in a policy-lint JSON report\n"

package/scripts/followup_cli.py

@@ -12,7 +12,8 @@ work. This command reads those records back.
 ``list`` names what is outstanding, ``ingest`` adds the diagnostics from a
 policy-lint JSON report, ``brief`` writes the task an agent works from, and
 ``clear`` empties the ledger once the follow-up pull request carries the
-fixes.
+fixes, and ``dedupe`` removes exact repeated lines a ``merge=union`` merge
+left behind.
 """
 
 from __future__ import annotations
@@ -30,6 +31,8 @@ from dev_env_scripts_constants.followup_constants import (
     BACKLOG_EXCEEDED_TEMPLATE,
     BACKLOG_WITHIN_TEMPLATE,
     COUNT_COMMAND_NAME,
+    DEDUPE_COMMAND_NAME,
+    DEDUPE_RESULT_TEMPLATE,
     DIAGNOSTIC_CHECK_ID_KEY,
     FOLLOWUP_BACKLOG_THRESHOLD,
     BRIEF_COMMAND_NAME,
@@ -59,6 +62,7 @@ if _hooks_directory not in sys.path:
 from followup_ledger import (
     FollowupFinding,
     all_recorded_findings,
+    deduplicate_ledger,
     followup_ledger_path,
     head_commit,
     record_followup_finding,
@@ -310,6 +314,24 @@ def _run_clear(repository_root: Path) -> int:
     return SUCCESS_EXIT_CODE
 
 
+def _run_dedupe(repository_root: Path, stdout: TextIO) -> int:
+    """Remove exact repeated lines from the repository's ledger.
+
+    Args:
+        repository_root: The repository whose ledger to clean.
+        stdout: The stream the removed-line count goes to.
+
+    Returns:
+        SUCCESS_EXIT_CODE.
+    """
+    removed_line_count = deduplicate_ledger(repository_root)
+    stdout.write(
+        DEDUPE_RESULT_TEMPLATE.format(removed_count=removed_line_count)
+        + LINE_SEPARATOR
+    )
+    return SUCCESS_EXIT_CODE
+
+
 def main(all_arguments: list[str], stdout: TextIO = sys.stdout) -> int:
     """Run one follow-up command.
 
@@ -336,6 +358,8 @@ def main(all_arguments: list[str], stdout: TextIO = sys.stdout) -> int:
         return _run_brief(repository_root, stdout)
     if parsed_arguments.command == COUNT_COMMAND_NAME:
         return _run_count(repository_root, stdout)
+    if parsed_arguments.command == DEDUPE_COMMAND_NAME:
+        return _run_dedupe(repository_root, stdout)
     return _run_clear(repository_root)
 
 

package/scripts/policy_lint/config/constants.py

@@ -73,6 +73,7 @@ ALL_ACTION_BOUNDARY_EXEMPT_REGISTRATION_PATHS = (
     "blocking/session_title_stop_gate.py",
     "blocking/image_read_size_gate.py",
     "blocking/artifact_dark_mode_gate.py",
+    "blocking/haiku_spawn_slim_gate.py",
 )
 ALL_TEST_DIRECTORY_NAMES = frozenset({"tests"})
 ALL_TEST_FILE_PREFIXES = ("test_",)

package/scripts/repository_checks/config/constants.py

@@ -9,6 +9,7 @@ from policy_lint.config.constants import (
 
 CHECK_ID_CLAUDE_MD_ORPHANS = "claude-md-orphans"
 CHECK_ID_ENV_VAR_DOCUMENTATION = "env-var-documentation"
+CHECK_ID_FOLLOWUP_LEDGER_DUPLICATES = "followup-ledger-duplicates"
 CHECK_ID_PACKAGE_INVENTORY = "package-inventory"
 CHECK_ID_PYTEST_TESTPATHS = "pytest-testpaths"
 CHECK_ID_TRACKED_PERSONAL_DATA = "tracked-secrets"
@@ -18,6 +19,7 @@ PRIVATE_TERMS_SKIPPED_FILE_NAME = "CHANGELOG.md"
 ALL_CHECK_IDS = (
     CHECK_ID_CLAUDE_MD_ORPHANS,
     CHECK_ID_ENV_VAR_DOCUMENTATION,
+    CHECK_ID_FOLLOWUP_LEDGER_DUPLICATES,
     CHECK_ID_PACKAGE_INVENTORY,
     CHECK_ID_PYTEST_TESTPATHS,
     CHECK_ID_TRACKED_PERSONAL_DATA,
@@ -29,6 +31,7 @@ SEVERITY_SMELL = "smell"
 SEVERITY_BY_CHECK_ID: dict[str, str] = {
     CHECK_ID_CLAUDE_MD_ORPHANS: SEVERITY_BREAKING,
     CHECK_ID_ENV_VAR_DOCUMENTATION: SEVERITY_BREAKING,
+    CHECK_ID_FOLLOWUP_LEDGER_DUPLICATES: SEVERITY_BREAKING,
     CHECK_ID_PACKAGE_INVENTORY: SEVERITY_SMELL,
     CHECK_ID_PYTEST_TESTPATHS: SEVERITY_BREAKING,
     CHECK_ID_TRACKED_PERSONAL_DATA: SEVERITY_BREAKING,
@@ -49,6 +52,9 @@ EMPTY_REPORT_TEXT = ""
 TRACKED_MATCH_MESSAGE_TEMPLATE = "[{category}] {preview}"
 CLAUDE_MD_MISSING_FILE_MESSAGE_TEMPLATE = "references missing file {filename}"
 PACKAGE_INVENTORY_MESSAGE_TEMPLATE = "production file is absent from package inventory"
+FOLLOWUP_LEDGER_DUPLICATE_MESSAGE_TEMPLATE = (
+    "{repeated_line_count} lines repeat an earlier line; run `cde followup dedupe`"
+)
 PYTEST_TESTPATH_MESSAGE_TEMPLATE = (
     "test file is outside the package testpaths allowlist"
 )

package/scripts/repository_checks/followup_ledger_duplicates.py

@@ -0,0 +1,55 @@
+"""Committed follow-up ledger check for exact repeated lines.
+
+GitHub's server-side merge ignores ``merge=union``, so repeated lines arrive
+only through a local union merge. This check stops them at the merge queue.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from pathlib import Path
+from types import ModuleType
+
+from policy_lint.config import constants as policy_constants
+
+from repository_checks.config import constants as repository_constants
+from repository_checks.hook_modules import load_hooks_module
+from repository_checks.models import RepositoryFinding
+
+
+def collect_followup_ledger_duplicate_findings(
+    repository_root: Path, all_tracked_paths: Sequence[str]
+) -> list[RepositoryFinding]:
+    """Return a finding when the tracked ledger repeats a line.
+
+    Args:
+        repository_root: Git repository root.
+        all_tracked_paths: Repository-relative tracked paths.
+
+    Returns:
+        One finding naming the repeated-line count, or no findings.
+    """
+    ledger = load_hooks_module(repository_constants.FOLLOWUP_LEDGER_MODULE_NAME)
+    ledger_path = ledger.followup_ledger_path(repository_root)
+    relative_path = ledger_path.relative_to(repository_root).as_posix()
+    if relative_path not in all_tracked_paths:
+        return []
+    repeated_line_count = _repeated_line_count(ledger, ledger_path)
+    if not repeated_line_count:
+        return []
+    return [
+        RepositoryFinding(
+            repository_constants.CHECK_ID_FOLLOWUP_LEDGER_DUPLICATES,
+            relative_path,
+            repository_constants.FOLLOWUP_LEDGER_DUPLICATE_MESSAGE_TEMPLATE.format(
+                repeated_line_count=repeated_line_count
+            ),
+        )
+    ]
+
+
+def _repeated_line_count(ledger: ModuleType, ledger_path: Path) -> int:
+    all_ledger_lines = ledger_path.read_text(
+        encoding=policy_constants.UTF8_ENCODING
+    ).splitlines()
+    return len(all_ledger_lines) - len(ledger.deduplicated_lines(all_ledger_lines))

package/scripts/repository_checks/runner.py

@@ -11,6 +11,9 @@ from repository_checks.config import constants as repository_constants
 from repository_checks.env_var_documentation import (
     collect_env_var_documentation_findings,
 )
+from repository_checks.followup_ledger_duplicates import (
+    collect_followup_ledger_duplicate_findings,
+)
 from repository_checks.models import RepositoryCheckReport, RepositoryFinding
 from repository_checks.package_inventory import collect_package_inventory_findings
 from repository_checks.pytest_testpaths import collect_pytest_testpath_findings
@@ -81,6 +84,10 @@ def _all_collectors() -> tuple[tuple[str, RepositoryCollector], ...]:
             repository_constants.CHECK_ID_ENV_VAR_DOCUMENTATION,
             collect_env_var_documentation_findings,
         ),
+        (
+            repository_constants.CHECK_ID_FOLLOWUP_LEDGER_DUPLICATES,
+            collect_followup_ledger_duplicate_findings,
+        ),
         (
             repository_constants.CHECK_ID_PACKAGE_INVENTORY,
             collect_package_inventory_findings,

package/scripts/test_followup_cli.py

@@ -10,12 +10,14 @@ from dev_env_scripts_constants.followup_constants import (
     BACKLOG_EXCEEDED_EXIT_CODE,
     BACKLOG_EXCEEDED_TEMPLATE,
     BACKLOG_WITHIN_TEMPLATE,
+    DEDUPE_RESULT_TEMPLATE,
     FOLLOWUP_BACKLOG_THRESHOLD,
 )
 from followup_cli import main
 from followup_ledger import (
     FollowupFinding,
     all_recorded_findings,
+    followup_ledger_path,
     record_followup_finding,
 )
 
@@ -303,3 +305,19 @@ def test_list_names_the_check_behind_each_finding(tmp_path: Path) -> None:
 
     assert "code-rules/constant-outside-config" in output_text
     assert "f00dcafe" in output_text
+
+
+def test_dedupe_removes_repeated_ledger_lines_and_keeps_the_order(
+    tmp_path: Path,
+) -> None:
+    ledger_path = followup_ledger_path(tmp_path)
+    ledger_path.parent.mkdir(parents=True)
+    ledger_path.write_text("first\nsecond\nfirst\n", encoding="utf-8")
+
+    exit_code, output_text = run_command(
+        ["dedupe", "--repository-root", str(tmp_path)]
+    )
+
+    assert exit_code == 0
+    assert output_text == DEDUPE_RESULT_TEMPLATE.format(removed_count=1) + "\n"
+    assert ledger_path.read_text(encoding="utf-8") == "first\nsecond\n"

package/scripts/tests/test_followup_ledger_duplicates.py

@@ -0,0 +1,58 @@
+"""Behavior tests for the committed follow-up ledger duplicate check."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_TESTS_DIRECTORY = Path(__file__).resolve().parent
+if str(_TESTS_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(_TESTS_DIRECTORY))
+
+from repository_checks.config.constants import (
+    CHECK_ID_FOLLOWUP_LEDGER_DUPLICATES,
+    FINDINGS_EXIT_CODE,
+    SUCCESS_EXIT_CODE,
+)
+from repository_policy_test_support import (
+    commit_tracked_files,
+    initialize_repository,
+    run_policy,
+    write_text,
+)
+
+_LEDGER_RELATIVE_PATH = ".claude/followups/smells.jsonl"
+
+
+def test_should_flag_a_committed_ledger_with_a_repeated_line(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    initialize_repository(repository_root)
+    write_text(
+        repository_root / _LEDGER_RELATIVE_PATH,
+        '{"rule_id": "a"}\n{"rule_id": "b"}\n{"rule_id": "a"}\n',
+    )
+    commit_tracked_files(repository_root)
+
+    exit_code, stdout_text, _stderr_text = run_policy(repository_root)
+
+    assert exit_code == FINDINGS_EXIT_CODE
+    assert (
+        f"{CHECK_ID_FOLLOWUP_LEDGER_DUPLICATES}: {_LEDGER_RELATIVE_PATH}:"
+        in stdout_text
+    )
+    assert "cde followup dedupe" in stdout_text
+
+
+def test_should_pass_a_committed_ledger_without_repeats(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    initialize_repository(repository_root)
+    write_text(
+        repository_root / _LEDGER_RELATIVE_PATH,
+        '{"rule_id": "a"}\n{"rule_id": "b"}\n',
+    )
+    commit_tracked_files(repository_root)
+
+    exit_code, stdout_text, _stderr_text = run_policy(repository_root)
+
+    assert exit_code == SUCCESS_EXIT_CODE
+    assert stdout_text == ""

package/scripts/tests/test_repository_policy.py

@@ -17,6 +17,7 @@ import repository_policy
 from repository_checks.config.constants import (
     CHECK_ID_CLAUDE_MD_ORPHANS,
     CHECK_ID_ENV_VAR_DOCUMENTATION,
+    CHECK_ID_FOLLOWUP_LEDGER_DUPLICATES,
     CHECK_ID_PACKAGE_INVENTORY,
     CHECK_ID_PYTEST_TESTPATHS,
     CHECK_ID_TRACKED_PERSONAL_DATA,
@@ -50,6 +51,7 @@ def test_should_keep_stable_check_identifiers() -> None:
     assert repository_policy.ALL_CHECK_IDS == (
         CHECK_ID_CLAUDE_MD_ORPHANS,
         CHECK_ID_ENV_VAR_DOCUMENTATION,
+        CHECK_ID_FOLLOWUP_LEDGER_DUPLICATES,
         CHECK_ID_PACKAGE_INVENTORY,
         CHECK_ID_PYTEST_TESTPATHS,
         CHECK_ID_TRACKED_PERSONAL_DATA,

package/settings.json

@@ -7,6 +7,15 @@
     ]
   },
   "advisorModel": "fable",
+  "autoCompactWindow": 350000,
+  "modelSettings": {
+    "claude-haiku-5-5": {
+      "autoCompactWindow": 100000
+    },
+    "claude-haiku-4-5": {
+      "autoCompactWindow": 100000
+    }
+  },
   "autoMode": {
     "allow": [
       "$defaults",