claude-dev-env 2.9.0 → 2.10.0

package/hooks/blocking/test_stop_dispatcher.py

@@ -156,9 +156,10 @@ def test_dispatcher_blocks_hedging_message_matching_standalone() -> None:
     payload_text = json.dumps(
         {
             "stop_hook_active": False,
-            "last_assistant_message": "This is probably correct without a source.",
+            "last_assistant_message": "This is probably correct.",
         }
     )
+    environment_by_key = {**os.environ, "CLAUDE_PROSE_STYLE_ENFORCEMENT": "1"}
     completed = subprocess.run(
         [sys.executable, _DISPATCHER_SCRIPT],
         check=False,
@@ -166,6 +167,7 @@ def test_dispatcher_blocks_hedging_message_matching_standalone() -> None:
         capture_output=True,
         text=True,
         encoding="utf-8",
+        env=environment_by_key,
     )
     assert completed.returncode == 0
     parsed = json.loads(completed.stdout)
@@ -173,14 +175,16 @@ def test_dispatcher_blocks_hedging_message_matching_standalone() -> None:
     assert "probably" in parsed["reason"].lower() or "hedging" in parsed["reason"].lower()
 
 
-def test_dispatcher_blocks_overlong_reply_matching_standalone() -> None:
-    """An overlong last_assistant_message blocks through the dispatcher."""
-    overlong_message = "\n".join(
-        " ".join(f"finding{each_index}" for each_index in range(10))
-        for _ in range(30)
+def test_dispatcher_blocks_eli11_shape_violation_matching_standalone() -> None:
+    """An ELI11 shape violation (too many bullets) blocks through the dispatcher."""
+    too_many_bullets_message = "\n".join(
+        f"- finding{each_index} detail for this line" for each_index in range(7)
     )
     payload_text = json.dumps(
-        {"stop_hook_active": False, "last_assistant_message": overlong_message}
+        {
+            "stop_hook_active": False,
+            "last_assistant_message": too_many_bullets_message,
+        }
     )
     completed = subprocess.run(
         [sys.executable, _DISPATCHER_SCRIPT],

package/hooks/blocking/test_volatile_path_in_post_blocker.py

@@ -31,13 +31,13 @@ def _body_names_volatile_path(tool_name: str, tool_input: dict[str, object]) ->
 
 
 def test_scan_detects_job_scratch_path_backslash() -> None:
-    text = r"See C:\Users\example\.claude-editor\jobs\95762cea\tmp\staging\contact_sheet.png"
-    assert scan_text_for_volatile_marker(text) == ".claude-editor/jobs/"
+    text = r"See C:\Users\example\.claude-profile-a\jobs\95762cea\tmp\staging\contact_sheet.png"
+    assert scan_text_for_volatile_marker(text) == ".claude-profile-a/jobs/"
 
 
 def test_scan_detects_job_scratch_path_forward_slash() -> None:
-    text = "artifact at /home/user/.claude-editor/jobs/abc/tmp/out.png"
-    assert scan_text_for_volatile_marker(text) == ".claude-editor/jobs/"
+    text = "artifact at /home/user/.claude-profile-a/jobs/abc/tmp/out.png"
+    assert scan_text_for_volatile_marker(text) == ".claude-profile-a/jobs/"
 
 
 def test_scan_detects_worktree_path() -> None:
@@ -92,12 +92,12 @@ def test_scan_home_anchored_worktree_path_is_detected() -> None:
 
 
 def test_scan_posix_absolute_job_scratch_path_is_detected() -> None:
-    text = "/home/me/.claude-editor/jobs/j1/log.txt"
-    assert scan_text_for_volatile_marker(text) == ".claude-editor/jobs/"
+    text = "/home/me/.claude-profile-a/jobs/j1/log.txt"
+    assert scan_text_for_volatile_marker(text) == ".claude-profile-a/jobs/"
 
 
 def test_scan_bare_parenthesized_job_scratch_mention_is_allowed() -> None:
-    text = "(.claude-editor/jobs/) as a directory name in prose"
+    text = "(.claude-profile-a/jobs/) as a directory name in prose"
     assert scan_text_for_volatile_marker(text) is None
 
 
@@ -139,8 +139,8 @@ def test_scan_markdown_link_relative_worktree_target_is_detected() -> None:
 
 
 def test_scan_space_prefixed_relative_job_scratch_path_is_detected() -> None:
-    text = "see .claude-editor/jobs/j1/log.txt"
-    assert scan_text_for_volatile_marker(text) == ".claude-editor/jobs/"
+    text = "see .claude-profile-a/jobs/j1/log.txt"
+    assert scan_text_for_volatile_marker(text) == ".claude-profile-a/jobs/"
 
 
 def test_scan_backslash_relative_worktree_path_is_detected() -> None:
@@ -171,7 +171,7 @@ def test_scan_sentence_final_marker_period_is_allowed() -> None:
 def test_gh_comment_with_job_scratch_path_is_blocked() -> None:
     command = (
         'gh pr comment 669 --body "Contact sheet at '
-        r'C:\Users\example\.claude-editor\jobs\95762cea\tmp\staging\contact_sheet.png"'
+        r'C:\Users\example\.claude-profile-a\jobs\95762cea\tmp\staging\contact_sheet.png"'
     )
     assert _body_names_volatile_path("Bash", {"command": command})
 
@@ -223,7 +223,7 @@ def test_substring_mention_of_gh_post_does_not_classify() -> None:
 
 
 def test_gh_word_not_first_token_does_not_classify() -> None:
-    command = r'echo gh pr comment 42 --body "see C:\.claude-editor\jobs\x"'
+    command = r'echo gh pr comment 42 --body "see C:\.claude-profile-a\jobs\x"'
     assert not _body_names_volatile_path("Bash", {"command": command})
 
 
@@ -279,7 +279,7 @@ def test_gh_issue_edit_quoting_bare_constant_is_allowed(tmp_path: pathlib.Path)
     body_file.write_text(
         "The manifest skips these tooling-state prefixes:\n"
         '    ".claude/worktrees/",\n'
-        '    ".claude-editor/jobs/",\n'
+        '    ".claude-profile-a/jobs/",\n'
         "Neither is a machine-local path.",
         encoding="utf-8",
     )

package/hooks/blocking/volatile_path_in_post_blocker.py

@@ -21,7 +21,7 @@ another argument never classifies.
 
 The marker scan runs in two tiers over the normalized body. Five bare markers
 — the system temp locations and env tokens — match as a plain substring
-anywhere. Two dot-relative directory markers, ``.claude-editor/jobs/`` and
+anywhere. Two dot-relative directory markers, ``.claude-profile-a/jobs/`` and
 ``.claude/worktrees/``, match when either a slash sits immediately before the
 marker or a path segment follows it. A machine-local absolute path
 (``~/.claude/worktrees/wt/f.py``) and a relative path that names a child
@@ -117,7 +117,7 @@ def scan_text_for_volatile_marker(text: str) -> str | None:
     markers match anywhere::
 
         ok:   "the `.claude/worktrees/` manifest key"    -> None
-        flag: r"C:\\Users\\me\\.claude-editor\\jobs\\x"   -> ".claude-editor/jobs/"
+        flag: r"C:\\Users\\me\\.claude-profile-a\\jobs\\x"   -> ".claude-profile-a/jobs/"
         flag: "see .claude/worktrees/wt-1/notes.md"       -> ".claude/worktrees/"
         flag: "saved to %TEMP%\\out.txt"                  -> "%temp%"
 

package/hooks/hooks.json

@@ -176,6 +176,21 @@
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/task_list_loop_starter.py",
             "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/working_style_prompt.py",
+            "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/orchestrator_auto_starter.py",
+            "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/issue_tracker_session_starter.py",
+            "timeout": 10
           }
         ]
       }

