claude-dev-env 2.9.0 → 2.11.0

package/hooks/hooks_constants/shell_command_pipeline.py

@@ -0,0 +1,397 @@
+"""Quote-aware shell command pipeline parsing.
+
+Turns one Bash command string into operator-paired simple-command segments after
+line-continuation join, comment strip, heredoc body drop, and parenthesis-group
+join::
+
+    scannable_command_lines("pytest tests | tee out.log")
+        -> ["pytest tests | tee out.log"]
+    segments_with_following_operator(["pytest", "tests", "|", "tee", "out.log"])
+        -> [(["pytest", "tests"], "|"), (["tee", "out.log"], "")]
+
+No pytest classification and no deny decision live here. Callers that need a
+program verdict compose on top of these segments.
+"""
+
+from __future__ import annotations
+
+import shlex
+from typing import NamedTuple
+
+from hooks_constants.piped_pytest_blocker_constants import (
+    ALL_OPERATOR_TOKENS_LONGEST_FIRST,
+    ALL_PIPE_OPERATOR_TOKENS,
+    ALL_REDIRECTION_SUFFIX_CHARACTERS,
+    ALL_SEGMENT_RESET_OPERATOR_TOKENS,
+    CLOSED_GROUP_DEPTH,
+    COMMAND_LINE_SPLIT_PATTERN,
+    COMMENT_START_CHARACTER,
+    COMMENT_START_GROUP,
+    COMMENT_START_SCAN_PATTERN,
+    DISABLED_LEXER_COMMENTERS,
+    GROUP_CLOSE_CHARACTER,
+    GROUP_OPEN_CHARACTER,
+    HEREDOC_OPENER_OPERATOR,
+    HEREDOC_OPENER_PATTERN,
+    HEREDOC_STRIPPED_INDENT_CHARACTERS,
+    HEREDOC_TAB_STRIP_GROUP,
+    HEREDOC_TAB_STRIP_MARKER,
+    HEREDOC_TERMINATOR_GROUP,
+    LINE_CONTINUATION_JOIN,
+    LINE_CONTINUATION_PATTERN,
+    NO_FOLLOWING_OPERATOR,
+    PAREN_GROUP_LINE_JOIN,
+    PUNCTUATION_ONLY_TOKEN_PATTERN,
+    QUOTED_REGION_PATTERN,
+    QUOTED_REGION_REPLACEMENT,
+)
+
+__all__ = [
+    "PendingHeredoc",
+    "all_operator_aware_tokenizations",
+    "all_operator_split_tokens",
+    "all_punctuation_token_parts",
+    "closes_the_heredoc",
+    "command_line_without_comment",
+    "join_line_continuations",
+    "live_command_lines",
+    "paren_group_joined_lines",
+    "pending_heredoc_opened_by",
+    "pipeline_segments_for_command",
+    "scannable_command_lines",
+    "segments_with_following_operator",
+]
+
+
+class PendingHeredoc(NamedTuple):
+    """The word an open heredoc closes on, and how its opener lets that word be indented."""
+
+    terminator: str
+    allows_leading_tabs: bool
+
+
+def join_line_continuations(command: str) -> str:
+    """Return the command with backslash line continuations joined.
+
+    ::
+
+        pytest tests \\\\
+            | tee out.log     ->  "pytest tests | tee out.log"
+
+    Args:
+        command: One Bash command that may carry trailing-backslash continuations.
+
+    Returns:
+        The same command with each continuation removed so the next line sits
+        on the same physical line.
+    """
+    return LINE_CONTINUATION_PATTERN.sub(LINE_CONTINUATION_JOIN, command)
+
+
+def all_operator_aware_tokenizations(command: str) -> list[list[str]]:
+    """Return quote-aware tokenizations that carry operators as their own tokens.
+
+    POSIX mode resolves quoting the way Git Bash does; raw mode keeps a Windows
+    interpreter path such as ``C:\\Python313\\python.exe`` whole, since POSIX
+    mode reads its backslashes as escapes. Both are returned so a caller can
+    grade either spelling.
+
+    The lexer's own commenters are cleared, because it cuts at a ``#`` anywhere
+    in a word while a shell starts a comment only at a word's start.
+    ``command_line_without_comment`` owns comment removal.
+
+    Args:
+        command: One logical Bash command line (continuations already joined).
+
+    Returns:
+        Zero, one, or two non-empty token lists (POSIX and/or raw).
+    """
+    all_tokenizations: list[list[str]] = []
+    for each_posix_mode in (True, False):
+        lexer = shlex.shlex(command, posix=each_posix_mode, punctuation_chars=True)
+        lexer.whitespace_split = True
+        lexer.commenters = DISABLED_LEXER_COMMENTERS
+        try:
+            all_tokens = list(lexer)
+        except ValueError:
+            continue
+        if all_tokens:
+            all_tokenizations.append(all_tokens)
+    return all_tokenizations
+
+
+def _trailing_operator_token(token: str) -> str | None:
+    """Return the longest control operator the token ends with, or None."""
+    for each_operator in ALL_OPERATOR_TOKENS_LONGEST_FIRST:
+        if token.endswith(each_operator):
+            return each_operator
+    return None
+
+
+def all_punctuation_token_parts(token: str) -> list[str]:
+    """Split a punctuation-only token into its leading text and trailing operators.
+
+    ::
+
+        )|      [')', '|']
+        )||     [')', '||']
+        tests   ['tests']
+
+    Args:
+        token: One token from an operator-aware tokenization.
+
+    Returns:
+        The token's parts in original order — a one-item list when no split is needed.
+    """
+    if PUNCTUATION_ONLY_TOKEN_PATTERN.fullmatch(token) is None:
+        return [token]
+    all_peeled_operators: list[str] = []
+    remaining_text = token
+    while True:
+        trailing_operator = _trailing_operator_token(remaining_text)
+        if trailing_operator is None or trailing_operator == remaining_text:
+            break
+        leading_text = remaining_text[: -len(trailing_operator)]
+        if leading_text.endswith(ALL_REDIRECTION_SUFFIX_CHARACTERS):
+            break
+        all_peeled_operators.append(trailing_operator)
+        remaining_text = leading_text
+    return [remaining_text, *reversed(all_peeled_operators)]
+
+
+def all_operator_split_tokens(all_command_tokens: list[str]) -> list[str]:
+    """Return the tokens with every glued punctuation-and-operator token split apart.
+
+    Args:
+        all_command_tokens: Tokens from an operator-aware tokenization.
+
+    Returns:
+        Tokens with glued punctuation operators peeled into their own items.
+    """
+    all_split_tokens: list[str] = []
+    for each_token in all_command_tokens:
+        all_split_tokens.extend(all_punctuation_token_parts(each_token))
+    return all_split_tokens
+
+
+def segments_with_following_operator(
+    all_command_tokens: list[str],
+) -> list[tuple[list[str], str]]:
+    """Pair each simple-command segment with the control operator that ends it.
+
+    A redirection token stays inside its segment. A close paren stays inside too,
+    so a subshell's program survives to the pipe that follows it.
+
+    Args:
+        all_command_tokens: Tokens from an operator-aware tokenization.
+
+    Returns:
+        ``(segment_tokens, following_operator)`` pairs; the last pair carries
+        an empty following operator when the command ends without one.
+    """
+    all_segments: list[tuple[list[str], str]] = []
+    current_segment: list[str] = []
+    for each_token in all_operator_split_tokens(all_command_tokens):
+        if (
+            each_token in ALL_PIPE_OPERATOR_TOKENS
+            or each_token in ALL_SEGMENT_RESET_OPERATOR_TOKENS
+        ):
+            all_segments.append((current_segment, each_token))
+            current_segment = []
+            continue
+        current_segment.append(each_token)
+    all_segments.append((current_segment, NO_FOLLOWING_OPERATOR))
+    return all_segments
+
+
+def pending_heredoc_opened_by(command_line: str) -> PendingHeredoc | None:
+    """Return the heredoc the line opens, or None when it opens none.
+
+    ::
+
+        cat > run.sh <<EOF     PendingHeredoc('EOF', allows_leading_tabs=False)
+        cat > run.sh <<-EOF    PendingHeredoc('EOF', allows_leading_tabs=True)
+        cat file <<<word       None
+        echo hi                None
+
+    Args:
+        command_line: One physical command line.
+
+    Returns:
+        The pending heredoc, or None when the line opens none.
+    """
+    heredoc_opener = HEREDOC_OPENER_PATTERN.search(command_line)
+    if heredoc_opener is None:
+        return None
+    return PendingHeredoc(
+        terminator=heredoc_opener.group(HEREDOC_TERMINATOR_GROUP),
+        allows_leading_tabs=(
+            heredoc_opener.group(HEREDOC_TAB_STRIP_GROUP) == HEREDOC_TAB_STRIP_MARKER
+        ),
+    )
+
+
+def closes_the_heredoc(command_line: str, pending_heredoc: PendingHeredoc) -> bool:
+    """Return True when the line is the terminator its opener spelled.
+
+    Args:
+        command_line: One physical command line inside an open heredoc.
+        pending_heredoc: The opener that is still waiting to close.
+
+    Returns:
+        True when this line ends the heredoc body.
+    """
+    if pending_heredoc.allows_leading_tabs:
+        return (
+            command_line.lstrip(HEREDOC_STRIPPED_INDENT_CHARACTERS)
+            == pending_heredoc.terminator
+        )
+    return command_line == pending_heredoc.terminator
+
+
+def live_command_lines(all_command_lines: list[str]) -> list[str]:
+    """Return the lines the call runs, dropping every heredoc body and terminator.
+
+    Args:
+        all_command_lines: The physical lines of one Bash command, in order.
+
+    Returns:
+        The lines outside every heredoc body, in their original order.
+    """
+    all_live_lines: list[str] = []
+    pending_heredoc: PendingHeredoc | None = None
+    for each_line in all_command_lines:
+        if pending_heredoc is not None:
+            if closes_the_heredoc(each_line, pending_heredoc):
+                pending_heredoc = None
+            continue
+        all_live_lines.append(each_line)
+        pending_heredoc = pending_heredoc_opened_by(each_line)
+    return all_live_lines
+
+
+def command_line_without_comment(command_line: str) -> str:
+    """Return the line with a shell comment and everything after it removed.
+
+    ::
+
+        python -m pytest tests  # fast   ->  python -m pytest tests
+        pytest -k "a#b"                  ->  unchanged (hash inside quotes)
+        tee run#1.log                    ->  unchanged (hash inside a word)
+
+    Args:
+        command_line: One physical command line.
+
+    Returns:
+        The line up to its comment, or the whole line when it carries none.
+    """
+    for each_match in COMMENT_START_SCAN_PATTERN.finditer(command_line):
+        if each_match.group(COMMENT_START_GROUP) is not None:
+            return command_line[: each_match.start(COMMENT_START_GROUP)]
+    return command_line
+
+
+def _comment_free_lines(all_command_lines: list[str]) -> list[str]:
+    """Return every line with its shell comment removed.
+
+    Args:
+        all_command_lines: The physical lines of one Bash command, in order.
+
+    Returns:
+        The comment-free lines, in their original order and count.
+    """
+    return [command_line_without_comment(each_line) for each_line in all_command_lines]
+
+
+def _paren_depth_change(command_line: str) -> int:
+    """Return how many parenthesis groups the line opens, minus the ones it closes."""
+    unquoted_line = QUOTED_REGION_PATTERN.sub(QUOTED_REGION_REPLACEMENT, command_line)
+    return unquoted_line.count(GROUP_OPEN_CHARACTER) - unquoted_line.count(
+        GROUP_CLOSE_CHARACTER
+    )
+
+
+def paren_group_joined_lines(all_command_lines: list[str]) -> list[str]:
+    """Return the lines with each open parenthesis group joined into one logical line.
+
+    Args:
+        all_command_lines: Live command lines, comments removed and heredoc bodies dropped.
+
+    Returns:
+        One line per closed parenthesis group, and the unchanged line for every other.
+    """
+    all_joined_lines: list[str] = []
+    all_pending_lines: list[str] = []
+    open_group_depth = CLOSED_GROUP_DEPTH
+    for each_line in all_command_lines:
+        all_pending_lines.append(each_line)
+        open_group_depth = max(
+            open_group_depth + _paren_depth_change(each_line), CLOSED_GROUP_DEPTH
+        )
+        if open_group_depth > CLOSED_GROUP_DEPTH:
+            continue
+        all_joined_lines.append(PAREN_GROUP_LINE_JOIN.join(all_pending_lines))
+        all_pending_lines = []
+    if all_pending_lines:
+        all_joined_lines.append(PAREN_GROUP_LINE_JOIN.join(all_pending_lines))
+    return all_joined_lines
+
+
+def scannable_command_lines(joined_command: str) -> list[str]:
+    """Return the lines to tokenize, running only the passes the command's text calls for.
+
+    ::
+
+        pytest tests | tee x            split only
+        pytest tests  # | tee x         comment pass runs
+        (pytest tests) | tee x          parenthesis-group join runs
+        cat <<EOF ... EOF               heredoc pass runs
+
+    Args:
+        joined_command: One Bash command, its line continuations already joined.
+
+    Returns:
+        The command lines ready for tokenization.
+    """
+    all_command_lines = COMMAND_LINE_SPLIT_PATTERN.split(joined_command)
+    if COMMENT_START_CHARACTER in joined_command:
+        all_command_lines = _comment_free_lines(all_command_lines)
+    if HEREDOC_OPENER_OPERATOR in joined_command:
+        all_command_lines = live_command_lines(all_command_lines)
+    if GROUP_OPEN_CHARACTER not in joined_command:
+        return all_command_lines
+    return paren_group_joined_lines(all_command_lines)
+
+
+def pipeline_segments_for_command(
+    command: str,
+) -> list[tuple[list[str], str]]:
+    """Return every operator-paired segment across every quote-aware tokenization.
+
+    Joins line continuations, builds scannable lines, tokenizes each, and pairs
+    segments with the control operator that follows them. Duplicate segment
+    pairs from the two tokenizations are kept only once, in first-seen order.
+
+    Args:
+        command: One Bash command as the tool would receive it.
+
+    Returns:
+        ``(segment_tokens, following_operator)`` pairs ready for a caller to
+        grade, with no program classification applied.
+    """
+    joined_command = join_line_continuations(command)
+    all_pairs: list[tuple[list[str], str]] = []
+    seen_pair_keys: set[tuple[tuple[str, ...], str]] = set()
+    for each_line in scannable_command_lines(joined_command):
+        if not each_line.strip():
+            continue
+        for each_tokenization in all_operator_aware_tokenizations(each_line):
+            for each_segment, each_operator in segments_with_following_operator(
+                each_tokenization
+            ):
+                pair_key = (tuple(each_segment), each_operator)
+                if pair_key in seen_pair_keys:
+                    continue
+                seen_pair_keys.add(pair_key)
+                all_pairs.append((each_segment, each_operator))
+    return all_pairs

