scripts/nl_controls.py

"""Natural-language control phrases for Universal Brain chat.

This is a lightweight, deterministic pre-router for actions that should not depend on
LLM JSON routing (and should work without requiring users to remember slash commands).

It is intentionally conservative: it only triggers on fairly explicit phrasing.
"""

from __future__ import annotations

from dataclasses import dataclass
import re


@dataclass(frozen=True)
class ControlAction:
    name: str
    value: str | None = None


_WS = re.compile(r"\s+")


def _norm(s: str) -> str:
    return _WS.sub(" ", (s or "").strip().lower())


def parse_control_action(message: str) -> ControlAction | None:
    """Return a ControlAction if the message is a natural-language control request."""
    m = _norm(message)
    if not m:
        return None

    # "What mode is this? What session/scope am I in?"
    if re.search(r"\b(what|show)\b.*\b(my )?(session|scope|settings|mode|status)\b", m) or re.search(
        r"\bwhich\b.*\b(scope|session)\b", m
    ):
        return ControlAction("show_session")

    # Start a fresh private session (new scope key).
    if re.search(r"\b(new|fresh)\b.*\b(private )?(session|scope)\b", m) or re.search(
        r"\b(start|begin)\b.*\b(private )?(session|scope)\b", m
    ):
        return ControlAction("new_private_session")

    # Switch to a named scope in chat, e.g. "use scope abc-123" / "switch to session foo".
    m2 = re.search(r"\b(use|switch to|set)\b.*\b(scope|session)\b\s*[:=]?\s*([a-z0-9][a-z0-9_.:-]{1,63})\b", m)
    if m2:
        return ControlAction("set_scope", m2.group(3))

    # Memory controls (order matters: list/show before export/download)
    if re.search(
        r"\b(show|list)\b.*\b(my )?(data|memory|memories|notes)\b",
        m,
    ):
        return ControlAction("list_memories")
    if re.search(
        r"\b(export|download)\b.*\b(my )?(data|memory|memories|notes)\b",
        m,
    ):
        return ControlAction("export_memory")
    if re.search(r"\b(clear|wipe|delete|forget)\b.*\b(session)\b.*\b(memory|memories|notes)?\b", m):
        return ControlAction("clear_session")
    if re.search(r"\b(forget|delete|erase|wipe)\b.*\b(all|everything)\b.*\b(memory|memories|notes|data)\b", m) or re.search(
        r"\b(delete|erase)\b.*\b(my )?(data|account data|data for this chat)\b", m
    ):
        return ControlAction("forget_scope")

    # Session toggles (chat UX) — short lines only so long questions are not hijacked
    # (e.g. "Show the brain trace. … outline a stakeholder map …" must stay normal chat).
    if len(m) <= 120:
        if re.search(r"\b(turn on|enable|show)\b.*\b(trace|brain trace|debug)\b", m):
            return ControlAction("set_trace", "on")
        if re.search(r"\b(turn off|disable|hide)\b.*\b(trace|brain trace|debug)\b", m):
            return ControlAction("set_trace", "off")

        if re.search(r"\b(turn on|enable)\b.*\b(smart routing|auto routing|router)\b", m):
            return ControlAction("set_smart_route", "on")
        if re.search(r"\b(turn off|disable)\b.*\b(smart routing|auto routing|router)\b", m):
            return ControlAction("set_smart_route", "off")

        if re.search(r"\b(turn on|enable)\b.*\b(faq|rag|retrieval)\b", m):
            return ControlAction("set_rag", "on")
        if re.search(r"\b(turn off|disable)\b.*\b(faq|rag|retrieval)\b", m):
            return ControlAction("set_rag", "off")

    # Reply style for the generative model (short lines only to avoid hijacking real questions).
    # Require "reply"/"answer" before style|format|length so phrases like "default quote style" / "reset tables"
    # are handled by narrower matchers below.
    if len(m) <= 140 and (
        re.search(r"\breset\b.*\b(reply|answer)\s+(style|format|length)\b", m)
        or re.search(r"\b(default|normal)\b.*\b(reply|answer)\s+(style|format|length)\b", m)
    ):
        return ControlAction("reset_reply_style")

    if len(m) <= 96 and re.search(
        r"\b(be brief|stay brief|keep it short|short answers|answer briefly|concise replies)\b",
        m,
    ):
        return ControlAction("set_verbosity", "brief")

    if len(m) <= 120 and re.search(
        r"\b(more detail|go deeper|in greater detail|explain thoroughly|longer answers|detailed answers)\b",
        m,
    ):
        return ControlAction("set_verbosity", "detailed")

    if len(m) <= 100 and re.search(
        r"\b(normal (answer )?length|default length|balanced length)\b",
        m,
    ):
        return ControlAction("set_verbosity", "normal")

    if len(m) <= 110 and re.search(r"\b(use|prefer)\b", m) and re.search(
        r"\b(bullet points?|numbered lists?)\b",
        m,
    ):
        return ControlAction("set_reply_format", "bullets")

    if len(m) <= 100 and re.search(
        r"\b(no bullets|plain paragraphs?|prose only|stop using lists)\b",
        m,
    ):
        return ControlAction("set_reply_format", "prose")

    # FAQ / RAG grounding hints for the assistant (short control lines).
    if len(m) <= 100 and re.search(
        r"\b(strict faq|faq only|stick to (the )?faq|only use (the )?faq|only trust (the )?faq)\b",
        m,
    ):
        return ControlAction("set_faq_grounding", "strict")

    if len(m) <= 115 and re.search(
        r"\b(balanced faq|normal faq|default faq(\s+grounding)?|default faq mode)\b",
        m,
    ):
        return ControlAction("set_faq_grounding", "normal")

    if len(m) <= 130 and re.search(
        r"\b(relaxed faq|faq plus general knowledge|general knowledge(\s+is)?\s+ok|mix faq and general knowledge)\b",
        m,
    ):
        return ControlAction("set_faq_grounding", "relaxed")

    # Explanation depth (who the answer is for) — short control lines only.
    if (
        (len(m) <= 40 and re.match(r"^(please\s+)?explain simply[\s.!?]*$", m))
        or re.match(r"^(please\s+)?eli5\b[\s.!?]*$", m)
        or (len(m) <= 56 and re.search(r"\b(i'?m\s+a\s+beginner|beginner\s+here)\b", m))
        or re.match(r"^(please\s+)?assume i'?m\s+new\b[\s.!?]*$", m)
        or (len(m) <= 56 and re.search(r"\bi\s+need\s+(the\s+)?basics\b", m))
    ):
        return ControlAction("set_audience", "simple")

    if len(m) <= 72 and (
        re.match(r"^(please\s+)?assume i'?m\s+technical[\s.!?]*$", m)
        or re.match(r"^expert\s+mode[\s.!?]*$", m)
        or re.match(r"^(please\s+)?use jargon freely[\s.!?]*$", m)
        or re.match(r"^technical audience[\s.!?]*$", m)
        or re.match(r"^for experts[\s.!?]*$", m)
    ):
        return ControlAction("set_audience", "technical")

    if len(m) <= 78 and (
        re.match(r"^(please\s+)?(default explanation level|normal explanation level|general audience)[\s.!?]*$", m)
        or re.match(r"^(please\s+)?(reset|default)\s+audience[\s.!?]*$", m)
    ):
        return ControlAction("set_audience", "normal")

    # Answer lead — whether to front-load a TL;DR line (orthogonal to verbosity).
    if len(m) <= 88 and (
        re.match(r"^(please\s+)?(tl;|tl)dr\s+first\b[\s.!?]*$", m)
        or re.match(r"^(please\s+)?(lead|start)\s+with\s+(a\s+)?(short\s+)?summary\b[\s.!?]*$", m)
        or re.match(r"^(please\s+)?summary\s+first\b[\s.!?]*$", m)
    ):
        return ControlAction("set_answer_lead", "tldr_first")

    if len(m) <= 92 and (
        re.match(r"^(please\s+)?no\s+tl;?dr\b[\s.!?]*$", m)
        or re.match(r"^(please\s+)?skip (the\s+)?summary\b[\s.!?]*$", m)
        or re.match(r"^(please\s+)?answer directly\b[\s.!?]*$", m)
        or re.match(r"^(please\s+)?direct answer\s+only\b[\s.!?]*$", m)
        or re.match(r"^(please\s+)?without\s+a\s+tldr\b[\s.!?]*$", m)
    ):
        return ControlAction("set_answer_lead", "direct")

    if len(m) <= 64 and (
        re.match(r"^(please\s+)?(default answer structure|normal answer opening|usual\s+opening)[\s.!?]*$", m)
        or re.match(r"^(please\s+)?reset\s+(answer\s+)?opening[\s.!?]*$", m)
    ):
        return ControlAction("set_answer_lead", "normal")

    # Procedures: numbered steps vs continuous prose (orthogonal to bullets).
    if len(m) <= 88 and (
        re.match(r"^(please\s+)?(step by step|step-by-step)[\s.!?]*$", m)
        or re.match(r"^(please\s+)?use numbered steps[\s.!?]*$", m)
        or re.match(r"^(please\s+)?numbered steps\b[\s.!?]*$", m)
        or re.match(r"^(please\s+)?walk me through( the)? steps\b[\s.!?]*$", m)
        or re.match(r"^(please\s+)?break it into steps[\s.!?]*$", m)
    ):
        return ControlAction("set_step_style", "numbered")

    if len(m) <= 92 and (
        re.match(r"^(please\s+)?(no numbered steps|don'?t number steps|skip step numbers)[\s.!?]*$", m)
        or re.match(r"^(please\s+)?(continuous prose|prose without steps)[\s.!?]*$", m)
    ):
        return ControlAction("set_step_style", "continuous")

    if len(m) <= 64 and re.match(r"^(please\s+)?(default step style|normal steps|reset steps)[\s.!?]*$", m):
        return ControlAction("set_step_style", "normal")

    # How hard to hedge / flag limits (orthogonal to FAQ strictness).
    if len(m) <= 94 and (
        re.match(r"^(please\s+)?flag your assumptions[\s.!?]*$", m)
        or re.match(r"^(please\s+)?be explicit about uncertainty[\s.!?]*$", m)
        or re.match(r"^(please\s+)?say if you don'?t know[\s.!?]*$", m)
        or re.match(r"^(please\s+)?tell me when you(?:'?re|\s+are)\s+unsure[\s.!?]*$", m)
        or re.match(r"^(please\s+)?say when you(?:'?re|\s+are)\s+unsure[\s.!?]*$", m)
    ):
        return ControlAction("set_confidence_tone", "transparent")

    if len(m) <= 72 and (
        re.match(r"^(please\s+)?be decisive[\s.!?]*$", m)
        or re.match(r"^(please\s+)?don'?t hedge[\s.!?]*$", m)
        or re.match(r"^(please\s+)?give firm answers[\s.!?]*$", m)
    ):
        return ControlAction("set_confidence_tone", "assertive")

    if len(m) <= 80 and re.match(
        r"^(please\s+)?(default confidence tone|normal confidence|reset uncertainty)[\s.!?]*$",
        m,
    ):
        return ControlAction("set_confidence_tone", "normal")

    # Whether to offer follow-ups / next steps at the end of answers.
    if len(m) <= 96 and (
        re.match(r"^(please\s+)?suggest next steps[\s.!?]*$", m)
        or re.match(r"^(please\s+)?offer follow[- ]up questions[\s.!?]*$", m)
        or re.match(r"^(please\s+)?end with (optional )?next steps[\s.!?]*$", m)
    ):
        return ControlAction("set_followup_close", "suggest")

    if len(m) <= 100 and (
        re.match(r"^(please\s+)?no follow[- ]up questions[\s.!?]*$", m)
        or re.match(r"^(please\s+)?don'?t ask follow[- ]up questions[\s.!?]*$", m)
        or re.match(r"^(please\s+)?no questions at the end[\s.!?]*$", m)
    ):
        return ControlAction("set_followup_close", "minimal")

    if len(m) <= 78 and (
        re.match(r"^(please\s+)?(default follow[- ]ups?|reset follow[- ]ups?|normal follow[- ]ups?)[\s.!?]*$", m)
    ):
        return ControlAction("set_followup_close", "normal")

    # Teach order: define terms vs motivate first (orthogonal to TL;DR / steps).
    if len(m) <= 80 and (
        re.match(r"^(please\s+)?definitions first[\s.!?]*$", m)
        or re.match(r"^(please\s+)?start with definitions[\s.!?]*$", m)
        or re.match(r"^(please\s+)?define terms first[\s.!?]*$", m)
    ):
        return ControlAction("set_exposition_order", "definitions_first")

    if len(m) <= 96 and (
        re.match(r"^(please\s+)?intuition first[\s.!?]*$", m)
        or re.match(r"^(please\s+)?big picture first[\s.!?]*$", m)
        or re.match(r"^(please\s+)?start with the big picture[\s.!?]*$", m)
    ):
        return ControlAction("set_exposition_order", "intuition_first")

    if len(m) <= 88 and re.match(
        r"^(please\s+)?(default explanation order|reset explanation order|normal explanation order)[\s.!?]*$",
        m,
    ):
        return ControlAction("set_exposition_order", "normal")

    # Examples vs terse explanations when comparing or teaching.
    if len(m) <= 76 and (
        re.match(r"^(please\s+)?include examples[\s.!?]*$", m)
        or re.match(r"^(please\s+)?use concrete examples[\s.!?]*$", m)
        or re.match(r"^(please\s+)?illustrate with examples[\s.!?]*$", m)
    ):
        return ControlAction("set_example_density", "rich")

    if len(m) <= 92 and (
        re.match(r"^(please\s+)?skip examples[\s.!?]*$", m)
        or re.match(r"^(please\s+)?don'?t add examples[\s.!?]*$", m)
        or re.match(r"^(please\s+)?no examples unless i ask[\s.!?]*$", m)
    ):
        return ControlAction("set_example_density", "sparse")

    if len(m) <= 68 and re.match(
        r"^(please\s+)?(default examples|normal examples|reset examples)[\s.!?]*$",
        m,
    ):
        return ControlAction("set_example_density", "normal")

    # Compare/contrast presentation.
    if len(m) <= 96 and (
        re.match(r"^(please\s+)?use pros and cons[\s.!?]*$", m)
        or re.match(r"^(please\s+)?pros and cons sections[\s.!?]*$", m)
        or re.match(r"^(please\s+)?compare with pros and cons[\s.!?]*$", m)
    ):
        return ControlAction("set_comparison_frame", "pros_cons")

    if len(m) <= 100 and (
        re.match(r"^(please\s+)?compare in flowing prose[\s.!?]*$", m)
        or re.match(r"^(please\s+)?prose comparison only[\s.!?]*$", m)
        or re.match(r"^(please\s+)?no pros and cons sections[\s.!?]*$", m)
    ):
        return ControlAction("set_comparison_frame", "narrative")

    if len(m) <= 82 and re.match(
        r"^(please\s+)?(default comparison style|normal comparison|reset comparison)[\s.!?]*$",
        m,
    ):
        return ControlAction("set_comparison_frame", "normal")

    # Professional vs conversational wording (orthogonal to verbosity).
    if len(m) <= 92 and (
        re.match(r"^(please\s+)?formal tone[\s.!?]*$", m)
        or re.match(r"^(please\s+)?professional register[\s.!?]*$", m)
        or re.match(r"^(please\s+)?business writing style[\s.!?]*$", m)
    ):
        return ControlAction("set_register_tone", "formal")

    if len(m) <= 96 and (
        re.match(r"^(please\s+)?casual tone[\s.!?]*$", m)
        or re.match(r"^(please\s+)?friendly casual style[\s.!?]*$", m)
        or re.match(r"^(please\s+)?speak casually[\s.!?]*$", m)
    ):
        return ControlAction("set_register_tone", "casual")

    if len(m) <= 76 and re.match(
        r"^(please\s+)?(default tone|neutral tone|reset tone)[\s.!?]*$",
        m,
    ):
        return ControlAction("set_register_tone", "normal")

    # Markdown code snippet layout.
    if len(m) <= 100 and (
        re.match(r"^(please\s+)?use code fences[\s.!?]*$", m)
        or re.match(r"^(please\s+)?fenced code blocks[\s.!?]*$", m)
        or re.match(r"^(please\s+)?markdown code fences[\s.!?]*$", m)
    ):
        return ControlAction("set_code_block_style", "fenced")

    if len(m) <= 104 and (
        re.match(r"^(please\s+)?inline code only[\s.!?]*$", m)
        or re.match(r"^(please\s+)?no triple backticks[\s.!?]*$", m)
        or re.match(r"^(please\s+)?no fenced code blocks[\s.!?]*$", m)
    ):
        return ControlAction("set_code_block_style", "inline")

    if len(m) <= 96 and re.match(
        r"^(please\s+)?(default code formatting|reset code style|normal code blocks)[\s.!?]*$",
        m,
    ):
        return ControlAction("set_code_block_style", "normal")

    # Analogies / metaphors vs literal explanations only.
    if len(m) <= 92 and (
        re.match(r"^(please\s+)?use analogies[\s.!?]*$", m)
        or re.match(r"^(please\s+)?analogies when helpful[\s.!?]*$", m)
        or re.match(r"^(please\s+)?metaphors are ok[\s.!?]*$", m)
    ):
        return ControlAction("set_analogy_use", "prefer")

    if len(m) <= 100 and (
        re.match(r"^(please\s+)?no analogies[\s.!?]*$", m)
        or re.match(r"^(please\s+)?skip metaphors[\s.!?]*$", m)
        or re.match(r"^(please\s+)?literal explanations only[\s.!?]*$", m)
    ):
        return ControlAction("set_analogy_use", "avoid")

    if len(m) <= 82 and re.match(
        r"^(please\s+)?(default analogy style|reset analogies|normal analogies)[\s.!?]*$",
        m,
    ):
        return ControlAction("set_analogy_use", "normal")

    # Expand vs terse acronym handling on first introduce.
    if len(m) <= 112 and (
        re.match(r"^(please\s+)?spell out acronyms[\s.!?]*$", m)
        or re.match(r"^(please\s+)?expand acronyms on first use[\s.!?]*$", m)
        or re.match(r"^(please\s+)?define acronyms when you use them[\s.!?]*$", m)
    ):
        return ControlAction("set_acronym_style", "spell_out")

    if len(m) <= 112 and (
        re.match(r"^(please\s+)?assume i know acronyms[\s.!?]*$", m)
        or re.match(r"^(please\s+)?don'?t expand acronyms[\s.!?]*$", m)
        or re.match(r"^(please\s+)?keep acronyms as is[\s.!?]*$", m)
    ):
        return ControlAction("set_acronym_style", "terse")

    if len(m) <= 92 and re.match(
        r"^(please\s+)?(default acronym style|reset acronyms|normal acronyms)[\s.!?]*$",
        m,
    ):
        return ControlAction("set_acronym_style", "normal")

    # Clarify-first: ask brief questions before answering if key info is missing.
    if len(m) <= 110 and (
        re.match(r"^(please\s+)?ask clarifying questions first[\s.!?]*$", m)
        or re.match(r"^(please\s+)?clarify first[\s.!?]*$", m)
        or re.match(r"^(please\s+)?ask me questions before answering[\s.!?]*$", m)
    ):
        return ControlAction("set_clarify_first", "on")

    if len(m) <= 110 and (
        re.match(r"^(please\s+)?no clarifying questions[\s.!?]*$", m)
        or re.match(r"^(please\s+)?just answer without questions[\s.!?]*$", m)
        or re.match(r"^(please\s+)?answer without asking questions[\s.!?]*$", m)
    ):
        return ControlAction("set_clarify_first", "off")

    if len(m) <= 96 and re.match(
        r"^(please\s+)?(default clarify mode|reset clarify mode|normal clarify mode)[\s.!?]*$",
        m,
    ):
        return ControlAction("set_clarify_first", "normal")

    # Speculation level: strict factual vs brainstorming.
    if len(m) <= 110 and (
        re.match(r"^(please\s+)?no speculation[\s.!?]*$", m)
        or re.match(r"^(please\s+)?stick to high confidence only[\s.!?]*$", m)
        or re.match(r"^(please\s+)?avoid guessing[\s.!?]*$", m)
    ):
        return ControlAction("set_speculation", "strict")

    if len(m) <= 110 and (
        re.match(r"^(please\s+)?brainstorm freely[\s.!?]*$", m)
        or re.match(r"^(please\s+)?speculate freely[\s.!?]*$", m)
        or re.match(r"^(please\s+)?wild ideas ok[\s.!?]*$", m)
    ):
        return ControlAction("set_speculation", "creative")

    if len(m) <= 100 and re.match(
        r"^(please\s+)?(default speculation|normal speculation|reset speculation)[\s.!?]*$",
        m,
    ):
        return ControlAction("set_speculation", "normal")

    # Math/explanations: show work vs final-only.
    if len(m) <= 110 and (
        re.match(r"^(please\s+)?show your work[\s.!?]*$", m)
        or re.match(r"^(please\s+)?show the derivation[\s.!?]*$", m)
        or re.match(r"^(please\s+)?include steps in math[\s.!?]*$", m)
    ):
        return ControlAction("set_math_detail", "show_work")

    if len(m) <= 110 and (
        re.match(r"^(please\s+)?final answer only[\s.!?]*$", m)
        or re.match(r"^(please\s+)?no derivation[\s.!?]*$", m)
        or re.match(r"^(please\s+)?skip the steps[\s.!?]*$", m)
    ):
        return ControlAction("set_math_detail", "final_only")

    if len(m) <= 110 and re.match(
        r"^(please\s+)?(default math detail|normal math detail|reset math detail)[\s.!?]*$",
        m,
    ):
        return ControlAction("set_math_detail", "normal")

    # Output structure: JSON-shaped vs normal prose.
    if len(m) <= 110 and (
        re.match(r"^(please\s+)?answer in json[\s.!?]*$", m)
        or re.match(r"^(please\s+)?json output[\s.!?]*$", m)
        or re.match(r"^(please\s+)?structured json[\s.!?]*$", m)
    ):
        return ControlAction("set_output_format", "json")

    if len(m) <= 110 and (
        re.match(r"^(please\s+)?plain text only[\s.!?]*$", m)
        or re.match(r"^(please\s+)?no json[\s.!?]*$", m)
        or re.match(r"^(please\s+)?no structured output[\s.!?]*$", m)
    ):
        return ControlAction("set_output_format", "plain")

    if len(m) <= 110 and re.match(
        r"^(please\s+)?(default output format|normal output format|reset output format)[\s.!?]*$",
        m,
    ):
        return ControlAction("set_output_format", "normal")

    # Safety/risk posture for recommendations.
    if len(m) <= 110 and (
        re.match(r"^(please\s+)?be risk averse[\s.!?]*$", m)
        or re.match(r"^(please\s+)?be conservative[\s.!?]*$", m)
        or re.match(r"^(please\s+)?err on the side of safety[\s.!?]*$", m)
    ):
        return ControlAction("set_risk_posture", "conservative")

    if len(m) <= 110 and (
        re.match(r"^(please\s+)?be pragmatic[\s.!?]*$", m)
        or re.match(r"^(please\s+)?optimize for speed[\s.!?]*$", m)
        or re.match(r"^(please\s+)?good enough is fine[\s.!?]*$", m)
    ):
        return ControlAction("set_risk_posture", "pragmatic")

    if len(m) <= 110 and re.match(
        r"^(please\s+)?(default risk posture|normal risk posture|reset risk posture)[\s.!?]*$",
        m,
    ):
        return ControlAction("set_risk_posture", "normal")

    # Actionability: runnable steps vs conceptual explanation.
    if len(m) <= 110 and (
        re.match(r"^(please\s+)?give me runnable commands[\s.!?]*$", m)
        or re.match(r"^(please\s+)?include commands[\s.!?]*$", m)
        or re.match(r"^(please\s+)?make it actionable[\s.!?]*$", m)
    ):
        return ControlAction("set_actionability", "commands")

    if len(m) <= 110 and (
        re.match(r"^(please\s+)?no commands[\s.!?]*$", m)
        or re.match(r"^(please\s+)?conceptual only[\s.!?]*$", m)
        or re.match(r"^(please\s+)?high level only[\s.!?]*$", m)
    ):
        return ControlAction("set_actionability", "conceptual")

    if len(m) <= 110 and re.match(
        r"^(please\s+)?(default actionability|normal actionability|reset actionability)[\s.!?]*$",
        m,
    ):
        return ControlAction("set_actionability", "normal")

    # Quote/citation preference when using supplied excerpts.
    if len(m) <= 110 and (
        re.match(r"^(please\s+)?quote the faq excerpts[\s.!?]*$", m)
        or re.match(r"^(please\s+)?use direct quotes[\s.!?]*$", m)
        or re.match(r"^(please\s+)?cite with quotes[\s.!?]*$", m)
    ):
        return ControlAction("set_quote_style", "quote")

    if len(m) <= 110 and (
        re.match(r"^(please\s+)?no quotes[\s.!?]*$", m)
        or re.match(r"^(please\s+)?don'?t quote excerpts[\s.!?]*$", m)
        or re.match(r"^(please\s+)?paraphrase only[\s.!?]*$", m)
    ):
        return ControlAction("set_quote_style", "paraphrase")

    if len(m) <= 110 and re.match(
        r"^(please\s+)?(default quote style|normal quote style|reset quote style)[\s.!?]*$",
        m,
    ):
        return ControlAction("set_quote_style", "normal")

    # Tables: prefer markdown tables vs avoid.
    if len(m) <= 110 and (
        re.match(r"^(please\s+)?use tables[\s.!?]*$", m)
        or re.match(r"^(please\s+)?markdown tables[\s.!?]*$", m)
        or re.match(r"^(please\s+)?tabular format[\s.!?]*$", m)
    ):
        return ControlAction("set_table_style", "prefer")

    if len(m) <= 110 and (
        re.match(r"^(please\s+)?no tables[\s.!?]*$", m)
        or re.match(r"^(please\s+)?avoid tables[\s.!?]*$", m)
        or re.match(r"^(please\s+)?no markdown tables[\s.!?]*$", m)
    ):
        return ControlAction("set_table_style", "avoid")

    if len(m) <= 110 and re.match(
        r"^(please\s+)?(default table style|normal tables|reset tables)[\s.!?]*$",
        m,
    ):
        return ControlAction("set_table_style", "normal")

    # Emoji in assistant replies (short lines; conservative wording).
    if len(m) <= 110 and (
        re.match(r"^(please\s+)?(use emoji|emoji ok|emoji welcome|include emoji)[\s.!?]*$", m)
        or re.match(r"^(please\s+)?add (a few )?emoji[\s.!?]*$", m)
    ):
        return ControlAction("set_emoji_style", "include")

    if len(m) <= 110 and (
        re.match(r"^(please\s+)?no emojis?[\s.!?]*$", m)
        or re.match(r"^(please\s+)?avoid emoji[\s.!?]*$", m)
        or re.match(r"^(please\s+)?don'?t use emoji[\s.!?]*$", m)
    ):
        return ControlAction("set_emoji_style", "avoid")

    if len(m) <= 110 and re.match(
        r"^(please\s+)?(default emoji style|normal emoji|reset emoji)[\s.!?]*$",
        m,
    ):
        return ControlAction("set_emoji_style", "normal")

    # Markdown section headings (## / ###) vs flat prose.
    if len(m) <= 110 and (
        re.match(r"^(please\s+)?use section headings[\s.!?]*$", m)
        or re.match(r"^(please\s+)?organize with headings[\s.!?]*$", m)
        or re.match(r"^(please\s+)?use markdown headings[\s.!?]*$", m)
    ):
        return ControlAction("set_section_headings", "prefer")

    if len(m) <= 110 and (
        re.match(r"^(please\s+)?no section headings[\s.!?]*$", m)
        or re.match(r"^(please\s+)?avoid markdown headings[\s.!?]*$", m)
        or re.match(r"^(please\s+)?flat (answer|prose)( please)?[\s.!?]*$", m)
    ):
        return ControlAction("set_section_headings", "avoid")

    if len(m) <= 110 and re.match(
        r"^(please\s+)?(default section headings|normal headings|reset headings)[\s.!?]*$",
        m,
    ):
        return ControlAction("set_section_headings", "normal")

    # Inline emphasis: bold a few key terms vs keep markdown minimal.
    if len(m) <= 110 and (
        re.match(r"^(please\s+)?bold key terms[\s.!?]*$", m)
        or re.match(r"^(please\s+)?highlight important terms[\s.!?]*$", m)
        or re.match(r"^(please\s+)?emphasize keywords[\s.!?]*$", m)
    ):
        return ControlAction("set_term_emphasis", "highlight")

    if len(m) <= 110 and (
        re.match(r"^(please\s+)?minimal bold[\s.!?]*$", m)
        or re.match(r"^(please\s+)?don'?t overuse bold[\s.!?]*$", m)
        or re.match(r"^(please\s+)?avoid excessive bold[\s.!?]*$", m)
    ):
        return ControlAction("set_term_emphasis", "minimal")

    if len(m) <= 110 and re.match(
        r"^(please\s+)?(default emphasis|normal bold|reset emphasis)[\s.!?]*$",
        m,
    ):
        return ControlAction("set_term_emphasis", "normal")

    # Counterpoint tone: supportive vs challenge assumptions (short lines).
    if len(m) <= 110 and (
        re.match(r"^(please\s+)?challenge my assumptions[\s.!?]*$", m)
        or re.match(r"^(please\s+)?play devils advocate[\s.!?]*$", m)
        or re.match(r"^(please\s+)?push back on weak points[\s.!?]*$", m)
    ):
        return ControlAction("set_counterpoint_tone", "challenge")

    if len(m) <= 110 and (
        re.match(r"^(please\s+)?be supportive[\s.!?]*$", m)
        or re.match(r"^(please\s+)?assume good intent[\s.!?]*$", m)
        or re.match(r"^(please\s+)?encourage my ideas[\s.!?]*$", m)
    ):
        return ControlAction("set_counterpoint_tone", "supportive")

    if len(m) <= 110 and re.match(
        r"^(please\s+)?(default counterpoints|normal pushback|reset counterpoints)[\s.!?]*$",
        m,
    ):
        return ControlAction("set_counterpoint_tone", "normal")

    return None


