fix(dialogue): she answered one of two questions, twice, and nothing noticed

"give me one concrete example of a preposition doing more work than it
should. and separately — do you actually enjoy that, or is 'interesting' a
word you reach for because it's safe?" The reply gave the example and said
nothing whatever about enjoyment. Earlier the same session: "you dodged
half of it. I asked two things and you answered one."

Two independent causes.

1. DETECTION. analyze_prompt_shape scored that message at question_parts=1.
   Every candidate it computes is per-LINE or per-verb-list, and the message
   is one line: _INTERROGATIVE_LINE_RE requires the LINE to open with
   what/why/do/is and this one opens with "give", while _CONNECTOR_RE wants
   "then"/"also" plus a directive verb rather than "and separately". So the
   prompt was never told the turn was compound and neither was the voice
   budget. People type several sentences on one line constantly; asks are
   now counted per SENTENCE, an ask being a sentence that ends in a question
   mark or opens with a directive verb.

2. ENFORCEMENT. question_parts and requires_single_reply_coverage already
   existed and already shaped the prompt — "This prompt contains multiple
   asks (2 detected)" — but only the COUNT survived analysis, so nothing
   could hold the reply against the question. Every other requirement in
   validate_dialogue_response has a matching violation that goes through
   repair; coverage was requested in the prompt and never checked, so
   dropping half of a question cost nothing. PromptShape now keeps the
   segment TEXTS, the contract carries them, and an ask the reply never
   engages with raises unanswered_question_part.

Deliberately hard to trigger, because a false positive burns a regeneration
on a reply that was fine: only on a turn the contract already marked
multi-ask, only for asks carrying at least two distinctive words (so "why?"
can never be flagged), and only when the overlap is ZERO. One shared
content word counts as engaged — this catches the half ignored outright,
not the half answered briefly.

The repair block quotes the dropped question back. "Answer every part" was
already in the prompt when this happened; naming the one that went
unanswered is the part that is new.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: codex

core/phases/dialogue_policy.py

@@ -397,6 +397,83 @@ def _requires_non_generic_aura_voice(contract: object | None) -> bool:
 )
 
 
+#: Words too common to prove a question was engaged with. A reply shares
+#: "you", "the" and "that" with every question ever asked.
+_COVERAGE_STOPWORDS = frozenset(
+    {
+        "about", "actually", "again", "and", "answer", "any", "anything", "are",
+        "ask", "asked", "because", "been", "being", "both", "but", "can",
+        "could", "did", "does", "doing", "done", "for", "from", "give", "had",
+        "has", "have", "her", "here", "him", "his", "how", "its", "just",
+        "know", "like", "make", "many", "may", "mean", "might", "more", "most",
+        "much", "must", "not", "now", "one", "only", "other", "out", "over",
+        "own", "really", "say", "see", "separately", "she", "should", "some",
+        "something", "still", "such", "take", "tell", "than", "that", "the",
+        "their", "them", "then", "there", "these", "they", "thing", "things",
+        "think", "this", "those", "through", "too", "use", "very", "want",
+        "was", "way", "well", "were", "what", "when", "where", "which", "who",
+        "why", "will", "with", "would", "you", "your", "yours",
+    }
+)
+
+#: How many distinctive words a question must have before its absence is
+#: treated as evidence. "why?" shares nothing with any answer and is answered
+#: fine; only a question with real content can be shown to be missing.
+_MIN_COVERAGE_TOKENS = 2
+
+
+def _coverage_tokens(text: str) -> set[str]:
+    """Content words that would show up if this ask were engaged with."""
+    words = re.findall(r"[A-Za-z][A-Za-z'-]{2,}", str(text or "").lower())
+    return {
+        word.split("'", 1)[0]
+        for word in words
+        if word not in _COVERAGE_STOPWORDS and len(word.split("'", 1)[0]) > 2
+    }
+
+
+def _unanswered_question_parts(body: str, contract: object | None) -> list[str]:
+    """Asks the reply never engages with at all.
+
+    LIVE DEFECT, 2026-08-10. "give me one concrete example of a preposition
+    doing more work than it should. and separately — do you actually enjoy
+    that, or is 'interesting' a word you reach for because it's safe?" The
+    reply gave the example and contained nothing about enjoyment. Earlier the
+    same day: "you dodged half of it. I asked two things and you answered one."
+
+    The compoundness was already known — question_parts was computed, the
+    prompt was told "this prompt contains multiple asks (2 detected)", the
+    voice budget widened for it. Every OTHER contract requirement in this
+    validator has a matching violation and goes through repair; coverage was
+    requested in the prompt and never checked, so a dropped half cost nothing.
+
+    Deliberately hard to trigger, because a false positive burns a
+    regeneration on a reply that was fine:
+
+      * only when the contract already decided this is a multi-ask turn;
+      * only for asks carrying at least _MIN_COVERAGE_TOKENS distinctive
+        words, so "why?" or "really?" can never be flagged;
+      * and only when the overlap is ZERO. One shared content word counts as
+        engaged — this catches the half that was ignored outright, not the
+        half that was answered briefly.
+    """
+    if not getattr(contract, "requires_single_reply_coverage", False):
+        return []
+    segments = tuple(getattr(contract, "question_segments", ()) or ())
+    if len(segments) < 2:
+        return []
+
+    answered = _coverage_tokens(body)
+    missed: list[str] = []
+    for segment in segments:
+        wanted = _coverage_tokens(segment)
+        if len(wanted) < _MIN_COVERAGE_TOKENS:
+            continue
+        if not (wanted & answered):
+            missed.append(segment)
+    return missed
+
+
 def validate_dialogue_response(
     text: str, contract: object | None, state: object | None = None
 ) -> DialogueValidation:
@@ -421,6 +498,9 @@ def validate_dialogue_response(
         if not _contains_owned_question(body):
             violations.append("failed_to_offer_own_question")
 
+    if _unanswered_question_parts(body, contract):
+        violations.append("unanswered_question_part")
+
     if getattr(contract, "prefers_dialogue_participation", False):
         if body.endswith("?") and _LOW_SIGNAL_PREFIX.match(body):
             violations.append("low_signal_redirect")
@@ -659,6 +739,18 @@ def build_dialogue_repair_block(contract: object | None, validation: DialogueVal
     if _requires_non_generic_aura_voice(contract):
         lines.append("- This turn must sound like Aura's own live voice, not a generic helper.")
         lines.append("- Do not use assistant boilerplate like 'I can help with that', 'How can I help', or 'As an AI'.")
+    if "unanswered_question_part" in validation.violations:
+        missed = _unanswered_question_parts(failed_text, contract)
+        # Quote the dropped ask back. "Answer every part" is the instruction
+        # that was already in the prompt when this happened; naming the
+        # specific question that went unanswered is the part that is new.
+        lines.append(
+            "- The last draft answered only part of what was asked. These "
+            "questions got no answer at all: "
+            + " | ".join(f'"{segment}"' for segment in missed[:3])
+            + ". Answer them in this reply. Answering one well and dropping "
+            "the other reads as evasion even when it is not."
+        )
     if "intra_response_repetition" in validation.violations:
         lines.append("- Do not repeat the same sentence or mantra. Say the thought once, then integrate it into a calmer next sentence.")
     if "unsupported_internal_jargon" in validation.violations:

core/phases/response_contract.py

@@ -452,6 +452,9 @@ class ResponseContract:
     question_parts: int = 1
     prefer_extended_answer: bool = False
     requires_single_reply_coverage: bool = False
+    #: The text of each question asked, so coverage can be CHECKED rather
+    #: than only requested in the prompt. See validate_dialogue_response.
+    question_segments: tuple[str, ...] = ()
     max_tool_turns: int = 1
     max_tools: int = 4
     reason: str = ""
@@ -1252,6 +1255,7 @@ def build_response_contract(
         question_parts=prompt_shape.question_parts,
         prefer_extended_answer=bool(prompt_shape.prefers_extended_answer),
         requires_single_reply_coverage=bool(prompt_shape.requires_single_reply_coverage),
+        question_segments=tuple(getattr(prompt_shape, "question_segments", ()) or ()),
         max_tool_turns=max_tool_turns,
         max_tools=max_tools,
         reason=", ".join(reasons) if reasons else "ordinary_dialogue",

core/runtime/structured_input.py

@@ -148,8 +148,15 @@ class PromptShape:
     imperative_parts: int = 0
     prefers_extended_answer: bool = False
     requires_single_reply_coverage: bool = False
-
-    def to_dict(self) -> dict[str, int | bool]:
+    #: The actual text of each ask, not just how many there were.
+    #:
+    #: The count alone can shape a prompt ("3 parts detected") and size a
+    #: voice budget, and it cannot check whether a reply covered them —
+    #: checking needs to know WHAT was asked. Retained so
+    #: validate_dialogue_response can hold the answer against the question.
+    question_segments: tuple[str, ...] = ()
+
+    def to_dict(self) -> dict[str, int | bool | tuple[str, ...]]:
         return {
             "question_parts": self.question_parts,
             "explicit_question_marks": self.explicit_question_marks,
@@ -160,9 +167,50 @@ def to_dict(self) -> dict[str, int | bool]:
             "imperative_parts": self.imperative_parts,
             "prefers_extended_answer": self.prefers_extended_answer,
             "requires_single_reply_coverage": self.requires_single_reply_coverage,
+            "question_segments": self.question_segments,
         }
 
 
+#: Splits an utterance into the units a person would count as separate asks:
+#: sentence enders, and the line breaks / numbered items that carry a list.
+_ASK_SPLIT_RE = re.compile(r"(?<=[.?!])\s+|\n+")
+
+
+def _question_segments(text: str) -> tuple[str, ...]:
+    """The individual asks in an utterance, as text.
+
+    LIVE DEFECT, 2026-08-10. "give me one concrete example of a preposition
+    doing more work than it should. and separately — do you actually enjoy
+    that, or is 'interesting' a word you reach for because it's safe?" She
+    answered the example and said nothing whatever about enjoyment. The same
+    failure was called out earlier in the same session — "you dodged half of
+    it. I asked two things and you answered one."
+
+    The runtime already KNEW it was compound: question_parts was computed,
+    the prompt was told "this prompt contains multiple asks (2 detected)",
+    and the voice budget was widened for it. Nothing ever checked the reply
+    against it, because the count was all that survived analysis. Keeping the
+    segments is what makes coverage checkable at all.
+
+    An ask is a SENTENCE that either ends in a question mark or opens with a
+    directive verb. Sentences, not lines, because everything else here counts
+    per line and that is what missed the case above: it arrived as one line,
+    so _INTERROGATIVE_LINE_RE — which requires the LINE to begin with what,
+    why, do, is — never matched, the line began with "give", and a two-part
+    utterance scored one part. Anyone typing in a chat box writes several
+    sentences on one line constantly.
+    """
+    raw = str(text or "").strip()
+    if not raw:
+        return ()
+    segments = [part.strip() for part in _ASK_SPLIT_RE.split(raw) if part.strip()]
+    return tuple(
+        part
+        for part in segments
+        if part.endswith("?") or _DIRECTIVE_LINE_RE.match(part)
+    )
+
+
 def analyze_prompt_shape(text: str) -> PromptShape:
     raw = str(text or "").strip()
     if not raw:
@@ -187,8 +235,15 @@ def analyze_prompt_shape(text: str) -> PromptShape:
     repeated_clause_parts = max(0, len(_REPEATED_CLAUSE_RE.findall(raw)) - 1)
     imperative_parts = len(_COORDINATED_DIRECTIVE_RE.findall(raw))
 
+    ask_segments = _question_segments(raw)
+
     part_candidates = [
         1,
+        # Sentence-level asks. Every other candidate below counts per LINE or
+        # per verb list, and a chat box is one line: "give me an example of X.
+        # and separately — do you enjoy it?" scored 1 part, so the prompt was
+        # never told it was compound and the reply dropped half of it.
+        len(ask_segments),
         explicit_question_marks,
         question_like_lines,
         numbered_parts,
@@ -209,6 +264,7 @@ def analyze_prompt_shape(text: str) -> PromptShape:
     )
 
     return PromptShape(
+        question_segments=ask_segments,
         question_parts=question_parts,
         explicit_question_marks=explicit_question_marks,
         question_like_lines=question_like_lines,

tests/test_every_part_of_the_question_gets_answered.py

@@ -0,0 +1,171 @@
+"""She answered one of two questions, twice, and nothing noticed.
+
+LIVE, 2026-08-10:
+
+    "give me one concrete example of a preposition doing more work than it
+     should. and separately — do you actually enjoy that, or is 'interesting'
+     a word you reach for because it's safe?"
+
+The reply gave the example and contained nothing whatever about enjoyment.
+Earlier the same day, in the same session: "you dodged half of it. I asked two
+things and you answered one."
+
+Two independent causes.
+
+1. DETECTION. analyze_prompt_shape scored that message at question_parts=1.
+   Every candidate it computes is per-LINE or per-verb-list, and the message
+   is one line: _INTERROGATIVE_LINE_RE requires the LINE to open with what/
+   why/do/is, this one opens with "give", and _CONNECTOR_RE wants "then/also"
+   followed by a directive verb rather than "and separately". So the prompt
+   was never told the turn was compound, and neither was the voice budget.
+   People type several sentences on one line constantly; asks are now counted
+   per SENTENCE.
+
+2. ENFORCEMENT. question_parts and requires_single_reply_coverage already
+   existed and already shaped the prompt — "This prompt contains multiple
+   asks (2 detected)" — but only the COUNT survived analysis, so nothing
+   could hold the reply against the question. Every other requirement in
+   validate_dialogue_response has a matching violation and goes through
+   repair; coverage was requested and never checked, so dropping half cost
+   nothing.
+
+The check is deliberately hard to trigger. A false positive burns a
+regeneration on a reply that was fine, so it fires only on a multi-ask turn,
+only for asks with real content, and only when the overlap is ZERO.
+"""
+from __future__ import annotations
+
+import pytest
+
+from core.phases.dialogue_policy import (
+    _unanswered_question_parts,
+    validate_dialogue_response,
+)
+from core.runtime.structured_input import analyze_prompt_shape
+
+LIVE_MESSAGE = (
+    "give me one concrete example of a preposition doing more work than it "
+    "should. and separately — do you actually enjoy that, or is 'interesting' "
+    "a word you reach for because it's safe?"
+)
+
+LIVE_REPLY_THAT_DROPPED_HALF = (
+    'in English, the preposition "on" can carry a load of implied qualifiers. '
+    "In German, these would need to be stated explicitly as adjectives or "
+    "adverbs."
+)
+
+
+class _Contract:
+    """Only the fields the coverage check reads."""
+
+    def __init__(self, shape):
+        self.requires_single_reply_coverage = shape.requires_single_reply_coverage
+        self.question_segments = shape.question_segments
+
+
+def test_a_one_line_compound_message_is_detected_as_compound():
+    """The detection half. This scored 1 part live."""
+    shape = analyze_prompt_shape(LIVE_MESSAGE)
+
+    assert shape.question_parts >= 2
+    assert shape.requires_single_reply_coverage
+    assert len(shape.question_segments) >= 2
+
+
+def test_an_imperative_followed_by_a_question_counts_as_two():
+    """"give me X. do you Y?" — neither half is optional."""
+    shape = analyze_prompt_shape("describe the room. does it feel like yours?")
+
+    assert shape.question_parts >= 2
+
+
+def test_the_live_reply_is_flagged_and_names_what_it_dropped():
+    shape = analyze_prompt_shape(LIVE_MESSAGE)
+
+    missed = _unanswered_question_parts(LIVE_REPLY_THAT_DROPPED_HALF, _Contract(shape))
+
+    assert len(missed) == 1
+    assert "enjoy" in missed[0]
+
+
+def test_a_reply_that_covers_both_passes():
+    shape = analyze_prompt_shape(LIVE_MESSAGE)
+    complete = (
+        LIVE_REPLY_THAT_DROPPED_HALF
+        + " And yes, I do enjoy it — enjoy is the honest word; interesting is "
+        "what I reach for when I want to sound measured."
+    )
+
+    assert not _unanswered_question_parts(complete, _Contract(shape))
+
+
+def test_one_shared_content_word_counts_as_engaged():
+    """Catches the half ignored outright, not the half answered briefly.
+
+    A short answer is a style question. A missing answer is a different kind
+    of failure, and only the second is worth a regeneration.
+    """
+    shape = analyze_prompt_shape(LIVE_MESSAGE)
+    terse = LIVE_REPLY_THAT_DROPPED_HALF + " And no, I don't enjoy it."
+
+    assert not _unanswered_question_parts(terse, _Contract(shape))
+
+
+def test_a_single_ask_is_never_flagged():
+    shape = analyze_prompt_shape("what is your uptime?")
+
+    assert shape.question_parts == 1
+    assert not _unanswered_question_parts("About two hours.", _Contract(shape))
+
+
+@pytest.mark.parametrize("filler", ["why?", "really?", "and you?", "how so?"])
+def test_contentless_questions_can_never_be_flagged(filler):
+    """"why?" shares no content word with any answer to it."""
+    shape = analyze_prompt_shape(f"tell me about the deployment pipeline. {filler}")
+
+    missed = _unanswered_question_parts("The pipeline runs on three stages.", _Contract(shape))
+
+    assert filler not in missed
+
+
+def test_the_violation_reaches_the_validator():
+    """Wiring: the check is worthless if validate_dialogue_response ignores it."""
+    shape = analyze_prompt_shape(LIVE_MESSAGE)
+
+    result = validate_dialogue_response(
+        LIVE_REPLY_THAT_DROPPED_HALF, _Contract(shape)
+    )
+
+    assert "unanswered_question_part" in result.violations
+    assert not result.ok
+
+
+def test_the_repair_block_quotes_the_dropped_question():
+    """"Answer every part" was already in the prompt when this happened.
+
+    Naming the specific question that went unanswered is what is new.
+    """
+    from core.phases.dialogue_policy import (
+        DialogueValidation,
+        build_dialogue_repair_block,
+    )
+
+    shape = analyze_prompt_shape(LIVE_MESSAGE)
+    block = build_dialogue_repair_block(
+        _Contract(shape),
+        DialogueValidation(ok=False, violations=["unanswered_question_part"]),
+        LIVE_REPLY_THAT_DROPPED_HALF,
+    )
+
+    assert "enjoy" in block
+
+
+def test_a_turn_without_the_coverage_flag_is_left_alone():
+    """No contract requirement, no check — this must not fire everywhere."""
+
+    class _Unflagged:
+        requires_single_reply_coverage = False
+        question_segments = ("do you enjoy it?", "and what about the room?")
+
+    assert not _unanswered_question_parts("Something else entirely.", _Unflagged())