claude-dev-env 8.106.1 → 8.106.3

package/bin/install-constants.mjs

@@ -174,11 +174,6 @@ export const WINDOWS_PYTHON_LAUNCHER_COMMAND = 'py -3';
 export const PYTHON_PROBE_TIMEOUT_MILLISECONDS = 10_000;
 export const ADDITIONAL_SETTINGS_BLOB_PREFIX = 'settings-';
 export const CODEX_NATIVE_ROUTING_MATCHER = 'multi_agent_v1__spawn_agent';
-export const CODEX_SUBAGENT_PROMPT_MATCHER = 'Agent|Task';
-export const ALL_CODEX_NATIVE_PRE_TOOL_USE_MATCHERS = new Set([
-    CODEX_NATIVE_ROUTING_MATCHER,
-    CODEX_SUBAGENT_PROMPT_MATCHER,
-]);
 export const ALL_CODEX_NATIVE_STOP_HOOK_SCRIPT_NAMES = new Set([
     'open_tasks_stop_gate.py',
     'owned_pr_merge_stop_gate.py',

package/bin/install.cursor-rules.test.mjs

@@ -130,11 +130,10 @@ test('seeds one editable policy and one native Codex routing hook', () => {
         assert.match(firstRoutingGroups[0].hooks[0].command, /subagent_model_routing\.mjs/);
         assert.match(firstRoutingGroups[0].hooks[1].command, /spawn_readiness_hook\.py/);
         assert.match(firstRoutingGroups[0].hooks[2].command, /spawn_oversight_hook\.py/);
-        const firstSpawnPromptGroups = firstCodexHooks.hooks.PreToolUse.filter(
-            group => group.matcher === 'Agent|Task',
+        assert.deepEqual(
+            firstCodexHooks.hooks.PreToolUse.map(group => group.matcher),
+            ['multi_agent_v1__spawn_agent'],
         );
-        assert.equal(firstSpawnPromptGroups.length, 1);
-        assert.match(firstSpawnPromptGroups[0].hooks[0].command, /skill_loaded_reminder\.py/);
         assert.deepEqual(Object.keys(firstCodexHooks.hooks), ['PreToolUse', 'UserPromptSubmit', 'PostToolUse', 'Stop', 'SessionStart']);
         const allCodexPostToolUseCommands = firstCodexHooks.hooks.PostToolUse.flatMap(
             group => group.hooks.map(hook => hook.command),
@@ -276,6 +275,7 @@ test('Codex reinstall removes omitted package hooks and preserves user configura
         const allLegacyRegistrations = [
             ['PreToolUse', 'Edit', '.claude', 'blocking/pre_tool_use_dispatcher.py'],
             ['PreToolUse', 'Bash', '.agents', 'blocking/bash_pre_tool_use_dispatcher.py'],
+            ['PreToolUse', 'Agent|Task', 'custom-codex', 'session/skill_loaded_reminder.py'],
             ['SessionStart', '*', 'custom-codex', 'session/issue_tracker_session_starter.py'],
             ['Stop', '*', '.claude', 'session/skill_loaded_reminder.py'],
             ['SessionEnd', '*', 'custom-codex', 'lifecycle/session_end_cleanup.py'],
@@ -311,8 +311,13 @@ test('Codex reinstall removes omitted package hooks and preserves user configura
 
         const migratedHooks = JSON.parse(readFileSync(codexHooksPath, 'utf8'));
         const allSpawnGroups = migratedHooks.hooks.PreToolUse.filter(eachGroup =>
-            ['Agent|Task', 'multi_agent_v1__spawn_agent'].includes(eachGroup.matcher));
-        assert.equal(allSpawnGroups.length, 2);
+            eachGroup.matcher === 'multi_agent_v1__spawn_agent');
+        assert.equal(allSpawnGroups.length, 1);
+        assert.equal(
+            migratedHooks.hooks.PreToolUse.flatMap(eachGroup => eachGroup.hooks)
+                .some(eachHook => String(eachHook.command).includes('skill_loaded_reminder.py')),
+            false,
+        );
         migratedHooks.hooks.PreToolUse = migratedHooks.hooks.PreToolUse.filter(eachGroup => !allSpawnGroups.includes(eachGroup));
         const allPackagePromptCommands = (migratedHooks.hooks.UserPromptSubmit ?? [])
             .flatMap(eachGroup => eachGroup.hooks)

package/bin/install.mjs

@@ -50,7 +50,7 @@ import {
     SUBAGENT_MODEL_POLICY_FILE_NAME,
     WINDOWS_PYTHON_LAUNCHER_COMMAND,
     PYTHON_PROBE_TIMEOUT_MILLISECONDS,
-    ALL_CODEX_NATIVE_PRE_TOOL_USE_MATCHERS,
+    CODEX_NATIVE_ROUTING_MATCHER,
     ALL_CODEX_NATIVE_SESSION_START_HOOK_SCRIPT_NAMES,
     ALL_CODEX_NATIVE_STOP_HOOK_SCRIPT_NAMES,
     ALL_CODEX_NATIVE_POST_TOOL_USE_HOOK_SCRIPT_NAMES,
@@ -1315,6 +1315,7 @@ export const RETIRED_HOOK_REGISTRATION_RELATIVE_PATHS = new Set([
     'blocking/session_title_stop_gate.py',
     'session/issue_tracker_session_starter.py',
     'session/deepen_first_prompt.py',
+    'workflow/investigation_tracker_reset.py',
 ]);
 
 export const MOVED_HOOK_RELATIVE_PATHS = new Set([
@@ -2283,7 +2284,7 @@ function selectCodexNativeHooksConfig(hooksConfig) {
         ...hooksConfig,
         hooks: {
             PreToolUse: Array.isArray(preToolUseGroups)
-                ? preToolUseGroups.filter(group => ALL_CODEX_NATIVE_PRE_TOOL_USE_MATCHERS.has(group?.matcher))
+                ? preToolUseGroups.filter(group => group?.matcher === CODEX_NATIVE_ROUTING_MATCHER)
                 : [],
             UserPromptSubmit: Array.isArray(userPromptSubmitGroups) ? userPromptSubmitGroups : [],
             PostToolUse: selectCodexNativeGroupsByScriptName(

package/bin/install.test.mjs

@@ -1245,6 +1245,7 @@ test('retired hook registrations stay managed so reinstall removes them', () =>
         'blocking/session_title_stop_gate.py',
         'session/issue_tracker_session_starter.py',
         'session/deepen_first_prompt.py',
+        'workflow/investigation_tracker_reset.py',
     ]);
     const shippedHooks = JSON.parse(
         readFileSync(new URL('../hooks/hooks.json', import.meta.url), 'utf8')

package/docs/codex-compatibility.md

@@ -26,8 +26,8 @@ Run `codex-compat bridge --surface <name> --payload '<json-object>'`. The bridge
 
 The package installer seeds `subagent-model-policy.json` in the agents-home
 `rules/` directory when the file is absent. It registers one `PreToolUse` group
-for `multi_agent_v1__spawn_agent` and one for `Agent|Task` in `$CODEX_HOME/hooks.json`.
-Before adding these groups, the installer removes obsolete package-owned hook
+for `multi_agent_v1__spawn_agent` in `$CODEX_HOME/hooks.json`.
+Before adding this group, the installer removes obsolete package-owned hook
 registrations from every event. Custom hook entries and Codex's enabled or
 disabled hook settings stay unchanged. Claude-only hook groups do not enter the
 Codex file.

package/hooks/blocking/reply_length_gate.py

@@ -83,6 +83,7 @@ import os
 import re
 import shlex
 import sys
+from collections.abc import Callable, Iterable
 from pathlib import Path
 
 hooks_root_directory = str(Path(__file__).resolve().parent.parent)
@@ -155,6 +156,8 @@ from hooks_constants.reply_length_gate_constants import (
     EM_DASH_MESSAGE,
     EM_DASH_PATTERN,
     FENCED_BLOCK_PATTERN,
+    FINDING_SEPARATOR,
+    FIX_EVERY_ITEM_INSTRUCTION,
     ADDITIONAL_CONTEXT_KEY,
     HOOK_EVENT_NAME,
     INLINE_CODE_PATTERN,
@@ -207,27 +210,92 @@ def sentence_word_lists(reply_text: str) -> list[list[str]]:
     return [each_word_list for each_word_list in all_word_lists if each_word_list]
 
 
+def joined_violations(all_violations: Iterable[str | None]) -> str | None:
+    """Join every violation found into one deny reason, one violation per line.
+
+    ::
+
+        []                         -> None
+        ["Too long."]              -> "Too long."
+        ["Too long.", "Em dash."]  -> "Too long." and "Em dash." on two lines
+
+    None entries are skipped. A joined reason can join again at an outer
+    level and stays one violation per line, so ``numbered_violations``
+    numbers the whole reason once.
+    """
+    all_found = [each_violation for each_violation in all_violations if each_violation]
+    return FINDING_SEPARATOR.join(all_found) if all_found else None
+
+
+def numbered_violations(violation: str) -> str:
+    """Number each line of a joined deny reason that holds several violations.
+
+    ::
+
+        "Too long."             -> "Too long."
+        "Too long.\nEm dash."   -> "1. Too long." and "2. Em dash." on two lines
+    """
+    all_lines = violation.split(FINDING_SEPARATOR)
+    if len(all_lines) == 1:
+        return violation
+    return FINDING_SEPARATOR.join(
+        f"{each_position}. {each_line}" for each_position, each_line in enumerate(all_lines, start=1)
+    )
+
+
+def collected_violations(all_checks: Iterable[Callable[[], str | None]]) -> str | None:
+    """Run every check in order and join each violation it reports.
+
+    A check that raises ends the run. With nothing found yet the error
+    propagates, which lets the call through as an early-return gate did.
+    After a finding, the findings so far stand, as the first one did when
+    the gate never ran the later checks.
+    """
+    all_violations: list[str | None] = []
+    for each_check in all_checks:
+        is_stopped, violation = _checked_violation(each_check, any(all_violations))
+        if is_stopped:
+            break
+        all_violations.append(violation)
+    return joined_violations(all_violations)
+
+
+def _checked_violation(check: Callable[[], str | None], has_finding: bool) -> tuple[bool, str | None]:
+    try:
+        return False, check()
+    except Exception:
+        if has_finding:
+            return True, None
+        raise
+
+
 def length_violation(reply_text: str) -> str | None:
-    """Return the deny reason for an over-long reply, or None when it fits."""
+    """Return the deny reason for an over-long reply and each over-long sentence, or None when it fits."""
     all_sentences = sentence_word_lists(reply_text)
-    if len(all_sentences) > MAXIMUM_SENTENCE_COUNT:
-        return TOO_MANY_SENTENCES_MESSAGE.format(
-            sentence_count=len(all_sentences), sentence_limit=MAXIMUM_SENTENCE_COUNT
-        )
-    return long_sentence_violation(reply_text)
+    return joined_violations(
+        [
+            TOO_MANY_SENTENCES_MESSAGE.format(
+                sentence_count=len(all_sentences), sentence_limit=MAXIMUM_SENTENCE_COUNT
+            )
+            if len(all_sentences) > MAXIMUM_SENTENCE_COUNT
+            else None,
+            long_sentence_violation(reply_text),
+        ]
+    )
 
 
 def long_sentence_violation(prose_text: str) -> str | None:
-    """Return the deny reason for the first sentence over the word limit, or None."""
-    for each_sentence in sentence_word_lists(prose_text):
-        if len(each_sentence) > MAXIMUM_WORDS_PER_SENTENCE:
-            sentence_preview = WORD_SEPARATOR.join(each_sentence[:SENTENCE_PREVIEW_WORD_COUNT])
-            return LONG_SENTENCE_MESSAGE.format(
-                word_count=len(each_sentence),
-                word_limit=MAXIMUM_WORDS_PER_SENTENCE,
-                sentence_preview=sentence_preview + SENTENCE_PREVIEW_SUFFIX,
-            )
-    return None
+    """Return the deny reason for each sentence over the word limit, or None."""
+    return joined_violations(
+        LONG_SENTENCE_MESSAGE.format(
+            word_count=len(each_sentence),
+            word_limit=MAXIMUM_WORDS_PER_SENTENCE,
+            sentence_preview=WORD_SEPARATOR.join(each_sentence[:SENTENCE_PREVIEW_WORD_COUNT])
+            + SENTENCE_PREVIEW_SUFFIX,
+        )
+        for each_sentence in sentence_word_lists(prose_text)
+        if len(each_sentence) > MAXIMUM_WORDS_PER_SENTENCE
+    )
 
 
 def mid_sentence_colon_violation(reply_text: str) -> str | None:
@@ -254,13 +322,13 @@ def prose_sentences(reply_text: str) -> list[str]:
 
 
 def unsourced_cause_violation(reply_text: str) -> str | None:
-    """Return the deny reason for the first causal sentence that cites no evidence itself, or None."""
-    for each_sentence in prose_sentences(reply_text):
-        is_causal = CAUSAL_CLAIM_PATTERN.search(INLINE_CODE_PATTERN.sub(" ", each_sentence))
-        has_evidence = any(each_pattern.search(each_sentence) for each_pattern in ALL_EVIDENCE_PATTERNS)
-        if is_causal and not has_evidence:
-            return UNSOURCED_CAUSE_MESSAGE.format(sentence=each_sentence.strip())
-    return None
+    """Return the deny reason for each causal sentence that cites no evidence itself, or None."""
+    return joined_violations(
+        UNSOURCED_CAUSE_MESSAGE.format(sentence=each_sentence.strip())
+        for each_sentence in prose_sentences(reply_text)
+        if CAUSAL_CLAIM_PATTERN.search(INLINE_CODE_PATTERN.sub(" ", each_sentence))
+        and not any(each_pattern.search(each_sentence) for each_pattern in ALL_EVIDENCE_PATTERNS)
+    )
 
 
 def prose_outside_links(reply_text: str) -> str:
@@ -272,11 +340,11 @@ def prose_outside_links(reply_text: str) -> str:
 
 
 def unlinked_pull_request_violation(reply_text: str) -> str | None:
-    """Return the deny reason for a pull request number outside a link, or None."""
-    unlinked_match = UNLINKED_PULL_REQUEST_PATTERN.search(prose_outside_links(reply_text))
-    if unlinked_match is None:
-        return None
-    return UNLINKED_PULL_REQUEST_MESSAGE.format(reference=unlinked_match.group(0))
+    """Return the deny reason for each pull request number outside a link, or None."""
+    return joined_violations(
+        UNLINKED_PULL_REQUEST_MESSAGE.format(reference=each_match.group(0))
+        for each_match in UNLINKED_PULL_REQUEST_PATTERN.finditer(prose_outside_links(reply_text))
+    )
 
 
 def banned_words_config_path() -> Path:
@@ -303,20 +371,25 @@ def configured_banned_words() -> tuple[str, ...]:
 
 
 def banned_word_violation(reply_text: str, all_banned_words: tuple[str, ...]) -> str | None:
-    """Return the deny reason for the first banned word in the prose, or None."""
+    """Return the deny reason for each banned word in the prose, or None."""
     prose_text = countable_text(reply_text)
-    for each_banned_word in all_banned_words:
-        word_pattern = BANNED_WORD_PART_SEPARATOR.join(
-            re.escape(each_part) for each_part in each_banned_word.split()
+    return joined_violations(
+        BANNED_WORD_MESSAGE.format(banned_word=each_banned_word)
+        for each_banned_word in all_banned_words
+        if re.search(
+            BANNED_WORD_PATTERN_TEMPLATE.format(
+                word_pattern=BANNED_WORD_PART_SEPARATOR.join(
+                    re.escape(each_part) for each_part in each_banned_word.split()
+                )
+            ),
+            prose_text,
+            re.IGNORECASE,
         )
-        whole_word_pattern = BANNED_WORD_PATTERN_TEMPLATE.format(word_pattern=word_pattern)
-        if re.search(whole_word_pattern, prose_text, re.IGNORECASE):
-            return BANNED_WORD_MESSAGE.format(banned_word=each_banned_word)
-    return None
+    )
 
 
 def unvalidated_claim_violation(reply_text: str) -> str | None:
-    """Return the deny reason quoting the first sentence that guesses or admits a skipped check, or None.
+    """Return the deny reason quoting each sentence that guesses or admits a skipped check, or None.
 
     A duration counts as a guess unless its sentence cites the run, job, check,
     or pull request that measured it::
@@ -324,6 +397,7 @@ def unvalidated_claim_violation(reply_text: str) -> str | None:
         flag: It should take about 40 minutes.
         ok:   The last queue build took 39 minutes, run 18239174012.
     """
+    all_claims: list[str] = []
     for each_sentence in prose_sentences(reply_text):
         prose_text = countable_text(each_sentence).replace(CURLY_APOSTROPHE, STRAIGHT_APOSTROPHE)
         is_guess = UNVALIDATED_CLAIM_PATTERN.search(prose_text) is not None
@@ -332,12 +406,12 @@ def unvalidated_claim_violation(reply_text: str) -> str | None:
             and CITED_NUMBER_PATTERN.search(each_sentence) is None
         )
         if is_guess or is_uncited_duration:
-            return UNVALIDATED_CLAIM_MESSAGE.format(claim=each_sentence)
-    return None
+            all_claims.append(UNVALIDATED_CLAIM_MESSAGE.format(claim=each_sentence))
+    return joined_violations(all_claims)
 
 
 def unseen_citation_violation(reply_text: str, transcript_path: object) -> str | None:
-    """Return the deny reason for the first cited run, job, check, or pull request no tool result shows.
+    """Return the deny reason for each cited run, job, check, or pull request no tool result shows.
 
     Returns None when the text cites nothing or the transcript cannot be read.
     """
@@ -347,11 +421,17 @@ def unseen_citation_violation(reply_text: str, transcript_path: object) -> str |
     result_text = successful_result_text(transcript_path)
     if result_text is None:
         return None
-    for each_match in all_citations:
-        cited_number = next(each_group for each_group in each_match.groups() if each_group)
-        if re.search(CITED_NUMBER_IN_RESULT_TEMPLATE.format(number=cited_number), result_text) is None:
-            return UNSEEN_CITATION_MESSAGE.format(citation=each_match.group(0))
-    return None
+    return joined_violations(
+        UNSEEN_CITATION_MESSAGE.format(citation=each_match.group(0))
+        for each_match in all_citations
+        if re.search(
+            CITED_NUMBER_IN_RESULT_TEMPLATE.format(
+                number=next(each_group for each_group in each_match.groups() if each_group)
+            ),
+            result_text,
+        )
+        is None
+    )
 
 
 def all_card_texts(
@@ -382,25 +462,25 @@ def card_length_violation(all_card_input: dict[str, object]) -> str | None:
 
 
 def card_shape_violation(all_card_input: dict[str, object]) -> str | None:
-    """Return the deny reason for a listed or over-long card context or card sentence, or None."""
+    """Return the deny reason for each listed or over-long card context and card sentence, or None."""
     context_text = all_card_input.get(DECISION_CARD_CONTEXT_KEY)
+    all_violations: list[str | None] = []
     if isinstance(context_text, str):
         if CARD_LIST_ITEM_PATTERN.search(FENCED_BLOCK_PATTERN.sub(" ", context_text)) is not None:
-            return CARD_CONTEXT_LIST_MESSAGE
+            all_violations.append(CARD_CONTEXT_LIST_MESSAGE)
         context_sentence_count = len(sentence_word_lists(context_text))
         if context_sentence_count > MAXIMUM_CARD_CONTEXT_SENTENCE_COUNT:
-            return CARD_CONTEXT_TOO_LONG_MESSAGE.format(
-                sentence_count=context_sentence_count,
-                sentence_limit=MAXIMUM_CARD_CONTEXT_SENTENCE_COUNT,
+            all_violations.append(
+                CARD_CONTEXT_TOO_LONG_MESSAGE.format(
+                    sentence_count=context_sentence_count,
+                    sentence_limit=MAXIMUM_CARD_CONTEXT_SENTENCE_COUNT,
+                )
             )
     all_length_checked_texts = all_card_texts(
         all_card_input, ALL_DECISION_CARD_LENGTH_KEYS, ALL_DECISION_OPTION_LENGTH_KEYS
     )
-    for each_text in all_length_checked_texts:
-        violation = long_sentence_violation(each_text)
-        if violation is not None:
-            return violation
-    return None
+    all_violations.extend(long_sentence_violation(each_text) for each_text in all_length_checked_texts)
+    return joined_violations(all_violations)
 
 
 def all_question_card_texts(all_card_input: dict[str, object]) -> list[str]:
@@ -429,37 +509,41 @@ def active_mode_rules() -> VisualReplyRules | None:
 
 
 def card_violation(card_text: str, mode_rules: VisualReplyRules | None) -> str | None:
-    """Return the deny reason for a decision card's prose, or None."""
-    return (
-        banned_word_violation(card_text, configured_banned_words())
-        or unvalidated_claim_violation(card_text)
-    ) or (
-        None if mode_rules is None else abbreviation_violation(prose_outside_links(card_text), mode_rules)
+    """Return the deny reason for each problem in a decision card's prose, or None."""
+    return collected_violations(
+        [
+            lambda: banned_word_violation(card_text, configured_banned_words()),
+            lambda: unvalidated_claim_violation(card_text),
+            lambda: None
+            if mode_rules is None
+            else abbreviation_violation(prose_outside_links(card_text), mode_rules),
+        ]
     )
 
 
 def reply_violation(
     reply_text: str, transcript_path: object, mode_rules: VisualReplyRules | None
 ) -> str | None:
-    """Return the deny reason for a reply's text, or None."""
-    violation = (
-        length_violation(reply_text)
-        or mid_sentence_colon_violation(reply_text)
-        or em_dash_violation(reply_text)
-        or unlinked_pull_request_violation(reply_text)
-        or unsourced_cause_violation(reply_text)
-        or banned_word_violation(reply_text, configured_banned_words())
-        or unvalidated_claim_violation(reply_text)
-        or unseen_citation_violation(reply_text, transcript_path)
-    )
-    if violation is not None or mode_rules is None:
-        return violation
-    prose_text = prose_outside_links(reply_text)
-    return (
-        abbreviation_violation(prose_text, mode_rules)
-        or second_reply_violation(transcript_path, mode_rules)
-        or visual_violation(len(sentence_word_lists(reply_text)), transcript_path, mode_rules)
-    )
+    """Return the deny reason for each problem in a reply's text, or None."""
+    all_checks: list[Callable[[], str | None]] = [
+        lambda: length_violation(reply_text),
+        lambda: mid_sentence_colon_violation(reply_text),
+        lambda: em_dash_violation(reply_text),
+        lambda: unlinked_pull_request_violation(reply_text),
+        lambda: unsourced_cause_violation(reply_text),
+        lambda: banned_word_violation(reply_text, configured_banned_words()),
+        lambda: unvalidated_claim_violation(reply_text),
+        lambda: unseen_citation_violation(reply_text, transcript_path),
+    ]
+    if mode_rules is not None:
+        all_checks.extend(
+            [
+                lambda: abbreviation_violation(prose_outside_links(reply_text), mode_rules),
+                lambda: second_reply_violation(transcript_path, mode_rules),
+                lambda: visual_violation(len(sentence_word_lists(reply_text)), transcript_path, mode_rules),
+            ]
+        )
+    return collected_violations(all_checks)
 
 
 def tool_violation(
@@ -467,26 +551,30 @@ def tool_violation(
 ) -> tuple[str, str] | None:
     """Return the deny reason and the checked text for one call, or None when it passes."""
     mode_rules = active_mode_rules()
-    if isinstance(tool_name, str) and mode_rules is not None:
-        anchor_violation = widget_anchor_violation(tool_name, all_tool_input)
-        if anchor_violation is not None:
-            return anchor_violation, str(all_tool_input)
+    anchor_violation = (
+        widget_anchor_violation(tool_name, all_tool_input)
+        if isinstance(tool_name, str) and mode_rules is not None
+        else None
+    )
+    if anchor_violation is None:
+        return _text_violation(tool_name, all_tool_input, transcript_path, mode_rules)
+    try:
+        checked = _text_violation(tool_name, all_tool_input, transcript_path, mode_rules)
+    except Exception:
+        checked = None
+    if checked is None:
+        return anchor_violation, str(all_tool_input)
+    return FINDING_SEPARATOR.join([anchor_violation, checked[0]]), checked[1]
+
+
+def _text_violation(
+    tool_name: object,
+    all_tool_input: dict[str, object],
+    transcript_path: object,
+    mode_rules: VisualReplyRules | None,
+) -> tuple[str, str] | None:
     if tool_name in (DECISION_CARD_TOOL_NAME, QUESTION_CARD_TOOL_NAME):
-        if tool_name == DECISION_CARD_TOOL_NAME:
-            all_texts = all_card_texts(
-                all_tool_input, ALL_DECISION_CARD_PROSE_KEYS, ALL_DECISION_OPTION_PROSE_KEYS
-            )
-            shape_violation = card_length_violation(all_tool_input)
-        else:
-            all_texts = all_question_card_texts(all_tool_input)
-            shape_violation = None
-        card_text = CARD_TEXT_SEPARATOR.join(all_texts)
-        violation = (
-            shape_violation
-            or card_violation(card_text, mode_rules)
-            or unseen_citation_violation(card_text, transcript_path)
-        )
-        return None if violation is None else (violation, card_text)
+        return _card_text_violation(tool_name, all_tool_input, transcript_path, mode_rules)
     if tool_name not in ALL_CHECKED_TOOL_NAMES:
         return None
     reply_text = all_tool_input.get(TEXT_KEY)
@@ -496,6 +584,29 @@ def tool_violation(
     return None if violation is None else (violation, reply_text)
 
 
+def _card_text_violation(
+    tool_name: object,
+    all_tool_input: dict[str, object],
+    transcript_path: object,
+    mode_rules: VisualReplyRules | None,
+) -> tuple[str, str] | None:
+    if tool_name == DECISION_CARD_TOOL_NAME:
+        all_texts = all_card_texts(all_tool_input, ALL_DECISION_CARD_PROSE_KEYS, ALL_DECISION_OPTION_PROSE_KEYS)
+        shape_violation = card_length_violation(all_tool_input)
+    else:
+        all_texts = all_question_card_texts(all_tool_input)
+        shape_violation = None
+    card_text = CARD_TEXT_SEPARATOR.join(all_texts)
+    violation = collected_violations(
+        [
+            lambda: shape_violation,
+            lambda: card_violation(card_text, mode_rules),
+            lambda: unseen_citation_violation(card_text, transcript_path),
+        ]
+    )
+    return None if violation is None else (violation, card_text)
+
+
 def github_comment_texts(tool_name: object, all_tool_input: dict[str, object]) -> list[str]:
     """Return the GitHub comment texts one call would post, or an empty list.
 
@@ -569,15 +680,21 @@ def comment_length_violation(comment_text: str) -> str | None:
 
 
 def github_comment_violation(tool_name: object, all_tool_input: dict[str, object]) -> tuple[str, str] | None:
-    """Return the deny reason and text for an over-long GitHub comment, or None.
+    """Return the deny reason and text for every over-long GitHub comment, or None.
 
     Fenced code blocks and collapsed ``<details>`` blocks carry no words.
     """
-    for each_comment_text in github_comment_texts(tool_name, all_tool_input):
-        violation = comment_length_violation(each_comment_text)
-        if violation is not None:
-            return violation, each_comment_text
-    return None
+    all_over_long = [
+        (violation, each_comment_text)
+        for each_comment_text in github_comment_texts(tool_name, all_tool_input)
+        if (violation := comment_length_violation(each_comment_text)) is not None
+    ]
+    if not all_over_long:
+        return None
+    return (
+        FINDING_SEPARATOR.join(each_violation for each_violation, _ in all_over_long),
+        CARD_TEXT_SEPARATOR.join(each_text for _, each_text in all_over_long),
+    )
 
 
 def write_flowchart_advice(tool_name: object, all_tool_input: dict[str, object]) -> None:
@@ -607,7 +724,13 @@ def main() -> int:
         write_flowchart_advice(tool_name, tool_input)
         return ALLOW_EXIT_CODE
     violation, reply_text = checked
-    block_reason = violation + RETRY_INSTRUCTION
+    numbered_violation = numbered_violations(violation)
+    instruction = RETRY_INSTRUCTION + FIX_EVERY_ITEM_INSTRUCTION
+    block_reason = (
+        numbered_violation + FINDING_SEPARATOR + instruction.lstrip()
+        if FINDING_SEPARATOR in numbered_violation
+        else numbered_violation + instruction
+    )
     log_hook_block(
         Path(__file__).name,
         HOOK_EVENT_NAME,

package/hooks/blocking/test_reply_length_gate.py

@@ -1076,3 +1076,80 @@ def test_should_report_an_over_long_comment_text_with_the_comment_instruction()
 def test_should_pass_a_comment_text_whose_long_part_sits_in_a_details_block() -> None:
     comment_text = "Fixed.\n<details><summary>Log</summary>\n" + LONG_GITHUB_COMMENT + "\n</details>"
     assert reply_length_gate.comment_length_violation(comment_text) is None
+
+
+def test_joined_violations_should_put_each_violation_on_its_own_line() -> None:
+    assert reply_length_gate.joined_violations(["Too long.", None, "Em dash.\nNo link."]) == (
+        "Too long.\nEm dash.\nNo link."
+    )
+
+
+def test_numbered_violations_should_number_each_line_once() -> None:
+    assert reply_length_gate.numbered_violations("Too long.\nEm dash.\nNo link.") == (
+        "1. Too long.\n2. Em dash.\n3. No link."
+    )
+    assert reply_length_gate.numbered_violations("Too long.") == "Too long."
+
+
+def test_joined_violations_should_keep_one_violation_unchanged() -> None:
+    assert reply_length_gate.joined_violations([None, "Too long."]) == "Too long."
+
+
+def test_collected_violations_should_keep_findings_made_before_a_check_raises() -> None:
+    def broken_check() -> str | None:
+        raise TypeError("malformed input")
+
+    assert reply_length_gate.collected_violations([lambda: "Too long.", broken_check]) == "Too long."
+
+
+def test_collected_violations_should_keep_findings_when_a_later_check_raises_any_error() -> None:
+    def broken_check() -> str | None:
+        raise RuntimeError("transcript unreadable")
+
+    assert reply_length_gate.collected_violations([lambda: "Too long.", broken_check]) == "Too long."
+
+
+def test_collected_violations_should_raise_when_a_check_breaks_before_any_finding() -> None:
+    def broken_check() -> str | None:
+        raise TypeError("malformed input")
+
+    with pytest.raises(TypeError):
+        reply_length_gate.collected_violations([lambda: None, broken_check])
+
+
+def test_should_name_every_broken_rule_in_one_refusal(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    exit_code, error_text = run_gate(
+        monkeypatch,
+        capsys,
+        POST_TOOL_NAME,
+        {"text": f"See PR 7452 and PR 7460.\n{SIXTEEN_WORD_SENTENCE}\nIt failed — again."},
+    )
+
+    assert exit_code == reply_length_gate.BLOCK_EXIT_CODE
+    assert "PR 7452" in error_text
+    assert "PR 7460" in error_text
+    assert "16 words" in error_text
+    assert reply_length_gate.EM_DASH_MESSAGE in error_text
+    assert error_text.endswith(reply_length_gate.FIX_EVERY_ITEM_INSTRUCTION)
+
+
+def test_should_number_nested_violations_once_in_one_refusal(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    exit_code, error_text = run_gate(
+        monkeypatch,
+        capsys,
+        POST_TOOL_NAME,
+        {"text": f"One.\nTwo.\nThree.\n{SIXTEEN_WORD_SENTENCE}\n{SIXTEEN_WORD_SENTENCE}\nIt failed — again."},
+    )
+
+    assert exit_code == reply_length_gate.BLOCK_EXIT_CODE
+    all_numbered_lines = [each_line for each_line in error_text.splitlines() if each_line[:1].isdigit()]
+    assert [each_line.split(". ", 1)[0] for each_line in all_numbered_lines] == ["1", "2", "3", "4"]
+    assert not any(each_line.split(". ", 1)[1][:1].isdigit() for each_line in all_numbered_lines)
+    assert "Reply too long: 6 sentences" in all_numbered_lines[0]
+    assert all_numbered_lines[1].count("16 words") == 1
+    assert all_numbered_lines[2].count("16 words") == 1
+    assert reply_length_gate.EM_DASH_MESSAGE in all_numbered_lines[3]

package/hooks/features/README.md

@@ -28,6 +28,6 @@ Each family page starts with a title and an agent-facing behavior summary. Its f
 - [Conduct gates](./conduct-gates.md) covers chat replies, edit markers, step notes, checked claims, and the pull request lifecycle skill.
 - [Session context](./session-context.md) covers skill reminders, startup guidance, and the auto mode denial quick fix.
 - [Spawn routing](./spawn-routing.md) covers spawn readiness, pacing, and model selection.
-- [Observability](./observability.md) covers instruction loads, edited files, and investigation resets.
+- [Observability](./observability.md) covers instruction loads and edited files.
 - [Read gates](./read-gates.md) covers the image size cap on Read.
 - [Lifecycle cleanup](./lifecycle-cleanup.md) covers nested checkouts, worktree setup, and session cleanup.