# Tokens for "write the reply in …" detection (allowlist avoids "in Python" / "in 24 hours").
_REPLY_LANG_TOKENS: dict[str, str] = {
    "arabic": "Arabic",
    "chinese": "Chinese (Simplified)",
    "czech": "Czech",
    "danish": "Danish",
    "dutch": "Dutch",
    "english": "English",
    "finnish": "Finnish",
    "french": "French",
    "german": "German",
    "greek": "Greek",
    "hebrew": "Hebrew",
    "hindi": "Hindi",
    "hungarian": "Hungarian",
    "indonesian": "Indonesian",
    "italian": "Italian",
    "japanese": "Japanese",
    "korean": "Korean",
    "norwegian": "Norwegian",
    "polish": "Polish",
    "portuguese": "Portuguese",
    "romanian": "Romanian",
    "russian": "Russian",
    "spanish": "Spanish",
    "swedish": "Swedish",
    "thai": "Thai",
    "turkish": "Turkish",
    "ukrainian": "Ukrainian",
    "vietnamese": "Vietnamese",
}


_LEN_CAP_UNIT_MAX: dict[str, int] = {
    "word": 2500,
    "words": 2500,
    "sentence": 80,
    "sentences": 80,
    "paragraph": 30,
    "paragraphs": 30,
    "line": 120,
    "lines": 120,
}


def _length_cap_instruction(m: str) -> tuple[str, str] | None:
    """If the user asked for a max length, return (system instruction, compact trace token)."""
    if len(m) < 24:
        return None
    patterns = [
        re.compile(
            r"\b(?:in under|at most|no more than|under|within|no longer than)\s+(\d{1,4})\s+"
            r"(words?|sentences?|paragraphs?|lines?)\b"
        ),
        re.compile(r"\b(?:max|maximum)\s+(\d{1,4})\s+(words?|sentences?|paragraphs?|lines?)\b"),
        re.compile(r"\b(\d{1,4})\s+words?\s+(?:max|maximum|only|at most|or less)\b"),
    ]
    for rx in patterns:
        mo = rx.search(m)
        if not mo:
            continue
        n_raw, unit = mo.group(1), mo.group(2).lower()
        try:
            n = int(n_raw)
        except ValueError:
            continue
        cap = _LEN_CAP_UNIT_MAX.get(unit)
        if cap is None or n < 1 or n > cap:
            continue
        if unit.startswith("word"):
            plural, short = "words", "w"
        elif unit.startswith("sentence"):
            plural, short = "sentences", "s"
        elif unit.startswith("paragraph"):
            plural, short = "paragraphs", "p"
        else:
            plural, short = "lines", "ln"
        trace_tok = f"len_cap={n}{short}"
        instr = (
            f"The user requested a **tight length cap** of about **{n} {plural}** for the full assistant answer "
            f"(including lists or headings). Stay at or under this cap; if it is impossible, say so in one short sentence "
            "then give the closest fit."
        )
        return instr, trace_tok
    return None


def _code_only_instruction(m: str) -> str | None:
    """Detect requests for code-heavy output with almost no prose."""
    if len(m) < 18:
        return None
    if re.search(
        r"\b(just the code|(?<!not )(?<!no )code only|only code|no prose,?\s*just code|"
        r"no explanation,?\s*just (?:the )?code|"
        r"skip (?:the )?explanation|omit (?:the )?explanation|(?:give|send|return)\s+me\s+only\s+the\s+code|"
        r"output\s+only\s+(?:the\s+)?code)\b",
        m,
    ):
        return (
            "The user asked for **code-first output**: put the working solution in **one fenced markdown code block** "
            "when the answer is code; keep any non-code text to **at most one short sentence** or omit it if the code "
            "is self-explanatory."
        )
    return None


def _embedded_code_commentary(m: str) -> tuple[str, str] | None:
    """``code_explained`` — snippet plus walkthrough (complement to ``code_only`` trace tag)."""
    if len(m) < 32:
        return None
    if not re.search(
        r"\b(code|script|function|snippet|program|implementation|bash|python|sql|regex|api|curl|"
        r"typescript|rust|java|module|class|method|algorithm)\b",
        m,
    ):
        return None
    explained = bool(
        re.search(
            r"\b(code (?:with|plus|and) (?:an? )?explanation|explain (?:the|what) (?:the )?code(?: does)?|"
            r"walk me through the (?:code|snippet)|comment(?:ed)? code|annotate (?:the )?(?:code|snippet)|"
            r"code (?:with|plus) (?:inline )?comments|don'?t (?:just )?give code without explaining|"
            r"not (?:just )?code only|no code[- ]only|"
            r"with (?:a )?line[- ]by[- ]line (?:walkthrough|explanation)|"
            r"explain (?:each|every) (?:line|part|step)|teach (?:me )?(?:through|with) the code|"
            r"show (?:me )?(?:the )?code (?:and|then) explain|"
            r"include (?:brief )?comments (?:in|on) the code)\b",
            m,
        )
    )
    if not explained:
        return None
    instr = (
        "The user asked for **code with explanation**: include a **fenced code block** (or clearly separated snippet) "
        "**and** a concise walkthrough—what it does, non-obvious lines, and how to run or adapt it. "
        "Do **not** return code alone without prose."
    )
    return instr, "code_explained"


def _embedded_guided_discovery(m: str) -> tuple[str, str] | None:
    """``guided`` (hints-first) vs ``full_solution`` for problem-solving (not one-line controls)."""
    if len(m) < 36:
        return None
    if not re.search(
        r"\b(why|how|explain|prove|derive|solve|puzzle|homework|problem|exercise|bug|code|implement|"
        r"design|compare|understand|learn|teach|practice|algorithm|proof|debug|refactor)\b",
        m,
    ):
        return None
    guided = bool(
        re.search(
            r"\b(don'?t (give|spell|hand) (me )?(the )?full (answer|solution)|don'?t spoil the solution|"
            r"hints? only|only hints|guide me with (hints|questions)|nudge me (in the right direction|toward)|"
            r"i want to (figure|work) it out myself|socratic(\s+method)?|"
            r"lead me to (the )?answer|questions first instead of answering|"
            r"without (giving|spelling) (out )?(the )?(whole )?solution)\b",
            m,
        )
        and not re.search(r"\bdon'?t do hints only\b", m)
    )
    full = bool(
        re.search(
            r"\b(give me the (?:full|complete) (?:worked )?(?:answer|solution)|"
            r"(?:show|spell out) (?:me )?(?:the )?(?:full|entire|complete) (?:worked )?solution|"
            r"complete solution now|don'?t do hints only|no hints only|skip the socratic|"
            r"not hints only|"
            r"just (?:give|tell) me the answer|"
            r"finish the (?:proof|solution) for me|"
            r"i'?m stuck.{0,40}(?:full|complete) solution)\b",
            m,
        )
    )
    if guided and full:
        return None
    if guided:
        instr = (
            "The user asked for **guided discovery** (Socratic / hint-first): prefer short **questions**, "
            "**nudges**, and **partial hints** over a complete solution in this turn. "
            "If one concrete step is essential, show **at most one** move, then check whether they want to continue. "
            "Offer the full worked answer if they say they are stuck or ask you to finish."
        )
        return instr, "guided"
    if full:
        instr = (
            "The user asked for a **complete solution** in this turn: provide the full worked answer with "
            "clear steps or reasoning—do **not** stay in hint-only or Socratic question mode unless a safety "
            "check is required."
        )
        return instr, "full_solution"
    return None


def _ephemeral_privacy_instruction(m: str) -> tuple[str, str] | None:
    """User asked not to treat this turn as content to persist (memory / logging)."""
    if len(m) < 22:
        return None
    if re.search(
        r"\b(off the record|no memory for this|nothing persisted|ephemeral question|ephemeral chat|"
        r"don'?t log this|don'?t persist this|"
        r"don'?t (?:remember|store) (?:this|that|it|anything)|"
        r"do not (?:remember|store) (?:this|that|it)|"
        r"please don'?t (?:remember|store) (?:this|that|it)|"
        r"forget this after|don'?t save (?:this|that)\s+to\s+memory)\b",
        m,
    ):
        instr = (
            "The user signaled **ephemeral intent** for this reply: do **not** invite `/remember`, `/session`, or "
            "long-term note-taking for this content; avoid urging them to store secrets, API keys, or passwords. "
            "Still answer helpfully within normal safety and deployment limits."
        )
        return instr, "ephemeral"

    return None


def _accessibility_sr_instruction(m: str) -> tuple[str, str] | None:
    """User wants screen-reader / WCAG-minded answer structure (linear, semantic headings)."""
    if len(m) < 44:
        return None
    if not re.search(
        r"\b(screen[- ]?reader|screenreader|nvda|jaws|voiceover|talkback|orca|"
        r"wcag(?:\s+[0-9]{1,2}(?:\.[0-9])?)?|\ba11y\b|accessibility|accessible to|"
        r"blind users?|low vision|visually impaired)\b",
        m,
    ):
        return None
    audience = re.search(
        r"\bfor\s+(?:blind|low-vision|screen[- ]?reader|a11y)\s+(?:users?|readers?|audiences?|visitors?)?\b",
        m,
    )
    format_rq = re.search(
        r"\b(friendly|friendlier|structure|structured|layout|linear|heading|headings|semantic|"
        r"readable|reformat|format this|annotate|describe (?:the\s+)?(?:chart|diagram|figure|image)|"
        r"please (?:reply|answer|write|help|summarize|reformat|structure)|"
        r"how (?:should|can) i (?:write|format|publish))\b",
        m,
    )
    if not audience and not format_rq:
        return None
    instr = (
        "The user asked for **screen-reader–friendly / accessibility-aware** formatting: prefer a **clear linear reading order**; "
        "use real markdown heading lines for sections when the answer is long; do **not** rely on a table as the **only** "
        "place critical facts appear—repeat key facts in prose if you use a table; briefly describe any chart or diagram "
        "in words; keep emoji sparse and never the sole carrier of meaning."
    )
    return instr, "a11y"


def _embedded_source_citations(m: str) -> tuple[str, str] | None:
    """``cite_sources`` vs ``cite_minimal`` — inline attribution for FAQ/web/supplied context."""
    if len(m) < 44:
        return None
    if not re.search(
        r"\b(faq|policy|article|paper|report|study|news|web|search|source|reference|claim|fact|"
        r"research|documentation|docs|excerpt|snippet|evidence|retrieved|grounded)\b",
        m,
    ):
        return None
    sources = bool(
        re.search(
            r"\b(cite (?:your )?sources|include (?:source )?links|link to (?:your )?sources|"
            r"(?:give|provide) (?:inline )?citations|attribute (?:each )?(?:claim|point)|"
            r"reference(?:s)? for (?:each|every)|where (?:did|does) (?:this|that) come from|"
            r"back (?:each )?(?:claim|point) with (?:a )?(?:link|source)|"
            r"include (?:the )?urls|show (?:me )?(?:the )?sources you used|"
            r"audit[- ]ready (?:citations|references)|source attribution)\b",
            m,
        )
    )
    minimal = bool(
        re.search(
            r"\b(no (?:source )?links|don'?t cite(?: sources)?|skip (?:the )?links|"
            r"without links or citations|no bibliography|don'?t include urls|"
            r"no footnotes|answer without citing)\b",
            m,
        )
    )
    if sources and minimal:
        return None
    if sources:
        instr = (
            "The user asked for **explicit source attribution**: when using FAQ excerpts, web snippets, "
            "or supplied context, **cite them inline** (e.g. `[FAQ excerpt 2]`, `[Web 1]`) and prefer "
            "**short links or clear source labels** for factual claims; say when something is general knowledge "
            "without a provided source."
        )
        return instr, "cite_sources"
    if minimal:
        instr = (
            "The user asked to **avoid heavy citation formatting**: answer in clear prose **without** "
            "a bibliography, long URL lists, or footnote blocks unless a single inline cite is essential "
            "for policy or safety."
        )
        return instr, "cite_minimal"
    return None