package/hooks/hooks_constants/CLAUDE.md

@@ -8,6 +8,7 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 |---|---|
 | `__init__.py` | Package marker (`# pragma: no-tdd-gate`) |
 | `any_type_config.py` | Config for the `Any`-type escape-hatch check |
+| `ask_user_question_shape.py` | Pure AskUserQuestion lean-block shape analyzer: grades question and option-description prose against shared chat-detail markers and sentence/word caps with no hook I/O |
 | `banned_identifiers_constants.py` | The set of banned short identifiers and banned function-name prefixes |
 | `bash_pre_tool_use_dispatcher_constants.py` | Permission outcomes, tool-name sets, and the ordered hosted-hook roster for the Bash PreToolUse dispatcher (also covers PowerShell-shared gates) |
 | `blocking_check_limits.py` | Max issue counts and preview lengths for blocking hooks |
@@ -31,11 +32,12 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 | `duplicate_function_body_constants.py` | Hashing and comparison config for the duplicate-body check |
 | `duplicate_rmtree_helper_blocker_constants.py` | Sanctioned Windows-safe rmtree helper names, the definition pattern, and the exempt-path set for the duplicate-rmtree-helper blocker |
 | `dynamic_stderr_handler.py` | `DynamicStderrHandler` — a logging handler that resolves `sys.stderr` at emit time (for testability) |
