claude-dev-env 2.9.0 → 2.11.0

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

package/hooks/hooks_constants/plain_language_blocker_constants.py

@@ -18,7 +18,9 @@ strippers the word scan runs first, and the lean-question-block tunables: the
 block-level chat-detail markers that belong in chat text, the line-ending
 spellings normalized before those markers run, the inline-code span the length
 counts collapse to one word, and the sentence and word caps a question and an
-option description each answer to.
+option description each answer to. The pure analyzer in
+``ask_user_question_shape`` reads the same lean-block tunables so shape grading
+and the runtime hook share one contract.
 """
 
 from __future__ import annotations
@@ -352,6 +354,7 @@ OPTION_DESCRIPTION_SURFACE_NAME: str = "an option description"
 
 LEAN_QUESTION_BLOCK_PREFIX: str = "BLOCKED: [LEAN_QUESTION] Question block carries chat detail -- "
 LEAN_QUESTION_VIOLATION_SEPARATOR: str = "; "
+HEAVY_WORD_SWAP_LIST_SEPARATOR: str = ", "
 LEAN_QUESTION_BLOCK_GUIDANCE: str = (
     "AskUserQuestion renders as one plain text block. Print the plan, the counts, "
     "and the tradeoffs in chat text before the call, keep the question block to a "

package/hooks/hooks_constants/pre_tool_use_dispatcher_constants.py

@@ -16,6 +16,8 @@ __all__ = [
     "BLOCKING_CRASH_EXIT_CODE",
     "EXIT_CODE_TWO_DENY_REASON",
     "BLOCKING_CRASH_DENY_REASON",
+    "REASON_JOIN_SEPARATOR",
+    "CONTEXT_JOIN_SEPARATOR",
     "WRITE_TOOL_NAME",
     "EDIT_TOOL_NAME",
     "MULTI_EDIT_TOOL_NAME",
@@ -23,6 +25,7 @@ __all__ = [
     "ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES",
     "STATE_DESCRIPTION_BLOCKER_MODULE_NAME",
     "PLAIN_LANGUAGE_BLOCKER_MODULE_NAME",
+    "SYSTEM_MESSAGE_JOIN_SEPARATOR",
     "HostedHookEntry",
     "ALL_HOSTED_HOOK_ENTRIES",
 ]
@@ -30,9 +33,12 @@ __all__ = [
 DENY_DECISION = "deny"
 ALLOW_DECISION = "allow"
 HOOK_EVENT_NAME = "PreToolUse"
+SYSTEM_MESSAGE_JOIN_SEPARATOR = "\n"
 BLOCKING_CRASH_EXIT_CODE = 2
 EXIT_CODE_TWO_DENY_REASON = "[dispatcher] hook denied via exit code 2 — write blocked"
 BLOCKING_CRASH_DENY_REASON = "[dispatcher] hook crash in blocking hook — write blocked for safety"
+REASON_JOIN_SEPARATOR = " | "
+CONTEXT_JOIN_SEPARATOR = "\n"
 
 WRITE_TOOL_NAME = "Write"
 EDIT_TOOL_NAME = "Edit"

package/hooks/hooks_constants/project_paths_reader.py

@@ -8,8 +8,11 @@ import os
 from pathlib import Path
 
 from hooks_constants.dynamic_stderr_handler import DynamicStderrHandler
-from hooks_constants.setup_project_paths_constants import META_KEY, UTF8_ENCODING
-
+from hooks_constants.setup_project_paths_constants import (
+    GIT_DIRECTORY_SEGMENT_NAME,
+    META_KEY,
+    UTF8_ENCODING,
+)
 
 _logger = logging.getLogger("project_paths_reader")
 if not _logger.handlers:
@@ -34,6 +37,30 @@ def _normalize_path_separators(raw_path: str) -> str:
     return os.path.normcase(os.path.normpath(forward_slash_form)).replace("\\", "/")
 
 
+def find_git_root(start_path: str) -> str | None:
+    """Walk upward for .git; stop at home or filesystem root.
+
+    Home bound prevents a parent .git above the user home from becoming the
+    session repo root (same contract as the untracked-repo SessionStart hook).
+
+    Args:
+        start_path: Directory to begin the upward walk.
+
+    Returns:
+        Absolute path of the git root, or None when none is found in bounds.
+    """
+    home_directory = Path.home().resolve()
+    candidate = Path(start_path).resolve()
+    while True:
+        if (candidate / GIT_DIRECTORY_SEGMENT_NAME).exists():
+            return str(candidate)
+        if candidate == home_directory:
+            return None
+        parent = candidate.parent
+        if parent == candidate:
+            return None
+        candidate = parent
+
 def load_registry(config_path: Path | None = None) -> dict[str, str]:
     """Return the name-to-absolute-path mapping with the _meta key stripped.
 
@@ -65,14 +92,14 @@ def load_registry(config_path: Path | None = None) -> dict[str, str]:
     }
 
 
-def registry_contains_path(known_registry: dict[str, str], path_to_find: str) -> bool:
+def registry_contains_path(all_known_registry: dict[str, str], path_to_find: str) -> bool:
     """Return True when the given path appears as any registry value.
 
     Normalizes both sides before comparing so Windows and POSIX separator
     forms of the same path compare equal.
     """
     normalized_target = _normalize_path_separators(path_to_find)
-    for each_registered_path in known_registry.values():
+    for each_registered_path in all_known_registry.values():
         if _normalize_path_separators(each_registered_path) == normalized_target:
             return True
     return False

package/hooks/hooks_constants/prose_matcher_precision_constants.py

@@ -0,0 +1,40 @@
+"""Thresholds and paths for prose-matcher precision measurement (OP-07B).
+
+::
+
+    labeled count < SAMPLE_FLOOR_PER_MATCHER  -> remain advisory
+    precision >= KEEP_PRECISION_FLOOR         -> keep
+    precision >= NARROW_PRECISION_FLOOR       -> narrow
+    otherwise                                 -> drop
+
+No matcher becomes hard-blocking from historical labels alone; classification
+only records keep/narrow/drop/advisory for the observation window.
+"""
+
+from __future__ import annotations
+
+ADVISORY_LOG_RELATIVE_PATH = ".claude/logs/prose-matcher-advisory.jsonl"
+SAMPLE_FLOOR_PER_MATCHER = 30
+KEEP_PRECISION_FLOOR = 0.7
+NARROW_PRECISION_FLOOR = 0.4
+MATCHER_ID_PLAIN_LANGUAGE_HEAVY_WORD = "plain_language_heavy_word"
+MATCHER_ID_HEDGING_WORD = "hedging_word"
+ALL_KNOWN_MATCHER_IDS = (
+    MATCHER_ID_PLAIN_LANGUAGE_HEAVY_WORD,
+    MATCHER_ID_HEDGING_WORD,
+)
+DECISION_TRUE_POSITIVE = "true_positive"
+DECISION_FALSE_POSITIVE = "false_positive"
+DECISION_UNLABELED = "unlabeled"
+ALL_LABEL_DECISIONS = (
+    DECISION_TRUE_POSITIVE,
+    DECISION_FALSE_POSITIVE,
+    DECISION_UNLABELED,
+)
+CLASSIFICATION_KEEP = "keep"
+CLASSIFICATION_NARROW = "narrow"
+CLASSIFICATION_DROP = "drop"
+CLASSIFICATION_ADVISORY = "advisory"
+CONTEXT_FINGERPRINT_HEX_LENGTH = 16
+MAXIMUM_ADVISORY_EMITS_PER_CALL = 5
+ADVISORY_CONTEXT_SNIPPET_MAX_CHARS = 120