def _embedded_ranked_options(m: str) -> tuple[str, str] | None:
    """``ranked_options`` — user wants choices ordered by priority/merit, not flat peer lists."""
    if len(m) < 48:
        return None
    if not re.search(
        r"\b(option|choice|alternative|approach|vendor|tool|framework|candidate|stack|"
        r"path|strategy|pick|recommend|solution|provider|platform|library|database|"
        r"architecture|design|method|technique|product)\b",
        m,
    ):
        return None
    ranked = bool(
        re.search(
            r"\b(rank (?:them|these|the|your)|ranked (?:list|recommendations?)|"
            r"in order of (?:priority|importance|preference|merit|likelihood)|"
            r"top \d+ (?:options?|choices?|picks?|recommendations?)|"
            r"ordered (?:from|by)|prioriti[sz]e (?:these|the|your)|"
            r"best to worst|strongest to weakest|from most to least|"
            r"highest to lowest(?: priority)?|"
            r"which (?:one|option) (?:first|should we pick first)|"
            r"order (?:them|these) by)\b",
            m,
        )
    )
    flat = bool(
        re.search(
            r"\b(no ranking|don'?t rank|order doesn'?t matter|unordered (?:list|options?)|"
            r"don'?t priorit[iy]ze|all options are equal|no priority order)\b",
            m,
        )
    )
    if ranked and flat:
        return None
    if ranked:
        instr = (
            "The user asked for a **ranked recommendation**: present options in a **clear priority order** "
            "(best-first or explicitly numbered 1., 2., 3.) with a short rationale for the ordering; "
            "do not present every alternative as equally good when they asked for ranking."
        )
        return instr, "ranked_options"
    return None


def _embedded_checklist_reply(m: str) -> tuple[str, str] | None:
    """``checklist`` vs ``no_checklist`` — markdown ``- [ ]`` task layout (not bullet-only lists)."""
    if len(m) < 44:
        return None
    if not re.search(
        r"\b(rollout|deploy|launch|onboard|audit|review|procedure|task|step|plan|"
        r"migrate|implement|runbook|playbook|incident|release|checklist|todo|action item)\b",
        m,
    ):
        return None
    prefer = bool(
        re.search(
            r"\b((?:give|provide|format|return|list|use|write).{0,24}checklist|"
            r"as a checklist|checklist (?:format|style)|action[- ]items? checklist|"
            r"task checklist|tick[- ]box(?:es)?|checkbox(?:es)? (?:list|format)|"
            r"markdown checkbox|to[- ]do list format)\b",
            m,
        )
    )
    avoid = bool(
        re.search(
            r"\b(no checklist|not a checklist|don'?t use checkboxes|avoid checklist|"
            r"without checkboxes|not tick[- ]boxes)\b",
            m,
        )
    )
    if prefer and avoid:
        return None
    if prefer:
        instr = (
            "The user asked for a **markdown checklist**: use **`- [ ]` task lines** (or `- [x]` if noting done) "
            "for actionable items; keep each item one short line; optional brief intro, then the checklist."
        )
        return instr, "checklist"
    if avoid:
        instr = (
            "The user asked **not** to format the answer as a markdown checkbox checklist; use prose, bullets, "
            "or numbered steps instead of `- [ ]` task lines."
        )
        return instr, "no_checklist"
    return None


def _embedded_pseudocode(m: str) -> tuple[str, str] | None:
    """``pseudocode`` vs ``runnable_code`` — abstract algorithm vs executable snippet."""
    if len(m) < 36:
        return None
    if not re.search(
        r"\b(code|algorithm|function|script|program|logic|implementation|sort|search|"
        r"loop|recursion|data structure|complexity)\b",
        m,
    ):
        return None
    pseudo = bool(
        re.search(
            r"\b(pseudo[- ]code only|pseudocode only|pseudo code only|"
            r"language[- ]agnostic(?: algorithm)?|"
            r"don'?t need (?:real |working |runnable )?code|"
            r"abstract algorithm|plain[- ]english algorithm|"
            r"no syntax(?:-specific)? (?:code|details)|not runnable|non[- ]runnable)\b",
            m,
        )
    )
    runnable = bool(
        re.search(
            r"\b((?<!not )runnable|(?<!not )executable|working code|production[- ]ready code|"
            r"copy[- ]paste(?:able)? code|(?<!not )real code|(?<!not )actual code|"
            r"(?<!not )runnable (?:python|javascript|bash|typescript|snippet))\b",
            m,
        )
    )
    if pseudo and runnable:
        return None
    if pseudo:
        instr = (
            "The user asked for **pseudocode**: use clear indented pseudocode or plain-language "
            "algorithm steps—not a language-specific runnable program; omit imports, compiler flags, "
            "and deployment detail unless essential."
        )
        return instr, "pseudocode"
    if runnable:
        instr = (
            "The user asked for **runnable, language-specific code**: prefer a concrete snippet they "
            "can copy-paste or execute, not abstract pseudocode alone."
        )
        return instr, "runnable_code"
    return None


_OPTION_COUNT_WORDS: dict[str, int] = {
    "one": 1,
    "two": 2,
    "three": 3,
    "four": 4,
    "five": 5,
    "six": 6,
    "seven": 7,
    "eight": 8,
    "nine": 9,
    "ten": 10,
}

_OPTION_COUNT_PATTERNS = (
    re.compile(
        r"\b(?:(?:give|provide|list|offer|suggest|propose|present|limit(?:\s+to)?|need)\s+(?:me\s+)?)?"
        r"(?:exactly|just|only|at most|no more than)\s+"
        r"(\d+|one|two|three|four|five|six|seven|eight|nine|ten)\s+"
        r"(?:distinct|different|separate)?\s*"
        r"(?:options?|choices?|alternatives?|approaches?|ideas?|recommendations?|picks?|paths?|solutions?)\b"
    ),
    re.compile(
        r"\btop\s+(\d+|one|two|three|four|five|six|seven|eight|nine|ten)\s+"
        r"(?:options?|choices?|alternatives?|picks?|recommendations?)\b"
    ),
)


def _parse_option_count_token(tok: str) -> int | None:
    if tok.isdigit():
        n = int(tok)
        return n if 1 <= n <= 10 else None
    return _OPTION_COUNT_WORDS.get(tok)


def _embedded_fixed_option_count(m: str) -> tuple[str, str] | None:
    """``options_n=N`` — user wants exactly N distinct alternatives (not an open-ended list)."""
    if len(m) < 44:
        return None
    if not re.search(
        r"\b(options?|choices?|alternatives?|approaches?|ideas?|recommendations?|picks?|"
        r"paths?|solutions?|vendors?|tools?|frameworks?|strategies?|candidates?)\b",
        m,
    ):
        return None
    found: set[int] = set()
    for pat in _OPTION_COUNT_PATTERNS:
        for mo in pat.finditer(m):
            n = _parse_option_count_token(mo.group(1))
            if n is not None:
                found.add(n)
    if len(found) != 1:
        return None
    n = next(iter(found))
    instr = (
        f"The user asked for **exactly {n} distinct options**: present **{n}** clearly labeled alternatives "
        f"(e.g. **Option 1** … **Option {n}**); do not pad with extras or collapse into fewer unless "
        f"{n} is infeasible—in that case say why in one short sentence."
    )
    return instr, f"options_n={n}"


def _embedded_diagram_visual(m: str) -> tuple[str, str] | None:
    """``diagram`` vs ``no_diagram`` — Mermaid/flowchart/ASCII visual vs text-only."""
    if len(m) < 44:
        return None
    if not re.search(
        r"\b(architecture|system|flow|pipeline|process|workflow|diagram|chart|topology|"
        r"sequence|component|service|deploy|design|how|explain|model|map|overview|"
        r"interaction|request|data)\b",
        m,
    ):
        return None
    prefer = bool(
        re.search(
            r"\b(sequence diagram|architecture diagram|component diagram|system diagram|"
            r"flowchart|flow chart|"
            r"mermaid.{0,20}diagram|"
            r"(?:include|add|draw|show|provide|use|give me).{0,28}diagram|"
            r"(?:ascii|text[- ]based) diagram|"
            r"visual(?:ize| diagram)|"
            r"as a (?:mermaid )?flowchart)\b",
            m,
        )
    )
    avoid = bool(
        re.search(
            r"\b(no diagrams?|without diagrams?|don'?t (?:use|include) (?:a )?diagrams?|"
            r"avoid (?:mermaid|flowcharts?|diagrams?)|"
            r"text[- ]only (?:please|answer)|no (?:mermaid|flowcharts?)|"
            r"skip (?:the )?diagrams?|prose only no (?:charts?|diagrams?))\b",
            m,
        )
    )
    if prefer and avoid:
        return None
    if prefer:
        instr = (
            "The user asked for a **visual diagram** in the reply: include **one** concise "
            "**Mermaid** diagram (preferred) or a short **ASCII** diagram when Mermaid is awkward; "
            "add brief prose before/after; keep node labels short."
        )
        return instr, "diagram"
    if avoid:
        instr = (
            "The user asked for **no diagrams**: answer in prose, bullets, numbered steps, or tables "
            "only—do **not** include Mermaid blocks, flowcharts, or ASCII art diagrams."
        )
        return instr, "no_diagram"
    return None


def _embedded_risks_benefits_order(m: str) -> tuple[str, str] | None:
    """``risks_first`` vs ``benefits_first`` — section order for trade-offs (not ``risk_posture``)."""
    if len(m) < 48:
        return None
    if not re.search(
        r"\b(plan|proposal|rollout|launch|migrate|design|strategy|decision|invest|build|ship|"
        r"product|feature|architecture|change|initiative|roadmap|pitch|trade[- ]?off)\b",
        m,
    ):
        return None
    risks = bool(
        re.search(
            r"\b(risks? first|downsides? first|cons first|what could go wrong first|"
            r"start with (?:the )?risks?|lead with (?:the )?risks?|"
            r"pitfalls? first|negative(?:s)? before positives?|"
            r"caveats? (?:before|then) benefits?|worst[- ]case first)\b",
            m,
        )
    )
    benefits = bool(
        re.search(
            r"\b(benefits? first|upsides? first|pros first|"
            r"start with (?:the )?benefits?|lead with (?:the )?upsides?|"
            r"positives? before negatives?|sell (?:me on )?the upside first|"
            r"good news first)\b",
            m,
        )
    )
    if risks and benefits:
        return None
    if risks:
        instr = (
            "The user asked for **risks / downsides first**: open with key **risks, caveats, and failure modes** "
            "before benefits or recommendations; keep the ordering explicit even if you later add upsides."
        )
        return instr, "risks_first"
    if benefits:
        instr = (
            "The user asked for **benefits / upsides first**: open with **advantages and positive outcomes** "
            "before risks or caveats; keep the ordering explicit even if you note downsides later."
        )
        return instr, "benefits_first"
    return None


