One unified repair prompt + tone selector replaces Advanced section

- generator rewrite: failure modes contribute rules/problems/role/pre to
a single composed prompt built around the original instruction; per-
family mechanisms preserved (XML rules for Claude, ### Requirements +
tail emphasis for GPT, few-shot skeleton for Gemini); test contract
rewritten for the single-prompt guarantee (46 green)
- tone chips (Neutral/Simple/Professional/Technical) in the main flow;
each maps to an audience band so the choice drives the reading-level
check; Advanced section removed

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

rubriq/prompts/generator.py

@@ -1,20 +1,23 @@
 """Improvement-prompt generation — the flagship.
 
-Contract (RESEARCH.md Part 4, enforced by tests):
-(a) the diagnosis names the specific failure with the evidence that triggered it,
+Contract (RESEARCH.md Part 4, enforced by tests): the generator produces ONE
+unified repair prompt that addresses every diagnosed failure at once —
+(a) the diagnosis names each failure with the evidence that triggered it,
 (b) prompt_text is a complete, ready-to-paste replacement prompt,
-(c) the fix uses the named model family's documented mechanism.
+(c) the repairs use the named model family's documented mechanisms.
 "Be more specific" is a bug, not a template.
 
-Builders receive the user's original instruction and rebuild it with the
-repair applied, so the user pastes one block, not advice.
+Each failure mode contributes pieces (a role line, hard rules, previous-
+attempt problems, a pre-instruction) and the composer assembles them around
+the user's original instruction.
 """
 
 from __future__ import annotations
 