package/hooks/hooks_constants/shell_command_segments.py

@@ -4,6 +4,11 @@ Tokenizes a command into simple-command segments on control operators and finds
 each segment's effective leading program after env assignments and launcher
 wrappers. NAS ssh enforcement and unscoped-search blocking both need this
 shape, so one module owns it.
+
+``split_into_segments`` is not quote-aware: a pipe inside ``-k "a|b"`` still
+splits. Quote-aware pipeline parsing — operators as their own tokens, heredoc
+bodies dropped, parenthesis groups joined — lives in
+``shell_command_pipeline``.
 """
 
 from __future__ import annotations

package/hooks/hooks_constants/test_ask_user_question_shape.py

@@ -0,0 +1,167 @@
+"""Payload-shape fixtures for the pure AskUserQuestion analyzer.
+
+Grades lean-block shape without hook I/O. Each case names one marker or cap
+the PR #720 contract preserves.
+"""
+
+from __future__ import annotations
+
+import pathlib
+import sys
+
+_HOOKS_ROOT = pathlib.Path(__file__).resolve().parent.parent
+if str(_HOOKS_ROOT) not in sys.path:
+    sys.path.insert(0, str(_HOOKS_ROOT))
+
+from hooks_constants.ask_user_question_shape import (  # noqa: E402
+    analyze_ask_user_question_shape,
+    count_prose_words,
+    find_question_block_violations,
+    mask_inline_code,
+    normalize_line_endings,
+)
+from hooks_constants.plain_language_blocker_constants import (  # noqa: E402
+    MAXIMUM_OPTION_DESCRIPTION_WORD_COUNT,
+    MAXIMUM_QUESTION_SENTENCE_COUNT,
+    MAXIMUM_QUESTION_WORD_COUNT,
+)
+
+LEAN_QUESTION = "Which gate should run first?"
+LEAN_DESCRIPTION = "Runs on every write."
+
+
+def _ask_payload(
+    question_text: str,
+    all_descriptions: list[str],
+) -> dict[str, object]:
+    return {
+        "questions": [
+            {
+                "question": question_text,
+                "options": [
+                    {"label": f"Option {each_index}", "description": each_description}
+                    for each_index, each_description in enumerate(all_descriptions, start=1)
+                ],
+            }
+        ]
+    }
+
+
+def test_lean_payload_is_clean() -> None:
+    result = analyze_ask_user_question_shape(
+        _ask_payload(LEAN_QUESTION, [LEAN_DESCRIPTION])
+    )
+    assert result.is_lean
+    assert result.all_violations == ()
+
+
+def test_list_marker_under_question_is_flagged() -> None:
+    plan_question = f"{LEAN_QUESTION}\n- Split the file\n- Wire the gate"
+    result = analyze_ask_user_question_shape(
+        _ask_payload(plan_question, [LEAN_DESCRIPTION])
+    )
+    assert not result.is_lean
+    assert any("list marker" in each for each in result.all_violations)
+
+
+def test_fenced_block_is_flagged() -> None:
+    fenced_question = f"{LEAN_QUESTION}\n```\nrun_gate()\n```"
+    result = analyze_ask_user_question_shape(
+        _ask_payload(fenced_question, [LEAN_DESCRIPTION])
+    )
+    assert any("fenced code block" in each for each in result.all_violations)
+
+
+def test_second_paragraph_is_flagged() -> None:
+    two_paragraph_question = f"{LEAN_QUESTION}\n\nThe write gate reads every file."
+    result = analyze_ask_user_question_shape(
+        _ask_payload(two_paragraph_question, [LEAN_DESCRIPTION])
+    )
+    assert any("more than one paragraph" in each for each in result.all_violations)
+
+
+def test_carriage_return_paragraph_break_is_flagged() -> None:
+    crlf_question = f"{LEAN_QUESTION}\r\n\r\nThe write gate reads every file."
+    result = analyze_ask_user_question_shape(
+        _ask_payload(crlf_question, [LEAN_DESCRIPTION])
+    )
+    assert any("more than one paragraph" in each for each in result.all_violations)
+
+
+def test_heading_is_flagged() -> None:
+    headed_question = f"{LEAN_QUESTION}\n## The write gate\nIt reads every file."
+    result = analyze_ask_user_question_shape(
+        _ask_payload(headed_question, [LEAN_DESCRIPTION])
+    )
+    assert any("heading" in each for each in result.all_violations)
+
+
+def test_table_row_in_option_is_flagged() -> None:
+    result = analyze_ask_user_question_shape(
+        _ask_payload(LEAN_QUESTION, ["| gate | 12 ms |"])
+    )
+    assert any("table row" in each for each in result.all_violations)
+
+
+def test_question_over_word_cap_is_flagged() -> None:
+    over_cap = " ".join(["word"] * (MAXIMUM_QUESTION_WORD_COUNT + 1))
+    result = analyze_ask_user_question_shape(_ask_payload(over_cap, [LEAN_DESCRIPTION]))
+    assert any("word" in each and "cap" in each for each in result.all_violations)
+
+
+def test_question_over_sentence_cap_is_flagged() -> None:
+    three_sentences = "One. Two. Three."
+    assert MAXIMUM_QUESTION_SENTENCE_COUNT < 3
+    result = analyze_ask_user_question_shape(
+        _ask_payload(three_sentences, [LEAN_DESCRIPTION])
+    )
+    assert any("sentence" in each and "cap" in each for each in result.all_violations)
+
+
+def test_option_description_over_word_cap_is_flagged() -> None:
+    over_cap = " ".join(["word"] * (MAXIMUM_OPTION_DESCRIPTION_WORD_COUNT + 1))
+    result = analyze_ask_user_question_shape(_ask_payload(LEAN_QUESTION, [over_cap]))
+    assert any(
+        "option description" in each and "word" in each for each in result.all_violations
+    )
+
+
+def test_option_description_over_sentence_cap_is_flagged() -> None:
+    result = analyze_ask_user_question_shape(
+        _ask_payload(LEAN_QUESTION, ["Runs on write. Reads every file."])
+    )
+    assert any(
+        "option description" in each and "sentence" in each
+        for each in result.all_violations
+    )
+
+
+def test_inline_code_counts_as_one_word() -> None:
+    masked = mask_inline_code("Does `git diff --cached --stat` list it?")
+    assert count_prose_words(masked) == count_prose_words("Does code list it?")
+
+
+def test_normalize_line_endings_folds_crlf() -> None:
+    assert normalize_line_endings("a\r\nb\rc") == "a\nb\nc"
+
+
+def test_duplicate_faults_report_once() -> None:
+    tool_input: dict[str, object] = {
+        "questions": [
+            {
+                "question": LEAN_QUESTION,
+                "options": [
+                    {"label": "A", "description": "| a | b |"},
+                    {"label": "B", "description": "| c | d |"},
+                ],
+            }
+        ]
+    }
+    all_violations = find_question_block_violations(tool_input)
+    table_faults = [each for each in all_violations if "table row" in each]
+    assert len(table_faults) == 1
+
+
+def test_non_dict_questions_list_is_clean() -> None:
+    result = analyze_ask_user_question_shape({"questions": "not-a-list"})
+    assert result.is_lean

package/hooks/hooks_constants/test_project_paths_reader.py

@@ -4,6 +4,7 @@ import inspect
 import json
 import sys
 from pathlib import Path
+from unittest.mock import patch
 
 import pytest
 
@@ -13,6 +14,7 @@ if str(_HOOKS_ROOT) not in sys.path:
 
 from hooks_constants import project_paths_reader
 from hooks_constants.project_paths_reader import (
+    find_git_root,
     load_registry,
     registry_contains_path,
     registry_file_path,
@@ -147,3 +149,30 @@ def test_load_registry_uses_shared_utf8_encoding_constant() -> None:
     assert 'encoding="utf-8"' not in source, (
         'load_registry must use UTF8_ENCODING constant, not the bare literal "utf-8"'
     )
+
+
+def test_find_git_root_returns_root_for_nested_path(tmp_path: Path) -> None:
+    repo_root = tmp_path / "repo"
+    nested = repo_root / "pkg"
+    nested.mkdir(parents=True)
+    (repo_root / ".git").mkdir()
+    found = find_git_root(str(nested))
+    assert found is not None
+    assert Path(found).resolve() == repo_root.resolve()
+
+
+def test_find_git_root_returns_none_without_git(tmp_path: Path) -> None:
+    bare = tmp_path / "bare"
+    bare.mkdir()
+    original_exists = Path.exists
+
+    def exists_without_ambient_git(self_path: Path) -> bool:
+        if self_path.name == ".git":
+            resolved_parent = self_path.resolve().parent
+            if resolved_parent == bare.resolve() or bare.resolve() in resolved_parent.parents:
+                return original_exists(self_path)
+            return False
+        return original_exists(self_path)
+
+    with patch.object(Path, "exists", exists_without_ambient_git):
+        assert find_git_root(str(bare)) is None

package/hooks/hooks_constants/test_prose_metrics_parity.py

@@ -35,6 +35,9 @@ from hooks_constants.eli11_reply_enforcer_constants import (
 from hooks_constants.eli11_reply_enforcer_constants import (
     COUNTABLE_WORD_PATTERN as ELI11_COUNTABLE_WORD_PATTERN,
 )
+from hooks_constants.ask_user_question_shape import (
+    COUNTABLE_WORD_PATTERN as SHAPE_COUNTABLE_WORD_PATTERN,
+)
 from hooks_constants.plain_language_blocker_constants import ALL_CHAT_DETAIL_MARKERS
 from hooks_constants.plain_language_blocker_constants import (
     COUNTABLE_WORD_PATTERN as PLAIN_LANGUAGE_COUNTABLE_WORD_PATTERN,
@@ -102,6 +105,11 @@ def test_countable_word_pattern_copies_stay_byte_equal() -> None:
     )
 
 
+def test_shape_analyzer_binds_the_plain_language_countable_word_pattern() -> None:
+    """The pure shape analyzer reuses the shared pattern object, not a private copy."""
+    assert SHAPE_COUNTABLE_WORD_PATTERN is PLAIN_LANGUAGE_COUNTABLE_WORD_PATTERN
+
+
 def test_table_row_pattern_copies_stay_byte_equal() -> None:
     plain_language_table_row = _chat_detail_marker_named(_TABLE_ROW_MARKER_LABEL)
     assert plain_language_table_row.pattern == TABLE_ROW_PATTERN.pattern