def _embedded_risks_mitigations(m: str) -> tuple[str, str] | None:
    """``risks_mitigations`` — paired risk + mitigation layout (not ``risks_first`` section order)."""
    if len(m) < 48:
        return None
    no_rm = bool(
        re.search(
            r"\b(no mitigations?|without mitigations?|skip (?:the\s+)?mitigation(?:s| plan)?|"
            r"don'?t (?:include|list) mitigations?|risks? only|"
            r"no (?:paired\s+)?mitigation section|avoid (?:a\s+)?mitigation section|"
            r"not a risk register|skip (?:the\s+)?risk register)\b",
            m,
        )
    )
    if no_rm:
        return None
    want = bool(
        re.search(
            r"\b(risks? and mitigations?|risks? with mitigations?|"
            r"mitigation(?:s| plan) for each risk|risk register|"
            r"list (?:the\s+)?(?:key\s+)?risks? (?:and|with) (?:corresponding\s+)?mitigations?|"
            r"each risk (?:with|and) (?:a\s+)?mitigation|"
            r"paired risk[- ]mitigation|mitigation steps? for (?:each|every) risk|"
            r"include mitigations? (?:for|against) (?:each|the) risks?)\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(plan|proposal|rollout|launch|migrate|design|strategy|security|"
        r"compliance|initiative|project|deployment|change|review|assess|write|describe|outline|report)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **risks + mitigations** layout: include a **Risks and mitigations** section "
        "where each key risk is paired with a **concrete mitigation** (bullets or a small table with "
        "Risk / Mitigation columns)—do not list risks without actionable mitigations."
    )
    return instr, "risks_mitigations"


def _embedded_revise_draft(m: str) -> tuple[str, str] | None:
    """``revise_draft`` — rewrite/polish user-supplied copy (not a greenfield explain-only ask)."""
    if len(m) < 48:
        return None
    revise = bool(
        re.search(
            r"\b(improve (?:my |this |the )?draft|polish (?:my |this |the )?(?:draft|email|memo)?|"
            r"rewrite (?:it|this|the (?:text|email|message))|"
            r"rewrite (?:my |this |the )?(?:draft|email|paragraph|message|memo|post|letter)|"
            r"edit (?:my |this )?(?:draft|text|copy)|proofread (?:my |this )?|"
            r"tighten (?:my |this )?(?:draft|writing|wording)|"
            r"make (?:this |it |the text )(?:clearer|more professional|more concise|shorter)|"
            r"copy[- ]?edit|wordsmithe)\b",
            m,
        )
    )
    no_revise = bool(
        re.search(
            r"\b(don'?t rewrite|do not rewrite|no rewrite|keep (?:my |the )?wording (?:as[- ]is|unchanged)|"
            r"don'?t edit (?:my |the )?text)\b",
            m,
        )
    )
    if not revise or no_revise:
        return None
    has_artifact = bool(
        re.search(
            r"\b(?:my|this|the)\s+draft\b|draft\s+(?:email|message|memo|slack|paragraph|letter|post)\b|"
            r"(?:text|email|memo)\s+below|following\s+(?:text|email|draft|memo)|"
            r"draft:\s|here(?:'s| is)\s+(?:my|the)\s+draft\b",
            m,
        )
    )
    if not has_artifact and len(m) < 100:
        return None
    instr = (
        "The user wants a **revision of supplied text**: treat their message as source copy to "
        "**rewrite or polish in place**—preserve intent and facts; return the improved version prominently "
        "(add brief bullets on what changed only if helpful); do **not** answer as if no draft was provided."
    )
    return instr, "revise_draft"


def _embedded_revise_diff(m: str) -> tuple[str, str] | None:
    """``revise_diff`` — when revising supplied copy, show before/after or track-changes layout."""
    if len(m) < 48:
        return None
    want_diff = bool(
        re.search(
            r"\b(before and after|before[- ]?after|side[- ]by[- ]side|"
            r"show (?:me )?(?:what|the) changed|show (?:the )?changes|track changes?|"
            r"redline(?:d)?(?:\s+version)?|diff format|as a diff|"
            r"strikethrough (?:for|on) (?:removed|deletions)|"
            r"highlight (?:what|the) changed|compare (?:the )?original (?:to|with|and))\b",
            m,
        )
    )
    no_diff = bool(
        re.search(
            r"\b(no before and after|don'?t show (?:a )?diff|without (?:a )?diff|"
            r"no track changes?|inline revision only|revision only no diff|"
            r"don'?t (?:show|include) (?:before|after)|skip (?:the )?diff)\b",
            m,
        )
    )
    if not want_diff or no_diff:
        return None
    revise = bool(
        re.search(
            r"\b(improve (?:my |this |the )?draft|polish|rewrite|edit (?:my |this )?|"
            r"proofread|copy[- ]?edit|revise (?:my |this |the )?|tighten (?:my )?)\b",
            m,
        )
    )
    has_artifact = bool(
        re.search(
            r"\b(?:my|this|the)\s+draft\b|draft\s+(?:email|message|memo|slack|paragraph|letter|post)\b|"
            r"(?:text|email|memo)\s+below|following\s+(?:text|email|draft|memo)|"
            r"draft:\s|here(?:'s| is)\s+(?:my|the)\s+draft\b",
            m,
        )
    )
    if not revise and not has_artifact:
        return None
    if not has_artifact and len(m) < 96:
        return None
    instr = (
        "The user wants a **before/after or track-changes style revision**: label sections **Before** "
        "and **After** (or use a concise unified diff / `~~removed~~` / **added** markup for changed spans). "
        "Keep the polished **After** copy complete; do not answer as if no source draft was provided."
    )
    return instr, "revise_diff"


def _embedded_email_format(m: str) -> tuple[str, str] | None:
    """``email_format`` — Subject / Greeting / Body / Sign-off layout (greenfield compose, not polish)."""
    if len(m) < 48:
        return None
    no_ef = bool(
        re.search(
            r"\b(no email format|without (?:an?\s+)?email format|not an email format|"
            r"skip (?:the\s+)?email format|don'?t use email format|"
            r"avoid email format|not as an email|no subject line block)\b",
            m,
        )
    )
    if no_ef:
        return None
    revise_only = bool(
        re.search(
            r"\b(rewrite (?:my |this |the )?(?:draft )?|polish (?:my |this )?(?:draft )?|"
            r"proofread (?:my |this )?|improve (?:my |this |the )?draft|copy[- ]?edit)\b",
            m,
        )
    )
    has_draft_artifact = bool(
        re.search(
            r"\b(?:my|this|the)\s+draft\b|draft:\s|here(?:'s| is)\s+(?:my|the)\s+draft\b",
            m,
        )
    )
    if revise_only and has_draft_artifact:
        return None
    want = bool(
        re.search(
            r"\b((?:write|draft|compose|prepare) (?:an?\s+)?email|"
            r"email (?:to|for) (?:the |my |our |a )?|"
            r"email format|as an email|in email format|"
            r"follow[- ]up email|outreach email|"
            r"reply (?:by|as|in) email|email (?:message|template))\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(write|draft|compose|prepare|notify|inform|send|follow[- ]?up|"
        r"apolog|request|update|client|customer|colleague|manager|team|"
        r"recipient|message|explain|describe)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **formatted email**: use labels **Subject:** (one line), "
        "a **Greeting** (Hi/Dear …), concise body paragraphs, and a **Sign-off** "
        "(Thanks/Best regards + optional name/role)—ready to paste into an email client; "
        "do not answer as a generic essay about how to write emails."
    )
    return instr, "email_format"


def _embedded_letter_format(m: str) -> tuple[str, str] | None:
    """``letter_format`` — formal business letter layout (distinct from ``email_format``)."""
    if len(m) < 48:
        return None
    no_lf = bool(
        re.search(
            r"\b(no letter format|without (?:a\s+)?letter format|not a letter format|"
            r"skip (?:the\s+)?letter format|don'?t use letter format|"
            r"avoid letter format|not as a letter|no formal letter (?:format|layout))\b",
            m,
        )
    )
    if no_lf:
        return None
    revise_only = bool(
        re.search(
            r"\b(rewrite (?:my |this |the )?(?:draft )?|polish (?:my |this )?(?:draft )?|"
            r"proofread (?:my |this )?|improve (?:my |this |the )?draft|copy[- ]?edit)\b",
            m,
        )
    )
    has_draft_artifact = bool(
        re.search(
            r"\b(?:my|this|the)\s+draft\b|draft:\s|here(?:'s| is)\s+(?:my|the)\s+draft\b",
            m,
        )
    )
    if revise_only and has_draft_artifact:
        return None
    email_only = bool(
        re.search(
            r"\b((?:write|draft|compose|prepare) (?:an?\s+)?email|"
            r"email format|as an email|in email format|follow[- ]up email)\b",
            m,
        )
    )
    if email_only:
        return None
    want = bool(
        re.search(
            r"\b((?:write|draft|compose|prepare) (?:a\s+)?(?:formal\s+)?letter|"
            r"letter (?:to|for) (?:the |my |our |a )?|"
            r"letter format|formal letter(?:\s+format)?|business letter(?:\s+format)?|"
            r"as a letter|in letter format|cover letter format|"
            r"official letter|letter of (?:request|notice|complaint|support))\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(write|draft|compose|prepare|notify|inform|send|request|apolog|"
        r"client|customer|office|agency|regulator|recipient|legal|"
        r"describe|explain|mail|correspondence)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **formal letter**: use labels **Date:**, **To:** (recipient name/address), "
        "**Salutation** (Dear …), body paragraphs, **Closing** (Sincerely / Respectfully), and "
        "**Signature** (name + title)—ready to print or mail; not an email with Subject/Greeting blocks."
    )
    return instr, "letter_format"


def _embedded_press_release(m: str) -> tuple[str, str] | None:
    """``press_release`` — media/PR announcement layout (distinct from ``email_format`` and ``letter_format``)."""
    if len(m) < 48:
        return None
    no_pr = bool(
        re.search(
            r"\b(no press release|without (?:a\s+)?press release|not a press release|"
            r"skip (?:the\s+)?press release|don'?t use press release|"
            r"avoid press release (?:format|template|layout)|"
            r"no press release format|skip (?:the\s+)?press release format|"
            r"not as a press release)\b",
            m,
        )
    )
    if no_pr:
        return None
    revise_only = bool(
        re.search(
            r"\b(rewrite (?:my |this |the )?(?:draft )?|polish (?:my |this )?(?:draft )?|"
            r"proofread (?:my |this )?|improve (?:my |this |the )?draft|copy[- ]?edit)\b",
            m,
        )
    )
    has_draft_artifact = bool(
        re.search(
            r"\b(?:my|this|the)\s+draft\b|draft:\s|here(?:'s| is)\s+(?:my|the)\s+draft\b",
            m,
        )
    )
    if revise_only and has_draft_artifact:
        return None
    email_only = bool(
        re.search(
            r"\b((?:write|draft|compose|prepare) (?:an?\s+)?email|"
            r"email format|as an email|in email format|follow[- ]up email)\b",
            m,
        )
    )
    if email_only:
        return None
    letter_only = bool(
        re.search(
            r"\b(letter format|formal letter(?:\s+format)?|business letter(?:\s+format)?|"
            r"(?:write|draft) (?:a\s+)?(?:formal\s+)?letter to)\b",
            m,
        )
    )
    if letter_only:
        return None
    want = bool(
        re.search(
            r"\b(press release(?:\s+format)?|media release(?:\s+format)?|"
            r"news release(?:\s+format)?|pr announcement(?:\s+format)?|"
            r"write (?:a\s+)?press release|draft (?:a\s+)?press release|"
            r"compose (?:a\s+)?press release|prepare (?:a\s+)?press release|"
            r"press release (?:for|about|announcing)|"
            r"media announcement(?:\s+format)?)\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(announce|launch|product|company|startup|partnership|milestone|"
        r"media|journalist|reporter|pr\b|communications|comms|"
        r"write|draft|compose|prepare|publish|describe|outline)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **press release**: use markdown headings **FOR IMMEDIATE RELEASE**, "
        "**Headline**, optional **Subhead**, **Dateline** (City, Date —), a **Lead paragraph** "
        "(who/what/when/where/why), **Body** (details + optional executive quote), "
        "**About [Company]** boilerplate, and **Media contact**—journalist-ready copy; "
        "not an email with Subject/Greeting or a formal business letter with To/Salutation blocks."
    )
    return instr, "press_release"


def _embedded_runbook_format(m: str) -> tuple[str, str] | None:
    """``runbook_format`` — ops/on-call runbook scaffold (distinct from ``postmortem`` and ``checklist``)."""
    if len(m) < 48:
        return None
    no_rb = bool(
        re.search(
            r"\b(no runbook format|without (?:a\s+)?runbook format|not a runbook format|"
            r"skip (?:the\s+)?runbook format|don'?t use runbook format|"
            r"avoid runbook (?:format|template|sections)|"
            r"no operational runbook (?:format|template))\b",
            m,
        )
    )
    if no_rb:
        return None
    checklist_only = bool(
        re.search(
            r"\b((?:as a|use a|markdown) checklist|checklist (?:format|style)|"
            r"tick[- ]box(?:es)?|checkbox(?:es)? (?:list|format))\b",
            m,
        )
    )
    if checklist_only:
        return None
    postmortem_only = bool(
        re.search(
            r"\b(postmortem format|blameless postmortem|incident postmortem|"
            r"post[- ]mortem format)\b",
            m,
        )
    )
    if postmortem_only:
        return None
    want = bool(
        re.search(
            r"\b(runbook(?:\s+format)?|operational runbook|on[- ]call runbook|"
            r"incident runbook|ops runbook|"
            r"write (?:an?\s+)?runbook|draft (?:an?\s+)?runbook|"
            r"playbook format|operational playbook|"
            r"runbook (?:for|to) (?:the\s+)?(?:on[- ]call|failover|rollback|restore|deploy))\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(on[- ]call|incident|outage|failover|rollback|restore|deploy|"
        r"sre|operations|ops|escalat|drill|procedure|write|draft|"
        r"describe|outline|publish|document)\b",
        m,
    ):
        return None
    instr = (
        "The user wants an **operational runbook**: use markdown headings **Purpose**, "
        "**Prerequisites**, **Procedure** (numbered steps), **Verification**, **Rollback**, "
        "**Escalation**, and optional **References**—concrete operator actions, not a "
        "postmortem narrative or `- [ ]` checkbox checklist."
    )
    return instr, "runbook_format"


def _embedded_job_aid(m: str) -> tuple[str, str] | None:
    """``job_aid`` — quick-reference / performance-support card (distinct from ``runbook_format`` and ``checklist``)."""
    if len(m) < 48:
        return None
    no_ja = bool(
        re.search(
            r"\b(no job aid|without (?:a\s+)?job aid|not a job aid|"
            r"skip (?:the\s+)?job aid|don'?t use job aid|"
            r"avoid job aid (?:format|template|sections)|"
            r"no job aid format|skip (?:the\s+)?job aid format)\b",
            m,
        )
    )
    if no_ja:
        return None
    runbook_only = bool(
        re.search(
            r"\b(runbook(?:\s+format)?|operational runbook|on[- ]call runbook|"
            r"incident runbook|ops runbook|operational playbook)\b",
            m,
        )
    )
    if runbook_only:
        return None
    checklist_only = bool(
        re.search(
            r"\b((?:as a|use a|markdown) checklist|checklist (?:format|style)|"
            r"tick[- ]box(?:es)?|checkbox(?:es)? (?:list|format))\b",
            m,
        )
    )
    if checklist_only:
        return None
    want = bool(
        re.search(
            r"\b(job aid(?:\s+format)?|job[- ]aid (?:card|template|format)|"
            r"quick reference(?:\s+card|\s+guide|\s+format)?|"
            r"cheat sheet(?:\s+format)?|desk reference|"
            r"performance support(?:\s+tool|\s+format)?|"
            r"write (?:a\s+)?job aid|draft (?:a\s+)?job aid|"
            r"quick[- ]reference (?:for|on))\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(training|onboarding|frontline|agent|staff|employee|team|"
        r"task|workflow|process|procedure|support|help desk|"
        r"write|draft|create|outline|document|describe|publish)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **job aid** (quick-reference card): use markdown headings **Task / purpose**, "
        "**When to use**, **Quick steps** (numbered, scannable), **Tips & reminders**, "
        "**Common mistakes**, and **Need help?**—compact performance support for someone doing "
        "the task at work; not an ops runbook with rollback/escalation or a `- [ ]` checkbox checklist."
    )
    return instr, "job_aid"


def _embedded_status_report(m: str) -> tuple[str, str] | None:
    """``status_report`` — periodic project/program status update (distinct from ``one_pager``)."""
    if len(m) < 48:
        return None
    no_sr = bool(
        re.search(
            r"\b(no status report|without (?:a\s+)?status report|not a status report|"
            r"skip (?:the\s+)?status report|don'?t use status report|"
            r"avoid status report (?:format|sections)|"
            r"no status report format|skip (?:the\s+)?status report format)\b",
            m,
        )
    )
    if no_sr:
        return None
    one_pager_only = bool(
        re.search(
            r"\b(one[- ]pager(?:\s+format|\s+memo|\s+brief)?|"
            r"single[- ]page (?:brief|memo|summary)|executive one[- ]pager)\b",
            m,
        )
    )
    if one_pager_only:
        return None
    want = bool(
        re.search(
            r"\b(status report(?:\s+format)?|project status report|program status report|"
            r"weekly status (?:report|update)|monthly status (?:report|update)|"
            r"status update (?:format|for)|"
            r"rag status (?:report|update)|red[- ]amber[- ]green status|"
            r"write (?:a\s+)?status (?:report|update)|draft (?:a\s+)?status (?:report|update))\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(project|program|initiative|migration|rollout|delivery|milestone|"
        r"sprint|stakeholder|leadership|pmo|update|report|outline|write|draft|describe)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **status report**: use markdown headings **Reporting period**, "
        "**Overall status** (Green/Amber/Red or On track/At risk/Blocked), **Highlights**, "
        "**Blockers / lowlights**, optional **Key metrics**, **Next period focus**, and "
        "**Risks / asks**—scannable for stakeholders; not a one-pager executive memo."
    )
    return instr, "status_report"


def _embedded_meeting_agenda(m: str) -> tuple[str, str] | None:
    """``meeting_agenda`` — timeboxed meeting run-of-show (distinct from ``action_plan`` owner tables)."""
    if len(m) < 48:
        return None
    no_ma = bool(
        re.search(
            r"\b(no meeting agenda|without (?:a\s+)?meeting agenda|not a meeting agenda|"
            r"skip (?:the\s+)?meeting agenda|don'?t use meeting agenda|"
            r"avoid meeting agenda (?:format|section)|"
            r"no agenda format|skip (?:the\s+)?agenda format)\b",
            m,
        )
    )
    if no_ma:
        return None
    want = bool(
        re.search(
            r"\b(meeting agenda(?:\s+format)?|agenda format|"
            r"prepare (?:an?\s+)?agenda|draft (?:an?\s+)?agenda|"
            r"run[- ]of[- ]show|meeting run[- ]of[- ]show|"
            r"timeboxed agenda|agenda with time(?:\s+)?boxes?|"
            r"agenda for (?:the |our |a )?(?:meeting|sync|workshop|kickoff|review))\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(meeting|sync|workshop|kickoff|review|standup|retro|planning|"
        r"session|facilitate|host|schedule|attendees|discuss|outline|write|prepare)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **meeting agenda**: use markdown headings **Meeting title**, "
        "**Objective** (1–2 lines), optional **Attendees**, **Agenda** as timeboxed items "
        "(e.g. `5 min — Topic`), **Pre-reads / prep** if relevant, and **Decisions needed**—"
        "keep it scannable for a live facilitator; not a checkbox checklist or owner/due-date table."
    )
    return instr, "meeting_agenda"


def _embedded_topic_guard(m: str) -> tuple[str, str] | None:
    """``topic_guard`` — user asked to omit specific subjects from the reply."""
    if len(m) < 44:
        return None
    avoid = bool(
        re.search(
            r"\b(don'?t mention|do not mention|avoid (?:mentioning|discussing|talking about)|"
            r"skip (?:mentioning|discussing)|leave out|no discussion of|"
            r"do not discuss|steer clear of|without mentioning|"
            r"don'?t bring up|do not bring up|exclude (?:any )?discussion of)\b",
            m,
        )
    )
    must_cover = bool(
        re.search(
            r"\b(make sure to mention|be sure to (?:mention|cover)|must (?:mention|cover|discuss)|"
            r"you must (?:mention|cover)|focus (?:only )?on|only discuss|"
            r"include (?:a )?section on)\b",
            m,
        )
    )
    if not avoid or must_cover:
        return None
    if not re.search(
        r"\b(explain|describe|what|how|why|help|write|draft|answer|summarize|compare|"
        r"faq|policy|guide|customer|user|team|product)\b",
        m,
    ):
        return None
    instr = (
        "The user set **topic guardrails**: do **not** mention or elaborate on subjects they flagged to "
        "avoid in this message (for example pricing, competitors, politics, or internal tools)—even if "
        "tangentially relevant; you may note briefly that you are omitting a flagged topic."
    )
    return instr, "topic_guard"


def _embedded_topic_must(m: str) -> tuple[str, str] | None:
    """``topic_must`` — user required specific subjects or sections in the reply."""
    if len(m) < 44:
        return None
    must_cover = bool(
        re.search(
            r"\b(make sure to mention|be sure to (?:mention|cover)|must (?:mention|cover|discuss|include)|"
            r"you must (?:mention|cover)|need (?:you )?to (?:mention|cover)|"
            r"include (?:a )?(?:section|subsection) (?:on|about|for)|"
            r"dedicated section (?:on|about|for)|don'?t skip (?:mentioning|discussing)|"
            r"address (?:the )?(?:topic|question) of|cover (?:the )?topic of)\b",
            m,
        )
    )
    avoid = bool(
        re.search(
            r"\b(don'?t mention|do not mention|avoid (?:mentioning|discussing|talking about)|"
            r"skip (?:mentioning|discussing)|leave out|no discussion of|"
            r"do not discuss|steer clear of|without mentioning|"
            r"don'?t bring up|do not bring up|exclude (?:any )?discussion of)\b",
            m,
        )
    )
    if not must_cover or avoid:
        return None
    if not re.search(
        r"\b(explain|describe|what|how|why|help|write|draft|answer|summarize|compare|"
        r"faq|policy|guide|customer|user|team|product|outline|prepare)\b",
        m,
    ):
        return None
    instr = (
        "The user set **required topics**: explicitly **cover** each subject or section they asked "
        "you to mention (use clear headings or bullets per required item); do not omit flagged "
        "must-cover topics even if they seem tangential."
    )
    return instr, "topic_must"


def _embedded_answer_frame(m: str) -> tuple[str, str] | None:
    """``frame_star`` / ``frame_prep`` / ``frame_irac`` — named professional answer scaffolds."""
    if len(m) < 48:
        return None
    if not re.search(
        r"\b(answer|write|explain|describe|respond|interview|behavioral|prompt|story|"
        r"example|scenario|case|memo|report|outline)\b",
        m,
    ):
        return None
    candidates: list[tuple[str, str]] = []
    if re.search(
        r"\b(star format|star method|situation[- ]task[- ]action[- ]result|"
        r"\bstar\b.{0,30}(?:situation|task|action|result))\b",
        m,
    ):
        candidates.append(
            (
                "Structure the answer using **STAR** with markdown headings **Situation**, **Task**, "
                "**Action**, and **Result** (one short paragraph each unless a length cap applies).",
                "frame_star",
            )
        )
    if re.search(r"\b(prep format|prep method|point[- ]reason[- ]example[- ]point)\b", m):
        candidates.append(
            (
                "Structure the answer using **PREP**: **Point**, **Reason**, **Example**, then restate the **Point**.",
                "frame_prep",
            )
        )
    if re.search(r"\b(irac format|irac method|issue[- ]rule[- ]analysis[- ]conclusion)\b", m):
        candidates.append(
            (
                "Structure the answer using **IRAC**: **Issue**, **Rule**, **Analysis**, **Conclusion**.",
                "frame_irac",
            )
        )
    if len(candidates) != 1:
        return None
    return candidates[0]


def _embedded_simple_audience(m: str) -> bool:
    """True if a longer prompt asks for child-level / lay explanations (ELI5-style) in prose."""
    if len(m) < 40:
        return False
    if re.search(
        r"\b(expert mode|technical audience|assume i'?m technical|phd level|for experts|deep technical)\b",
        m,
    ):
        return False
    if not re.search(
        r"\b(eli5|explain like i'?m(?:\s+a)? five|like i'?m(?:\s+a)? five\b|"
        r"for (?:my )?kids to understand|total beginner|i'?m\s+a\s+beginner\b|beginner\s+here\b|"
        r"non-technical (?:parent|reader|manager|audience)|"
        r"lay audience|no technical background|zero prior knowledge)\b",
        m,
    ):
        return False
    return bool(
        re.search(
            r"\b(why|how|what|when|where|explain|describe|tell me|help me (?:to )?understand|walk me through|"
            r"learn about|new to)\b",
            m,
        )
    )


def _embedded_technical_audience(m: str) -> bool:
    """True if a longer prompt asks for expert-depth explanations (not short *Expert mode* controls)."""
    if len(m) < 40:
        return False
    if re.search(
        r"\b(eli5|explain like i'?m(?:\s+a)? five|total beginner|i'?m\s+a\s+beginner\b|beginner\s+here\b|"
        r"lay audience|no technical background|zero prior knowledge|explain simply)\b",
        m,
    ):
        return False
    if not re.search(
        r"\b(expert mode|technical audience|assume i'?m technical|phd level|for experts|deep technical|"
        r"staff engineer audience|senior (?:sre|eng|engineer) audience|"
        r"use jargon freely|skip the basics|don'?t dumb (?:it )?down|"
        r"peer[- ]level technical|internals[- ]focused|implementation[- ]heavy)\b",
        m,
    ):
        return False
    return bool(
        re.search(
            r"\b(why|how|what|when|where|explain|describe|tell me|walk me through|"
            r"compare|design|architect|debug|troubleshoot|analyze|review|implement)\b",
            m,
        )
    )


def _embedded_register_tone(m: str) -> str | None:
    """One-shot formal vs casual register when prose names an audience (not the short *Formal tone* control)."""
    if len(m) < 48:
        return None
    formal = re.search(
        r"\b(board-ready|for regulators|regulatory filing|formal memo|audit[- ]friendly|"
        r"client-facing|for (?:the\s+)?board(?:\s+of\s+directors)?\b|for leadership review|"
        r"executive summary for|c[- ]suite|for executives|board presentation|investor[- ]ready|"
        r"sec filing tone)\b",
        m,
    )
    casual = re.search(
        r"\b(slack message|teams message to the team|keep it casual|casual tone|friendly teammate|"
        r"like you(?:'re|\s+are)\s+my coworker|water cooler|informal note|keep it light|"
        r"pub chat|chatty tone)\b",
        m,
    )
    if formal and not casual:
        return "formal"
    if casual and not formal:
        return "casual"
    return None


def _embedded_verbosity(m: str) -> str | None:
    """``brief`` vs ``detailed`` reply length (not short *Be brief* controls; distinct from ``len_cap``)."""
    if len(m) < 44:
        return None
    detailed = bool(
        re.search(
            r"\b(more detail|go deeper|in greater detail|explain thoroughly|longer answers?|"
            r"detailed answers?|comprehensive explanation|deep dive|"
            r"don'?t skimp on detail|fuller explanation|elaborate (?:on|please)|"
            r"walk me through (?:it )?in depth)\b",
            m,
        )
    )
    brief = bool(
        re.search(
            r"\b(be brief|stay brief|keep it short|short answers?|answer briefly|concise replies?|"
            r"keep (?:your )?answer short|just the essentials|high[- ]level summary only|"
            r"don'?t ramble|brevity (?:please|is key))\b",
            m,
        )
    )
    if brief and detailed:
        return None
    if brief:
        return "brief"
    if detailed:
        return "detailed"
    return None


def _embedded_output_format(m: str) -> str | None:
    """``json`` vs ``plain`` output shape (not short *Answer in JSON* / *Plain text only* controls)."""
    if len(m) < 40:
        return None
    plain = bool(
        re.search(
            r"\b(plain text only|no json(?:\s+block)?|not json|avoid json|skip json|"
            r"no structured output|don'?t use json|without json|"
            r"normal (?:plain )?text(?:\s+only)?|prose only.{0,30}no json|"
            r"don'?t (?:return|emit|output) json)\b",
            m,
        )
    )
    json_fmt = bool(
        re.search(
            r"\b(valid json|return json|reply in json|answer in json|json output|structured json|"
            r"json object|json array|as json\b|as a json|machine[- ]readable json|emit json|"
            r"serialize (?:to|as) json|output as json|respond with json)\b",
            m,
        )
    )
    if plain and json_fmt:
        return None
    if plain:
        return "plain"
    if json_fmt:
        return "json"
    return None


def _embedded_speculation(m: str) -> str | None:
    """``strict`` vs ``creative`` speculation level (not short *No speculation* / *Brainstorm freely* controls)."""
    if len(m) < 44:
        return None
    creative = bool(
        re.search(
            r"\b(brainstorm freely|speculate freely|wild ideas(?:\s+ok)?|creative speculation|"
            r"go ahead and guess|reasonable guesses welcome|speculate a bit|"
            r"blue[- ]sky (?:thinking|ideas)|throw out (?:some )?possibilities|"
            r"explore hypotheticals|what[- ]if scenarios (?:are )?welcome|"
            r"ideation (?:mode|session)|open[- ]ended brainstorming)\b",
            m,
        )
    )
    strict = bool(
        re.search(
            r"\b(don'?t guess|no guessing|avoid guessing|only high confidence|stick to (?:the\s+)?facts|"
            r"avoid halluc|no hallucinations|don'?t hallucinate|if you don'?t know say|"
            r"if unsure say|say when you(?:'re|\s+are)\s+unsure|no speculation|avoid speculation|"
            r"don'?t speculate|fact[- ]checked|grounded only|evidence[- ]based only|"
            r"only if (?:you(?:'re|\s+are)\s+)?(?:certain|sure)|do not invent (?:facts|numbers))\b",
            m,
        )
    )
    if creative and strict:
        return None
    if strict:
        return "strict"
    if creative:
        return "creative"
    return None


def _embedded_answer_lead(m: str) -> str | None:
    """``tldr_first`` vs ``direct`` answer opening (not short *TLDR first* / *Answer directly* controls)."""
    if len(m) < 44:
        return None
    direct = bool(
        re.search(
            r"\b(no tldr|skip (?:the )?summary|answer directly|without a (?:summary|tldr)|"
            r"no executive summary|don'?t (?:add|give) a tldr|direct answer only|"
            r"jump straight to the answer|no summary (?:upfront|at the top)|"
            r"get straight to the (?:answer|point)|omit (?:the )?(?:opening )?summary)\b",
            m,
        )
    )
    tldr = bool(
        re.search(
            r"\b(tl;?dr first|tldr first|lead with (?:a\s+)?(?:one[- ]line\s+)?summary|summary first|"
            r"executive summary first|bottom line up front|bluf|"
            r"start with (?:a\s+)?(?:short\s+)?summary|headline first|"
            r"give me the (?:key\s+)?takeaway first)\b",
            m,
        )
    )
    if direct and tldr:
        return None
    if direct:
        return "direct"
    if tldr:
        return "tldr_first"
    return None


def _embedded_recommendation_first(m: str) -> tuple[str, str] | None:
    """``recommendation_first`` — open with an explicit recommendation before rationale (not generic BLUF)."""
    if len(m) < 44:
        return None
    no_rec = bool(
        re.search(
            r"\b(no recommendation (?:upfront|first|at the top)|"
            r"don'?t (?:lead with|start with|give) (?:your\s+)?recommendation|"
            r"skip (?:the\s+)?(?:upfront\s+)?recommendation|"
            r"without (?:an?\s+)?(?:upfront\s+)?recommendation|"
            r"recommendation (?:only\s+)?at the end|"
            r"conclude with (?:your\s+)?recommendation|"
            r"end with (?:your\s+)?recommendation|"
            r"hold (?:your\s+)?recommendation until (?:the\s+)?end)\b",
            m,
        )
    )
    if no_rec:
        return None
    want = bool(
        re.search(
            r"\b(lead with (?:your\s+)?recommendation|recommendation first|"
            r"state your recommendation (?:upfront|first|at the top)|"
            r"start with (?:your\s+)?(?:clear\s+)?recommendation|"
            r"give (?:your\s+)?recommendation (?:upfront|first|at the top)|"
            r"upfront recommendation (?:then|before)|"
            r"recommendation before (?:the\s+)?(?:analysis|rationale|details)|"
            r"open with (?:your\s+)?recommendation|"
            r"lead with what you recommend)\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(recommend|choose|pick|select|decide|advise|should we|which (?:option|approach|tool|vendor)|"
        r"go with|prefer|adoption|migrate|switch|buy|build vs buy)\b",
        m,
    ):
        return None
    instr = (
        "The user wants **recommendation-first** structure: open with a short **Recommendation** line "
        "that states clearly what you advise (one concrete choice or go/no-go), **then** provide "
        "supporting rationale—do not bury the recommendation after long background."
    )
    return instr, "recommendation_first"


def _embedded_go_no_go(m: str) -> tuple[str, str] | None:
    """``go_no_go`` — explicit Go / No-go / Conditional gate verdict for approval reviews."""
    if len(m) < 48:
        return None
    no_gng = bool(
        re.search(
            r"\b(no go[- ]?/?no[- ]?go|without (?:a\s+)?go[- ]?/?no[- ]?go|"
            r"skip (?:the\s+)?go[- ]?/?no[- ]?go|not a go[- ]?/?no[- ]?go|"
            r"don'?t (?:include|use) go[- ]?/?no[- ]?go|"
            r"avoid go[- ]?/?no[- ]?go (?:format|section|verdict)|"
            r"no proceed[- ]or[- ]halt section)\b",
            m,
        )
    )
    if no_gng:
        return None
    want = bool(
        re.search(
            r"\b(go[- ]?/?no[- ]?go (?:decision|recommendation|verdict|call|assessment)|"
            r"go or no[- ]go|no[- ]go or go|"
            r"proceed or (?:halt|pause|stop)|halt or proceed|"
            r"should we proceed (?:or|vs\.?) (?:pause|halt|stop|wait)|"
            r"gate review (?:decision|memo|recommendation)|"
            r"approval gate (?:decision|review)|"
            r"launch gate (?:decision|review)|"
            r"explicit (?:go|no[- ]go) (?:verdict|recommendation))\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(rollout|launch|release|migrate|deploy|production|project|initiative|"
        r"approve|approval|steering|committee|board|gate|proceed|write|memo|report|assess|decide)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **go/no-go gate** verdict: open with a bold **Go**, **No-go**, or "
        "**Conditional go** line (pick one), then brief **Criteria met**, **Risks / blockers**, and "
        "**Conditions** (if conditional)—keep it decision-ready for an approval meeting."
    )
    return instr, "go_no_go"


def _embedded_actionability(m: str) -> str | None:
    """``commands`` vs ``conceptual`` actionability (not short *Make it actionable* / *Conceptual only* controls)."""
    if len(m) < 44:
        return None
    conceptual = bool(
        re.search(
            r"\b(conceptual only|high level only|no commands|without commands|no shell commands|"
            r"avoid command dumps|don'?t include (?:bash|shell|terminal) commands|"
            r"focus on concepts(?:\s+and\s+rationale)?|strategic discussion only|"
            r"architecture overview only|no runnable snippets|theory and tradeoffs only)\b",
            m,
        )
    )
    commands = bool(
        re.search(
            r"\b(include (?:a\s+)?(?:bash|sh|zsh|powershell) snippet|run(?:nable)? commands?|"
            r"copy[- ]paste (?:into )?(?:the\s+)?(?:terminal|shell)|"
            r"curl (?:one[- ]?liner|example)|one[- ]liner (?:for|to)|"
            r"bash one[- ]liner|powershell command|terminal commands?|"
            r"give me (?:the\s+)?(?:exact\s+)?commands?|include kubectl|"
            r"docker (?:run|compose) (?:example|snippet)|(?:pip|npm|pnpm|yarn) install (?:line|command)|"
            r"ready[- ]to[- ]run (?:script|snippet)|paste(?:able)? commands?)\b",
            m,
        )
    )
    if conceptual and commands:
        return None
    if conceptual:
        return "conceptual"
    if commands:
        return "commands"
    return None


def _embedded_confidence_tone(m: str) -> str | None:
    """``transparent`` vs ``assertive`` confidence (not short *Flag assumptions* / *Be decisive* controls)."""
    if len(m) < 44:
        return None
    skip_transparent = bool(
        re.search(
            r"\b(no assumptions? section|skip (?:the\s+)?assumptions?|don'?t list assumptions|"
            r"without caveats|no caveats|omit limitations)\b",
            m,
        )
    )
    transparent = (
        not skip_transparent
        and (
            bool(
                re.search(
                    r"\b(state|list|spell out|call out|identify|enumerate|label)\s+"
                    r"(?:your\s+|the\s+|our\s+|key\s+|main\s+)?(?:key\s+|main\s+)?assumptions?\b",
                    m,
                )
            )
            or bool(
                re.search(
                    r"\b(assumptions?\s+and\s+limitations?|limitations?\s+and\s+caveats?|"
                    r"limitations?\s+section|caveats?\s+(?:first|upfront|at\s+the\s+top)|"
                    r"upfront\s+caveats?|scope\s+and\s+assumptions?|boundary\s+conditions?|"
                    r"what\s+(?:we\s+)?(?:are\s+)?assuming\b|"
                    r"explicit(?:ly)?\s+about\s+(?:limitations?|uncertainty|what\s+we\s+don'?t\s+know)|"
                    r"where\s+this\s+(?:breaks?\s+down|stops?\s+working|doesn'?t\s+apply))\b",
                    m,
                )
            )
            or bool(
                re.search(
                    r"\b(flag|surface|highlight)\s+(?:key\s+)?(?:uncertainties|unknowns|gaps|risk\s+factors)\b",
                    m,
                )
            )
        )
    )
    assertive = bool(
        re.search(
            r"\b(be decisive|don'?t hedge|give firm answers?|minimal hedging|"
            r"sound\s+confident|avoid disclaimers|confident (?:recommendation|tone)|"
            r"take a clear stance|no throat[- ]clearing|decisive recommendation)\b",
            m,
        )
    )
    if transparent and assertive:
        return None
    if transparent:
        return "transparent"
    if assertive:
        return "assertive"
    return None


def _embedded_example_density(m: str) -> str | None:
    """``rich`` or ``sparse`` from prose (not the short *Include examples* / *Skip examples* control lines)."""
    if len(m) < 44:
        return None
    sparse = bool(
        re.search(
            r"\b(skip examples?|don'?t add examples?|don'?t include examples?|"
            r"without examples?|keep (?:it\s+)?abstract|theory[- ]only|abstract only|"
            r"example[- ]free|no examples? (?:please|in your (?:answer|reply))|"
            r"avoid illustrative examples?)\b",
            m,
        )
    )
    rich = bool(
        re.search(
            r"\b(include (?:at\s+least\s+)?(?:one|two|a few)\s+concrete examples?|"
            r"at least one (?:short\s+)?concrete example|"
            r"illustrate (?:this|that|it)\s+with (?:a\s+)?(?:concrete\s+|real[- ]world\s+)?example|"
            r"worked example|walk(?:\s+me)? through (?:a\s+)?(?:small|tiny|toy|minimal)\s+example|"
            r"\b(?:a\s+)?toy example\b|miniature scenario|"
            r"ground (?:this|it|your answer) in (?:a\s+)?(?:concrete\s+)?example|"
            r"give (?:me\s+)?a (?:concrete\s+)?example|"
            r"show (?:me\s+)?(?:this\s+)?with (?:a\s+)?(?:concrete\s+)?example)\b",
            m,
        )
    )
    if sparse and rich:
        return None
    if sparse:
        return "sparse"
    if rich:
        return "rich"
    return None


def _embedded_exposition_order(m: str) -> str | None:
    """``definitions_first`` vs ``intuition_first`` from prose (not short *Definitions first* controls)."""
    if len(m) < 48:
        return None
    if re.search(
        r"\b(skip definitions first|don'?t start with definitions|"
        r"no formal definitions upfront)\b",
        m,
    ):
        return None
    if re.search(
        r"\b(skip the intuition|cut the warm[- ]?up|no hand[- ]?wavy intro)\b",
        m,
    ):
        return None
    defn = bool(
        re.search(
            r"\b(define (?:the\s+)?(?:key\s+)?terms? (?:first|before|upfront)|"
            r"definitions?\s+(?:first|before|upfront)|"
            r"start with (?:a\s+)?(?:brief\s+)?definition|"
            r"formal definitions? (?:first|before)|"
            r"precise definitions? before|"
            r"terminology (?:first|upfront)|"
            r"establish definitions before|"
            r"glossary[- ]style (?:intro|opening)|"
            r"define jargon before)\b",
            m,
        )
    )
    intu = bool(
        re.search(
            r"\b(intuition (?:first|before (?:the\s+)?(?:math|formal|proof|details?))|"
            r"big[- ]picture (?:first|before|then)|"
            r"high[- ]level intuition (?:first|before)|"
            r"motivation before (?:the\s+)?(?:formal|proof|math)|"
            r"informal (?:picture|overview) before|"
            r"start with (?:the\s+)?(?:big\s+picture|intuition|high[- ]level sketch)|"
            r"warm(?:\s+up)? with (?:an?\s+)?intuitive)\b",
            m,
        )
    )
    if defn and intu:
        return None
    if defn:
        return "definitions_first"
    if intu:
        return "intuition_first"
    return None


def _embedded_glossary_section(m: str) -> tuple[str, str] | None:
    """``glossary`` — include a short glossary / key-terms definitions section."""
    if len(m) < 48:
        return None
    no_glossary = bool(
        re.search(
            r"\b(no glossary|without glossary|skip glossary|avoid glossary|don'?t (?:include|add) glossary)\b",
            m,
        )
    )
    if no_glossary:
        return None

    no_headings = bool(
        re.search(
            r"\b(flat answer|no section headings|avoid markdown headings|continuous prose only|prose without headings)\b",
            m,
        )
    )

    want = bool(
        re.search(
            r"\b(glossary(?:[- ]style)?|provide (?:a )?glossary|include (?:a )?glossary|"
            r"terms and definitions|define (?:the )?(?:key )?terms)\b",
            m,
        )
    )
    if not want or no_headings:
        return None

    instr = (
        "The user requested a **Glossary**: include a short **Glossary** section defining 3–8 "
        "key terms mentioned in the prompt (especially jargon). Provide each definition as a "
        "single concise sentence."
    )
    return instr, "glossary"


def _embedded_spelling_locale(m: str) -> tuple[str, str] | None:
    """``spelling_uk`` / ``spelling_us`` — British vs American English spelling in the reply."""
    if len(m) < 44:
        return None
    uk = bool(
        re.search(
            r"\b(british english|uk english|uk spelling|british spelling|"
            r"use british spellings?|spell(?:ing)? (?:in )?british english|"
            r"en[- ]?gb (?:spelling|english)|"
            r"colour not color|favour not favor|organise not organize)\b",
            m,
        )
    )
    us = bool(
        re.search(
            r"\b(american english|us english|us spelling|american spelling|"
            r"use american spellings?|spell(?:ing)? (?:in )?american english|"
            r"en[- ]?us (?:spelling|english)|"
            r"color not colour|favor not favour|organize not organise)\b",
            m,
        )
    )
    if uk and us:
        return None
    if uk:
        instr = (
            "The user asked for **British English (UK) spelling** throughout the reply "
            "(e.g. colour, organise, centre, licence)—not US forms unless quoting source text verbatim."
        )
        return instr, "spelling_uk"
    if us:
        instr = (
            "The user asked for **American English (US) spelling** throughout the reply "
            "(e.g. color, organize, center, license)—not UK forms unless quoting source text verbatim."
        )
        return instr, "spelling_us"
    return None


def _embedded_timeline_order(m: str) -> tuple[str, str] | None:
    """``timeline_chron`` / ``timeline_reverse`` — chronological vs reverse-chronological event layout."""
    if len(m) < 48:
        return None
    if re.search(
        r"\b(no timeline|not a timeline|without a timeline|skip (?:the )?timeline|"
        r"don'?t use a timeline)\b",
        m,
    ):
        return None
    reverse = bool(
        re.search(
            r"\b(reverse chronological|anti[- ]chronological|newest first|most recent first|"
            r"latest first|work backwards|backward in time|from latest to earliest|"
            r"most recent event first)\b",
            m,
        )
    )
    chron = bool(
        re.search(
            r"\b(?:in chronological order|(?<!reverse )chronological order|time order|"
            r"timeline format|as a timeline|event timeline|what happened when|"
            r"from earliest to latest|oldest first|earliest first|"
            r"history in order)\b",
            m,
        )
    )
    if reverse and chron:
        return None
    if not re.search(
        r"\b(explain|describe|summarize|outline|what happened|history|incident|outage|"
        r"rollout|migration|deployment|release|postmortem|timeline|events|sequence|"
        r"when did|how did .{0,40} unfold)\b",
        m,
    ):
        return None
    if reverse:
        instr = (
            "The user wants a **reverse-chronological timeline**: list events **newest → oldest** "
            "with short date/time or phase labels (e.g. **Now**, **T+2h**, **Day 0**); one line or "
            "bullet per milestone."
        )
        return instr, "timeline_reverse"
    if chron:
        instr = (
            "The user wants a **chronological timeline**: list events **earliest → latest** "
            "with short date/time or phase labels (e.g. **09:00 UTC**, **Phase 1**, **Day 2**); "
            "one line or bullet per milestone."
        )
        return instr, "timeline_chron"
    return None


def _embedded_writing_voice(m: str) -> tuple[str, str] | None:
    """``voice_second`` / ``voice_third`` — address reader as *you* vs impersonal third person."""
    if len(m) < 48:
        return None
    third = bool(
        re.search(
            r"\b(third person|3rd person|impersonal tone|impersonal voice|"
            r"don'?t address (?:the )?reader as you|avoid second person|"
            r"no second person|don'?t use (?:you|your) (?:throughout|in the reply)|"
            r"refer to (?:the )?user(?:s)? not you|neutral documentation voice|"
            r"formal documentation style.{0,30}not you)\b",
            m,
        )
    )
    second = bool(
        re.search(
            r"\b(?:(?<!avoid )(?<!no )second person|2nd person|"
            r"speak directly to (?:the )?reader|talk to me as the user|"
            r"use you and your throughout|write to me using you|"
            r"directly address me as you|use second[- ]person (?:you|voice))\b",
            m,
        )
    )
    if not second and re.search(r"\baddress (?:the )?reader as you\b", m):
        if not re.search(r"\b(don'?t|do not) address (?:the )?reader as you\b", m):
            second = True
    if second and third:
        return None
    if not re.search(
        r"\b(explain|describe|write|draft|guide|help|walk|tell|outline|"
        r"document|instructions|how (?:do|can|should) i|tutorial|onboarding)\b",
        m,
    ):
        return None
    if second:
        instr = (
            "The user wants **second-person voice**: address the reader as **you/your** "
            "(tutorial or coaching tone)—not impersonal third-person phrasing like "
            "*the user should* unless quoting policy verbatim."
        )
        return instr, "voice_second"
    if third:
        instr = (
            "The user wants **third-person / impersonal voice**: avoid addressing the reader "
            "as **you**; prefer neutral phrasing (*the administrator*, *one*, *the team*) "
            "suited to formal docs or policy text."
        )
        return instr, "voice_third"
    return None


def _embedded_faq_qa_format(m: str) -> tuple[str, str] | None:
    """``faq_qa`` — reply as explicit question-and-answer pairs (``Q:`` / ``A:`` layout)."""
    if len(m) < 48:
        return None
    no_qa = bool(
        re.search(
            r"\b(no q&a format|not q&a format|without q&a|skip q&a format|"
            r"don'?t use q&a|prose not q&a|not in q&a format|"
            r"no question[- ]and[- ]answer pairs?|avoid q&a layout)\b",
            m,
        )
    )
    if no_qa:
        return None
    want = bool(
        re.search(
            r"\b(q&a format|question[- ]and[- ]answer format|questions? and answers? format|"
            r"format as q&a|faq[- ]style q&a|faq q&a layout|"
            r"each question (?:with|followed by) (?:an )?answer|"
            r"question answer pairs?|q:\s*/\s*a: layout|"
            r"use q:\s*and a:\s*headings|pair each question with an answer)\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(explain|describe|write|draft|document|outline|prepare|"
        r"faq|support|customer|policy|helpdesk|knowledge base|kb)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **FAQ Q&A layout**: structure the reply as clear **question → answer** "
        "pairs using markdown labels **Q:** and **A:** (or **Question** / **Answer** headings); "
        "keep each answer concise under its question—not one undifferentiated essay."
    )
    return instr, "faq_qa"


def _embedded_summary_last(m: str) -> tuple[str, str] | None:
    """``summary_last`` — close the reply with a brief recap (complement to ``answer_lead=tldr_first``)."""
    if len(m) < 44:
        return None
    no_end = bool(
        re.search(
            r"\b(no summary at the end|skip (?:the )?(?:closing|final) summary|"
            r"don'?t (?:add|end with) a (?:tldr|summary) at the end|"
            r"without a closing summary|no recap at the end)\b",
            m,
        )
    )
    if no_end:
        return None
    tldr_first = bool(
        re.search(
            r"\b(tl;?dr first|tldr first|summary first|executive summary first|"
            r"bottom line up front|\bbluf\b|lead with (?:a\s+)?(?:one[- ]line\s+)?summary|"
            r"(?:key\s+)?takeaway first|headline first)\b",
            m,
        )
    )
    end_sum = bool(
        re.search(
            r"\b(summary at the end|tldr at the (?:bottom|end)|executive summary at the end|"
            r"wrap up with (?:a\s+)?(?:brief\s+)?summary|close with (?:a\s+)?(?:one[- ]line\s+)?summary|"
            r"end with (?:a\s+)?(?:brief\s+)?(?:summary|tldr|recap|key takeaway)|"
            r"recap at the (?:bottom|end)|closing summary|final summary (?:line|paragraph))\b",
            m,
        )
    )
    if not end_sum or tldr_first:
        return None
    if not re.search(
        r"\b(explain|describe|write|draft|summarize|report|outline|brief|memo|answer|"
        r"analysis|review|compare|recommend)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **closing summary**: after the main answer, end with a short "
        "**Summary** or **TL;DR** line (1–3 sentences) that recaps the key takeaway—"
        "do **not** open with that recap (unless they also asked for BLUF elsewhere)."
    )
    return instr, "summary_last"


def _embedded_decision_matrix(m: str) -> tuple[str, str] | None:
    """``decision_matrix`` — criteria × options markdown table for side-by-side evaluation."""
    if len(m) < 48:
        return None
    no_matrix = bool(
        re.search(
            r"\b(no decision matrix|without a (?:decision|comparison|feature) matrix|"
            r"not a (?:decision|comparison|feature) matrix|skip the matrix|"
            r"don'?t use a (?:decision|comparison|feature) matrix|"
            r"avoid a (?:decision|comparison|feature) matrix|"
            r"no matrix (?:format|table))\b",
            m,
        )
    )
    if no_matrix:
        return None
    want = bool(
        re.search(
            r"\b(decision matrix|comparison matrix|feature matrix|"
            r"evaluation matrix|criteria matrix|"
            r"score each option (?:on|against|across)|"
            r"matrix (?:comparing|of) (?:the )?(?:options|vendors|tools|alternatives|platforms)|"
            r"options (?:as|in) columns?(?: and criteria as rows?)?|"
            r"criteria (?:as|in) rows?(?: and options as columns?)?|"
            r"side[- ]by[- ]side matrix|"
            r"rate each option (?:on|against) (?:each|the) criteri(?:a|on))\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(compare|choose|pick|select|evaluate|decide|recommend|rank|"
        r"vendor|tool|option|alternative|approach|platform|solution)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **decision matrix**: include a markdown **table** with **options/alternatives "
        "as columns** and **evaluation criteria as rows** (cells: short scores, ratings, or ✓/✗). "
        "Add a one-line legend if you use symbols; keep supporting prose outside the table."
    )
    return instr, "decision_matrix"


def _embedded_build_vs_buy(m: str) -> tuple[str, str] | None:
    """``build_vs_buy`` — structured Build (in-house) vs Buy (vendor/SaaS) decision layout."""
    if len(m) < 48:
        return None
    no_bvb = bool(
        re.search(
            r"\b(no build[- ]vs[- ]buy|without (?:a\s+)?build[- ]vs[- ]buy|"
            r"skip (?:the\s+)?build[- ]vs[- ]buy|not a build[- ]vs[- ]buy|"
            r"don'?t use build[- ]vs[- ]buy|avoid build[- ]vs[- ]buy (?:analysis|section)|"
            r"no make[- ]vs[- ]buy section)\b",
            m,
        )
    )
    if no_bvb:
        return None
    want = bool(
        re.search(
            r"\b(build[- ]vs[- ]buy|build[- ]versus[- ]buy|make[- ]vs[- ]buy|make[- ]versus[- ]buy|"
            r"build or buy|make or buy|"
            r"in[- ]house vs (?:vendor|outsource|saas|third[- ]party)|"
            r"build in[- ]house (?:vs\.?|versus|or) (?:buy|purchase|vendor)|"
            r"custom build vs (?:commercial|off[- ]the[- ]shelf|saas|vendor)|"
            r"diy vs (?:buy|purchase|vendor solution))\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(build|buy|vendor|outsource|saas|platform|tool|service|solution|"
        r"decide|evaluate|recommend|assess|choose|write|describe|outline|report|memo)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **build vs buy** analysis: structure the answer with markdown headings "
        "**Build (in-house)** and **Buy (vendor/SaaS)** (bullets under each on cost, time, risk, "
        "and fit), then a brief **Recommendation** line—do not bury the choice after long background."
    )
    return instr, "build_vs_buy"


def _embedded_one_pager(m: str) -> tuple[str, str] | None:
    """``one_pager`` — single-page executive brief with fixed scannable sections."""
    if len(m) < 48:
        return None
    no_op = bool(
        re.search(
            r"\b(no one[- ]pager|without (?:a\s+)?one[- ]pager|not a one[- ]pager|"
            r"skip (?:the\s+)?one[- ]pager|don'?t use one[- ]pager|"
            r"avoid one[- ]pager (?:format|section|layout)|"
            r"no single[- ]page (?:brief|memo format))\b",
            m,
        )
    )
    if no_op:
        return None
    bluf_first = bool(
        re.search(
            r"\b(tl;?dr first|tldr first|summary first|executive summary first|"
            r"bottom line up front|\bbluf\b|lead with (?:a\s+)?(?:one[- ]line\s+)?summary)\b",
            m,
        )
    )
    end_sum = bool(
        re.search(
            r"\b(summary at the end|tldr at the (?:bottom|end)|executive summary at the end|"
            r"wrap up with (?:a\s+)?(?:brief\s+)?summary|close with (?:a\s+)?(?:one[- ]line\s+)?summary)\b",
            m,
        )
    )
    if bluf_first or end_sum:
        return None
    want = bool(
        re.search(
            r"\b(one[- ]pager(?:\s+format|\s+memo|\s+brief|\s+summary)?|"
            r"one page (?:memo|brief|summary|write[- ]up|document)|"
            r"single[- ]page (?:brief|memo|summary|executive brief)|"
            r"executive one[- ]pager|"
            r"fit(?:s|ting)? on (?:a\s+)?single page|"
            r"one[- ]page (?:executive\s+)?(?:brief|memo|summary))\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(write|draft|prepare|outline|describe|brief|memo|report|"
        r"leadership|executive|steering|board|stakeholder|committee|"
        r"initiative|program|proposal|decision|update)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **one-pager** executive brief: use compact markdown headings "
        "**Title / Purpose**, **Context**, **Problem / Opportunity**, **Recommendation** "
        "(1–2 sentences), **Key points** (3–5 bullets), **Next steps**, and brief "
        "**Risks / dependencies**—keep it scannable on one screen; avoid long background prose."
    )
    return instr, "one_pager"


def _embedded_action_plan(m: str) -> tuple[str, str] | None:
    """``action_plan`` — actionable items with owners and due dates (not ``- [ ]`` checklists)."""
    if len(m) < 48:
        return None
    no_ap = bool(
        re.search(
            r"\b(no action plan|without (?:an\s+)?action plan|not an action plan|"
            r"skip (?:the\s+)?action plan|don'?t use action plan|"
            r"avoid action plan (?:format|section|table)|"
            r"no implementation plan (?:table|format))\b",
            m,
        )
    )
    if no_ap:
        return None
    checklist_only = bool(
        re.search(
            r"\b((?:as a|use a|markdown) checklist|checklist (?:format|style)|"
            r"tick[- ]box(?:es)?|checkbox(?:es)? (?:list|format))\b",
            m,
        )
    )
    if checklist_only:
        return None
    want = bool(
        re.search(
            r"\b(action plan(?:\s+format)?|implementation plan(?:\s+with)?(?:\s+)?owners|"
            r"who does what(?:\s+by when)?|owners? and (?:due dates?|deadlines?|timelines?)|"
            r"assign owners?(?:\s+and)?(?:\s+)?(?:due dates?|deadlines?)|"
            r"delivery plan with owners|work plan with (?:owners|assignees)|"
            r"table of actions? (?:with|and) (?:owners?|due dates?))\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(rollout|deploy|launch|migrate|implement|project|program|initiative|"
        r"sprint|workstream|deliverable|plan|outline|write|describe|track|execute)\b",
        m,
    ):
        return None
    instr = (
        "The user wants an **action plan**: list actionable items in a markdown **table** "
        "(or clearly labeled rows) with **Action**, **Owner** (role/team), **Due / target date** "
        "(or phase), and brief **Notes** if needed—group by phase when useful; "
        "use **not** `- [ ]` checkbox checklists unless they also asked for tick-boxes."
    )
    return instr, "action_plan"


def _embedded_raci_matrix(m: str) -> tuple[str, str] | None:
    """``raci`` — Responsible / Accountable / Consulted / Informed role assignment table."""
    if len(m) < 48:
        return None
    no_raci = bool(
        re.search(
            r"\b(no raci|without (?:a\s+)?raci|not a raci|skip (?:the\s+)?raci|"
            r"don'?t use raci|avoid raci (?:matrix|chart|table)|"
            r"no raci (?:matrix|chart|table|section))\b",
            m,
        )
    )
    if no_raci:
        return None
    want = bool(
        re.search(
            r"\b(raci matrix|raci chart|raci table|raci format|"
            r"responsible[, ]+accountable[, ]+consulted[, ]+(?:and )?informed|"
            r"\braci\b.{0,40}(?:responsible|accountable|consulted|informed)|"
            r"r\s*\/\s*a\s*\/\s*c\s*\/\s*i (?:matrix|roles|chart)|"
            r"who is (?:responsible|accountable) (?:vs\.?|and|versus) (?:consulted|informed)|"
            r"assign (?:raci|r\s*\/\s*a\s*\/\s*c\s*\/\s*i) roles)\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(project|rollout|migration|initiative|workstream|deliverable|team|"
        r"launch|deployment|program|plan|outline|write|describe|assign|ownership)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **RACI matrix**: include a markdown **table** with rows for key "
        "tasks/workstreams and columns **R** (Responsible), **A** (Accountable), **C** (Consulted), "
        "**I** (Informed)—use role names or teams in cells; add a one-line legend if needed."
    )
    return instr, "raci"


def _embedded_stakeholder_map(m: str) -> tuple[str, str] | None:
    """``stakeholder_map`` — influence/interest stakeholder table (distinct from ``raci`` task roles)."""
    if len(m) < 48:
        return None
    no_sm = bool(
        re.search(
            r"\b(no stakeholder map|without (?:a\s+)?stakeholder map|not a stakeholder map|"
            r"skip (?:the\s+)?stakeholder map|don'?t use stakeholder map|"
            r"avoid stakeholder (?:map|matrix|analysis)|"
            r"no stakeholder (?:map|matrix|analysis format))\b",
            m,
        )
    )
    if no_sm:
        return None
    raci_only = bool(
        re.search(
            r"\b(raci matrix|raci chart|raci table|"
            r"responsible[, ]+accountable[, ]+consulted[, ]+(?:and )?informed|"
            r"r\s*\/\s*a\s*\/\s*c\s*\/\s*i (?:matrix|roles|chart))\b",
            m,
        )
    )
    if raci_only:
        return None
    want = bool(
        re.search(
            r"\b(stakeholder map(?:\s+format)?|stakeholder matrix|stakeholder analysis|"
            r"map (?:the\s+)?stakeholders?|stakeholder mapping|"
            r"influence[- ](?:interest|impact) (?:matrix|grid|map)|"
            r"power[- ]interest (?:matrix|grid|map)|"
            r"interest[- ]influence (?:matrix|grid)|"
            r"who (?:are|is) (?:the\s+)?stakeholders? (?:and|with) (?:their\s+)?(?:influence|interests))\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(project|rollout|migration|initiative|program|change|launch|"
        r"communicate|engage|adopt|implement|outline|write|describe|plan|announce)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **stakeholder map**: include a markdown **table** with columns "
        "**Stakeholder / group**, **Interest**, **Influence** (High/Med/Low), **Key concerns**, "
        "and **Engagement approach**—optionally add a one-line **Power–Interest** quadrant note; "
        "this is **not** a RACI task-assignment matrix."
    )
    return instr, "stakeholder_map"


def _embedded_swot_analysis(m: str) -> tuple[str, str] | None:
    """``swot`` — Strengths / Weaknesses / Opportunities / Threats strategic layout."""
    if len(m) < 48:
        return None
    no_swot = bool(
        re.search(
            r"\b(no swot|without (?:a\s+)?swot|not a swot|skip (?:the\s+)?swot|"
            r"don'?t use swot|avoid swot|no swot (?:format|section|framework))\b",
            m,
        )
    )
    if no_swot:
        return None
    want = bool(
        re.search(
            r"\b(swot analysis|swot format|swot framework|swot breakdown|"
            r"strengths[, ]+weaknesses[, ]+opportunities[, ]+(?:and )?threats|"
            r"strengths weaknesses opportunities threats|"
            r"s\.w\.o\.t\.|"
            r"\bswot\b.{0,40}(?:strengths|weaknesses|opportunities|threats))\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(analy(?:s|z)e|analysis|assess|evaluate|review|plan|strategy|launch|"
        r"product|initiative|market|competitive|position|expansion|rollout|"
        r"describe|write|outline|report|memo)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **SWOT analysis**: structure the answer with markdown headings "
        "**Strengths**, **Weaknesses**, **Opportunities**, and **Threats** (bullets under each). "
        "Focus on one subject (product, team, initiative, or market position)—not a generic essay."
    )
    return instr, "swot"


def _embedded_pestle_analysis(m: str) -> tuple[str, str] | None:
    """``pestle`` — Political / Economic / Social / Technological / Legal / Environmental macro scan."""
    if len(m) < 48:
        return None
    no_pestle = bool(
        re.search(
            r"\b(no pestle|without (?:a\s+)?pestle|not a pestle|skip (?:the\s+)?pestle|"
            r"don'?t use pestle|avoid pestle|no pestle (?:format|section|framework))\b",
            m,
        )
    )
    if no_pestle:
        return None
    want = bool(
        re.search(
            r"\b(pestle analysis|pestle format|pestle framework|pestle breakdown|"
            r"political[, ]+economic[, ]+social[, ]+technological[, ]+legal[, ]+(?:and )?environmental|"
            r"political economic social technological legal environmental|"
            r"p\.e\.s\.t\.l\.e\.|"
            r"\bpestle\b.{0,40}(?:political|economic|social|technological|legal|environmental))\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(analy(?:s|z)e|analysis|assess|evaluate|review|plan|strategy|market|"
        r"expansion|entry|regulatory|policy|macro|environment|industry|"
        r"describe|write|outline|report|memo|initiative)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **PESTLE analysis**: structure the answer with markdown headings "
        "**Political**, **Economic**, **Social**, **Technological**, **Legal**, and **Environmental** "
        "(bullets under each). Focus on external macro factors affecting one market or initiative."
    )
    return instr, "pestle"


def _embedded_cost_benefit(m: str) -> tuple[str, str] | None:
    """``cost_benefit`` — structured costs vs benefits analysis for business cases."""
    if len(m) < 48:
        return None
    no_cb = bool(
        re.search(
            r"\b(no cost[- ]benefit|without (?:a\s+)?cost[- ]benefit|"
            r"skip (?:the\s+)?cost[- ]benefit|not a cost[- ]benefit|"
            r"don'?t use cost[- ]benefit|avoid cost[- ]benefit (?:format|section)|"
            r"no cba section|skip (?:the\s+)?cba)\b",
            m,
        )
    )
    if no_cb:
        return None
    want = bool(
        re.search(
            r"\b(cost[- ]benefit analysis|cost benefit analysis|"
            r"costs? and benefits? (?:analysis|breakdown|section)|"
            r"benefits? (?:and|vs\.?) costs? (?:analysis|breakdown)|"
            r"\bcba\b (?:format|analysis|section)|"
            r"weigh (?:the\s+)?costs? against (?:the\s+)?benefits?|"
            r"weigh benefits? against costs?|"
            r"costs? versus benefits? (?:analysis|comparison))\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(project|proposal|invest|build|migrate|rollout|initiative|business case|"
        r"strategy|plan|evaluate|assess|decide|recommend|write|describe|outline|report|memo)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **cost-benefit analysis**: structure the answer with markdown headings "
        "**Costs** and **Benefits** (bullets under each), then a brief **Net assessment** line "
        "comparing them—keep dollar/time estimates qualitative unless the user supplied numbers."
    )
    return instr, "cost_benefit"


def _embedded_open_questions(m: str) -> tuple[str, str] | None:
    """``open_questions`` — end section listing unresolved unknowns / TBD items (not user-facing closers)."""
    if len(m) < 48:
        return None
    no_oq = bool(
        re.search(
            r"\b(no open questions?|without (?:an?\s+)?open questions? section|"
            r"skip (?:the\s+)?open questions?|don'?t (?:include|list) open questions?|"
            r"not an open questions? section|avoid (?:an?\s+)?open questions? section|"
            r"no tbd section|skip (?:the\s+)?(?:tbd|unknowns?) section)\b",
            m,
        )
    )
    if no_oq:
        return None
    want = bool(
        re.search(
            r"\b(open questions? section|include (?:an?\s+)?open questions?|"
            r"list (?:the\s+)?open questions?|outstanding questions?|unresolved questions?|"
            r"questions? (?:we )?still need (?:to )?(?:answer|resolve)|"
            r"what(?:'s| is) still (?:unknown|tbd|unclear)|"
            r"(?:information|info) gaps?(?: to (?:flag|note))?|"
            r"unknowns? (?:to|we still need to) (?:flag|resolve|clarify)|"
            r"tbd items?(?: at the end)?|"
            r"end with (?:an?\s+)?open questions? section)\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(plan|proposal|memo|report|outline|draft|review|analysis|initiative|"
        r"rollout|strategy|design|recommend|assess|evaluate|write|describe|explain)\b",
        m,
    ):
        return None
    instr = (
        "The user wants an **Open questions** section: after the main answer, add a heading "
        "**Open questions** with 3–6 bullet points listing **unresolved unknowns**, missing data, "
        "or decisions still TBD—do **not** use this section to ask the user rhetorical follow-ups "
        "or stock closers like “let me know if you need more.”"
    )
    return instr, "open_questions"


def _embedded_scenario_cases(m: str) -> tuple[str, str] | None:
    """``scenario_cases`` — Best / base / worst case (or similar) multi-scenario breakdown."""
    if len(m) < 48:
        return None
    no_sc = bool(
        re.search(
            r"\b(no scenarios?|without (?:a\s+)?scenario analysis|skip (?:the\s+)?scenario(?:s)?|"
            r"don'?t use scenarios?|avoid scenario analysis|not a scenario analysis|"
            r"single scenario only|one scenario only|no best[- ]case section)\b",
            m,
        )
    )
    if no_sc:
        return None
    want = bool(
        re.search(
            r"\b(best[- ]case(?:\s*[/,&]\s*(?:base|worst)[- ]case)?|"
            r"worst[- ]case(?:\s*[/,&]\s*(?:base|best)[- ]case)?|"
            r"base[- ]case(?:\s*[/,&]\s*(?:best|worst)[- ]case)?|"
            r"best,?\s+base,?\s+(?:and\s+)?worst[- ]case|"
            r"optimistic,?\s+(?:realistic|base)[, ]+(?:and\s+)?pessimistic|"
            r"scenario analysis|three scenarios?|3 scenarios?|"
            r"multiple scenarios?|range of outcomes?|"
            r"upside[- ]downside[- ]base|bull[- ]base[- ]bear case)\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(plan|forecast|budget|revenue|growth|launch|initiative|rollout|strategy|"
        r"project|invest|risk|outlook|memo|report|analysis|assess|evaluate|describe|write|explain)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **scenario analysis**: structure the answer with markdown headings "
        "**Best case**, **Base case**, and **Worst case** (or clearly labeled optimistic / "
        "realistic / pessimistic scenarios). Under each, give 2–4 bullet points on outcomes, "
        "assumptions, and key triggers—keep it focused on one decision or initiative."
    )
    return instr, "scenario_cases"


def _embedded_postmortem_format(m: str) -> tuple[str, str] | None:
    """``postmortem`` — blameless incident postmortem scaffold (SRE-style sections)."""
    if len(m) < 48:
        return None
    no_pm = bool(
        re.search(
            r"\b(no postmortem|without (?:a\s+)?postmortem|not a postmortem|"
            r"skip (?:the\s+)?postmortem|don'?t use postmortem format|"
            r"avoid postmortem (?:format|sections|template)|"
            r"no post[- ]mortem (?:format|template|sections))\b",
            m,
        )
    )
    if no_pm:
        return None
    want = bool(
        re.search(
            r"\b(postmortem format|post[- ]mortem format|blameless postmortem|"
            r"blameless post[- ]mortem|incident postmortem|postmortem template|"
            r"post[- ]mortem template|postmortem outline|structure (?:as|in) a postmortem|"
            r"write (?:it\s+)?(?:as|in) postmortem format|"
            r"postmortem.{0,50}(?:lessons learned|root cause|action items))\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(incident|outage|failure|on[- ]call|sre|deploy|rollback|downtime|"
        r"sev[0-9]|production|service|system|write|draft|outline|describe|explain|report)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **blameless postmortem** layout: use markdown headings "
        "**Summary**, **Impact**, **Timeline**, **Root cause**, **Lessons learned**, and "
        "**Action items** (short bullets under each). Stay factual and avoid blaming individuals."
    )
    return instr, "postmortem"


def _embedded_sprint_retro(m: str) -> tuple[str, str] | None:
    """``sprint_retro`` — agile sprint retrospective layout (distinct from incident ``postmortem``)."""
    if len(m) < 48:
        return None
    no_sr = bool(
        re.search(
            r"\b(no sprint retro|without (?:a\s+)?sprint retro|not a sprint retro|"
            r"skip (?:the\s+)?sprint retro|don'?t use sprint retro|"
            r"avoid sprint retro(?:spective)? (?:format|sections)|"
            r"no (?:sprint\s+)?retrospective format|"
            r"skip (?:the\s+)?(?:sprint\s+)?retrospective format)\b",
            m,
        )
    )
    if no_sr:
        return None
    postmortem_only = bool(
        re.search(
            r"\b(postmortem format|blameless postmortem|incident postmortem|"
            r"post[- ]mortem format|postmortem outline)\b",
            m,
        )
    )
    if postmortem_only:
        return None
    want = bool(
        re.search(
            r"\b(sprint retro(?:spective)?(?:\s+format)?|"
            r"sprint retrospective(?:\s+format)?|"
            r"agile retro(?:spective)?|scrum retro(?:spective)?|"
            r"retro format|retrospective format|"
            r"run (?:a\s+)?(?:sprint\s+)?retro(?:spective)?|"
            r"facilitate (?:a\s+)?(?:sprint\s+)?retro(?:spective)?)\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(sprint|iteration|scrum|agile|team|delivery|release|"
        r"reflect|review|improve|outline|write|describe|facilitate|discuss)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **sprint retrospective** layout: use markdown headings "
        "**Sprint / period** (one line), **What went well**, **What didn't go well**, "
        "**Ideas / experiments**, and **Action items** (concrete next-sprint improvements)—"
        "stay blameless and team-focused; this is **not** an incident postmortem."
    )
    return instr, "sprint_retro"


def _embedded_user_story(m: str) -> tuple[str, str] | None:
    """``user_story`` — agile As a / I want / So that stories with acceptance criteria."""
    if len(m) < 48:
        return None
    no_us = bool(
        re.search(
            r"\b(no user stor(?:y|ies)|without user stor(?:y|ies)|not user stor(?:y|ies)|"
            r"skip (?:the\s+)?user stor(?:y|ies)|don'?t use user stor(?:y|ies)|"
            r"avoid user story (?:format|template)|"
            r"no user story format|skip (?:the\s+)?user story format)\b",
            m,
        )
    )
    if no_us:
        return None
    star_only = bool(
        re.search(
            r"\b(star format|star method|situation[- ]task[- ]action[- ]result)\b",
            m,
        )
    )
    if star_only:
        return None
    want = bool(
        re.search(
            r"\b(user stor(?:y|ies)(?:\s+format)?|"
            r"write (?:the\s+)?user stor(?:y|ies)|"
            r"draft (?:the\s+)?user stor(?:y|ies)|"
            r"backlog (?:user\s+)?stor(?:y|ies)|"
            r"as an? .{0,48} i want .{0,72} so that|"
            r"acceptance criteria (?:for|per) (?:each|the) (?:user\s+)?stor(?:y|ies)|"
            r"in user story format|user story template)\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(backlog|sprint|product|feature|agile|scrum|requirement|"
        r"pm|develop|implement|write|draft|describe|outline|plan|sso|login|flow)\b",
        m,
    ):
        return None
    instr = (
        "The user wants **user stories**: for each story use a short **Title**, then "
        "**As a** … **I want** … **So that** … on separate lines, and **Acceptance criteria** "
        "(3–5 testable bullets or compact Given/When/Then)—INVEST-sized, not essay requirements."
    )
    return instr, "user_story"


def _embedded_definition_of_done(m: str) -> tuple[str, str] | None:
    """``definition_of_done`` — agile DoD checklist of verifiable completion criteria."""
    if len(m) < 48:
        return None
    no_dod = bool(
        re.search(
            r"\b(no definition of done|without (?:a\s+)?definition of done|"
            r"not a definition of done|skip (?:the\s+)?definition of done|"
            r"don'?t use definition of done|avoid definition of done (?:format|section)|"
            r"no dod format|skip (?:the\s+)?dod format|"
            r"no done criteria section|skip (?:the\s+)?done criteria section)\b",
            m,
        )
    )
    if no_dod:
        return None
    checklist_only = bool(
        re.search(
            r"\b((?:as a|use a|markdown) checklist|checklist (?:format|style)|"
            r"tick[- ]box(?:es)?|checkbox(?:es)? (?:list|format))\b",
            m,
        )
    )
    if checklist_only:
        return None
    want = bool(
        re.search(
            r"\b(definition of done(?:\s+format)?|definition[- ]of[- ]done|"
            r"\bdod\b(?:\s+format|\s+checklist|\s+criteria)?|"
            r"done criteria(?:\s+checklist)?|"
            r"what counts as done|exit criteria (?:for|on) (?:the\s+)?(?:story|sprint|feature|epic|release)|"
            r"completion criteria (?:for|before)|"
            r"ready for (?:done|merge|release) criteria)\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(sprint|story|epic|feature|backlog|agile|scrum|team|deliverable|"
        r"ship|merge|release|implement|write|draft|describe|outline|align)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **Definition of Done**: use a **Definition of Done** heading with a "
        "one-line **Scope** (story / sprint / release), then 5–10 **Done criteria** as "
        "verifiable bullets (code review, tests, docs, deploy, sign-off, etc.)—concrete and "
        "checkable; distinct from per-story **acceptance criteria** unless they asked for both."
    )
    return instr, "definition_of_done"


def _embedded_five_whys(m: str) -> tuple[str, str] | None:
    """``five_whys`` — iterative Why chain for root-cause analysis (distinct from full postmortem)."""
    if len(m) < 48:
        return None
    no_fw = bool(
        re.search(
            r"\b(no five whys|no 5 whys|without five whys|skip (?:the\s+)?(?:five|5) whys|"
            r"don'?t use (?:the\s+)?(?:five|5) whys|avoid five whys|"
            r"not a five whys|no why chain|skip (?:the\s+)?why chain)\b",
            m,
        )
    )
    if no_fw:
        return None
    want = bool(
        re.search(
            r"\b(five whys|5 whys|five[- ]whys analysis|5[- ]whys analysis|"
            r"five whys (?:method|technique|root cause)|"
            r"root cause (?:using|with|via) (?:the\s+)?(?:five|5) whys|"
            r"ask why (?:five|5) times|why chain analysis|"
            r"iterative whys?|successive whys?)\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(incident|outage|failure|bug|defect|problem|issue|root cause|"
        r"debug|diagnose|explain|investigate|analyze|analysis|why did|what caused)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **5 Whys** root-cause analysis: start with a one-line **Problem statement**, "
        "then numbered **Why 1** … **Why 5** (each answer feeds the next why; stop early if the root "
        "is clear), and end with a **Root cause** summary line—stay blameless and factual."
    )
    return instr, "five_whys"


def _embedded_fishbone(m: str) -> tuple[str, str] | None:
    """``fishbone`` — Ishikawa cause-and-effect diagram by category (complements ``five_whys``)."""
    if len(m) < 48:
        return None
    no_fb = bool(
        re.search(
            r"\b(no fishbone|without (?:a\s+)?fishbone|not a fishbone|"
            r"skip (?:the\s+)?fishbone|don'?t use fishbone|"
            r"avoid fishbone (?:diagram|analysis|format)|"
            r"no ishikawa (?:diagram|analysis)|"
            r"no cause[- ]and[- ]effect diagram)\b",
            m,
        )
    )
    if no_fb:
        return None
    want = bool(
        re.search(
            r"\b(fishbone (?:diagram|analysis|chart|format)|"
            r"ishikawa (?:diagram|analysis|chart|format)|"
            r"cause[- ]and[- ]effect (?:diagram|analysis|chart)|"
            r"fishbone.{0,40}(?:root cause|categories|6m|6 m)|"
            r"6\s*m(?:s)? (?:fishbone|analysis|diagram)|"
            r"diagram the causes? (?:by|into) categories)\b",
            m,
        )
    )
    if not want:
        return None
    if not re.search(
        r"\b(incident|outage|failure|defect|bug|problem|issue|quality|"
        r"process|production|root cause|analyze|analysis|investigate|"
        r"explain|describe|outline|diagnose|why did|what caused)\b",
        m,
    ):
        return None
    instr = (
        "The user wants a **fishbone (Ishikawa)** cause-and-effect analysis: start with "
        "**Problem / Effect** (one line), then markdown headings for cause categories "
        "(e.g. **People**, **Process**, **Technology**, **Environment**, **Materials/Data**, "
        "**Management/Policy**) with 2–4 sub-cause bullets under each; end with a brief "
        "**Likely root cause** line—stay blameless; optional compact ASCII spine is fine."
    )
    return instr, "fishbone"


def _embedded_followup_close(m: str) -> str | None:
    """``minimal`` vs ``suggest`` from prose (not short *No follow-up questions* controls)."""
    if len(m) < 48:
        return None
    minimal = bool(
        re.search(
            r"\b(no questions? at the end|don'?t (?:ask|end) with (?:a\s+)?questions?|"
            r"don'?t ask if i need (?:anything|more) else|don'?t ask whether i need more|"
            r"skip (?:the\s+)?(?:stock\s+)?closer|no follow[- ]up questions (?:at\s+the\s+)?(?:end|please)?|"
            r"don'?t prompt for follow[- ]ups?|finish crisply|stop after the core answer|"
            r"avoid rhetorical closers?|no offers? to help further|"
            r"don'?t (?:close|end) with (?:an?\s+)?(?:offer|invitation) to continue)\b",
            m,
        )
    )
    suggest = bool(
        re.search(
            r"\b(suggest next steps|optional next steps at the end|"
            r"end with (?:brief\s+)?(?:actionable\s+)?next steps|"
            r"close with suggested next actions|what should we do next|"
            r"offer ways to go deeper|give me follow[- ]ups? i can take|"
            r"recommend what to do next|include (?:optional\s+)?next steps)\b",
            m,
        )
    )
    if minimal and suggest:
        return None
    if minimal:
        return "minimal"
    if suggest:
        return "suggest"
    return None


def _embedded_clarify_first(m: str) -> str | None:
    """``on`` vs ``off`` from prose (not short *Clarify first* / *No clarifying questions* controls)."""
    if len(m) < 48:
        return None
    off = bool(
        re.search(
            r"\b(no clarifying questions (?:first|please)?|don'?t ask clarifying questions|"
            r"skip clarifying questions|answer without asking questions first|"
            r"don'?t (?:pause to\s+)?ask questions first|"
            r"give (?:your\s+)?best answer without asking|"
            r"don'?t interrogate me first|skip the q&a preamble|"
            r"answer immediately (?:even\s+)?if (?:the\s+)?(?:spec|specs) (?:is|are) incomplete)\b",
            m,
        )
    )
    on = bool(
        re.search(
            r"\b(ask clarifying questions before (?:you\s+)?answer|"
            r"clarify (?:any\s+)?ambiguities before|"
            r"if anything is unclear ask me first|"
            r"before you (?:answer|dive in) ask (?:me\s+)?(?:what\s+you\s+need|any questions)|"
            r"pause and ask (?:me\s+)?(?:short\s+)?questions if|"
            r"confirm my (?:constraints|requirements) before|"
            r"ask what you need (?:to know )?first|"
            r"i may have left details out[-—]\s*ask|"
            r"feel free to ask (?:me\s+)?(?:1[-–]3\s+)?clarifying questions first)\b",
            m,
        )
    )
    if on and off:
        return None
    if off:
        return "off"
    if on:
        return "on"
    return None


def _embedded_section_headings(m: str) -> str | None:
    """``prefer`` vs ``avoid`` for markdown ##/### structure (not short *Use section headings* controls)."""
    if len(m) < 48:
        return None
    avoid = bool(
        re.search(
            r"\b(flat answer|no section headings|avoid markdown headings|"
            r"no (?:##|hash)\s*style headings|without (?:##|markdown) title lines|"
            r"continuous prose (?:only|without headings)|"
            r"don'?t use (?:leading\s+)?#+\s*headings?|"
            r"skip (?:the\s+)?##\s*headers?)\b",
            m,
        )
    )
    prefer = bool(
        re.search(
            r"\b(use (?:markdown\s+)?(?:section\s+)?headings|organize with (?:markdown\s+)?headings|"
            r"structure (?:the\s+)?answer with (?:clear\s+)?headings|"
            r"break (?:it|this|the answer) into (?:titled\s+)?sections|"
            r"(?:clear\s+)?markdown headings for each|"
            r"##\s*(?:or|/)\s*###\s*headings|"
            r"top[- ]level headings for each (?:major\s+)?(?:topic|section))\b",
            m,
        )
    )
    if avoid and prefer:
        return None
    if avoid:
        return "avoid"
    if prefer:
        return "prefer"
    return None


def _embedded_analogy_use(m: str) -> str | None:
    """``prefer`` vs ``avoid`` for analogies/metaphors (not short *Use analogies* / *No analogies* controls)."""
    if len(m) < 48:
        return None
    avoid = bool(
        re.search(
            r"\b(no analogies|skip metaphors|avoid metaphors|skip the analogies|"
            r"without analogies or metaphors|literal (?:explanations?|wording) only|"
            r"don'?t use analogies|don'?t use metaphors|no cute comparisons|"
            r"stick to literal (?:technical\s+)?(?:language|description|wording)|"
            r"keep (?:it\s+)?strictly literal)\b",
            m,
        )
    )
    prefer = bool(
        re.search(
            r"\b(use (?:a\s+)?(?:helpful\s+|tight\s+)?analogy|"
            r"explain (?:it\s+)?with (?:a\s+)?(?:simple\s+)?(?:real[- ]world\s+)?analogy|"
            r"include (?:a\s+)?(?:brief\s+)?(?:metaphor|analogy)|"
            r"liken (?:this|it) to (?:something|a\s+familiar)|"
            r"compare (?:this|it)\s+to (?:a\s+)?(?:real[- ]world|everyday)|"
            r"map (?:this|it) to an everyday example|"
            r"metaphor that helps|ground (?:the\s+)?idea in (?:an?\s+)?analogy)\b",
            m,
        )
    )
    if avoid and prefer:
        return None
    if avoid:
        return "avoid"
    if prefer:
        return "prefer"
    return None


def _embedded_term_emphasis(m: str) -> str | None:
    """``highlight`` vs ``minimal`` inline bold (not short *Bold key terms* controls)."""
    if len(m) < 48:
        return None
    minimal = bool(
        re.search(
            r"\b(minimal bold|don'?t overuse bold|avoid excessive bold|"
            r"sparse bold|keep bold (?:to a )?minimum|"
            r"no bold except (?:for )?code|plain text without bold|"
            r"don'?t bold every|avoid bolding (?:whole|entire) sentences)\b",
            m,
        )
    )
    highlight = bool(
        re.search(
            r"\b(bold (?:the\s+)?(?:key\s+)?terms|highlight (?:the\s+)?(?:key\s+)?(?:terms|phrases)|"
            r"emphasize (?:the\s+)?(?:key\s+)?(?:terms|keywords)|"
            r"make (?:the\s+)?key terms stand out|"
            r"use bold (?:on|for) (?:a\s+)?(?:few\s+)?(?:key\s+)?(?:terms|phrases|keywords)|"
            r"so (?:execs|leadership|managers) can scan.{0,50}bold)\b",
            m,
        )
    )
    if minimal and highlight:
        return None
    if minimal:
        return "minimal"
    if highlight:
        return "highlight"
    return None


def _embedded_acronym_style(m: str) -> str | None:
    """``spell_out`` vs ``terse`` acronym handling (not short *Spell out acronyms* controls)."""
    if len(m) < 48:
        return None
    terse = bool(
        re.search(
            r"\b(assume (?:i|we) know acronyms|don'?t expand acronyms|"
            r"keep acronyms as[- ]is|skip acronym expansion|"
            r"no need to spell out acronyms|acronym[- ]literate (?:audience|readers?)|"
            r"terse acronyms only)\b",
            m,
        )
    )
    spell = bool(
        re.search(
            r"\b(spell out acronyms|expand acronyms (?:on|at) first use|"
            r"define acronyms when you (?:use|introduce)|"
            r"write out acronyms (?:on|at) first mention|"
            r"full form (?:once|on first mention).{0,40}(?:acronym|initialism)|"
            r"expand (?:each\s+)?(?:api|sla|sso|gdpr|hipaa|pci)[- ]style (?:term|acronym)|"
            r"for (?:auditors|compliance|non-technical).{0,50}spell out)\b",
            m,
        )
    )
    if spell and terse:
        return None
    if terse:
        return "terse"
    if spell:
        return "spell_out"
    return None


def _embedded_risk_posture(m: str) -> str | None:
    """``conservative`` vs ``pragmatic`` recommendation tone (not short *Be risk averse* controls)."""
    if len(m) < 48:
        return None
    pragmatic = bool(
        re.search(
            r"\b(optimize for speed|good enough is fine|be pragmatic about|"
            r"avoid over[- ]engineering|ship (?:it )?fast|move fast (?:and|&)|"
            r"time[- ]efficient (?:fix|approach|recommendation)|"
            r"practical trade[- ]offs over perfection|"
            r"don'?t gold[- ]plate|bias toward shipping)\b",
            m,
        )
    )
    conservative = bool(
        re.search(
            r"\b(err on the side of safety|be risk[- ]averse|"
            r"risk[- ]averse (?:recommendation|approach)|"
            r"choose the (?:safest|lower[- ]risk) option|"
            r"minimize (?:downside|blast radius)|"
            r"prefer (?:safer|low[- ]risk) (?:options?|paths?)|"
            r"conservative (?:recommendation|rollout|approach)|"
            r"safety[- ]first (?:for|on) (?:this|the) (?:rollout|migration|change))\b",
            m,
        )
    )
    if conservative and pragmatic:
        return None
    if conservative:
        return "conservative"
    if pragmatic:
        return "pragmatic"
    return None


def _embedded_quote_style(m: str) -> str | None:
    """``quote`` vs ``paraphrase`` when relying on supplied FAQ excerpts (not short *Quote the FAQ* controls)."""
    if len(m) < 48:
        return None
    src = r"(?:faq|excerpt|policy|knowledge base|kb article|documentation|provided (?:text|docs))"
    paraphrase = bool(
        re.search(
            rf"\b(paraphrase (?:the )?{src}|paraphrase only|"
            rf"(?:don'?t|do not) quote (?:the )?{src}|no direct quotes? from (?:the )?{src}|"
            rf"summarize (?:the )?{src} in your own words|"
            rf"avoid quoting (?:the )?{src}|in your own words.{0,40}(?:faq|excerpt))\b",
            m,
        )
    )
    quote = bool(
        re.search(
            rf"\b((?<!not )(?<!don't )quote (?:the )?{src}|direct quotes? from (?:the )?{src}|"
            rf"cite with (?:direct )?quotes? when (?:you )?(?:use|reference) (?:the )?{src}|"
            rf"verbatim (?:quotes?|passages?) from (?:the )?{src}|"
            rf"include (?:a )?(?:short )?verbatim quote.{0,50}(?:faq|excerpt)|"
            rf"when you rely on (?:the )?{src}.{0,50}quote)\b",
            m,
        )
    )
    if quote and paraphrase:
        return None
    if quote:
        return "quote"
    if paraphrase:
        return "paraphrase"
    return None


def _embedded_emoji_style(m: str) -> str | None:
    """``include`` vs ``avoid`` emoji in replies (not short *Use emoji* / *No emoji* controls)."""
    if len(m) < 48:
        return None
    avoid = bool(
        re.search(
            r"\b(no emojis? in (?:your|the) reply|avoid emoji|emoji[- ]free (?:reply|tone)|"
            r"don'?t use emoji|do not use emoji|keep (?:it\s+)?(?:strictly\s+)?professional.{0,40}no emoji|"
            r"without emoji|skip (?:the\s+)?emoji|no cute emoji|"
            r"plain text only.{0,30}no emoji)\b",
            m,
        )
    )
    include = bool(
        re.search(
            r"\b(use (?:a few\s+)?(?:tasteful\s+)?emoji|include emoji|emoji (?:are|is) ok|"
            r"emoji welcome|feel free to use emoji|sprinkle (?:in\s+)?emoji|"
            r"a few emoji (?:are|is) fine|light emoji (?:are|is) ok|"
            r"you may use emoji|add (?:a few\s+)?emoji (?:if|when) (?:helpful|appropriate))\b",
            m,
        )
    )
    if avoid and include:
        return None
    if avoid:
        return "avoid"
    if include:
        return "include"
    return None


def _embedded_counterpoint_tone(m: str) -> str | None:
    """``challenge`` vs ``supportive`` pushback on plans (not short *Challenge my assumptions* controls)."""
    if len(m) < 52:
        return None
    ctx = (
        r"\b(plan|plans|design|approach|idea|ideas|architecture|proposal|strategy|"
        r"implementation|rollout|pitch|deck|draft|thesis|launch|release|migration|schema|"
        r"deployment|code|system)\b"
    )
    gentle = bool(
        re.search(r"\b(don'?t challenge|be gentle|go easy on me|no criticism|don'?t be harsh)\b", m)
    )
    challenge = bool(
        not gentle
        and re.search(
            r"\b(red team|red-team|stress[- ]?test|pick apart|tear down|what am i missing|sanity check|"
            r"challenge my|poke holes|find (?:weaknesses|gaps|flaws)|critique (?:my|this|our)|"
            r"devil'?s advocate)\b",
            m,
        )
        and re.search(ctx, m)
    )
    supportive = bool(
        re.search(
            r"\b(be supportive (?:of|about|with)|assume good intent|encourage my (?:idea|plan|proposal)|"
            r"constructive and supportive|help me build on (?:this|my) (?:idea|plan)|"
            r"coach me through (?:this|my) (?:idea|plan|pitch)|"
            r"gentle (?:feedback|pushback) on (?:my|this|our)|"
            r"avoid harsh criticism|frame improvements as next steps|"
            r"lean supportive and (?:specific|actionable))\b",
            m,
        )
        and re.search(ctx, m)
    )
    if challenge and supportive:
        return None
    if challenge:
        return "challenge"
    if supportive:
        return "supportive"
    return None


def _embedded_math_detail(m: str) -> str | None:
    """``show_work`` vs ``final_only`` for math-like answers (not short *Show your work* controls)."""
    if len(m) < 44:
        return None
    show = bool(
        re.search(
            r"\b(show your work|show (?:all )?(?:the )?steps|with (?:a )?derivation|prove (that|it)|rigorously|"
            r"walk through (?:the )?derivation|show intermediate steps|step[- ]by[- ]step derivation|"
            r"derive (?:it|the result) (?:step by step|explicitly))\b",
            m,
        )
    )
    final = bool(
        re.search(
            r"\b(final answer only|no derivation|skip (?:the )?steps|just (?:give )?(?:me )?the (?:final )?result|"
            r"don'?t show your work|do not show your work|answer without (?:showing )?steps|"
            r"no intermediate steps|closed[- ]form (?:answer|result) only|"
            r"(?:numerical |numeric )?answer only.{0,30}no steps)\b",
            m,
        )
    )
    if show and final:
        return None
    if show:
        return "show_work"
    if final and re.search(
        r"\b(math|equation|integral|derivative|probability|calculate|calculus|algebra|"
        r"proof|formula|theorem|matrix|solve|statistics|bayes|variance|expected value)\b",
        m,
    ):
        return "final_only"
    return None


def _embedded_faq_grounding(m: str) -> str | None:
    """``strict`` vs ``relaxed`` FAQ/RAG grounding (not short *Strict FAQ* / *Relaxed FAQ* controls)."""
    if len(m) < 48:
        return None
    src = r"(?:faq|excerpt|policy|knowledge base|kb article|documentation|provided excerpts|retrieved passages)"
    strict = bool(
        re.search(
            rf"\b(stick to (?:the )?{src}|only use (?:the )?{src}|"
            rf"only trust (?:the )?{src}|faq[- ]only (?:for|on) (?:this|the)|"
            rf"strict faq (?:grounding|only)|if (?:it(?:'s| is) )?not in (?:the )?{src}.{0,40}(?:say|admit)|"
            rf"don'?t go beyond (?:the )?{src}|must be supported by (?:the )?{src}|"
            rf"policy claims must come from (?:the )?{src}|"
            rf"grounded strictly in (?:the )?{src})\b",
            m,
        )
    )
    relaxed = bool(
        re.search(
            rf"\b(faq plus general knowledge|mix (?:the )?{src} with general knowledge|"
            rf"relaxed faq (?:grounding|mode)|"
            rf"general knowledge (?:is )?ok.{0,50}(?:faq|excerpt|policy|documentation)|"
            rf"(?:faq|excerpt|policy|documentation).{0,50}general knowledge (?:is )?ok|"
            rf"supplement (?:the )?{src} with (?:brief )?general[- ]knowledge|"
            rf"beyond (?:the )?{src} you may add (?:brief )?general context)\b",
            m,
        )
    )
    if strict and relaxed:
        return None
    if strict:
        return "strict"
    if relaxed:
        return "relaxed"
    return None


def _embedded_code_block_style(m: str) -> str | None:
    """``fenced`` vs ``inline`` code layout (not short *Use code fences* / *Inline code only* controls)."""
    if len(m) < 48:
        return None
    code_ctx = (
        r"\b(code|snippet|command|script|bash|shell|python|curl|kubectl|docker|sql|"
        r"regex|yaml|terraform|powershell|config|api call|terminal)\b"
    )
    fenced = bool(
        re.search(
            r"\b(use code fences|fenced code blocks?|markdown code fences?|"
            r"triple[- ]backtick fences?|put (?:the )?(?:code|commands?|script) in (?:a )?fenced block|"
            r"use markdown fenced code blocks?|wrap (?:the )?(?:code|snippet) in (?:triple )?backticks)\b",
            m,
        )
    )
    inline = bool(
        re.search(
            r"\b(inline code only|no triple backticks?|no fenced code blocks?|"
            r"avoid code fences|single backticks? only|don'?t use fenced blocks?|"
            r"keep (?:code|snippets?) inline|inline backticks? only)\b",
            m,
        )
    )
    if not fenced and not inline:
        return None
    if not re.search(code_ctx, m):
        return None
    if fenced and inline:
        return None
    if fenced:
        return "fenced"
    return "inline"


def _embedded_reply_format(m: str) -> str | None:
    """``bullets`` vs ``prose`` list layout (not short *Use bullet points* / *No bullets* controls)."""
    if len(m) < 48:
        return None
    prose = bool(
        re.search(
            r"\b(no bullets?|plain paragraphs?|prose only|stop using lists|"
            r"continuous prose only|avoid bullet lists?|write in paragraphs|"
            r"paragraph form only|don'?t use bullet points?|"
            r"keep (?:it\s+)?in (?:flowing )?prose|not as a bulleted list)\b",
            m,
        )
    )
    bullets = bool(
        re.search(
            r"\b(bullet points?|bulleted list|use bullets|format as bullets|"
            r"list (?:the\s+)?key points in bullets|markdown bullets?|"
            r"give me a bulleted list|bullet(?:ed)? format)\b",
            m,
        )
    )
    if prose and bullets:
        return None
    if prose:
        return "prose"
    if bullets:
        return "bullets"
    return None


def _embedded_comparison_frame(m: str) -> str | None:
    """``pros_cons`` vs ``narrative`` comparison layout (not short *Use pros and cons* controls)."""
    if len(m) < 48:
        return None
    if not re.search(r"\b(compare|comparing|comparison|contrasted?|contrast|trade-?offs?)\b", m):
        return None
    narrative = bool(
        re.search(
            r"\b(no pros|without pros|avoid pros|no pros\/cons|no pros and cons sections?)\b",
            m,
        )
        or re.search(
            r"\b(flowing prose|continuous prose|narrative comparison|prose comparison only|"
            r"compare in flowing prose)\b",
            m,
        )
    )
    pros = bool(
        re.search(
            r"\b(trade-?offs?|(?<!no )pros and cons|advantages and disadvantages)\b",
            m,
        )
        or re.search(r"\bdifference between\b.+\band\b", m)
        or re.search(r"\b(compare|comparing|comparison|contrasted?|contrast)\b.+\b(vs\.?|versus)\b", m)
        or (
            re.search(r"\b(compare|comparing|comparison)\b", m)
            and re.search(r"\b(and|with)\b", m)
            and len(m) >= 72
            and re.search(
                r"\b(versus|vs\.?|option|approach|tool|stack|framework|language|model|database|db|cloud)\b",
                m,
            )
        )
    )
    if narrative and pros:
        return None
    if narrative:
        return "narrative"
    if pros:
        return "pros_cons"
    return None


def _embedded_table_style(m: str) -> str | None:
    """``prefer`` vs ``avoid`` markdown tables (not short *Use tables* / *No tables* controls)."""
    if len(m) < 48:
        return None
    avoid = bool(
        re.search(
            r"\b(no tables?|without a table|avoid tables?|no markdown tables?|"
            r"don'?t use tables?|skip the table|table[- ]free (?:summary|answer)|"
            r"not in a table|avoid tabular format)\b",
            m,
        )
    )
    prefer = bool(
        re.search(
            r"\b(in a table|as a table|markdown table|(?<!avoid )tabular format|two-?column|rows and columns|"
            r"use a (?:markdown )?table|format as a table|put (?:it|this) in a table|"
            r"present (?:it|the comparison) in a table)\b",
            m,
        )
    )
    if avoid and prefer:
        return None
    if avoid:
        return "avoid"
    if prefer:
        return "prefer"
    return None


def _embedded_step_style(m: str) -> str | None:
    """``numbered`` vs ``continuous`` procedure layout (not short *Step by step* controls)."""
    if len(m) < 48:
        return None
    continuous = bool(
        re.search(
            r"\b(no numbered steps|don'?t number steps|skip step numbers|"
            r"prose without steps|avoid numbered step lists?|"
            r"continuous prose (?:only|instead)|not as numbered steps|"
            r"connected paragraphs?(?:\s+only)?|explain as (?:flowing )?prose)\b",
            m,
        )
    )
    numbered = bool(
        re.search(r"\b(step by step|step-by-step)\b", m)
        or re.search(r"\b(walk me through|show me how)\b", m)
        or re.search(r"\b(?<!no )(?:use )?numbered steps\b|break it into steps\b", m)
        or (
            re.search(r"\b(how do i|how can i|how should i|how to)\b", m)
            and re.search(
                r"\b(install|set up|setup|configure|enable|deploy|migrate|upgrade|fix|debug|troubleshoot)\b",
                m,
            )
        )
    )
    if continuous and numbered:
        return None
    if continuous:
        return "continuous"
    if numbered:
        return "numbered"
    return None


def _reply_lang_phrase(m: str) -> str | None:
    """Return display name (e.g. 'French') if the user asked for a reply in a known language."""
    for mo in re.finditer(
        r"\b(respond|answer|reply|write|explain)\s+(?:in|using)\s+([a-z]{3,20})\b(?:\s*[.?!]|$|,|\s+please|\s+thanks)?",
        m,
    ):
        tok = mo.group(2)
        if tok in _REPLY_LANG_TOKENS:
            return _REPLY_LANG_TOKENS[tok]
    mo = re.search(
        r"\b(translate|translating)\s+(?:this|that|it|your answer|the above|my text)\s+(?:to|into)\s+([a-z]{3,20})\b",
        m,
    )
    if mo and mo.group(2) in _REPLY_LANG_TOKENS:
        return _REPLY_LANG_TOKENS[mo.group(2)]
    mo = re.search(r"\b(entire reply|whole answer|full answer)\s+(?:in|using)\s+([a-z]{3,20})\b", m)
    if mo and mo.group(2) in _REPLY_LANG_TOKENS:
        return _REPLY_LANG_TOKENS[mo.group(2)]
    # Trailing clause: "... in french" / "... in spanish, please"
    tail = m[-100:] if len(m) > 100 else m
    mo = re.search(r"\b(in|into)\s+([a-z]{3,20})\s*(?:[,.]|please|thanks)?\s*$", tail)
    if mo and mo.group(2) in _REPLY_LANG_TOKENS:
        return _REPLY_LANG_TOKENS[mo.group(2)]
    return None


def analyze_embedded_prompt_signals(message: str) -> tuple[dict[str, str], list[str], list[str]]:
    """Infer reply-style preferences from wording inside longer questions (one-shot overlays).

    Used only when ``parse_control_action`` does not treat the line as a dedicated control
    command. Conservative patterns avoid hijacking short chit-chat.

    Returns:
        (field_overrides, extra_system_paragraphs, trace_tags) — overrides use the same keys/values as
        ``ub_session`` reply-style fields; extra paragraphs are appended as separate system sections;
        ``trace_tags`` are short tokens for the brain-trace ``prompt_signals:`` line (e.g. ``language``,
        ``code_only``, ``code_explained``, ``len_cap=80w``, ``guided``, ``ephemeral``, ``a11y``,
        ``cite_sources``, ``cite_minimal``, ``ranked_options``, ``checklist``, ``no_checklist``,
        ``pseudocode``, ``runnable_code``, ``options_n=N``, ``diagram``, ``no_diagram``,
        ``risks_first``, ``benefits_first``, ``revise_draft``, ``revise_diff``, ``email_format``, ``letter_format``, ``press_release``, ``runbook_format``, ``job_aid``, ``meeting_agenda``, ``topic_guard``,
        ``topic_must``, ``glossary``, ``spelling_uk``, ``spelling_us``, ``risks_mitigations``,
        ``timeline_chron``, ``timeline_reverse``, ``voice_second``, ``voice_third``, ``faq_qa``,
        ``summary_last``, ``decision_matrix``, ``build_vs_buy``, ``one_pager``, ``status_report``, ``action_plan``, ``raci``, ``stakeholder_map``, ``swot``, ``pestle``, ``cost_benefit``, ``open_questions``, ``scenario_cases``,
        ``postmortem``, ``sprint_retro``, ``user_story``, ``definition_of_done``, ``five_whys``, ``fishbone``,
        ``recommendation_first``,
        ``go_no_go``,
        ``frame_star``, ``frame_prep``, ``frame_irac``). Session-style overrides
        (e.g. ``confidence_tone=transparent``) appear as ``key=value`` tokens in the same line.
    """
    m = _norm(message)
    overrides: dict[str, str] = {}
    extras: list[str] = []
    trace_tags: list[str] = []

    if len(m) >= 24:
        lang = _reply_lang_phrase(m)
        if lang:
            trace_tags.append("language")
            extras.append(
                f"The user asked (via natural wording) for the assistant reply in **{lang}**. "
                f"Write the **entire** answer in {lang}, including headings and lists, unless a quoted passage must stay "
                "verbatim in another language."
            )

    co = _code_only_instruction(m)
    cex = _embedded_code_commentary(m)
    if co and cex:
        pass
    elif co:
        trace_tags.append("code_only")
        extras.append(co)
    elif cex:
        extras.append(cex[0])
        trace_tags.append(cex[1])

    pc = _embedded_pseudocode(m)
    if pc and not (co or cex):
        extras.append(pc[0])
        trace_tags.append(pc[1])

    lc = _length_cap_instruction(m)
    if lc:
        extras.append(lc[0])
        trace_tags.append(lc[1])

    gdd = _embedded_guided_discovery(m)
    if gdd:
        extras.append(gdd[0])
        trace_tags.append(gdd[1])

    ep = _ephemeral_privacy_instruction(m)
    if ep:
        extras.append(ep[0])
        trace_tags.append(ep[1])

    ax = _accessibility_sr_instruction(m)
    if ax:
        extras.append(ax[0])
        trace_tags.append(ax[1])

    sc = _embedded_source_citations(m)
    if sc:
        extras.append(sc[0])
        trace_tags.append(sc[1])

    ro = _embedded_ranked_options(m)
    if ro:
        extras.append(ro[0])
        trace_tags.append(ro[1])

    dmx = _embedded_decision_matrix(m)
    if dmx:
        extras.append(dmx[0])
        trace_tags.append(dmx[1])

    bvb = _embedded_build_vs_buy(m)
    if bvb:
        extras.append(bvb[0])
        trace_tags.append(bvb[1])

    opg = _embedded_one_pager(m)
    if opg:
        extras.append(opg[0])
        trace_tags.append(opg[1])

    strpt = _embedded_status_report(m)
    if strpt:
        extras.append(strpt[0])
        trace_tags.append(strpt[1])

    apl = _embedded_action_plan(m)
    if apl:
        extras.append(apl[0])
        trace_tags.append(apl[1])

    rac = _embedded_raci_matrix(m)
    if rac:
        extras.append(rac[0])
        trace_tags.append(rac[1])

    stm = _embedded_stakeholder_map(m)
    if stm:
        extras.append(stm[0])
        trace_tags.append(stm[1])

    cl = _embedded_checklist_reply(m)
    if cl:
        extras.append(cl[0])
        trace_tags.append(cl[1])

    oc = _embedded_fixed_option_count(m)
    if oc:
        extras.append(oc[0])
        trace_tags.append(oc[1])

    dv = _embedded_diagram_visual(m)
    if dv:
        extras.append(dv[0])
        trace_tags.append(dv[1])

    rbo = _embedded_risks_benefits_order(m)
    if rbo:
        extras.append(rbo[0])
        trace_tags.append(rbo[1])

    rskm = _embedded_risks_mitigations(m)
    if rskm:
        extras.append(rskm[0])
        trace_tags.append(rskm[1])

    emf = _embedded_email_format(m)
    if emf:
        extras.append(emf[0])
        trace_tags.append(emf[1])

    ltf = _embedded_letter_format(m)
    if ltf:
        extras.append(ltf[0])
        trace_tags.append(ltf[1])

    prf = _embedded_press_release(m)
    if prf:
        extras.append(prf[0])
        trace_tags.append(prf[1])

    rbf = _embedded_runbook_format(m)
    if rbf:
        extras.append(rbf[0])
        trace_tags.append(rbf[1])

    jba = _embedded_job_aid(m)
    if jba:
        extras.append(jba[0])
        trace_tags.append(jba[1])

    mag = _embedded_meeting_agenda(m)
    if mag:
        extras.append(mag[0])
        trace_tags.append(mag[1])

    rd = _embedded_revise_draft(m)
    if rd:
        extras.append(rd[0])
        trace_tags.append(rd[1])

    rdiff = _embedded_revise_diff(m)
    if rdiff:
        extras.append(rdiff[0])
        trace_tags.append(rdiff[1])

    tg = _embedded_topic_guard(m)
    if tg:
        extras.append(tg[0])
        trace_tags.append(tg[1])

    tm = _embedded_topic_must(m)
    if tm:
        extras.append(tm[0])
        trace_tags.append(tm[1])

    af = _embedded_answer_frame(m)
    if af:
        extras.append(af[0])
        trace_tags.append(af[1])

    swot = _embedded_swot_analysis(m)
    if swot:
        extras.append(swot[0])
        trace_tags.append(swot[1])

    pest = _embedded_pestle_analysis(m)
    if pest:
        extras.append(pest[0])
        trace_tags.append(pest[1])

    cba = _embedded_cost_benefit(m)
    if cba:
        extras.append(cba[0])
        trace_tags.append(cba[1])

    oq = _embedded_open_questions(m)
    if oq:
        extras.append(oq[0])
        trace_tags.append(oq[1])

    scn = _embedded_scenario_cases(m)
    if scn:
        extras.append(scn[0])
        trace_tags.append(scn[1])

    pm = _embedded_postmortem_format(m)
    if pm:
        extras.append(pm[0])
        trace_tags.append(pm[1])

    srt = _embedded_sprint_retro(m)
    if srt:
        extras.append(srt[0])
        trace_tags.append(srt[1])

    ust = _embedded_user_story(m)
    if ust:
        extras.append(ust[0])
        trace_tags.append(ust[1])

    dod = _embedded_definition_of_done(m)
    if dod:
        extras.append(dod[0])
        trace_tags.append(dod[1])

    fw = _embedded_five_whys(m)
    if fw:
        extras.append(fw[0])
        trace_tags.append(fw[1])

    fb = _embedded_fishbone(m)
    if fb:
        extras.append(fb[0])
        trace_tags.append(fb[1])

    gls = _embedded_glossary_section(m)
    if gls:
        extras.append(gls[0])
        trace_tags.append(gls[1])

    spl = _embedded_spelling_locale(m)
    if spl:
        extras.append(spl[0])
        trace_tags.append(spl[1])

    tlo = _embedded_timeline_order(m)
    if tlo:
        extras.append(tlo[0])
        trace_tags.append(tlo[1])

    wvc = _embedded_writing_voice(m)
    if wvc:
        extras.append(wvc[0])
        trace_tags.append(wvc[1])

    fqa = _embedded_faq_qa_format(m)
    if fqa:
        extras.append(fqa[0])
        trace_tags.append(fqa[1])

    sml = _embedded_summary_last(m)
    if sml:
        extras.append(sml[0])
        trace_tags.append(sml[1])

    if _embedded_simple_audience(m):
        overrides["audience"] = "simple"
    elif _embedded_technical_audience(m):
        overrides["audience"] = "technical"

    ert = _embedded_register_tone(m)
    if ert:
        overrides["register_tone"] = ert

    oft = _embedded_output_format(m)
    if oft:
        overrides["output_format"] = oft

    vrb = _embedded_verbosity(m)
    if vrb:
        overrides["verbosity"] = vrb

    spc = _embedded_speculation(m)
    if spc:
        overrides["speculation"] = spc

    ald = _embedded_answer_lead(m)
    if ald:
        overrides["answer_lead"] = ald

    rcf = _embedded_recommendation_first(m)
    if rcf:
        extras.append(rcf[0])
        trace_tags.append(rcf[1])

    gng = _embedded_go_no_go(m)
    if gng:
        extras.append(gng[0])
        trace_tags.append(gng[1])

    act = _embedded_actionability(m)
    if act:
        overrides["actionability"] = act

    cft = _embedded_confidence_tone(m)
    if cft:
        overrides["confidence_tone"] = cft

    exd = _embedded_example_density(m)
    if exd:
        overrides["example_density"] = exd

    if len(m) < 48:
        return overrides, extras, trace_tags

    cmf = _embedded_comparison_frame(m)
    if cmf:
        overrides["comparison_frame"] = cmf

    stl = _embedded_step_style(m)
    if stl:
        overrides["step_style"] = stl

    tbl = _embedded_table_style(m)
    if tbl:
        overrides["table_style"] = tbl

    rpf = _embedded_reply_format(m)
    if rpf:
        overrides["reply_format"] = rpf

    mth = _embedded_math_detail(m)
    if mth:
        overrides["math_detail"] = mth

    cpt = _embedded_counterpoint_tone(m)
    if cpt:
        overrides["counterpoint_tone"] = cpt

    eord = _embedded_exposition_order(m)
    if eord:
        overrides["exposition_order"] = eord

    fuc = _embedded_followup_close(m)
    if fuc:
        overrides["followup_close"] = fuc

    clf = _embedded_clarify_first(m)
    if clf:
        overrides["clarify_first"] = clf

    shd = _embedded_section_headings(m)
    if shd:
        overrides["section_headings"] = shd

    anu = _embedded_analogy_use(m)
    if anu:
        overrides["analogy_use"] = anu

    tem = _embedded_term_emphasis(m)
    if tem:
        overrides["term_emphasis"] = tem

    acs = _embedded_acronym_style(m)
    if acs:
        overrides["acronym_style"] = acs

    rsk = _embedded_risk_posture(m)
    if rsk:
        overrides["risk_posture"] = rsk

    qst = _embedded_quote_style(m)
    if qst:
        overrides["quote_style"] = qst

    emj = _embedded_emoji_style(m)
    if emj:
        overrides["emoji_style"] = emj

    fgr = _embedded_faq_grounding(m)
    if fgr:
        overrides["faq_grounding"] = fgr

    cbs = _embedded_code_block_style(m)
    if cbs:
        overrides["code_block_style"] = cbs

    return overrides, extras, trace_tags