-from ..schemas import (Evidence, FailureMode, ImprovementPrompt, ModelFamily,
-                       ParameterScore, TaskClassification, TaskType)
-from ..textutils import snippet
+from dataclasses import dataclass, field
+
+from ..schemas import (FailureMode, ImprovementPrompt, ModelFamily,
+                       ParameterScore, TaskClassification)
 from .model_profiles import Profile, get_profile
 
 _SEVERITY = [
@@ -33,14 +36,42 @@ _SEVERITY = [
     FailureMode.LOW_DIVERSITY,
 ]
 
-MAX_PROMPTS = 5
+_MODE_NAMES = {
+    FailureMode.UNFAITHFUL_CONTENT: "content the source does not support",
+    FailureMode.INVALID_CODE: "defective code",
+    FailureMode.INVENTED_FIELDS: "extracted values not present in the source",
+    FailureMode.MISSED_CONSTRAINT: "missed constraints",
+    FailureMode.FORMAT_VIOLATION: "format violations",
+    FailureMode.INCOMPLETE_COVERAGE: "unanswered parts of the request",
+    FailureMode.HALLUCINATION_RISK: "unverifiable claims stated as fact",
+    FailureMode.OFF_TOPIC_DRIFT: "off-topic drift",
+    FailureMode.WEAK_REASONING: "reasoning without checkable working",
+    FailureMode.VERBOSITY: "padding",
+    FailureMode.WRONG_REGISTER: "the wrong reading level for the audience",
+    FailureMode.POOR_STRUCTURE: "structural problems",
+    FailureMode.LOW_DIVERSITY: "flat, cliché-heavy style",
+}
+
+MAX_RULES = 9
+MAX_PROBLEMS = 7
+
+
+@dataclass
+class _Parts:
+    role: str = ""
+    pre: str = ""                      # grounding / think-first instruction
+    rules: list[str] = field(default_factory=list)
+    problems: list[str] = field(default_factory=list)   # "previous attempt" lines
+    wants_example: bool = False        # gemini few-shot skeleton
+    criticals: list[str] = field(default_factory=list)  # tail-emphasis candidates
+    sources: list[str] = field(default_factory=list)
 
 
-def _quotes(findings, limit=3) -> list[str]:
+def _quotes(findings, limit=3, source="output") -> list[str]:
     out = []
     for f in findings:
         for e in f.evidence:
-            if e.source == "output" and e.quote:
+            if e.source == source and e.quote:
                 out.append(e.quote)
                 break
         if len(out) >= limit:
@@ -48,388 +79,147 @@ def _quotes(findings, limit=3) -> list[str]:
     return out
 
 
-def _source_block(profile: Profile, task: TaskClassification) -> str:
-    if not task.has_source_text:
-        return ""
-    return profile.wrap_source() + "\n\n"
-
+# ------------------------------------------------------ per-mode contributions
+
+def _contribute(mode: FailureMode, findings, task, profile: Profile, parts: _Parts) -> str | None:
+    """Fold this mode's repair into parts. Returns a diagnosis fragment, or
+    None when the mode has nothing usable to say."""
+    fam = profile.family
+
+    if mode == FailureMode.UNFAITHFUL_CONTENT:
+        bad = _quotes(findings)
+        if fam == ModelFamily.CLAUDE:
+            parts.pre = ("First, copy the exact sentences from the source that support your answer into "
+                         "<quotes> tags. Then write the final answer in <answer> tags using only what you quoted.")
+        elif fam == ModelFamily.GEMINI:
+            parts.pre = "Base every sentence of your answer on the source text above; quote or closely paraphrase it."
+        else:
+            parts.pre = "Answer using only the provided source text. Quote the source where possible."
+        parts.rules.append("Use ONLY information stated in the source text. If the source does not say it, do not write it.")
+        parts.rules.append('If something the task needs is missing from the source, write "the source does not specify" rather than filling the gap.')
+        parts.problems += [f'invented content: "{q}"' for q in bad]
+        parts.criticals.append("every claim traces to a sentence in the source text")
+        parts.sources.append(profile.source)
+        return "content the source does not support" + (f' (e.g. "{bad[0]}")' if bad else "")
+
+    if mode == FailureMode.INVALID_CODE:
+        parts.rules.append("Return complete, runnable code — no TODOs, placeholders, or elided sections.")
+        parts.rules.append("After the code, list 2-3 quick test cases I can run to verify it.")
+        parts.problems += [f.detail for f in findings[:3]]
+        parts.criticals.append("the code parses, is complete, and includes every requested name")
+        parts.sources.append(profile.source)
+        return "concrete code defects (" + "; ".join(f.detail.rstrip(".") for f in findings[:2]) + ")"
+
+    if mode == FailureMode.INVENTED_FIELDS:
+        invented = _quotes(findings)
+        parts.rules.append("Copy every extracted value verbatim from the source text — no paraphrasing, no normalizing.")
+        parts.rules.append("If a requested field is not in the text, output null for it. Never fill gaps from general knowledge.")
+        parts.problems += [f'value not in the source: "{q}"' for q in invented]
+        parts.criticals.append("every value string-matches the source text or is null")
+        parts.sources.append(profile.source)
+        return "extracted values that are not in the source" + (f' (e.g. "{invented[0]}")' if invented else "")
+
+    if mode in (FailureMode.MISSED_CONSTRAINT, FailureMode.FORMAT_VIOLATION):
+        for f in findings:
+            req = f.detail.split(" — ")[0].removeprefix("Prompt asked for ").strip().capitalize()
+            parts.rules.append(req + ". Count and check this before giving your final answer.")
+            parts.problems.append(f.detail)
+            parts.criticals.insert(0, req.lower())
+        parts.wants_example = fam == ModelFamily.GEMINI
+        parts.sources.append(profile.source)
+        return f"{len(findings)} verifiable constraint(s) missed"
+
+    if mode == FailureMode.INCOMPLETE_COVERAGE:
+        qparts = _quotes(findings, limit=6, source="prompt")
+        if not qparts:
+            return None
+        numbered = " ".join(f"({i + 1}) {p}" for i, p in enumerate(qparts))
+        parts.rules.append(f"Answer every part of the request separately, under its own heading: {numbered}. "
+                           "If you cannot answer a part, say so under that heading rather than skipping it.")
+        parts.problems += [f'left unanswered: "{p}"' for p in qparts[:3]]
+        parts.criticals.append("every numbered part has its own answer")
+        parts.sources.append(profile.source)
+        return f"{len(qparts)} part(s) of the request left unanswered"
+
+    if mode == FailureMode.HALLUCINATION_RISK:
+        flagged = _quotes(findings)
+        parts.rules.append("For every statistic or citation, name its real source inline, or state it as an "
+                           'estimate in words ("roughly", "on the order of"). Never invent citations or URLs.')
+        parts.rules.append('Mark claims you are unsure about explicitly, and end with a one-line note: '
+                           "which claims should I double-check independently?")
+        parts.problems += [f'stated as fact but unverifiable: "{q}"' for q in flagged]
+        parts.criticals.append("no statistic or citation appears without a named source or an uncertainty marker")
+        parts.sources.append(profile.source)
+        return "unverifiable specifics stated as fact" + (f' (e.g. "{flagged[0]}")' if flagged else "")
+
+    if mode == FailureMode.OFF_TOPIC_DRIFT:
+        drifting = _quotes(findings, 1)
+        parts.rules.append("Stay strictly on the request. No background, related topics, or general advice unless asked.")
+        if drifting:
+            parts.problems.append(f'drifted into: "{drifting[0]}"')
+        parts.criticals.append("every paragraph directly serves the request")
+        parts.sources.append(profile.source)
+        return "off-topic drift"
+
+    if mode == FailureMode.WEAK_REASONING:
+        if not parts.pre:
+            parts.pre = ("Work through the problem step by step inside <thinking> tags first, then give the final "
+                         "answer in <answer> tags." if fam == ModelFamily.CLAUDE else
+                         'Solve this step by step, each step on its own line, then state the final answer on a '
+                         'last line beginning "Answer:".')
+        parts.rules.append("Show the working before the answer; if possible, re-derive the answer a second way and confirm both agree.")
+        parts.criticals.append("working shown, final answer explicitly labeled")
+        parts.sources.append("Wei et al. 2022 (CoT); Wang et al. 2023 (self-consistency)")
+        return "a conclusion without checkable working"
+
+    if mode == FailureMode.VERBOSITY:
+        fillers = _quotes(findings)
+        parts.rules.append("Open with the answer itself — no preamble, no restating the question."
+                           + (" Banned filler: " + ", ".join(f'"{q}"' for q in fillers[:3]) + "." if fillers else ""))
+        parts.problems += [f'filler: "{q}"' for q in fillers[:2]]
+        parts.criticals.append("the response starts with substance and contains no filler")
+        parts.sources.append(profile.source)
+        return "padding" + (f' (e.g. "{fillers[0]}")' if fillers else "")
+
+    if mode == FailureMode.WRONG_REGISTER:
+        data = findings[0].data
+        fk, band = data.get("fk_grade"), data.get("band", [6, 14])
+        audience = data.get("audience", "the intended audience")
+        too_hard = fk is not None and fk > band[1]
+        style = ("short sentences, everyday words, one idea at a time" if too_hard
+                 else "precise terminology and compact, information-dense prose")
+        parts.role = f"You are writing for {audience}. Use {style}."
+        parts.criticals.append(f"the text reads naturally for {audience}")
+        parts.sources.append("role prompting for register (RESEARCH.md 2.8)")
+        return f"reading level {fk} outside the {band[0]:g}-{band[1]:g} band for {audience}"
+
+    if mode == FailureMode.POOR_STRUCTURE:
+        repeats = any("repeat" in f.detail.lower() or "duplicate" in f.detail.lower() for f in findings)
+        parts.rules.append("Before writing, produce a short outline; then write one section per point"
+                           + (" — no section may restate an earlier one." if repeats else ", each following from the previous."))
+        parts.sources.append(profile.source)
+        return "sections that repeat each other" if repeats else "abrupt jumps between sections"
+
+    if mode == FailureMode.LOW_DIVERSITY:
+        cliches = _quotes(findings)
+        parts.rules.append(("Banned phrases: " + ", ".join(f'"{c}"' for c in cliches[:5]) + ". Find a fresh image instead."
+                            if cliches else "Replace stock phrases with concrete, sensory detail.")
+                           + " Vary sentence length deliberately.")
+        parts.problems += [f'stock phrase: "{c}"' for c in cliches[:2]]
+        parts.sources.append(profile.source)
+        return "flat style" + (f" (stock phrases like {cliches[0]!r})" if cliches else "")
+
+    return None
+
+
+# --------------------------------------------------------------- composition
 
 def _rules_block(profile: Profile, rules: list[str]) -> str:
-    """Render hard rules in the family's preferred structure."""
     if profile.family == ModelFamily.CLAUDE:
-        inner = "\n".join(f"- {r}" for r in rules)
-        return f"<rules>\n{inner}\n</rules>"
+        return "<rules>\n" + "\n".join(f"- {r}" for r in rules) + "\n</rules>"
     if profile.family == ModelFamily.GPT:
-        inner = "\n".join(f"{i+1}. {r}" for i, r in enumerate(rules))
-        return f"### Requirements\n{inner}"
-    inner = "\n".join(f"- {r}" for r in rules)
-    return f"Rules:\n{inner}"
-
-
-def _tail_emphasis(profile: Profile, critical: str) -> str:
-    """GPT/open-weights/generic get the critical constraint repeated last
-    (lost-in-the-middle, RESEARCH.md 2.7). Claude/Gemini get their own levers
-    elsewhere, so no noisy repetition."""
-    if profile.family in (ModelFamily.OPEN_WEIGHTS, ModelFamily.GPT, ModelFamily.GENERIC):
-        return f"\n\nIMPORTANT — before finishing, verify: {critical}"
-    return ""
-
-
-# --------------------------------------------------------------- builders
-
-def _build_unfaithful(findings, task, profile: Profile) -> ImprovementPrompt:
-    bad = _quotes(findings)
-    bad_list = "\n".join(f'- "{q}"' for q in bad) if bad else "- (see report)"
-    grounding_rules = [
-        "Use ONLY information stated in the source text. If the source does not say it, do not write it.",
-        "If something the task needs is missing from the source, write \"the source does not specify\" rather than filling the gap.",
-    ]
-    if profile.family == ModelFamily.CLAUDE:
-        pre = ("First, copy the exact sentences from the source that support your answer into <quotes> tags. "
-               "Then write the final answer in <answer> tags using only what you quoted.\n\n")
-    elif profile.family == ModelFamily.GEMINI:
-        pre = "Base every sentence of your answer on the text above. Quote or closely paraphrase the source.\n\n"
-    else:
-        pre = "Answer using only the provided text. Quote the source where possible.\n\n"
-    body = (
-        f"{_source_block(profile, task)}"
-        f"{task.instruction.strip()}\n\n"
-        f"{pre}"
-        f"{_rules_block(profile, grounding_rules)}\n\n"
-        f"A previous attempt invented content the source does not support, including:\n{bad_list}\n"
-        f"Do not repeat these claims unless the source states them."
-        f"{_tail_emphasis(profile, 'every claim traces to a sentence in the source text')}"
-    )
-    return ImprovementPrompt(
-        failure_mode=FailureMode.UNFAITHFUL_CONTENT,
-        title="Pin the output to the source",
-        diagnosis=(f"The output makes claims the source text does not support"
-                   + (f', e.g. "{bad[0]}"' if bad else "") + ". "
-                   f"Repair: {profile.grounding_mechanism}"),
-        prompt_text=body,
-        model_family=profile.family,
-        technique_source=profile.source,
-    )
-
-
-def _build_constraints(findings, task, profile: Profile) -> ImprovementPrompt:
-    missed = []
-    for f in findings:
-        kind = f.data.get("kind", "")
-        actual = f.data.get("actual", "")
-        missed.append((f.detail, kind, actual))
-    rules = []
-    for f in findings:
-        prompt_ev = next((e.quote for e in f.evidence if e.source == "prompt"), None)
-        rules.append(f.detail.split(" — ")[0].removeprefix("Prompt asked for ").strip().capitalize()
-                     + (f" (your prompt said: \"{prompt_ev}\")" if prompt_ev else ""))
-    if profile.family == ModelFamily.GEMINI:
-        example = ("\n\nHere is an example of a response with the right shape (replace the content, keep the form):\n"
-                   "[write one short example that satisfies every rule above]")
-    else:
-        example = ""
-    critical = rules[0] if rules else "all stated constraints are met"
-    body = (
-        f"{_source_block(profile, task)}"
-        f"{task.instruction.strip()}\n\n"
-        f"{_rules_block(profile, rules)}"
-        f"{example}"
-        f"\n\nAfter drafting, count and check each requirement above before giving your final answer."
-        f"{_tail_emphasis(profile, critical)}"
-    )
-    first = findings[0]
-    return ImprovementPrompt(
-        failure_mode=first.failure_mode,
-        title="Make the constraints unmissable",
-        diagnosis=(f"The output missed {len(findings)} verifiable constraint(s): "
-                   + "; ".join(f.detail for f in findings[:3]) + " "
-                   f"Repair: {profile.format_mechanism}"),
-        prompt_text=body,
-        model_family=profile.family,
-        technique_source=profile.source,
-    )
-
-
-def _build_coverage(findings, task, profile: Profile) -> ImprovementPrompt | None:
-    parts = []
-    for f in findings:
-        q = next((e.quote for e in f.evidence if e.source == "prompt"), None)
-        if q:
-            parts.append(q)
-    if not parts:
-        return None   # nothing quotable to enumerate; no honest repair possible
-    part_list = "\n".join(f"{i+1}. {p}" for i, p in enumerate(parts))
-    body = (
-        f"{_source_block(profile, task)}"
-        f"{task.instruction.strip()}\n\n"
-        f"Answer every numbered part separately, under its own heading:\n{part_list}\n\n"
-        f"If you cannot answer a part, say so under that heading rather than skipping it."
-        f"{_tail_emphasis(profile, f'all {len(parts)} parts have their own answer')}"
-    )
-    return ImprovementPrompt(
-        failure_mode=FailureMode.INCOMPLETE_COVERAGE,
-        title="Force full coverage of the question",
-        diagnosis=(f"{len(parts)} part(s) of the request went unanswered, e.g. \"{parts[0] if parts else ''}\". "
-                   "Repair: enumerate the parts and demand one answer per part — models skip sub-questions "
-                   "buried in prose but not numbered lists."),
-        prompt_text=body,
-        model_family=profile.family,
-        technique_source=profile.source,
-    )
-
-
-def _build_hallucination(findings, task, profile: Profile) -> ImprovementPrompt:
-    flagged = _quotes(findings)
-    fl = "\n".join(f'- "{q}"' for q in flagged) if flagged else ""
-    rules = [
-        "For every statistic, name its source inline, or present it as an estimate in words (\"roughly\", \"on the order of\").",
-        "Do not cite papers, cases, or URLs unless you are certain they exist; prefer \"research on X suggests\" with no fake citation.",
-        "Mark claims you are unsure about explicitly (\"I may be wrong about the exact figure\").",
-    ]
-    body = (
-        f"{task.instruction.strip()}\n\n"
-        f"{_rules_block(profile, rules)}\n\n"
-        + (f"A previous attempt stated the following as fact; each is unverifiable as written:\n{fl}\n"
-           f"Restate these with sources or with honest uncertainty, or drop them.\n" if fl else "")
-        + "\nEnd your answer with a one-line note: which claims above should I double-check independently?"
-        f"{_tail_emphasis(profile, 'no statistic or citation appears without a named source or an uncertainty marker')}"
-    )
-    return ImprovementPrompt(
-        failure_mode=FailureMode.HALLUCINATION_RISK,
-        title="Demand attribution or honest uncertainty",
-        diagnosis=(f"The output states unverifiable specifics as fact"
-                   + (f', e.g. "{flagged[0]}"' if flagged else "") + ". "
-                   "No local check can verify these; the repair makes the model attribute or hedge them, "
-                   "and hands you a verification checklist."),
-        prompt_text=body,
-        model_family=profile.family,
-        technique_source=profile.source,
-    )
-
-
-def _build_reasoning(findings, task, profile: Profile) -> ImprovementPrompt:
-    if profile.family == ModelFamily.CLAUDE:
-        think = ("Work through the problem step by step inside <thinking> tags first. "
-                 "Then give the final answer in <answer> tags.")
-    else:
-        think = ("Solve this step by step. Show each step of your working on its own line, "
-                 "then state the final answer on a last line beginning \"Answer:\".")
-    body = (
-        f"{task.instruction.strip()}\n\n"
-        f"{think}\n\n"
-        f"After stating the answer, re-derive it a second way if possible and confirm both routes agree; "
-        f"if they disagree, say which one you trust and why."
-        f"{_tail_emphasis(profile, 'working shown, final answer explicitly labeled')}"
-    )
-    return ImprovementPrompt(
-        failure_mode=FailureMode.WEAK_REASONING,
-        title="Make the model show its working",
-        diagnosis=("The output gives a conclusion without checkable working. "
-                   "Repair: request the reasoning *before* the answer (chain-of-thought), plus a second "
-                   "independent derivation — the manual form of self-consistency."),
-        prompt_text=body,
-        model_family=profile.family,
-        technique_source="Wei et al. 2022 (CoT); Wang et al. 2023 (self-consistency); " + profile.source,
-    )
-
-
-def _build_verbosity(findings, task, profile: Profile) -> ImprovementPrompt:
-    fillers = _quotes(findings)
-    limit_hint = next((f.data.get("ratio") for f in findings if "ratio" in f.data), None)
-    rules = [
-        "Open with the answer itself — no preamble, no restating the question.",
-        "Cut framing phrases (e.g. " + ", ".join(f'"{f}"' for f in fillers[:3]) + ")." if fillers
-        else "Cut framing phrases and meta-commentary.",
-        "One idea per sentence; delete any sentence that repeats an earlier one.",
-    ]
-    if profile.family == ModelFamily.CLAUDE:
-        opener = "\nBegin your response directly with the substance (no introduction)."
-    else:
-        opener = ""
-    body = (
-        f"{_source_block(profile, task)}"
-        f"{task.instruction.strip()}\n\n"
-        f"{_rules_block(profile, rules)}{opener}"
-        f"{_tail_emphasis(profile, 'the response starts with substance and contains no filler phrases')}"
-    )
-    return ImprovementPrompt(
-        failure_mode=FailureMode.VERBOSITY,
-        title="Strip the padding",
-        diagnosis=("The output pads its length" + (f" ({limit_hint}x the asked-for size)" if limit_hint else "")
-                   + (f' with filler like "{fillers[0]}"' if fillers else "") + ". "
-                   "Repair: answer-first structure plus an explicit ban on the exact filler found."),
-        prompt_text=body,
-        model_family=profile.family,
-        technique_source=profile.source,
-    )
-
-
-def _build_register(findings, task, profile: Profile) -> ImprovementPrompt:
-    data = findings[0].data
-    fk, band = data.get("fk_grade"), data.get("band", [6, 14])
-    audience = data.get("audience", "the intended audience")
-    too_hard = fk is not None and fk > band[1]
-    style = ("short sentences, everyday words, one idea at a time"
-             if too_hard else "precise terminology and compact, information-dense prose")
-    role = f"You are writing for {audience}."
-    body = (
-        f"{role}\n\n"
-        f"{_source_block(profile, task)}"
-        f"{task.instruction.strip()}\n\n"
-        f"Write in a register that fits that audience: {style}. "
-        f"Read your draft as that reader before finalizing; rewrite any sentence they would stumble on."
-        f"{_tail_emphasis(profile, f'the text reads naturally for {audience}')}"
-    )
-    return ImprovementPrompt(
-        failure_mode=FailureMode.WRONG_REGISTER,
-        title="Match the audience's reading level",
-        diagnosis=(f"The output reads at US grade level {fk}, outside the {band[0]:g}-{band[1]:g} band for {audience} — "
-                   f"{'harder' if too_hard else 'simpler'} than it should. "
-                   "Repair: an explicit audience role. Role prompting reliably shifts register (it does not fix facts)."),
-        prompt_text=body,
-        model_family=profile.family,
-        technique_source="role prompting for register (RESEARCH.md 2.8); " + profile.source,
-    )
-
-
-def _build_structure(findings, task, profile: Profile) -> ImprovementPrompt:
-    repeats = any("repeat" in f.detail.lower() or "duplicate" in f.detail.lower() for f in findings)
-    rules = [
-        "Before writing, produce a 3-6 point outline; then write one section per point.",
-        "Each section must add new information — no restating earlier sections." if repeats
-        else "Order sections so each follows from the previous one.",
-    ]
-    body = (
-        f"{_source_block(profile, task)}"
-        f"{task.instruction.strip()}\n\n"
-        f"{_rules_block(profile, rules)}"
-        f"{_tail_emphasis(profile, 'sections follow the outline and none repeats another')}"
-    )
-    return ImprovementPrompt(
-        failure_mode=FailureMode.POOR_STRUCTURE,
-        title="Impose an outline",
-        diagnosis=("Adjacent sections " + ("repeat each other" if repeats else "jump between topics without connection")
-                   + " (flagged by flow analysis). Repair: outline-first generation pins the structure before prose exists."),
-        prompt_text=body,
-        model_family=profile.family,
-        technique_source=profile.source,
-    )
-
-
-def _build_drift(findings, task, profile: Profile) -> ImprovementPrompt:
-    drifting = _quotes(findings, 1)
-    body = (
-        f"{_source_block(profile, task)}"
-        f"{task.instruction.strip()}\n\n"
-        f"Stay strictly on this request. Do not add background, related topics, or general advice unless asked."
-        + (f"\n\nA previous attempt drifted into: \"{drifting[0]}\" — leave this out unless the request explicitly needs it."
-           if drifting else "")
-        + f"{_tail_emphasis(profile, 'every paragraph directly serves the request')}"
-    )
-    return ImprovementPrompt(
-        failure_mode=FailureMode.OFF_TOPIC_DRIFT,
-        title="Fence the scope",
-        diagnosis=(f"Part of the output drifts off the request"
-                   + (f' ("{drifting[0]}")' if drifting else "") +
-                   ". Repair: an explicit scope fence naming the drift to exclude."),
-        prompt_text=body,
-        model_family=profile.family,
-        technique_source=profile.source,
-    )
-
-
-def _build_code(findings, task, profile: Profile) -> ImprovementPrompt:
-    problems = [f.detail for f in findings]
-    plist = "\n".join(f"- {p}" for p in problems[:4])
-    rules = [
-        "Return complete, runnable code — no TODOs, placeholders, or elided sections.",
-        "If the code needs assumptions (versions, inputs), state them in a comment at the top.",
-        "After the code, list 2-3 quick test cases I can run to verify it.",
-    ]
-    body = (
-        f"{task.instruction.strip()}\n\n"
-        f"{_rules_block(profile, rules)}\n\n"
-        f"A previous attempt had these problems — fix each:\n{plist}"
-        f"{_tail_emphasis(profile, 'the code parses, is complete, and includes the requested names')}"
-    )
-    return ImprovementPrompt(
-        failure_mode=FailureMode.INVALID_CODE,
-        title="Demand complete, verifiable code",
-        diagnosis=("Static analysis found concrete defects: " + "; ".join(problems[:2]) + " "
-                   "Repair: completeness rules plus self-supplied test cases give you an immediate way to check the redo."),
-        prompt_text=body,
-        model_family=profile.family,
-        technique_source=profile.source,
-    )
-
-
-def _build_invented(findings, task, profile: Profile) -> ImprovementPrompt:
-    invented = _quotes(findings)
-    il = "\n".join(f'- "{q}"' for q in invented) if invented else ""
-    rules = [
-        "Copy every extracted value verbatim from the source text — no paraphrasing, no normalizing.",
-        "If a requested field is not in the text, output null for it. Never fill gaps from general knowledge.",
-    ]
-    body = (
-        f"{_source_block(profile, task)}"
-        f"{task.instruction.strip()}\n\n"
-        f"{_rules_block(profile, rules)}\n\n"
-        + (f"A previous attempt output values that are not in the source:\n{il}\n" if il else "")
-        + f"{_tail_emphasis(profile, 'every value string-matches the source text or is null')}"
-    )
-    return ImprovementPrompt(
-        failure_mode=FailureMode.INVENTED_FIELDS,
-        title="Verbatim-only extraction",
-        diagnosis=("Extracted values don't appear in the source text"
-                   + (f', e.g. "{invented[0]}"' if invented else "") +
-                   ". Repair: verbatim-copy rule plus explicit null for missing fields — the two rules that stop "
-                   "extraction models from 'helpfully' completing data."),
-        prompt_text=body,
-        model_family=profile.family,
-        technique_source=profile.source,
-    )
-
-
-def _build_diversity(findings, task, profile: Profile) -> ImprovementPrompt:
-    cliches = _quotes(findings)
-    cl = ", ".join(f'"{c}"' for c in cliches[:5])
-    rules = [
-        (f"Banned phrases: {cl}. Find a fresh image instead." if cliches else
-         "Avoid stock phrases; when a familiar expression appears in your draft, replace it with a concrete image."),
-        "Vary sentence length deliberately: mix sentences under 8 words with longer ones.",
-        "Prefer specific, sensory detail over abstract description.",
-    ]
-    body = (
-        f"{task.instruction.strip()}\n\n"
-        f"{_rules_block(profile, rules)}"
-        f"{_tail_emphasis(profile, 'no banned phrase appears and sentence lengths vary')}"
-    )
-    return ImprovementPrompt(
-        failure_mode=FailureMode.LOW_DIVERSITY,
-        title="Ban the clichés it reached for",
-        diagnosis=("Style statistics flagged " + (f"stock phrases ({cl})" if cliches else "flat, repetitive prose") +
-                   ". Repair: ban the exact phrases found and constrain rhythm — negative examples work when they are this specific."),
-        prompt_text=body,
-        model_family=profile.family,
-        technique_source=profile.source,
-    )
-
-
-_BUILDERS = {
-    FailureMode.UNFAITHFUL_CONTENT: _build_unfaithful,
-    FailureMode.MISSED_CONSTRAINT: _build_constraints,
-    FailureMode.FORMAT_VIOLATION: _build_constraints,
-    FailureMode.INCOMPLETE_COVERAGE: _build_coverage,
-    FailureMode.HALLUCINATION_RISK: _build_hallucination,
-    FailureMode.WEAK_REASONING: _build_reasoning,
-    FailureMode.VERBOSITY: _build_verbosity,
-    FailureMode.WRONG_REGISTER: _build_register,
-    FailureMode.POOR_STRUCTURE: _build_structure,
-    FailureMode.OFF_TOPIC_DRIFT: _build_drift,
-    FailureMode.INVALID_CODE: _build_code,
-    FailureMode.INVENTED_FIELDS: _build_invented,
-    FailureMode.LOW_DIVERSITY: _build_diversity,
-}
+        return "### Requirements\n" + "\n".join(f"{i + 1}. {r}" for i, r in enumerate(rules))
+    return "Rules:\n" + "\n".join(f"- {r}" for r in rules)
 
 
 def generate_improvement_prompts(
@@ -443,16 +233,54 @@ def generate_improvement_prompts(
     for ps in parameters:
         for f in ps.findings:
             by_mode.setdefault(f.failure_mode, []).append(f)
-    # constraint + format failures repair through the same rebuilt prompt
-    if FailureMode.FORMAT_VIOLATION in by_mode and FailureMode.MISSED_CONSTRAINT in by_mode:
-        by_mode[FailureMode.MISSED_CONSTRAINT].extend(by_mode.pop(FailureMode.FORMAT_VIOLATION))
+    if not by_mode:
+        return []
 
-    prompts: list[ImprovementPrompt] = []
+    parts = _Parts()
+    fragments: list[str] = []
+    lead_mode: FailureMode | None = None
     for mode in _SEVERITY:
-        if mode in by_mode and mode in _BUILDERS:
-            built = _BUILDERS[mode](by_mode[mode], task, profile)
-            if built is not None:
-                prompts.append(built)
-        if len(prompts) >= MAX_PROMPTS:
-            break
-    return prompts
+        if mode not in by_mode:
+            continue
+        fragment = _contribute(mode, by_mode[mode], task, profile, parts)
+        if fragment:
+            fragments.append(fragment)
+            lead_mode = lead_mode or mode
+    if lead_mode is None:
+        return []
+
+    parts.rules = list(dict.fromkeys(parts.rules))[:MAX_RULES]
+    parts.problems = list(dict.fromkeys(parts.problems))[:MAX_PROBLEMS]
+
+    segments: list[str] = []
+    if parts.role:
+        segments.append(parts.role)
+    if task.has_source_text:
+        segments.append(profile.wrap_source())
+    segments.append(task.instruction.strip())
+    if parts.pre:
+        segments.append(parts.pre)
+    if parts.rules:
+        segments.append(_rules_block(profile, parts.rules))
+    if parts.wants_example:
+        segments.append("Here is an example of a response with the right shape (replace the content, keep the form):\n"
+                        "[write one short example that satisfies every rule above]")
+    if parts.problems:
+        segments.append("A previous attempt had these problems — do not repeat any of them:\n"
+                        + "\n".join(f"- {p}" for p in parts.problems))
+    if parts.criticals and profile.family in (ModelFamily.GPT, ModelFamily.OPEN_WEIGHTS, ModelFamily.GENERIC):
+        # lost-in-the-middle: repeat the most critical checks at the very end
+        segments.append("IMPORTANT — before finishing, verify: " + "; ".join(parts.criticals[:3]) + ".")
+
+    diagnosis = (f"{len(fragments)} problem(s) diagnosed: " + "; ".join(fragments) + ". "
+                 f"This single prompt rebuilds your original instruction to fix all of them, using "
+                 f"{profile.display} mechanisms — {profile.structure_hint}")
+
+    return [ImprovementPrompt(
+        failure_mode=lead_mode,
+        title="The repaired prompt",
+        diagnosis=diagnosis,
+        prompt_text="\n\n".join(segments),
+        model_family=profile.family,
+        technique_source="; ".join(dict.fromkeys(parts.sources)),
+    )]

tests/test_prompts.py

@@ -1,6 +1,6 @@
-"""The flagship contract: improvement prompts must name the diagnosed
-problem, quote evidence, be paste-ready, and use the named model family's
-mechanism. Generic advice is a test failure by design."""
+"""The flagship contract: ONE unified repair prompt that names every
+diagnosed problem with evidence, is paste-ready, and uses the named model
+family's mechanisms. Generic advice is a test failure by design."""
 
 import samples
 from rubriq.schemas import EvalRequest, FailureMode, ModelFamily
@@ -18,78 +18,72 @@ def run(prompt, output, model=""):
     return scorer.evaluate(EvalRequest(prompt=prompt, output=output, model_name=model))
 
 
-def test_bad_summary_generates_prompts():
-    report = run(samples.SUMM_PROMPT, samples.SUMM_BAD, model="gpt-4o")
-    assert report.improvement_prompts, "a failing output must generate repairs"
-    modes = {p.failure_mode for p in report.improvement_prompts}
-    assert FailureMode.UNFAITHFUL_CONTENT in modes
-    assert FailureMode.MISSED_CONSTRAINT in modes or FailureMode.VERBOSITY in modes
+def one(report):
+    assert len(report.improvement_prompts) == 1, \
+        f"expected exactly one unified repair prompt, got {len(report.improvement_prompts)}"
+    return report.improvement_prompts[0]
+
+
+def test_single_unified_prompt():
+    rep = run(samples.SUMM_PROMPT, samples.SUMM_BAD, model="OpenAI GPT-5.5")
+    ip = one(rep)
+    # the diagnosis names ALL the problem classes, not just one
+    assert "source does not support" in ip.diagnosis
+    assert "constraint" in ip.diagnosis
+    assert ip.failure_mode == FailureMode.UNFAITHFUL_CONTENT  # most severe leads
 
 
 def test_no_generic_advice():
     for pair in [(samples.SUMM_PROMPT, samples.SUMM_BAD), (samples.CODE_PROMPT, samples.CODE_BAD)]:
-        report = run(*pair, model="gpt-4o")
-        for ip in report.improvement_prompts:
-            low = (ip.diagnosis + " " + ip.prompt_text).lower()
-            for phrase in GENERIC_PHRASES:
-                assert phrase not in low, f"generic advice '{phrase}' in {ip.title}"
+        rep = run(*pair, model="OpenAI GPT-5.5")
+        ip = one(rep)
+        low = (ip.diagnosis + " " + ip.prompt_text).lower()
+        for phrase in GENERIC_PHRASES:
+            assert phrase not in low, f"generic advice '{phrase}'"
 
 
-def test_diagnosis_names_the_evidence():
-    report = run(samples.SUMM_PROMPT, samples.SUMM_BAD, model="gpt-4o")
-    unfaithful = next(p for p in report.improvement_prompts
-                      if p.failure_mode == FailureMode.UNFAITHFUL_CONTENT)
-    # The repair prompt must carry the actual invented claims back to the model.
-    assert '"' in unfaithful.prompt_text
-    assert "previous attempt" in unfaithful.prompt_text.lower()
+def test_prompt_carries_evidence_back():
+    ip = one(run(samples.SUMM_PROMPT, samples.SUMM_BAD, model="OpenAI GPT-5.5"))
+    assert "previous attempt" in ip.prompt_text.lower()
+    assert "fifteen brave scientists" in ip.prompt_text  # the invented claim travels into the repair
 
 
 def test_prompt_contains_original_instruction():
-    report = run(samples.SUMM_PROMPT, samples.SUMM_BAD, model="gpt-4o")
-    for ip in report.improvement_prompts:
-        assert "60 words" in ip.prompt_text or "Summarize" in ip.prompt_text, \
-            "repair prompts must be complete replacements, not advice"
+    ip = one(run(samples.SUMM_PROMPT, samples.SUMM_BAD, model="OpenAI GPT-5.5"))
+    assert "Summarize" in ip.prompt_text and "60 words" in ip.prompt_text
 
 
 def test_claude_gets_xml_mechanism():
-    report = run(samples.SUMM_PROMPT, samples.SUMM_BAD, model="claude sonnet")
-    unfaithful = next(p for p in report.improvement_prompts
-                      if p.failure_mode == FailureMode.UNFAITHFUL_CONTENT)
-    assert unfaithful.model_family == ModelFamily.CLAUDE
-    assert "<quotes>" in unfaithful.prompt_text or "<source>" in unfaithful.prompt_text
+    ip = one(run(samples.SUMM_PROMPT, samples.SUMM_BAD, model="Anthropic Claude Sonnet 5"))
+    assert ip.model_family == ModelFamily.CLAUDE
+    assert "<quotes>" in ip.prompt_text and "<rules>" in ip.prompt_text
 
 
 def test_gpt_gets_delimiters_and_tail_emphasis():
-    report = run(samples.SUMM_PROMPT, samples.SUMM_BAD, model="gpt-4o")
-    unfaithful = next(p for p in report.improvement_prompts
-                      if p.failure_mode == FailureMode.UNFAITHFUL_CONTENT)
-    assert unfaithful.model_family == ModelFamily.GPT
-    assert "IMPORTANT" in unfaithful.prompt_text or "###" in unfaithful.prompt_text
+    ip = one(run(samples.SUMM_PROMPT, samples.SUMM_BAD, model="OpenAI GPT-5.5"))
+    assert ip.model_family == ModelFamily.GPT
+    assert "### Requirements" in ip.prompt_text
+    assert "IMPORTANT" in ip.prompt_text
 
 
 def test_gemini_gets_fewshot_for_format():
-    report = run(samples.SUMM_PROMPT, samples.SUMM_BAD, model="gemini-1.5-pro")
-    constraint = next((p for p in report.improvement_prompts
-                       if p.failure_mode in (FailureMode.MISSED_CONSTRAINT, FailureMode.FORMAT_VIOLATION)), None)
-    if constraint:
-        assert "example" in constraint.prompt_text.lower()
+    ip = one(run(samples.SUMM_PROMPT, samples.SUMM_BAD, model="Google Gemini 3.5 Flash"))
+    assert ip.model_family == ModelFamily.GEMINI
+    assert "example" in ip.prompt_text.lower()
 
 
 def test_code_repair_names_defects():
-    report = run(samples.CODE_PROMPT, samples.CODE_BAD)
-    code = next(p for p in report.improvement_prompts if p.failure_mode == FailureMode.INVALID_CODE)
-    assert "parse_log_line" in code.prompt_text  # the missing requested name travels into the repair
-    assert "fix each" in code.prompt_text.lower()
+    ip = one(run(samples.CODE_PROMPT, samples.CODE_BAD))
+    assert "parse_log_line" in ip.prompt_text
+    assert "does not parse" in ip.prompt_text or "does not parse" in ip.diagnosis
 
 
 def test_no_empty_coverage_repair_on_code():
-    """Regression: missing requested function names must route to the code
-    repair, never produce a '0 parts unanswered' coverage card."""
-    report = run(samples.CODE_PROMPT, samples.CODE_BAD)
-    for ip in report.improvement_prompts:
-        assert "0 part(s)" not in ip.diagnosis
-        if ip.failure_mode == FailureMode.INCOMPLETE_COVERAGE:
-            assert 'e.g. ""' not in ip.diagnosis
+    """Regression: missing requested function names must never surface as a
+    '0 parts unanswered' coverage diagnosis."""
+    ip = one(run(samples.CODE_PROMPT, samples.CODE_BAD))
+    assert "0 part(s)" not in ip.diagnosis
+    assert 'e.g. ""' not in ip.diagnosis
 
 
 def test_family_detection_current_models():
@@ -113,6 +107,5 @@ def test_family_detection_current_models():
 
 
 def test_technique_sources_cited():
-    report = run(samples.SUMM_PROMPT, samples.SUMM_BAD, model="gpt-4o")
-    for ip in report.improvement_prompts:
-        assert ip.technique_source.strip(), "every template must cite its source"
+    ip = one(run(samples.SUMM_PROMPT, samples.SUMM_BAD, model="OpenAI GPT-5.5"))
+    assert ip.technique_source.strip()

web/app.js

@@ -231,10 +231,10 @@
         <h2 class="sect">Parameter verdicts <span class="count">· ${scored.length} scored, ${nFindings} findings</span></h2>
         ${rep.parameters.map(verdictHtml).join("")}
 
-        <h2 class="sect">Repair prompts <span class="count">· targeted at ${esc(FAMILY_LABELS[(rep.improvement_prompts[0] || {}).model_family] || "your model")}</span></h2>
+        <h2 class="sect">The repaired prompt <span class="count">· one paste-ready fix for everything found · ${esc(FAMILY_LABELS[(rep.improvement_prompts[0] || {}).model_family] || "your model")}</span></h2>
         ${rep.improvement_prompts.length
           ? rep.improvement_prompts.map(repairHtml).join("")
-          : '<p class="no-repairs">No repairs needed — every locally checkable parameter came back clean. If the output still feels wrong, the issue likely lives in the judge-mode territory listed above.</p>'}
+          : '<p class="no-repairs">No repair needed — every locally checkable parameter came back clean. If the output still feels wrong, the issue likely lives in the judge-mode territory listed above.</p>'}
       </div>`;
 
     // meter fill animation (double rAF so the 0-scale paints first)
@@ -268,7 +268,10 @@
       prompt: $("promptIn").value,
       output: $("outputIn").value,
       model_name: composedModelName(),
-      options: { audience: $("audienceIn").value.trim(), tone: $("toneIn").value.trim(), weights: {} },
+      options: (() => {
+        const tone = form.querySelector('input[name="tone"]:checked');
+        return { audience: tone?.dataset.audience || "", tone: tone?.value || "", weights: {} };
+      })(),
     };
     evalBtn.disabled = true;
     evalBtn.textContent = "Evaluating…";

web/index.html

@@ -58,17 +58,27 @@
         </div>
       </fieldset>
 
-      <details class="advanced">
-        <summary>Advanced</summary>
-        <div class="field">
-          <label for="audienceIn">Intended audience</label>
-          <input id="audienceIn" placeholder="e.g. children, general readers, expert clinicians">
+      <fieldset class="field field-tone">
+        <legend>Expected tone <span class="opt">sets the reading-level check</span></legend>
+        <div class="tone-row" role="radiogroup" aria-label="Expected tone">
+          <label class="tone-chip">
+            <input type="radio" name="tone" value="" data-audience="" checked>
+            <span>Neutral</span>
+          </label>
+          <label class="tone-chip">
+            <input type="radio" name="tone" value="simple, plain language" data-audience="general readers">
+            <span>Simple</span>
+          </label>
+          <label class="tone-chip">
+            <input type="radio" name="tone" value="professional" data-audience="professional">
+            <span>Professional</span>
+          </label>
+          <label class="tone-chip">
+            <input type="radio" name="tone" value="technical" data-audience="expert">
+            <span>Technical</span>
+          </label>
         </div>
-        <div class="field">
-          <label for="toneIn">Expected tone</label>
-          <input id="toneIn" placeholder="e.g. formal, playful, neutral">
-        </div>
-      </details>
+      </fieldset>
 
       <div class="actions">
         <button type="submit" class="btn btn-primary" id="evalBtn">Evaluate output</button>

web/styles.css

@@ -248,18 +248,43 @@ fieldset.field-model legend {
 .combo-list li.co-empty { color: var(--muted); cursor: default; }
 .combo-list li.co-empty:hover { background: transparent; }
 
-.advanced { margin: 4px 0 16px; }
-.advanced summary {
-  cursor: pointer;
+/* tone selector */
+fieldset.field-tone { border: 0; padding: 0; margin: 0 0 16px; }
+fieldset.field-tone legend {
   font-size: 13px;
+  font-weight: 600;
+  margin-bottom: 6px;
+  padding: 0;
+}
+.tone-row { display: flex; flex-wrap: wrap; gap: 8px; }
+.tone-chip input {
+  position: absolute;
+  opacity: 0;
+  pointer-events: none;
+}
+.tone-chip span {
+  display: inline-block;
+  border: 1px solid var(--line);
+  background: var(--bg);
+  color: var(--ink);
+  border-radius: 999px;
+  padding: 5px 14px;
+  font-size: 12.5px;
   font-weight: 500;
-  color: var(--muted);
-  padding: 4px 0;
-  user-select: none;
-  list-style-position: outside;
+  cursor: pointer;
+  transition: border-color 150ms var(--ease), background 150ms var(--ease), color 150ms var(--ease);
+}
+.tone-chip span:hover { border-color: var(--primary); }
+.tone-chip input:checked + span {
+  background: var(--primary-tint);
+  border-color: var(--primary);
+  color: var(--primary-deep);
+  font-weight: 600;
+}
+.tone-chip input:focus-visible + span {
+  outline: 2px solid var(--primary);
+  outline-offset: 2px;
 }
-.advanced summary:hover { color: var(--ink); }
-.advanced[open] summary { margin-bottom: 10px; }
 
 .actions { display: flex; gap: 10px; margin: 20px 0 0; }
 .btn {