-| `eli11_reply_enforcer_constants.py` | Reply-shape thresholds (word cap, enforced word floor, bullet cap, lead-line window, per-line word cap, over-packed line cap), the `Long form:` escape prefix, the bullet / numbered-step / table-row / link-target / word patterns, the imperative instruction verbs, and the user-facing notice for the ELI11 reply-shape Stop hook |
+| `eli11_reply_enforcer_constants.py` | Reply-shape thresholds (bullet cap, lead-line window, per-list-line word cap, overpacked list-line cap), the bullet / numbered-step / table-row / link-target / word patterns, the imperative instruction verbs, and the user-facing notice for the ELI11 reply-shape Stop hook |
 | `fable_spawn_gate_constants.py` | The spawn tool-name set, the fable model alias and the model-id segment split pattern, the `FABLE-SPAWN-AUTHORIZED` authorization token, the advisor-protocol document path, payload field names, the deny message, and the deny `additionalContext` recovery text for the fable-tier spawn gate |
 | `gh_pr_author_swap_constants.py` | Constants for the PR-author swap enforcement hooks |
 | `hardcoded_user_path_constants.py` | Patterns for detecting hardcoded home-directory paths |
 | `harness_scratchpad_constants.py` | Fixed path components (`claude` / `claude-` user-directory name and prefix, `scratchpad` leaf name), the PreToolUse session-id payload key, and the `CLAUDE_CODE_SESSION_ID` environment variable name that the code-rules and TDD gates use to recognize an existing harness session scratchpad directory |
+| `hedging_uncertainty_constants.py` | Sentence-boundary pattern, explicit uncertainty label patterns, hedge-term list separator, and positive corrective block text for OP-07C sentence-scoped hedging |
 | `hook_block_logger.py` | `log_hook_block()` — shared fail-safe logger every blocking hook calls to append a JSON record of each block decision to `~/.claude/logs/hook-blocks.log` |
 | `hook_log_extractor_constants.py` | Neon table name, offset state file path, timeouts, and outcome-type mapping for the hook-log extractor |
 | `hook_prose_detector_consistency_constants.py` | Trigger patterns and corrective messages for the hook-prose consistency checker |
@@ -54,15 +56,17 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 | `paired_test_coverage_constants.py` | Test-directory name, stem-test filename affixes, test-file globs, exempt public-function names, scan budget, coverage threshold, and guidance text for the public-function paired-test coverage check |
 | `path_rewriter_constants.py` | Path rewriting patterns for the Everything-search path rewriter |
 | `pii_prevention_constants.py` | Patterns, allowlists, path exemptions, and deny-message text for `pii_prevention_blocker` |
-| `piped_pytest_blocker_constants.py` | Bash tool name, pytest program basenames and the python-interpreter basename pattern, the pipe and segment-reset operator token sets, and the deny message for the piped-pytest blocker |
+| `piped_pytest_blocker_constants.py` | Bash tool name, pytest program basenames and the python-interpreter basename pattern, the pipe and segment-reset operator token sets, and the deny message for the piped-pytest blocker; classification that consumes those program and wrapper constants lives in `pytest_invocation.py` |
+| `pytest_invocation.py` | Pure parsed-segment classifier for pytest runs through interpreters, shims, wrappers, and shell string-exec forms; no pipeline deny decision |
 | `plain_language_blocker_constants.py` | The list of heavy words and their everyday replacements |
 | `pr_converge_bugteam_enforcer_constants.py` | State keys and timing config for the bugteam-parallel enforcer |
 | `pr_converge_bugteam_enforcer_state.py` | State-file helpers for the bugteam enforcer |
 | `pr_description_enforcer_constants.py` | PR-description shape rules and command patterns |
 | `pr_description_proof_of_work_constants.py` | Proof-part detection patterns, gh command tokens, and corrective messages for the proof-of-work comment audit |
+| `prose_matcher_precision_constants.py` | Sample floor, keep/narrow precision floors, matcher ids, label decisions, advisory log path, emit caps, and context fingerprint length for OP-07B prose-matcher advisory telemetry |
 | `pre_tool_use_stdin.py` | `read_hook_input_dictionary_from_stdin()` — shared stdin parser for PreToolUse hooks |
 | `precommit_code_rules_gate_constants.py` | Scope argument and exit-code constants for the precommit gate |
