From 3e9c9ce10d161d1a709078a53492be85861ef0c6 Mon Sep 17 00:00:00 2001 From: Shay Date: Wed, 20 May 2026 21:00:22 -0700 Subject: [PATCH] =?UTF-8?q?chore:=20comb-pass=20closeout=20=E2=80=94=20ite?= =?UTF-8?q?m=2017=20+=20Tier=205=20minor=20cleanups=20(#94)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Comb pass 2026-05-21. Item 17 — redundant ``^`` anchors in ``re.match()`` patterns: ``re.match`` anchors at the start of the string automatically, so the leading ``^`` was documentation-only noise on every pattern consumed via ``.match()``. Audited each pattern's call site: * ``_RULES`` (line 144) — used via ``pattern.match(text)`` → strip * ``_ANAPHORIC_FOLLOWUPS`` — used via ``pattern.match(text)`` → strip * Module-level ``_COMPARE_RE`` / ``_TRANSITIVE_QUERY_RE`` / ``_FRAME_TRANSFER_RE`` / ``_BELONG_QUERY_RE`` / ``_DECLARATIVE_RELATION_RE`` / ``_HOW_DOES_X_RE`` — all ``.match()`` → strip * Inline ``re.match`` in ``_strip_confirmation_tail`` → strip * ``_RESPONSE_MODE_RULES`` — used via ``pattern.search(text)`` → KEEP ``^`` (``re.search`` does not anchor) Trailing ``$`` anchors retained throughout because neither ``re.match`` nor ``re.search`` anchors at the end. A comment block documents the convention so future contributors understand the ``^`` retain-vs-strip rule. Tier 5 minor (``chat/runtime.py``): * Hoisted ``{"is", "are", "was", "were"}`` to module-level ``_BE_FORMS`` constant. Pre-fix ``_prefer_prompt_anchor`` constructed this set on every English turn. * Replaced the content-token list comprehension + ``[-1]`` slice with a reverse-iteration short-circuit. Pre-fix the function materialised the full filtered list just to pick the last element. * Cached ``token.casefold()`` once per token via a local in the loop body. Pre-fix the comprehension called ``.casefold()`` twice per token (against ``_QUESTION_WORDS`` and the inline aux-verb set). Validation: * ``core eval cognition`` byte-identical across all three splits: public 100/100/91.7/100, dev 100/100/78.6/100, holdout 100/100/83.3/100. * ``core test --suite cognition`` 120/0/1, ``smoke`` 67/0. * ``pytest -k intent`` 236/0 (all intent classification tests pass with the ``^`` removals — the patterns behave identically under ``re.match`` regardless of the leading anchor). --- chat/runtime.py | 28 ++++++++++++------- generate/intent.py | 67 +++++++++++++++++++++++++++------------------- 2 files changed, 59 insertions(+), 36 deletions(-) diff --git a/chat/runtime.py b/chat/runtime.py index 0c6478ce..5b660cf7 100644 --- a/chat/runtime.py +++ b/chat/runtime.py @@ -123,6 +123,11 @@ _SEED_ALIASES = { "aletheia": "\u1f00\u03bb\u03ae\u03b8\u03b5\u03b9\u03b1", } _QUESTION_WORDS = frozenset({"what", "who", "how", "why", "when", "where", "which"}) +# Comb pass 2026-05-21 — module-level constant so ``_prefer_prompt_anchor`` +# does not allocate a fresh set on every English turn. Aux-verbs that +# precede the prompt's content noun ("is", "are", "was", "were") get +# filtered out so the content-noun search lands on the actual subject. +_BE_FORMS: frozenset[str] = frozenset({"is", "are", "was", "were"}) _TERMINALS = frozenset({".", "?", ";", "!"}) _UNKNOWN_DOMAIN_SURFACE = "I don't know — insufficient grounding for that yet." @@ -173,15 +178,20 @@ def _prefer_prompt_anchor( ) -> ArticulationPlan: if output_language != "en" or len(filtered_tokens) < 2: return articulation - content_tokens = [ - token - for token in filtered_tokens - if token.casefold() not in _QUESTION_WORDS and token.casefold() not in {"is", "are", "was", "were"} - ] - if not content_tokens: - return articulation - anchor = content_tokens[-1] - if anchor == articulation.subject: + # Comb pass 2026-05-21 — find the last content-bearing token by + # reverse iteration with short-circuit; pre-fix this built a full + # ``content_tokens`` list and then took ``[-1]``. Also: cache + # ``token.casefold()`` once per token via walrus operator instead + # of calling it twice (against ``_QUESTION_WORDS`` and the + # historical inline ``{"is", "are", "was", "were"}`` literal). + anchor: str | None = None + for token in reversed(filtered_tokens): + lower = token.casefold() + if lower in _QUESTION_WORDS or lower in _BE_FORMS: + continue + anchor = token + break + if anchor is None or anchor == articulation.subject: return articulation return replace( articulation, diff --git a/generate/intent.py b/generate/intent.py index af9d7131..3a682642 100644 --- a/generate/intent.py +++ b/generate/intent.py @@ -74,7 +74,11 @@ class DialogueIntent: _COMPARE_RE = re.compile( - r"^compare\s+(.+?)\s+(?:and|vs\.?|versus|with)\s+(.+)", + # Comb pass 2026-05-21 — ``^`` removed where consumed via ``.match()`` + # only (anchored at start automatically). Patterns consumed via + # ``.search()`` (see ``_RESPONSE_MODE_RULES`` below) retain their + # leading ``^`` because ``.search()`` does not anchor. + r"compare\s+(.+?)\s+(?:and|vs\.?|versus|with)\s+(.+)", re.IGNORECASE, ) @@ -85,7 +89,7 @@ _COMPARE_RE = re.compile( # operator layer handles unrecognised relations by falling back to a # cross-relation traversal (rather than a strict literal-relation match). _TRANSITIVE_QUERY_RE = re.compile( - r"^what\s+does\s+(?P[a-z][a-z\-]*(?:\s+[a-z][a-z\-]*)?)\s+" + r"what\s+does\s+(?P[a-z][a-z\-]*(?:\s+[a-z][a-z\-]*)?)\s+" r"(?P[a-z][a-z\-]*)\b", re.IGNORECASE, ) @@ -95,18 +99,18 @@ _TRANSITIVE_QUERY_RE = re.compile( # probe shape. Must be tried before the generic transitive-query rule # so the "in Y" tail is not silently truncated. _FRAME_TRANSFER_RE = re.compile( - r"^what\s+does\s+(?P[a-z][a-z\-]+)\s+" + r"what\s+does\s+(?P[a-z][a-z\-]+)\s+" r"(?P[a-z][a-z\-]+)(?P\s+to)?\s+in\s+" r"(?P[a-z][a-z\-]+)\b", re.IGNORECASE, ) _BELONG_QUERY_RE = re.compile( - r"^where\s+does\s+(?P[a-z][a-z\-]*(?:\s+[a-z][a-z\-]*)?)\s+" + r"where\s+does\s+(?P[a-z][a-z\-]*(?:\s+[a-z][a-z\-]*)?)\s+" r"belong(?:s?)\b", re.IGNORECASE, ) _DECLARATIVE_RELATION_RE = re.compile( - r"^(?P[a-z][a-z\-]*(?:\s+[a-z][a-z\-]*)?)\s+" + r"(?P[a-z][a-z\-]*(?:\s+[a-z][a-z\-]*)?)\s+" r"(?:(?Pdoes|do|did)\s+not\s+)?" r"(?Preveals|reveal|grounds|ground|supports|support|" r"requires|require|causes|cause|precedes|precede|follows|follow)\s+" @@ -120,7 +124,7 @@ _DECLARATIVE_RELATION_RE = re.compile( # Routes to CAUSE so the teaching-chain / cross-pack / pack-surface # dispatcher fires on X. _HOW_DOES_X_RE = re.compile( - r"^how\s+do(?:es)?\s+(?P[a-z][a-z\-]*(?:\s+[a-z][a-z\-]*)?)\s+" + r"how\s+do(?:es)?\s+(?P[a-z][a-z\-]*(?:\s+[a-z][a-z\-]*)?)\s+" r"(?:work|function|operate|happen|exist|behave|act|emerge)\b", re.IGNORECASE, ) @@ -142,21 +146,27 @@ _RELATION_NORMALIZE: dict[str, str] = { } _RULES: tuple[tuple[re.Pattern[str], IntentTag], ...] = ( + # Comb pass 2026-05-21 — every pattern in ``_RULES`` is consumed + # via ``pattern.match(text)`` (see the loop at the bottom of + # ``classify_intent``). ``re.match`` anchors at the start of the + # string automatically, so the leading ``^`` is redundant and + # was previously documentation-only noise. Removed. + # # P3.3 — NARRATIVE patterns precede DEFINITION so "Tell me about X" # does not accidentally classify as DEFINITION on the noun span. - (re.compile(r"^tell\s+me\s+about\s+", re.IGNORECASE), IntentTag.NARRATIVE), - (re.compile(r"^describe\s+", re.IGNORECASE), IntentTag.NARRATIVE), - (re.compile(r"^what\s+(?:can|do)\s+you\s+(?:say|know)\s+about\s+", re.IGNORECASE), IntentTag.NARRATIVE), + (re.compile(r"tell\s+me\s+about\s+", re.IGNORECASE), IntentTag.NARRATIVE), + (re.compile(r"describe\s+", re.IGNORECASE), IntentTag.NARRATIVE), + (re.compile(r"what\s+(?:can|do)\s+you\s+(?:say|know)\s+about\s+", re.IGNORECASE), IntentTag.NARRATIVE), # P3.4 — EXAMPLE patterns precede DEFINITION for the same reason. - (re.compile(r"^(?:give|show)\s+(?:me\s+)?an?\s+(?:example|instance)\s+of\s+", re.IGNORECASE), IntentTag.EXAMPLE), - (re.compile(r"^example\s+of\s+", re.IGNORECASE), IntentTag.EXAMPLE), - (re.compile(r"^what\s+(?:is|are)\s+", re.IGNORECASE), IntentTag.DEFINITION), + (re.compile(r"(?:give|show)\s+(?:me\s+)?an?\s+(?:example|instance)\s+of\s+", re.IGNORECASE), IntentTag.EXAMPLE), + (re.compile(r"example\s+of\s+", re.IGNORECASE), IntentTag.EXAMPLE), + (re.compile(r"what\s+(?:is|are)\s+", re.IGNORECASE), IntentTag.DEFINITION), # Imperative-form DEFINITION — "Define X", "Define X." — produces # the same routing as "What is X?". Without this rule the prompt # falls through to UNKNOWN and the whole text becomes the subject, # making pack-resolved lemmas like "moment" or "evident" silently # un-groundable. - (re.compile(r"^define\s+", re.IGNORECASE), IntentTag.DEFINITION), + (re.compile(r"define\s+", re.IGNORECASE), IntentTag.DEFINITION), # Expository-DEFINITION variants — "Explain X." and the paragraph # request forms — route to DEFINITION so the grounded substrate # fires on X. Presentation depth ("explain at length", "as a @@ -164,17 +174,17 @@ _RULES: tuple[tuple[re.Pattern[str], IntentTag], ...] = ( # request is still "the definition of X". Placed AFTER the # NARRATIVE rules so "Tell me about X" and "Describe X" continue # to route to NARRATIVE. - (re.compile(r"^explain\s+", re.IGNORECASE), IntentTag.DEFINITION), + (re.compile(r"explain\s+", re.IGNORECASE), IntentTag.DEFINITION), ( re.compile( - r"^(?:write|compose|draft)\s+(?:a\s+)?(?:short\s+|brief\s+)?" + r"(?:write|compose|draft)\s+(?:a\s+)?(?:short\s+|brief\s+)?" r"paragraph\s+(?:about|on)\s+", re.IGNORECASE, ), IntentTag.DEFINITION, ), ( - re.compile(r"^paragraph\s+(?:about|on)\s+", re.IGNORECASE), + re.compile(r"paragraph\s+(?:about|on)\s+", re.IGNORECASE), IntentTag.DEFINITION, ), # WALKTHROUGH-shape requests — semantic intent is "describe X step @@ -184,23 +194,23 @@ _RULES: tuple[tuple[re.Pattern[str], IntentTag], ...] = ( # time. Same orthogonality discipline as the EXPLAIN rule. ( re.compile( - r"^walk\s+(?:me\s+)?through\s+", + r"walk\s+(?:me\s+)?through\s+", re.IGNORECASE, ), IntentTag.DEFINITION, ), - (re.compile(r"^why\s+", re.IGNORECASE), IntentTag.CAUSE), + (re.compile(r"why\s+", re.IGNORECASE), IntentTag.CAUSE), # "What causes / triggers / enables / prevents / drives X?" — the # query is about what causes X, so the subject of the CAUSE intent # is X (not the causative verb). Place ahead of the generic # VERIFICATION rule because "What causes X?" starts with "what" not # an aux verb so VERIFICATION wouldn't match anyway, but the # ordering also documents the intent priority. - (re.compile(r"^what\s+(?:causes|triggers|enables|prevents|drives|produces|induces|yields)\s+", re.IGNORECASE), IntentTag.CAUSE), - (re.compile(r"^how\s+(?:do|can|should|would)\s+(?:I|we|you)\s+", re.IGNORECASE), IntentTag.PROCEDURE), - (re.compile(r"^(?:is|are|does|do|can|could|would|should|was|were|has|have|will)\s+.+\??\s*$", re.IGNORECASE), IntentTag.VERIFICATION), - (re.compile(r"^(?:no|that'?s\s+(?:not|wrong)|incorrect|actually|correction)", re.IGNORECASE), IntentTag.CORRECTION), - (re.compile(r"^remember\s+", re.IGNORECASE), IntentTag.RECALL), + (re.compile(r"what\s+(?:causes|triggers|enables|prevents|drives|produces|induces|yields)\s+", re.IGNORECASE), IntentTag.CAUSE), + (re.compile(r"how\s+(?:do|can|should|would)\s+(?:I|we|you)\s+", re.IGNORECASE), IntentTag.PROCEDURE), + (re.compile(r"(?:is|are|does|do|can|could|would|should|was|were|has|have|will)\s+.+\??\s*$", re.IGNORECASE), IntentTag.VERIFICATION), + (re.compile(r"(?:no|that'?s\s+(?:not|wrong)|incorrect|actually|correction)", re.IGNORECASE), IntentTag.CORRECTION), + (re.compile(r"remember\s+", re.IGNORECASE), IntentTag.RECALL), ) @@ -288,7 +298,7 @@ def _strip_confirmation_tail(text: str) -> str: """ stripped = text.strip() match = re.match( - r"^(?P.+?)[,.]\s*(?:right|yes|no|ok)\?\s*$", + r"(?P.+?)[,.]\s*(?:right|yes|no|ok)\?\s*$", stripped, re.IGNORECASE, ) @@ -524,11 +534,14 @@ _COMPOUND_SPLIT_RE = re.compile( # support, *not* metaphysical importance as a new primitive. No # ``IMPORTANCE`` tag is introduced. _ANAPHORIC_FOLLOWUPS: tuple[tuple[re.Pattern[str], str], ...] = ( - (re.compile(r"^why\s+does\s+(?:it|that|this)\s+matter\??$", re.IGNORECASE), + # Comb pass 2026-05-21 — consumed via ``pattern.match(text)``; + # leading ``^`` redundant. Trailing ``$`` retained because + # ``re.match`` does not anchor at the end. + (re.compile(r"why\s+does\s+(?:it|that|this)\s+matter\??$", re.IGNORECASE), "why does {subject} matter"), - (re.compile(r"^how\s+does\s+(?:it|that|this)\s+work\??$", re.IGNORECASE), + (re.compile(r"how\s+does\s+(?:it|that|this)\s+work\??$", re.IGNORECASE), "how does {subject} work"), - (re.compile(r"^what\s+causes\s+(?:it|that|this)\??$", re.IGNORECASE), + (re.compile(r"what\s+causes\s+(?:it|that|this)\??$", re.IGNORECASE), "what causes {subject}"), )