-| `project_paths_reader.py` | Loads `~/.claude/project-paths.json` — the per-user project-path registry |
+| project_paths_reader.py | Loads ~/.claude/project-paths.json and finds a home-bounded git root for registry checks |
 | `pyproject_config_discovery_constants.py` | Table names (``tool`` key, ``mypy``, ``ruff``) for resolving a validator's config from a pyproject.toml `[tool.<name>]` table |
 | `pytest_testpaths_orphan_blocker_constants.py` | Marker filename, section and key names, test-file pattern, search budget, and block-message text for the pytest unregistered-test-directory blocker |
 | `python_style_checks_constants.py` | Command-line argument count and blank-line count between top-level functions for the style validator |
@@ -72,8 +76,14 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 | `sensitive_file_protector_constants.py` | Sensitive filename patterns, the committed-template suffixes that earn an exemption, the write/edit tool names, and the deny decision and message template for `sensitive_file_protector` |
 | `session_edit_stage_gate_constants.py` | Tracker filename prefix/suffix, JSON payload key, edit tool name set, session-id sanitize pattern, lock filename suffix and lock-acquire timing, git diff command, commit flag escapes, and deny-message template shared by the session edit stage gate trio |
 | `session_env_cleanup_constants.py` | Stale-age threshold and directory names for the session-env cleanup hook |
+| `session_start_injector.py` | Pure SessionStart context injector: normalize `source` (`startup`/`resume`/`clear`/`compact`), honor enable/timeout, return structured injection results for starter hooks |
+| `session_start_injector_constants.py` | Known SessionStart source values, injection status codes, enable env var, default timeout for the shared injector |
+| `test_session_start_injector.py` | Behavioral tests for every known source, disabled, timeout, and unknown-source paths |
+| `orchestrator_auto_starter_constants.py` | Opt-in env var, enable values, timeout, and SessionStart directive text for the orchestrator auto-starter |
+| `issue_tracker_session_starter_constants.py` | Opt-in env var, enable values, timeout, and SessionStart directive text for the repository-gated issue-tracker starter |
 | `session_handoff_blocker_constants.py` | Trigger phrases for the session-handoff blocker |
 | `setup_project_paths_constants.py` | Encoding policy, BOM marker, and registry meta-key used across multiple hooks |
+| `shell_command_pipeline.py` | Quote-aware shell pipeline parsing: operator-paired segments after line-continuation join, comment strip, heredoc body drop, and parenthesis-group join |
 | `shell_command_segments.py` | Shell tokenization helpers shared by the segment-walking blockers: segment splitting on control operators, a segment's effective leading program, and a token's basename |
 | `shell_substitution_blocker_constants.py` | Tool name, payload keys, the four substitution-detection patterns, the deny decision shape, and the corrective message for the shell-substitution blocker |
 | `stale_comment_reference_blocker_constants.py` | Identifier pattern, comment stopwords, and denial text for the stale-comment-reference blocker |
@@ -91,6 +101,7 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 | `volatile_path_in_post_blocker_constants.py` | Volatile path markers, affected `gh` post subcommands, MCP body param names, and the corrective message for the volatile-path post blocker |
 | `windows_rmtree_blocker_constants.py` | The unsafe `shutil.rmtree` pattern and the safe replacement pattern |
 | `workflow_substitution_slot_blocker_constants.py` | Per-iteration token patterns for the workflow-slot blocker |
+| `working_style_prompt_constants.py` | The fixed multi-paragraph working-style prompt text for the SessionStart working_style_prompt hook |
 
 ## Conventions
 

package/hooks/hooks_constants/ask_user_question_shape.py

@@ -0,0 +1,281 @@
+"""Pure AskUserQuestion payload-shape analysis.
+
+Maps an AskUserQuestion tool input to lean-block violations without hook I/O,
+deny payloads, or environment state::
+
+    analyze_ask_user_question_shape({"questions": [...]})
+        ok:   a lean question and short options -> empty violations
+        flag: a bullet list under the question  -> named violation texts
+
+Callers that need a deny reason compose with the shared lean-block message
+constants; this module only grades shape.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+
+from hooks_constants.plain_language_blocker_constants import (
+    ALL_CHAT_DETAIL_MARKERS,
+    ALL_LINE_ENDING_REPLACEMENTS,
+    COUNTABLE_WORD_PATTERN,
+    INLINE_CODE_PLACEHOLDER,
+    INLINE_CODE_SPAN_PATTERN,
+    MAXIMUM_OPTION_DESCRIPTION_SENTENCE_COUNT,
+    MAXIMUM_OPTION_DESCRIPTION_WORD_COUNT,
+    MAXIMUM_QUESTION_SENTENCE_COUNT,
+    MAXIMUM_QUESTION_WORD_COUNT,
+    OPTION_DESCRIPTION_SURFACE_NAME,
+    QUESTION_SURFACE_NAME,
+    SENTENCE_BOUNDARY_PATTERN,
+)
+
+__all__ = [
+    "AskUserQuestionShapeResult",
+    "analyze_ask_user_question_shape",
+    "count_prose_sentences",
+    "count_prose_words",
+    "find_chat_detail_markers",
+    "find_lean_block_violations",
+    "find_question_block_violations",
+    "mask_inline_code",
+    "normalize_line_endings",
+    "violations_for_one_question",
+]
+
+
+@dataclass(frozen=True)
+class AskUserQuestionShapeResult:
+    """Shape-grade for one AskUserQuestion tool input.
+
+    Attributes:
+        all_violations: One violation text per broken lean-block rule, in
+            first-seen order, empty when the whole question block is lean.
+    """
+
+    all_violations: tuple[str, ...]
+
+    @property
+    def is_lean(self) -> bool:
+        """True when the payload carries no lean-block violations."""
+        return not self.all_violations
+
+
+def normalize_line_endings(prose_text: str) -> str:
+    """Return the prose with every line ending spelled as a bare line feed.
+
+    ::
+
+        in:  "Which gate?\\r\\n\\r\\nThe write gate reads it."
+        out: "Which gate?\\n\\nThe write gate reads it."
+
+    Args:
+        prose_text: One question text or one option description.
+
+    Returns:
+        The prose with carriage returns folded into line feeds.
+    """
+    normalized_text = prose_text
+    for each_line_ending, each_replacement in ALL_LINE_ENDING_REPLACEMENTS:
+        normalized_text = normalized_text.replace(each_line_ending, each_replacement)
+    return normalized_text
+
+
+def mask_inline_code(prose_text: str) -> str:
+    """Return the prose with each inline code span collapsed to a single word.
+
+    ::
+
+        in:  "Does `git diff --cached` list it?"
+        out: "Does code list it?"
+
+    Args:
+        prose_text: One question text or one option description.
+
+    Returns:
+        The prose with every single-line inline code span replaced.
+    """
+    return INLINE_CODE_SPAN_PATTERN.sub(INLINE_CODE_PLACEHOLDER, prose_text)
+
+
+def count_prose_sentences(prose_text: str) -> int:
+    """Return how many sentences one piece of question-block prose carries.
+
+    ::
+
+        in:  "Which gate runs first? Both read the same lines."
+        out: 2
+
+    Args:
+        prose_text: One question text or one option description.
+
+    Returns:
+        The count of sentence closings the prose carries.
+    """
+    return len(SENTENCE_BOUNDARY_PATTERN.findall(prose_text))
+
+
+def count_prose_words(prose_text: str) -> int:
+    """Return how many reader-visible words one piece of prose carries.
+
+    Args:
+        prose_text: One question text or one option description.
+
+    Returns:
+        The count of whitespace-separated tokens carrying a letter or digit.
+    """
+    return len(COUNTABLE_WORD_PATTERN.findall(prose_text))
+
+
+def find_chat_detail_markers(prose_text: str) -> list[str]:
+    """Return the name of each chat-detail marker the prose carries.
+
+    ::
+
+        ok:   "Which gate should run first?"        -> []
+        flag: "Which gate?\\n- write\\n- commit"      -> ["a bullet or numbered
+              list marker"]
+
+    Args:
+        prose_text: One question text or one option description.
+
+    Returns:
+        One marker name per marker found, in the order the markers are tried.
+    """
+    return [
+        each_marker_name
+        for each_pattern, each_marker_name in ALL_CHAT_DETAIL_MARKERS
+        if each_pattern.search(prose_text)
+    ]
+
+
+def find_lean_block_violations(
+    prose_text: str,
+    surface_name: str,
+    maximum_sentence_count: int,
+    maximum_word_count: int,
+) -> list[str]:
+    """Return every lean-block rule one piece of question-block prose breaks.
+
+    Args:
+        prose_text: One question text or one option description.
+        surface_name: How the violation text names this piece of prose.
+        maximum_sentence_count: The sentence cap this piece answers to.
+        maximum_word_count: The word cap this piece answers to.
+
+    Returns:
+        One violation text per broken rule, empty when the prose is lean.
+    """
+    normalized_text = normalize_line_endings(prose_text)
+    masked_text = mask_inline_code(normalized_text)
+    all_violations = [
+        f"{surface_name} carries {each_marker_name}"
+        for each_marker_name in find_chat_detail_markers(normalized_text)
+    ]
+    sentence_count = count_prose_sentences(masked_text)
+    if sentence_count > maximum_sentence_count:
+        all_violations.append(
+            f"{surface_name} runs {sentence_count} sentences, over the "
+            f"{maximum_sentence_count}-sentence cap"
+        )
+    word_count = count_prose_words(masked_text)
+    if word_count > maximum_word_count:
+        all_violations.append(
+            f"{surface_name} runs {word_count} words, over the "
+            f"{maximum_word_count}-word cap"
+        )
+    return all_violations
+
+
+def violations_for_one_question(question_by_key: Mapping[str, object]) -> list[str]:
+    """Return the lean-block violations one question entry carries.
+
+    Args:
+        question_by_key: One entry of the AskUserQuestion questions list.
+
+    Returns:
+        One violation text per broken rule across the question text and every
+        option description the entry carries.
+    """
+    all_violations: list[str] = []
+    question_text = question_by_key.get("question", "")
+    if isinstance(question_text, str):
+        all_violations.extend(
+            find_lean_block_violations(
+                question_text,
+                QUESTION_SURFACE_NAME,
+                MAXIMUM_QUESTION_SENTENCE_COUNT,
+                MAXIMUM_QUESTION_WORD_COUNT,
+            )
+        )
+    all_options = question_by_key.get("options", [])
+    if not isinstance(all_options, Sequence) or isinstance(all_options, (str, bytes)):
+        return all_violations
+    for each_option in all_options:
+        if not isinstance(each_option, Mapping):
+            continue
+        option_description = each_option.get("description", "")
+        if not isinstance(option_description, str):
+            continue
+        all_violations.extend(
+            find_lean_block_violations(
+                option_description,
+                OPTION_DESCRIPTION_SURFACE_NAME,
+                MAXIMUM_OPTION_DESCRIPTION_SENTENCE_COUNT,
+                MAXIMUM_OPTION_DESCRIPTION_WORD_COUNT,
+            )
+        )
+    return all_violations
+
+
+def find_question_block_violations(payload_by_key: Mapping[str, object]) -> list[str]:
+    """Return every lean-block violation an AskUserQuestion payload carries.
+
+    ::
+
+        ok:   "Which gate should run first?" + "Runs on every write." -> []
+        flag: a question with a three-bullet plan under it
+              -> ["the question carries a bullet or numbered list marker"]
+
+    Each violation text appears once, so two options breaking the same cap read
+    as one line.
+
+    Args:
+        payload_by_key: The AskUserQuestion tool input carrying the questions list.
+
+    Returns:
+        One violation text per broken rule, in first-seen order, empty when the
+        whole question block is lean.
+    """
+    all_questions = payload_by_key.get("questions", [])
+    if not isinstance(all_questions, Sequence) or isinstance(all_questions, (str, bytes)):
+        return []
+    all_violations: list[str] = []
+    for each_question in all_questions:
+        if isinstance(each_question, Mapping):
+            all_violations.extend(violations_for_one_question(each_question))
+    return list(dict.fromkeys(all_violations))
+
+
+def analyze_ask_user_question_shape(
+    payload_by_key: Mapping[str, object],
+) -> AskUserQuestionShapeResult:
+    """Grade an AskUserQuestion tool input for lean-block shape only.
+
+    ::
+
+        analyze_ask_user_question_shape({"questions": [
+            {"question": "Which gate?", "options": [{"description": "Runs on write."}]}
+        ]}).is_lean
+            True
+
+    Args:
+        payload_by_key: The AskUserQuestion tool input carrying the questions list.
+
+    Returns:
+        A frozen result holding the ordered, de-duplicated violation texts.
+    """
+    return AskUserQuestionShapeResult(
+        all_violations=tuple(find_question_block_violations(payload_by_key))
+    )

package/hooks/hooks_constants/code_rules_enforcer_constants.py

@@ -27,7 +27,8 @@ CLAUDE_JOB_DIR_SCRATCH_SUBDIRECTORY: str = "tmp"
 EPHEMERAL_EXEMPT_DISABLE_ENVIRONMENT_VARIABLE_NAME: str = "CLAUDE_CODE_RULES_DISABLE_EPHEMERAL_EXEMPT"
 ALL_EPHEMERAL_EXEMPT_DISABLE_TRUTHY_VALUES: frozenset[str] = frozenset({"1", "true", "yes", "on"})
 LEADING_DRIVE_LETTER_PATTERN: re.Pattern[str] = re.compile(r"^[a-z]:")
-ALL_HOOK_INFRASTRUCTURE_PATTERNS = {"/.claude/hooks/", "\\.claude\\hooks\\", "\\.claude/hooks/", "/packages/claude-dev-env/hooks/", "\\packages\\claude-dev-env\\hooks\\"}
+ALL_AGENT_HOME_TOOLING_PATTERNS = {"/.grok/", "\\.grok\\", "\\.grok/"}
+ALL_HOOK_INFRASTRUCTURE_PATTERNS = {"/.claude/hooks/", "\\.claude\\hooks\\", "\\.claude/hooks/", "/packages/claude-dev-env/hooks/", "\\packages\\claude-dev-env\\hooks\\"} | ALL_AGENT_HOME_TOOLING_PATTERNS
 ALL_WORKFLOW_REGISTRY_PATTERNS = {"/workflow/", "\\workflow\\", "_tab.py", "/states.py", "\\states.py", "/modules.py", "\\modules.py"}
 ALL_MIGRATION_PATH_PATTERNS = {"/migrations/", "\\migrations\\"}
 

package/hooks/hooks_constants/eli11_reply_enforcer_constants.py

@@ -24,13 +24,10 @@ __all__ = [
     "IMPERATIVE_OBJECT_TOKEN_PATTERN",
     "LINK_TARGET_PATTERN",
     "LIST_MARKER_PREFIX_PATTERN",
-    "LONG_FORM_ESCAPE_PREFIX",
     "MARKDOWN_LEAD_MARKER_PATTERN",
     "MAXIMUM_BULLET_LINE_COUNT",
-    "MAXIMUM_OVERPACKED_LINE_COUNT",
-    "MAXIMUM_REPLY_WORD_COUNT",
-    "MAXIMUM_WORDS_PER_LINE",
-    "MINIMUM_ENFORCED_WORD_COUNT",
+    "MAXIMUM_OVERPACKED_LIST_LINE_COUNT",
+    "MAXIMUM_WORDS_PER_LIST_LINE",
     "NUMBERED_STEP_PATTERN",
     "TABLE_ROW_PATTERN",
     "TARGET_BULLET_LINE_COUNT",
@@ -38,18 +35,14 @@ __all__ = [
     "VIOLATION_SEPARATOR",
 ]
 
-MAXIMUM_REPLY_WORD_COUNT = 120
-MINIMUM_ENFORCED_WORD_COUNT = 60
 MAXIMUM_BULLET_LINE_COUNT = 6
 TARGET_BULLET_LINE_COUNT = 3
 ACTION_FIRST_LEAD_LINE_COUNT = 6
-MAXIMUM_WORDS_PER_LINE = 20
-MAXIMUM_OVERPACKED_LINE_COUNT = 2
+MAXIMUM_WORDS_PER_LIST_LINE = 20
+MAXIMUM_OVERPACKED_LIST_LINE_COUNT = 2
 
-LONG_FORM_ESCAPE_PREFIX = "long form:"
 VIOLATION_SEPARATOR = "; "
-USER_FACING_ELI11_NOTICE = "Agent wrote a long reply - rewriting it short..."
-
+USER_FACING_ELI11_NOTICE = "Rewrite the reply into a short action-first shape..."
 TABLE_ROW_PATTERN = re.compile(r"^[ \t]*\|.*\|[ \t]*$", re.MULTILINE)
 LINK_TARGET_PATTERN = re.compile(r"(?:https?://|www\.)\S+", re.IGNORECASE)
 COUNTABLE_WORD_PATTERN = re.compile(r"\S*[A-Za-z0-9]\S*")

package/hooks/hooks_constants/hedging_uncertainty_constants.py

@@ -0,0 +1,42 @@
+"""Explicit uncertainty labels that co-occur with hedge words in one sentence.
+
+::
+
+    ok:   This claim is unverified; the port is probably down.
+    flag: The port is probably down. (no label in that sentence)
+
+A response-wide "unverified" label does not exempt a bare hedge in another
+sentence. Classification of matcher precision (OP-07B) uses the same blocking
+surface: only hedges that survive this filter count toward hard-block evidence.
+"""
+
+from __future__ import annotations
+
+import re
+
+# Sentence ends at . ! ? when followed by space or end; keep the terminator
+# attached to the sentence so labels next to periods still match.
+SENTENCE_BOUNDARY_PATTERN = re.compile(r"(?<=[.!?])\s+")
+
+ALL_EXPLICIT_UNCERTAINTY_LABEL_PATTERNS = (
+    re.compile(r"\bunverified\b", re.IGNORECASE),
+    re.compile(r"\bi don't know\b", re.IGNORECASE),
+    re.compile(r"\bi do not know\b", re.IGNORECASE),
+    re.compile(r"\bno source for this claim\b", re.IGNORECASE),
+    re.compile(r"\bwithout a (credible )?source\b", re.IGNORECASE),
+    re.compile(r"\bnamed (as )?unverified\b", re.IGNORECASE),
+)
+
+HEDGING_TERM_LIST_SEPARATOR = ", "
+
+POSITIVE_CORRECTIVE_GUIDANCE = (
+    "State the claim with evidence that backs it, or label that claim unverified "
+    "in the same sentence as the uncertainty word. "
+    "Gather a source, run a live probe, or ask the user through AskUserQuestion — "
+    "then re-output the complete revised response."
+)
+
+BLOCK_REASON_PREFIX = (
+    "ANTI-HALLUCINATION GUARDRAIL: Your response contains hedging language without "
+    "an explicit uncertainty label in the same sentence: "
+)

package/hooks/hooks_constants/issue_tracker_session_starter_constants.py

@@ -0,0 +1,23 @@
+"""Constants for the repository-gated issue-tracker SessionStart starter.
+
+Default off. Set CLAUDE_ISSUE_TRACKER_SESSION_STARTER_ENABLED to 1/true/yes/on.
+Even when enabled, injects only when the session cwd's git root is registered
+in ~/.claude/project-paths.json. Missing registry fails closed (no inject).
+"""
+
+from __future__ import annotations
+
+ISSUE_TRACKER_SESSION_STARTER_ENABLED_ENV_VAR: str = (
+    "CLAUDE_ISSUE_TRACKER_SESSION_STARTER_ENABLED"
+)
+ALL_ISSUE_TRACKER_STARTER_ENABLED_ENV_VALUES: frozenset[str] = frozenset(
+    {"1", "true", "yes", "on"}
+)
+ISSUE_TRACKER_STARTER_TIMEOUT_MILLISECONDS: int = 50
+
+ISSUE_TRACKER_SESSION_START_DIRECTIVE: str = (
+    "SessionStart issue-tracker opt-in is active for this registered repository. "
+    "Load the issue-tracker skill when the session needs one GitHub issue action "
+    "(open epic, file sub-issue, update status, refresh checklist, close sub-issue). "
+    "Manual issue-tracker agent spawn remains available unchanged."
+)

package/hooks/hooks_constants/orchestrator_auto_starter_constants.py

@@ -0,0 +1,23 @@
+"""Constants for the opt-in orchestrator SessionStart auto-starter.
+
+Default off. Set CLAUDE_ORCHESTRATOR_AUTO_STARTER_ENABLED to 1/true/yes/on to
+emit an additionalContext directive that points the session at the orchestrator
+skill. Manual /orchestrator invocation is unchanged.
+"""
+
+from __future__ import annotations
+
+ORCHESTRATOR_AUTO_STARTER_ENABLED_ENV_VAR: str = (
+    "CLAUDE_ORCHESTRATOR_AUTO_STARTER_ENABLED"
+)
+ALL_ORCHESTRATOR_STARTER_ENABLED_ENV_VALUES: frozenset[str] = frozenset(
+    {"1", "true", "yes", "on"}
+)
+ORCHESTRATOR_STARTER_TIMEOUT_MILLISECONDS: int = 50
+
+ORCHESTRATOR_SESSION_START_DIRECTIVE: str = (
+    "SessionStart orchestrator opt-in is active. Load the orchestrator skill "
+    "and run in executor-advisor mode for this session's multi-step work. "
+    "Do not invent a second orchestrator path; follow the skill. Manual "
+    "/orchestrator remains available unchanged."
+)

package/hooks/hooks_constants/piped_pytest_blocker_constants.py

@@ -13,7 +13,10 @@ flags from its first operand, the wrapper commands whose run passes through to
 the program behind them, the separator that rejoins a wrapper's argument
 tokens, the empty commenter set that leaves ``#`` to the comment-start pattern,
 the quote characters stripped before a basename read, and the deny message.
-Segment helpers come from ``shell_command_segments.py``.
+Segment helpers come from ``shell_command_segments.py``. Quote-aware pipeline
+parsing lives in ``shell_command_pipeline``. Pytest invocation classification
+that consumes these program, wrapper, and option constants lives in
+``pytest_invocation``.
 
 Two wrapper shapes reach the program behind them differently. ``sudo`` and
 ``uvx`` take their own option flags and then the command, so the step-over drops