diff --git a/CHANGELOG.md b/CHANGELOG.md
index 77cc6a2..cdf2760 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -30,6 +30,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   under its verdict) warns that the evaluator checked nothing because no example offered
   tools. Coverage is written by `evaluate`, so an older run needs `evaluate` re-run to
   drop the stale coverage; `analyze` alone keeps it, and the `conditional_pass` with it.
+- The run-insights narrative no longer guesses why a run failed. The prompt listed each
+  budget's limit but not its result, so a FAIL on the latency ceiling alone was explained
+  as "failed to meet the budget for Trace-rule violations" — a budget that held. Every
+  budget, slice rows included, now enters the prompt with its status, the breached ones
+  are listed as `failed_budgets`, and the decision's `reason` travels with them in plain
+  words, without `evalshift.yaml` keys. Only a breached budget may be named as the cause,
+  and on a FAIL a summary or recommendation that blames a budget that held is rejected
+  and retried, then replaced by the templated prose. Naming a held budget to clear it
+  ("Cost increase stayed within its limit", "not Cost increase") is not blame, and
+  neither is a figure "over the source". Narratives are cached on the run's
+  config hash and model, not the CLI version: delete a run's `insights.json` and re-run
+  `report` to rewrite an existing one.
 
 ## [1.4.1] - 2026-10-11
 
diff --git a/DOCS.md b/DOCS.md
index ba95693..07432e6 100644
--- a/DOCS.md
+++ b/DOCS.md
@@ -781,6 +781,10 @@ CI wiring (on `analyze` and `compare`):
 
 **A gate that measured nothing is never counted as a gate that passed.** A budget handed an empty sample — a tool-divergence ceiling on a run that scored no divergence row, a cost ceiling on a run with no priced call — is within its limit by arithmetic: `0/0` is below every ceiling. Counted naively that renders "7 of 7 budgets passed", and a narrative restates it as "all hard constraints are met" while the report body two sections above names the blocking evaluators that scored nothing. So `budgets_passed` counts only budgets that were *measured*, the blind ones are named on their own `unmeasured_budgets` / `unmeasured_evaluators` facts with a digit-free `coverage_basis` saying why, and the instruction forbids claiming a clean sweep, a met constraint or a safe migration while that basis is present. The blind-gate set is the same one `migration_decision.json`'s own `recommendations` name, computed by one shared function, so the two surfaces cannot disagree. This is distinct from the rates rule above and not covered by it: that fires when the *whole run* measured nothing, this fires when only *some* gate did.
 
+**A FAIL's cause is read off the facts, not inferred.** Every gating budget, overall and slice rows alike, enters the prompt with its status beside its limit — `budget "<label>": limit <x>, <status>`, where the status is `breached`, `within`, `measured nothing`, or `over its limit but not confirmed at this sample size`. Beside them go the `failed_budgets` list (the breached rows, overall and slice, named as the decision prose names them: "'security' slice overall regression rate") and, when the decision carries one, its `reason` as `verdict_reason`, in plain words: the `evalshift.yaml` keys it quotes are reworded (`migration_policy.max_invariant_violations` becomes "the trace-rule violations budget", or "the 'security' slice trace-rule violations budget" where the reason quotes it beside that slice's limit, and `fail_on_dropped_params` / `drop_params` are put into words), and its figures join the permitted numbers. `breached` is the only status that may be blamed: the instruction allows only a breached budget to be named as why the run failed or as something to fix, forbids describing a `within` budget as breached, exceeded, failed, missed, violated or something to address, and requires the verdict summary to agree with `verdict_reason`. Both new keys are FACTS keys like any other, so echoing either in prose rejects the generation. A narrative once explained a FAIL as "failed to meet the budget for Trace-rule violations" on a run where that budget held and only the latency ceiling was breached: the prompt had listed limits without results, so the model guessed.
+
+On a `fail` the verdict summary and recommendation are also scanned for a held budget that shares a clause with a blame word (breach…, exceed…, fail…, violat…, address…, miss/missed/misses/missing, unmet, not met, broke, broken, and over/above/beyond followed by a limit phrase — an optional "the", "its" or "their", at most two words or figures, then a limit noun: limit, budget, ceiling, threshold, maximum, allowance or policy, singular or plural, as in "over budget" or "over the +200% cost limit" — so "+102% over the source" is not blame) that is not negated by a "not", "no", "never" or "without" in the 24 characters before it. Each mention of a held budget in that clause is judged on its own, and a mention is excused — it names the budget without accusing it — in two cases. A negation directly before it, with only other budget labels, "or", "and", "nor" or commas between, clears it when the name stands alone — the label, and any labels chained to it, is followed by a comma, the end of the clause, or "or", "and", "nor" or "but": "failed only because of Latency increase, not Cost increase or Trace-rule violations" passes, while "failed with no Cost increase headroom left" is still rejected, because there the negation belongs to the noun the label modifies. A holding phrase after it describes it when the phrase is measured against the limit — "within", "inside", "under" or "below" followed by the same limit phrase the blame words use ("within policy", "within budget", "under their limits", "under the +200% cost limit"), or a bare "held", "holds" or "passed" with nothing but punctuation after it to the end of the clause ("Trace-rule violations held.") — provided that phrase is not itself negated, no blame word stands between the two, and no other budget label does unless joined by "and", "or", "nor" or a comma. A verb or a preposition alone is not a holding phrase: "the migration failed on Latency increase alone, as Cost increase and Trace-rule violations all stayed within budget" passes, while "Cost increase remained above the +200% limit", "Cost increase held at +250%, exceeding its limit", "Cost increase under the target model breached its ceiling", "Cost increase, within hours, broke its ceiling", "Cost increase exceeded its limit and stayed within budget" and "failed on Cost increase as Latency increase stayed within its ceiling" are still rejected. Four misses are accepted: a holding phrase excuses the mention before it whatever follows, so "Cost increase stayed within budget at first, then exceeded it", "Address Cost increase so it stays within budget", "Cost increase below the target's ceiling failed the run" and "Cost increase, below the ceiling on 3 prompts, failed on the rest" pass. A held budget is blamed when one of its mentions is not excused and the clause has an un-negated blame word. Clauses split at sentence punctuation (`. ; : ! ?`), at while, but, whereas, although, though and however, at ", and", ", but", ", with" and ", however,", and at an em or en dash — not at a bare "and" or a bare comma, because "exceeded latency and failed to meet Trace-rule violations" accuses both. Every budget label, held or not, is located longest-first and masked before the scan, matching case-insensitively with hyphens, whitespace and quote characters folded: "checkout slice cost increase" is still the slice's label rather than a mention of the held "Cost increase" inside it, and "Trace-rule violations" does not read as a violation of whichever budget shares its clause. A match rejects the generation like an invented number, the retry names the misblamed budgets ("Your previous answer blamed budgets that held: …", followed by "No budget was breached" on a fail no budget caused), and two rejections ship the templated prose, which names the breached budget, or the overall blocking regressions when no budget was breached, and otherwise points the reader at the decision's recommendations and the budget table. The scan is a safety net, not a parser: it catches the shipped phrasing and its close variants, and the prompt change is the primary fix. A false match is not free: it costs the retry, which is shared with invented-number rejections, and a repeated one ships the templated prose, which has no findings. A narrative is cached per run (see below), and the cache key does not change with the CLI, so an existing run keeps its old prose until its `insights.json` is deleted.
+
 ```yaml
 defaults:
   insights_model: gemini-3.1-flash-lite-preview   # optional; falls back to judge_model
diff --git a/docs/faq.md b/docs/faq.md
index 1f97775..682f28d 100644
--- a/docs/faq.md
+++ b/docs/faq.md
@@ -34,6 +34,11 @@ deterministic templated prose instead (shown as model `none`). So a figure in
 that block is the same figure as in the tables below it, or it is not there at
 all.
 
+The same goes for the cause of a FAIL. The model is told which budgets were
+breached and which held, and only a breached one may be named as the cause. On
+a failed run a summary or recommendation that blames a budget that held is
+rejected and retried the same way, then replaced by the templated prose.
+
 It costs one model call per run, is cached in `insights.json`, and skips
 itself when no API key is configured. Disable it with
 `evalshift report --no-insights` or `evalshift compare --no-insights`.
diff --git a/docs/superpowers/plans/2026-10-12-insight-budget-status.md b/docs/superpowers/plans/2026-10-12-insight-budget-status.md
new file mode 100644
index 0000000..4e8ec48
--- /dev/null
+++ b/docs/superpowers/plans/2026-10-12-insight-budget-status.md
@@ -0,0 +1,946 @@
+# Insight Budget Status Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** The machine-written run narrative names the budget that actually failed a run, and a narrative that blames a budget that held never ships.
+
+**Architecture:** The prompt's FACTS block gains each budget's *status* beside its limit (`breached` / `within` / `measured nothing` / unconfirmed), the `failed_budgets` list the templated fallback already uses, and the decision's own `reason`. The instruction lets only a breached budget be named as the cause. A third validator, `validate_blame`, scans a `fail` run's verdict summary and recommendation for a held budget that shares a clause with a non-negated blame word; a hit rejects the generation like an invented number, the retry names the misblamed labels, and two rejections ship the templated prose (which is already correct).
+
+**Tech Stack:** Python 3.11+, dataclasses, `re`, pytest (async tests via the repo's pytest-asyncio config), uv.
+
+**Spec:** No separate spec file — the design was agreed in chat on 2026-10-12 ("status + rule + check"). The motivating run is `r_20261012_converter_d418e5` in `/home/lukas/repos/testApp`: verdict `fail` on `max_latency_increase` alone (+175.3% vs +30%), every other budget within; the narrative said the run "failed to meet the budget for Trace-rule violations" and recommended "address the Trace-rule violations" — a budget that passed at 0 against a limit of 1. The prompt listed each budget's limit with no result, so the model guessed.
+
+## Global Constraints
+
+- Python floor 3.11: no 3.12+ syntax. Every module starts with `from __future__ import annotations`; public functions get Google-style docstrings; `mypy --strict src/evalshift_cli` stays clean.
+- No config, suite, `state.json`, `scores.jsonl`, `insights.json` or bundle schema change. `Insight` gets no new field. `Facts` is in-memory only and may grow.
+- Everything the model may copy stays digit-free or enters `Facts.allowed_numbers`: the four status words carry no digits; slice-budget limits and the `verdict_reason` text's figures join the allow-list.
+- New FACTS keys (`failed_budgets`, `verdict_reason`) join `_FACTS_FIELD_NAMES` so an echo is rejected like `coverage_basis` is today.
+- User-facing strings, verbatim:
+  - budget line: `budget "{label}": limit {limit}, {status}`
+  - status words: `breached`, `within`, `measured nothing`, `over its limit but not confirmed at this sample size`
+  - retry hint: `Your previous answer blamed budgets that held: {labels}. Only the budgets under failed_budgets were breached; a budget marked within may be described as within policy or left out, never as a cause of the verdict or as something to address.`
+- The blame scan runs only when `facts.verdict == "fail"`, only over `verdict_summary` and `recommendation`, only for labels whose status is `within`.
+- Gate ("green" = all four, as CI): `uv run ruff check . && uv run ruff format --check . && uv run mypy --strict src/evalshift_cli && uv run pytest -q` (coverage floor 90). `make ci` is the exact CI mirror.
+- Commit with `uv run --with pre-commit git commit …` (the shared hook points at a deleted venv). Never `--no-verify`. Conventional Commits, ending with `Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>`. `docs/superpowers/` is gitignored: add this plan with `git add -f`.
+- Always `git -C /home/lukas/repos/evalshift/evalshift-cli` (= `$WT`). Before each commit confirm the branch is `fix/insight-budget-status`, not `main`.
+
+## Review Focus
+
+- A `fail` whose summary *mentions* a held budget without blaming it ("Trace-rule violations stayed within budget") must ship on the first attempt — Task 3 `test_a_fail_may_mention_a_held_budget_without_blaming_it`.
+- A negated accusation ("was not breached", "no breach of") is not blame — Task 3 `test_a_negated_blame_is_not_blame`.
+- The shipped sentence and the shipped recommendation are both caught, including lower-case and unhyphenated spellings of the label — Task 3 `test_blame_catches_the_shipped_sentence`, `test_blame_catches_advice_to_address_a_held_budget`, `test_blame_matches_case_and_hyphen_variants`.
+- A `verdict_reason` carrying figures (`effect size -2.15, adjusted p 0.0004`) must not get a generation that copies them rejected as invented — Task 1 `test_the_decision_reason_travels_with_the_facts`, Task 2 `test_a_copied_reason_figure_is_not_an_invented_number`.
+- A slice budget's limit (only ever rendered in the new status lines) is a copyable figure — Task 1 `test_a_slice_budget_is_listed_under_its_scope`.
+
+---
+
+### Task 1: Facts carry each budget's status and the decision's reason
+
+**Files:**
+- Modify: `src/evalshift_cli/insights/facts.py` (`Facts`, `build_facts`, `_failed_budget_label` → `_scoped_budget_label`, new `_budget_status`, `_allowed_numbers`, `__all__`)
+- Modify: `tests/unit/insights_factories.py` (new `converter_decision`, `SEVERITY_REASON`)
+- Test: `tests/unit/test_insight_facts.py`
+
+**Interfaces:**
+- Consumes: `BudgetResult.measured/passed/conclusive/scope`, `gating_budget_results(decision)`, `MigrationDecision.reason` (all existing in `analysis/policy.py`).
+- Produces: `facts.BUDGET_BREACHED = "breached"`, `BUDGET_WITHIN = "within"`, `BUDGET_UNMEASURED = "measured nothing"`, `BUDGET_UNCONFIRMED = "over its limit but not confirmed at this sample size"`; `Facts.budget_statuses: list[tuple[str, str, str]]` (display label, rendered limit, status), one per gating budget row in policy order; `Facts.verdict_reason: str` (`""` when the decision has none); factories `converter_decision() -> MigrationDecision`, `SEVERITY_REASON: str`.
+
+- [ ] **Step 1: Add the shared factories**
+
+In `tests/unit/insights_factories.py`, after `unmeasured_budget` (line ~257) add:
+
+```python
+#: A severity-only fail's ``MigrationDecision.reason``, as the policy words it.
+#: Carries figures: a generation that copies them must not be rejected.
+SEVERITY_REASON = (
+    "semantic.cosine regressed at critical severity on prompt replay "
+    "(effect size -2.15, adjusted p 0.0004). A critical or high regression from a "
+    "blocking evaluator fails the run on its own, whatever the budgets say."
+)
+
+
+def converter_decision() -> MigrationDecision:
+    """r_20261012_converter_d418e5: the latency ceiling breached, every other budget held.
+
+    The run whose narrative blamed "Trace-rule violations" — a budget that
+    passed at 0 against a limit of 1 — because the prompt listed each budget's
+    limit without its result. Six held budgets, one breached, one blind.
+    """
+    return decision(
+        verdict="fail",
+        budget_results=[
+            *budgets()[:5],
+            BudgetResult(
+                name="max_latency_increase", observed=1.753, allowed=0.30, passed=False
+            ),
+            BudgetResult(name="max_invariant_violations", observed=0.0, allowed=1.0, passed=True),
+            unmeasured_budget(),
+        ],
+    )
+```
+
+`decision` is defined later in the same file; a module-level function body resolves it at call time, so the order is fine.
+
+- [ ] **Step 2: Write the failing tests**
+
+In `tests/unit/test_insight_facts.py` add `MigrationDecision` to the `evalshift_cli.analysis.policy` import, add `from dataclasses import replace`, add `BUDGET_BREACHED, BUDGET_UNCONFIRMED, BUDGET_UNMEASURED, BUDGET_WITHIN` to the `evalshift_cli.insights.facts` import (alongside `build_facts`), and add `SEVERITY_REASON` and `converter_decision` to the `tests.unit.insights_factories` import. Append:
+
+```python
+# ---------------------------------------------------------------------------
+# Budget status and the decision's reason — what a FAIL's cause is read from
+# ---------------------------------------------------------------------------
+
+
+def _status_of(facts_statuses: list[tuple[str, str, str]], label: str) -> tuple[str, str]:
+    (hit,) = [(limit, status) for name, limit, status in facts_statuses if name == label]
+    return hit
+
+
+def test_every_gating_budget_carries_a_status(sample_run: dict[str, Any]) -> None:
+    """The converter run: one breached, one blind, the rest held."""
+    sample_run["decision"] = converter_decision()
+    facts = build_facts(**sample_run)
+
+    assert len(facts.budget_statuses) == 8
+    assert _status_of(facts.budget_statuses, "Latency increase") == ("+30%", BUDGET_BREACHED)
+    assert _status_of(facts.budget_statuses, "Trace-rule violations") == ("1", BUDGET_WITHIN)
+    assert _status_of(facts.budget_statuses, "Cost increase") == ("+200%", BUDGET_WITHIN)
+    assert _status_of(facts.budget_statuses, "Tool-selection divergence") == (
+        "20%",
+        BUDGET_UNMEASURED,
+    )
+    assert facts.failed_budgets == ["Latency increase"]
+
+
+def test_an_unconfirmed_breach_has_its_own_status(sample_run: dict[str, Any]) -> None:
+    over = BudgetResult(
+        name="max_overall_regression_rate",
+        observed=0.1,
+        allowed=0.03,
+        passed=False,
+        conclusive=False,
+        ci_low=0.0,
+        ci_high=0.3,
+    )
+    sample_run["decision"] = decision(
+        verdict="inconclusive", budget_results=[over, *budgets()[1:]]
+    )
+    facts = build_facts(**sample_run)
+    assert _status_of(facts.budget_statuses, "Overall regression rate") == (
+        "3%",
+        BUDGET_UNCONFIRMED,
+    )
+    assert facts.failed_budgets == []
+
+
+def test_a_slice_budget_is_listed_under_its_scope(sample_run: dict[str, Any]) -> None:
+    """A slice row is a gating budget too, and its limit is a copyable figure."""
+    facts = build_facts(**_slice_budget_run(sample_run, extra=[]))
+    assert _status_of(facts.budget_statuses, "'security' slice overall regression rate") == (
+        "0%",
+        BUDGET_BREACHED,
+    )
+    assert "0%" in facts.allowed_numbers
+
+
+def test_the_decision_reason_travels_with_the_facts(sample_run: dict[str, Any]) -> None:
+    sample_run["decision"] = replace(decision(verdict="fail"), reason=SEVERITY_REASON)
+    facts = build_facts(**sample_run)
+    assert facts.verdict_reason == SEVERITY_REASON
+    # Its figures are facts the model may copy.
+    assert {"-2.15", "2.15", "0.0004"} <= facts.allowed_numbers
+
+
+def test_a_decision_without_a_reason_renders_none(sample_run: dict[str, Any]) -> None:
+    assert build_facts(**sample_run).verdict_reason == ""
+```
+
+- [ ] **Step 3: Run them to see them fail**
+
+Run: `uv run pytest tests/unit/test_insight_facts.py -q -k "status or reason or scope"`
+Expected: FAIL at import — `ImportError: cannot import name 'BUDGET_BREACHED'`.
+
+- [ ] **Step 4: Implement the facts**
+
+In `src/evalshift_cli/insights/facts.py`:
+
+1. After `_COUNT_BUDGETS` (line ~84) add:
+
+```python
+#: Budget status words, rendered beside each budget's limit in the FACTS
+#: block. Digit-free plain English — the model copies them into prose — and
+#: the only vocabulary the blame validator keys on.
+BUDGET_BREACHED = "breached"
+BUDGET_WITHIN = "within"
+BUDGET_UNMEASURED = "measured nothing"
+BUDGET_UNCONFIRMED = "over its limit but not confirmed at this sample size"
+```
+
+2. In `Facts`, after `overall_blocking_evaluators` add:
+
+```python
+    #: One ``(display label, rendered limit, status)`` per gating budget row —
+    #: the overall rows and the distinct slice rows, in policy order. Handed to
+    #: the model beside each limit so a FAIL's cause is read off the line, not
+    #: guessed: a narrative once blamed "Trace-rule violations" on a run where
+    #: that budget held and only the latency ceiling was breached, because the
+    #: prompt listed limits without results.
+    budget_statuses: list[tuple[str, str, str]] = field(default_factory=list)
+    #: The decision's own explanation of its verdict
+    #: (``MigrationDecision.reason``), or ``""`` when it carries none. The same
+    #: sentence the report hero renders, so the two surfaces cannot disagree.
+    verdict_reason: str = ""
+```
+
+3. In `build_facts`, directly after the `failed_budgets = _unique(...)` statement add:
+
+```python
+    budget_statuses = [
+        (_scoped_budget_label(b), _budget_limit(b.name, b.allowed), _budget_status(b))
+        for b in gating_budget_results(decision)
+    ]
+    verdict_reason = decision.reason or ""
+```
+
+   and in the `failed_budgets` comprehension rename the call `_failed_budget_label(b)` → `_scoped_budget_label(b)`.
+
+4. In the `Facts(...)` return, change the `allowed_numbers=_allowed_numbers(` call to pass two new keywords after `budget_limits=budget_limits,`:
+
+```python
+            slice_limits=[limit for _, limit, _ in budget_statuses],
+            verdict_reason=verdict_reason,
+```
+
+   and add `budget_statuses=budget_statuses,` and `verdict_reason=verdict_reason,` after `overall_blocking_evaluators=...`.
+
+5. Rename `_failed_budget_label` → `_scoped_budget_label` and replace its docstring with:
+
+```python
+    """A budget's display name, scoped when it is a slice's own row.
+
+    A bare "overall regression rate" for a slice row would send the reader to
+    the overall row — green in exactly the run that names it. Worded so the
+    templated advice reads "the 'security' slice overall regression rate
+    budget was breached" and the FACTS block lists the row under that name.
+    """
+```
+
+6. After `_budget_limit` add:
+
+```python
+def _budget_status(budget: BudgetResult) -> str:
+    """Which of the four things a budget row says, as a word the prose may use.
+
+    ``measured`` first: the ``0/0`` default passes by arithmetic, and calling
+    it ``within`` is the clean-sweep claim the coverage facts exist to stop.
+    """
+    if not budget.measured:
+        return BUDGET_UNMEASURED
+    if budget.passed:
+        return BUDGET_WITHIN
+    if budget.conclusive:
+        return BUDGET_BREACHED
+    return BUDGET_UNCONFIRMED
+```
+
+7. In `_allowed_numbers`, add the parameters `slice_limits: Sequence[str],` and `verdict_reason: str,` after `budget_limits: dict[str, str],`, extend the docstring's first sentence list with "the slice budgets' limits (rendered only in the status lines) and the decision reason's own figures", and add to `sources` after `*budget_limits.values(),`:
+
+```python
+        *slice_limits,
+        verdict_reason,
+```
+
+8. Add `"BUDGET_BREACHED", "BUDGET_UNCONFIRMED", "BUDGET_UNMEASURED", "BUDGET_WITHIN",` to `__all__` (alphabetical, before `"NOT_AVAILABLE"`).
+
+- [ ] **Step 5: Run the facts tests and the type check**
+
+Run: `uv run pytest tests/unit/test_insight_facts.py -q && uv run mypy --strict src/evalshift_cli/insights`
+Expected: all pass (the five new tests plus every existing one — `failed_budgets` behaviour is unchanged by the rename); mypy `Success`.
+
+- [ ] **Step 6: Commit**
+
+```bash
+WT=/home/lukas/repos/evalshift/evalshift-cli
+git -C $WT branch --show-current   # fix/insight-budget-status
+git -C $WT add src/evalshift_cli/insights/facts.py tests/unit/insights_factories.py tests/unit/test_insight_facts.py
+cd $WT && uv run --with pre-commit git commit -m "feat(insights): facts carry each budget's status and the decision's reason
+
+Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 2: The prompt shows the statuses and the instruction rules on them
+
+**Files:**
+- Modify: `src/evalshift_cli/insights/generator.py` (`_INSTRUCTION`, `_FACTS_FIELD_NAMES`, `_facts_block`)
+- Test: `tests/unit/test_insight_generator.py`
+
+**Interfaces:**
+- Consumes: `Facts.budget_statuses`, `Facts.failed_budgets`, `Facts.verdict_reason` (Task 1).
+- Produces: FACTS lines `budget "{label}": limit {limit}, {status}`, `failed_budgets: {a, b}`, `verdict_reason: {text}`; the instruction rule quoted in Step 3.
+
+- [ ] **Step 1: Write the failing tests**
+
+In `tests/unit/test_insight_generator.py` add `from dataclasses import replace`, and add `SEVERITY_REASON`, `converter_decision` to the `tests.unit.insights_factories` import. Change the existing assertion at line ~424 from `assert 'budget "Cost increase": +200%' in prompt` to `assert 'budget "Cost increase": limit +200%, within' in prompt` (it pinned the limit-only line this task replaces). Append:
+
+```python
+# ---------------------------------------------------------------------------
+# A FAIL's cause is a fact, not an inference
+# ---------------------------------------------------------------------------
+
+
+async def test_each_budget_line_carries_its_status(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    """The converter run: the model is told which budget broke and which held.
+
+    The shipped narrative blamed "Trace-rule violations" because every budget
+    line read as a bare limit — nothing said which one the run had failed on.
+    """
+    sample_run["decision"] = converter_decision()
+    fake_client.queue_responses(_payload())
+    await _generate(build_facts(**sample_run), fake_client)
+
+    prompt = fake_client.prompts[0]
+    assert '\nbudget "Latency increase": limit +30%, breached\n' in prompt
+    assert '\nbudget "Trace-rule violations": limit 1, within\n' in prompt
+    assert '\nbudget "Tool-selection divergence": limit 20%, measured nothing\n' in prompt
+    assert "\nfailed_budgets: Latency increase\n" in prompt
+
+
+async def test_a_passing_run_lists_no_failed_budgets_and_no_reason(
+    fake_client: FakeModelClient, sample_facts: Facts
+) -> None:
+    fake_client.queue_responses(_payload())
+    await _generate(sample_facts, fake_client)
+
+    prompt = fake_client.prompts[0]
+    assert "\nfailed_budgets: " not in prompt
+    assert "\nverdict_reason: " not in prompt
+    assert '\nbudget "Cost increase": limit +200%, within\n' in prompt
+
+
+async def test_the_verdict_reason_reaches_the_prompt(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    sample_run["decision"] = replace(decision(verdict="fail"), reason=SEVERITY_REASON)
+    fake_client.queue_responses(_payload())
+    await _generate(build_facts(**sample_run), fake_client)
+
+    assert f"\nverdict_reason: {SEVERITY_REASON}\n" in fake_client.prompts[0]
+
+
+async def test_a_copied_reason_figure_is_not_an_invented_number(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    """The reason's own figures are facts; copying them must not cost a retry."""
+    sample_run["decision"] = replace(decision(verdict="fail"), reason=SEVERITY_REASON)
+    fake_client.queue_responses(
+        _payload(verdict_summary="semantic.cosine regressed with effect size -2.15 (p 0.0004).")
+    )
+    insight = await _generate(build_facts(**sample_run), fake_client)
+
+    assert insight.verdict_summary.endswith("(p 0.0004).")
+    assert fake_client.call_count == 1
+
+
+async def test_the_instruction_rules_on_budget_status(
+    fake_client: FakeModelClient, sample_facts: Facts
+) -> None:
+    """A plain-English accusation carries no digit; the rule has to be spelled out."""
+    fake_client.queue_responses(_payload())
+    await _generate(sample_facts, fake_client)
+
+    instruction = fake_client.prompts[0].split("FACTS (")[0]
+    assert '"breached"' in instruction
+    assert '"within"' in instruction
+    assert "failed_budgets" in instruction
+    assert "verdict_reason" in instruction
+
+
+async def test_an_echoed_failed_budgets_key_is_rejected_and_retried(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    sample_run["decision"] = converter_decision()
+    fake_client.queue_responses(
+        _payload(verdict_summary="failed_budgets: Latency increase."),
+        _payload(verdict_summary="The latency ceiling of +30% was exceeded."),
+    )
+    insight = await _generate(build_facts(**sample_run), fake_client)
+
+    assert insight.verdict_summary == "The latency ceiling of +30% was exceeded."
+    assert fake_client.call_count == 2
+```
+
+`decision` is already imported in this file from the factories (check the import block; add it if not).
+
+- [ ] **Step 2: Run them to see them fail**
+
+Run: `uv run pytest tests/unit/test_insight_generator.py -q -k "status or failed_budgets or reason"`
+Expected: `test_each_budget_line_carries_its_status`, `test_a_passing_run_lists_no_failed_budgets_and_no_reason`, `test_the_verdict_reason_reaches_the_prompt`, `test_the_instruction_rules_on_budget_status`, `test_an_echoed_failed_budgets_key_is_rejected_and_retried` FAIL (old line format; no `failed_budgets`/`verdict_reason` lines; echo not rejected). `test_a_copied_reason_figure_is_not_an_invented_number` passes already (Task 1 put the figures on the allow-list). The pre-existing test at line ~424 FAILS on its updated assertion.
+
+- [ ] **Step 3: Implement the prompt**
+
+In `src/evalshift_cli/insights/generator.py`:
+
+1. In `_INSTRUCTION`, after the `unmeasured_budgets` rule (the bullet ending `and say their silence is unknown.`) insert:
+
+```
+- Every "budget" line ends with its status. Only a budget whose status is
+  "breached" — the same ones listed under "failed_budgets" — may be named as
+  why the run failed or as something to fix. A budget marked "within" held:
+  never write that it was breached, exceeded, failed, missed, violated or
+  must be addressed. When "verdict_reason" is present it is the decision's
+  own explanation of the verdict, and your verdict summary must agree with it.
+```
+
+2. Add `"failed_budgets",` and `"verdict_reason",` to `_FACTS_FIELD_NAMES` (after `"coverage_basis",`).
+
+3. In `_facts_block`, after the `coverage_basis` line add:
+
+```python
+    if facts.failed_budgets:
+        lines.append(f"failed_budgets: {', '.join(facts.failed_budgets)}")
+    if facts.verdict_reason:
+        lines.append(f"verdict_reason: {facts.verdict_reason}")
+```
+
+   and replace the budget loop and its comment (`# Budgets and categories reach the model …` through `lines.append(f'budget "{BUDGET_LABELS.get(name, name)}": {limit}')`) with:
+
+```python
+    # Budgets and categories reach the model under their display names: it is
+    # told to copy tokens verbatim, so whatever appears here is what a reader
+    # may end up seeing in the narrative. Each budget carries its status, so
+    # the cause of a FAIL is read off the line rather than guessed from the
+    # limit — a narrative once blamed a budget that held.
+    for label, limit, status in facts.budget_statuses:
+        lines.append(f'budget "{label}": limit {limit}, {status}')
+```
+
+   `BUDGET_LABELS` stays imported — `banned_identifiers` still uses it.
+
+- [ ] **Step 4: Run the generator tests and the type check**
+
+Run: `uv run pytest tests/unit/test_insight_generator.py tests/unit/test_insight_facts.py tests/unit/test_insights_stage.py -q && uv run mypy --strict src/evalshift_cli/insights`
+Expected: all pass; mypy `Success`.
+
+- [ ] **Step 5: Commit**
+
+```bash
+WT=/home/lukas/repos/evalshift/evalshift-cli
+git -C $WT branch --show-current   # fix/insight-budget-status
+git -C $WT add src/evalshift_cli/insights/generator.py tests/unit/test_insight_generator.py
+cd $WT && uv run --with pre-commit git commit -m "fix(insights): tell the narrative which budget failed the run
+
+The prompt listed each budget's limit with no result, so a FAIL on the
+latency ceiling alone was explained as 'failed to meet the budget for
+Trace-rule violations' — a budget that held. Each budget line now ends
+with its status, the breached ones ride on failed_budgets, the decision's
+reason travels with them, and the instruction allows only a breached
+budget to be named as the cause.
+
+Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 3: A fail that blames a held budget is rejected, retried, then templated
+
+**Files:**
+- Modify: `src/evalshift_cli/insights/generator.py` (new `_BLAME_RE`, `_NEGATION_RE`, `_CLAUSE_RE`, `_normalise`, `validate_blame`; `GenerationError.misblamed`; `generate_insight`; `build_prompt`; `_build_insight`; `__all__`)
+- Test: `tests/unit/test_insight_generator.py`
+
+**Interfaces:**
+- Consumes: `Facts.verdict`, `Facts.budget_statuses`, `facts.BUDGET_WITHIN` (Task 1); `fallback_insight` (existing).
+- Produces: `validate_blame(text: str, within: Sequence[str]) -> list[str]`; `GenerationError(message, *, tokens=None, misblamed=None)` with `.misblamed: list[str]`; `build_prompt(facts, *, invented=None, misblamed=None)`.
+
+- [ ] **Step 1: Write the failing validator tests**
+
+Append to `tests/unit/test_insight_generator.py` (and add `validate_blame` to the `evalshift_cli.insights.generator` import):
+
+```python
+# ---------------------------------------------------------------------------
+# The blame validator
+# ---------------------------------------------------------------------------
+
+_HELD = ["Trace-rule violations", "Cost increase"]
+
+
+def test_blame_catches_the_shipped_sentence() -> None:
+    text = (
+        "The migration failed because the target model exceeded the latency ceiling "
+        "of +30% and failed to meet the budget for Trace-rule violations."
+    )
+    assert validate_blame(text, _HELD) == ["Trace-rule violations"]
+
+
+def test_blame_catches_advice_to_address_a_held_budget() -> None:
+    text = (
+        "Investigate the cause of the latency increase and address the Trace-rule "
+        "violations before re-evaluating."
+    )
+    assert validate_blame(text, _HELD) == ["Trace-rule violations"]
+
+
+def test_a_held_budget_may_be_called_within() -> None:
+    assert validate_blame("Trace-rule violations stayed within budget.", _HELD) == []
+
+
+def test_a_contrast_clause_separates_the_blame() -> None:
+    text = "Latency increase was exceeded while Trace-rule violations stayed within budget."
+    assert validate_blame(text, _HELD) == []
+
+
+def test_a_sentence_boundary_separates_the_blame() -> None:
+    text = "The latency ceiling was exceeded. Trace-rule violations and Cost increase held."
+    assert validate_blame(text, _HELD) == []
+
+
+def test_a_negated_blame_is_not_blame() -> None:
+    assert validate_blame("The Trace-rule violations budget was not breached.", _HELD) == []
+    assert validate_blame("No breach of Cost increase was observed.", _HELD) == []
+
+
+def test_blame_matches_case_and_hyphen_variants() -> None:
+    assert validate_blame("the run failed on trace rule violations", _HELD) == [
+        "Trace-rule violations"
+    ]
+
+
+def test_a_budget_not_in_the_held_list_may_be_blamed() -> None:
+    assert validate_blame("Latency increase was breached.", _HELD) == []
+
+
+def test_every_misblamed_budget_is_returned_once_in_list_order() -> None:
+    text = "Cost increase was exceeded and Trace-rule violations were violated; Cost increase failed."
+    assert validate_blame(text, _HELD) == ["Trace-rule violations", "Cost increase"]
+```
+
+- [ ] **Step 2: Run them to see them fail**
+
+Run: `uv run pytest tests/unit/test_insight_generator.py -q -k blame`
+Expected: FAIL at import — `ImportError: cannot import name 'validate_blame'`.
+
+- [ ] **Step 3: Implement the validator**
+
+In `src/evalshift_cli/insights/generator.py`:
+
+1. Add `from collections.abc import Sequence` to the imports (after `import re`), and `BUDGET_WITHIN` to the `evalshift_cli.insights.facts` import.
+
+2. After `_JSON_OBJECT_RE` add:
+
+```python
+#: Words that lay a verdict at a budget's door. A budget marked "within" that
+#: shares a clause with one of these, un-negated, is a cause the model
+#: invented: a shipped narrative said a run "failed to meet the budget for
+#: Trace-rule violations" when that budget held and only latency broke.
+_BLAME_RE = re.compile(
+    r"\b(?:breach\w*|exceed\w*|fail\w*|violat\w*|address\w*|miss(?:ed|es|ing)?|"
+    r"unmet|not met|over (?:the|its)|above (?:the|its)|broke|broken)\b",
+    re.IGNORECASE,
+)
+
+#: A blame word shortly after one of these is a denial ("was not breached",
+#: "no breach of"), not an accusation. Bounded so a "not" three clauses back
+#: cannot excuse an accusation.
+_NEGATION_RE = re.compile(r"\b(?:not|no|never|without)\b[^.;,]{0,24}$", re.IGNORECASE)
+
+#: Clause boundaries. A contrast word starts a new claim, so "latency was
+#: exceeded while Trace-rule violations stayed within budget" blames only
+#: latency. A bare "and" is deliberately not one: "exceeded latency and failed
+#: to meet Trace-rule violations" is the shipped sentence, and both halves
+#: accuse.
+_CLAUSE_RE = re.compile(
+    r"[.;:!?]\s+|\s(?:while|but|whereas|although|though|however)\s|,\s*(?:and|but)\s",
+    re.IGNORECASE,
+)
+```
+
+3. After `validate_numbers` add:
+
+```python
+def validate_blame(text: str, within: Sequence[str]) -> list[str]:
+    """Return the budgets in ``within`` that ``text`` blames for the verdict.
+
+    A budget that held may be mentioned — "Trace-rule violations stayed within
+    budget" is accurate — but not accused: it may not share a clause with a
+    blame word unless that word is negated. A plain-English accusation carries
+    no digit for :func:`validate_numbers` and no identifier for
+    :func:`validate_identifiers`, so this is the only check that sees it.
+
+    A safety net, not a parser: it catches the shipped phrasing and its close
+    variants, and a false match costs one retry. Labels are matched
+    case-insensitively with hyphens and runs of whitespace folded to one space.
+
+    Args:
+        text: One prose field of a generation.
+        within: Display labels of the budgets whose status is
+            :data:`~evalshift_cli.insights.facts.BUDGET_WITHIN`.
+
+    Returns:
+        The wrongly blamed labels, each once, in ``within`` order. Empty means
+        valid.
+    """
+    needles = {label: _normalise(label) for label in within}
+    blamed: set[str] = set()
+    for clause in (_normalise(c) for c in _CLAUSE_RE.split(text)):
+        present = [label for label, needle in needles.items() if needle in clause]
+        if not present:
+            continue
+        # Every held label comes out before the scan, not just the one under
+        # test: "Trace-rule violations" would otherwise read as a violation
+        # of whichever budget shares its clause.
+        rest = clause
+        for needle in needles.values():
+            rest = rest.replace(needle, " ")
+        if any(not _NEGATION_RE.search(rest[: m.start()]) for m in _BLAME_RE.finditer(rest)):
+            blamed.update(present)
+    return [label for label in within if label in blamed]
+
+
+def _normalise(text: str) -> str:
+    """Lower-case with hyphens and whitespace runs folded, for label matching."""
+    return re.sub(r"[-\s]+", " ", text.lower())
+```
+
+4. Add `"validate_blame",` to `__all__` (after `"validate_numbers",`).
+
+- [ ] **Step 4: Run the validator tests**
+
+Run: `uv run pytest tests/unit/test_insight_generator.py -q -k blame`
+Expected: 9 passed.
+
+- [ ] **Step 5: Write the failing integration tests**
+
+Append to `tests/unit/test_insight_generator.py`:
+
+```python
+# ---------------------------------------------------------------------------
+# Blame in a generation: retry with the labels named, then the template
+# ---------------------------------------------------------------------------
+
+_SHIPPED_SUMMARY = (
+    "The migration failed because the target model exceeded the latency ceiling of "
+    "+30% and failed to meet the budget for Trace-rule violations."
+)
+
+
+async def test_a_fail_that_blames_a_held_budget_is_rejected_and_retried(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    sample_run["decision"] = converter_decision()
+    fake_client.queue_responses(
+        _payload(verdict_summary=_SHIPPED_SUMMARY),
+        _payload(verdict_summary="The migration failed because the latency ceiling was exceeded."),
+    )
+    insight = await _generate(build_facts(**sample_run), fake_client)
+
+    assert insight.verdict_summary.endswith("latency ceiling was exceeded.")
+    assert fake_client.call_count == 2
+    assert (
+        "Your previous answer blamed budgets that held: Trace-rule violations."
+        in fake_client.prompts[1]
+    )
+
+
+async def test_a_misblaming_recommendation_is_rejected(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    sample_run["decision"] = converter_decision()
+    fake_client.queue_responses(
+        _payload(recommendation="Address the Trace-rule violations before re-evaluating."),
+        _payload(recommendation="Bring latency back under the ceiling, then re-run."),
+    )
+    insight = await _generate(build_facts(**sample_run), fake_client)
+
+    assert insight.recommendation == "Bring latency back under the ceiling, then re-run."
+    assert fake_client.call_count == 2
+
+
+async def test_two_misblaming_generations_fall_back_to_the_template(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    """The template already names the breached budget, so it is the safe floor."""
+    sample_run["decision"] = converter_decision()
+    bad = _payload(recommendation="Address the Trace-rule violations before re-evaluating.")
+    fake_client.queue_responses(bad, bad)
+    insight = await _generate(build_facts(**sample_run), fake_client)
+
+    assert insight.model == "none"
+    assert insight.recommendation.startswith(
+        "Do not migrate under the configured policy — the latency increase budget was breached."
+    )
+
+
+async def test_a_fail_may_mention_a_held_budget_without_blaming_it(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    sample_run["decision"] = converter_decision()
+    fake_client.queue_responses(
+        _payload(
+            verdict_summary=(
+                "The latency ceiling of +30% was exceeded; Trace-rule violations stayed "
+                "within budget."
+            )
+        )
+    )
+    await _generate(build_facts(**sample_run), fake_client)
+
+    assert fake_client.call_count == 1
+
+
+async def test_blame_is_not_checked_outside_a_fail(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    """The scan is scoped to a FAIL (Global Constraints): only a FAIL assigns a cause.
+
+    The sentence is false on a pass, but it accuses no budget of failing a
+    run that did not fail; the scope is pinned here so widening it is a
+    deliberate change.
+    """
+    fake_client.queue_responses(
+        _payload(verdict_summary="PASS although the Cost increase budget was exceeded.")
+    )
+    await _generate(build_facts(**sample_run), fake_client)
+
+    assert fake_client.call_count == 1
+
+
+async def test_an_invented_number_and_a_misblame_are_both_named_on_retry(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    sample_run["decision"] = converter_decision()
+    fake_client.queue_responses(
+        _payload(verdict_summary=_SHIPPED_SUMMARY, economics_summary="Cost rose +43%."),
+        _payload(),
+    )
+    await _generate(build_facts(**sample_run), fake_client)
+
+    retry = fake_client.prompts[1]
+    assert "+43%" in retry
+    assert "blamed budgets that held: Trace-rule violations" in retry
+```
+
+- [ ] **Step 6: Run them to see them fail**
+
+Run: `uv run pytest tests/unit/test_insight_generator.py -q -k "misblam or blames or blame_is_not or mention_a_held"`
+Expected: `test_a_fail_that_blames_a_held_budget_is_rejected_and_retried`, `test_a_misblaming_recommendation_is_rejected`, `test_two_misblaming_generations_fall_back_to_the_template`, `test_an_invented_number_and_a_misblame_are_both_named_on_retry` FAIL (the bad generation ships, `call_count == 1`); the other two pass already.
+
+- [ ] **Step 7: Wire the validator into generation**
+
+In `src/evalshift_cli/insights/generator.py`:
+
+1. `GenerationError`: extend the docstring's `Attributes` with
+
+```
+        misblamed: Display labels of budgets that held but were blamed for
+            the verdict — fed back the same way, under their own hint.
+```
+
+   and change `__init__` to:
+
+```python
+    def __init__(
+        self,
+        message: str,
+        *,
+        tokens: list[str] | None = None,
+        misblamed: list[str] | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.tokens = tokens or []
+        self.misblamed = misblamed or []
+```
+
+2. `generate_insight`: declare `misblamed: list[str] = []` beside `invented`, pass `misblamed=misblamed` to `build_prompt`, and in the `except GenerationError as exc:` branch add `misblamed = exc.misblamed` after `invented = exc.tokens`.
+
+3. `build_prompt`: signature `def build_prompt(facts: Facts, *, invented: list[str] | None = None, misblamed: list[str] | None = None) -> str:` (wrap to the file's line width), add to the docstring's Args:
+
+```
+        misblamed: Budgets that held but a previous attempt blamed for the
+            verdict. Named separately from ``invented``: the label itself is
+            allowed in prose, the accusation is not.
+```
+
+   and after the `if invented:` block add:
+
+```python
+    if misblamed:
+        sections.append(
+            "Your previous answer blamed budgets that held: "
+            + ", ".join(dict.fromkeys(misblamed))
+            + ". Only the budgets under failed_budgets were breached; a budget "
+            "marked within may be described as within policy or left out, never "
+            "as a cause of the verdict or as something to address."
+        )
+```
+
+4. `_build_insight`: replace the block from `banned = banned_identifiers(facts)` through the `raise GenerationError(...)` with:
+
+```python
+    banned = banned_identifiers(facts)
+    offending: list[str] = []
+    for field in (*prose.values(), *(t for f in findings for t in (f.title, f.detail))):
+        offending.extend(validate_numbers(field, facts.allowed_numbers))
+        offending.extend(t for t in validate_identifiers(field, banned) if t not in offending)
+    # Only a FAIL assigns a cause, and only its verdict summary and
+    # recommendation do the assigning; the advisory and economics summaries
+    # describe signals, and findings describe behaviour.
+    misblamed: list[str] = []
+    if facts.verdict == "fail":
+        held = [label for label, _, status in facts.budget_statuses if status == BUDGET_WITHIN]
+        for field in (prose["verdict_summary"], prose["recommendation"]):
+            misblamed.extend(t for t in validate_blame(field, held) if t not in misblamed)
+    if offending or misblamed:
+        problems: list[str] = []
+        if offending:
+            problems.append(f"tokens that may not be shown: {', '.join(offending)}")
+        if misblamed:
+            problems.append(f"budgets blamed although they held: {', '.join(misblamed)}")
+        raise GenerationError(
+            "response contained " + "; ".join(problems),
+            tokens=offending,
+            misblamed=misblamed,
+        )
+```
+
+5. Update the module docstring's second paragraph opening `Two attempts, then` to read: `Three checks on the way out — invented figures, echoed identifiers, and on a FAIL a held budget blamed for the verdict (:func:`validate_blame`). Two attempts, then` (keep the rest of the sentence).
+
+- [ ] **Step 8: Full gate, then commit**
+
+Run: `uv run ruff check . && uv run ruff format --check . && uv run mypy --strict src/evalshift_cli && uv run pytest -q`
+Expected: green.
+
+```bash
+WT=/home/lukas/repos/evalshift/evalshift-cli
+git -C $WT branch --show-current   # fix/insight-budget-status
+git -C $WT add src/evalshift_cli/insights/generator.py tests/unit/test_insight_generator.py
+cd $WT && uv run --with pre-commit git commit -m "fix(insights): reject a narrative that blames a budget that held
+
+On a FAIL the verdict summary and recommendation are scanned for a
+'within' budget sharing a clause with a non-negated blame word. A hit is
+rejected like an invented number, the retry names the labels, and two
+rejections ship the templated prose, which already names the breached
+budget.
+
+Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 4: Docs and changelog
+
+**Files:**
+- Modify: `DOCS.md` (Run insights, ~l.782), `llms-full.txt` (Run insights, ~l.1190), `docs/faq.md` (~l.31-35), `CHANGELOG.md` (`## [Unreleased]` → `### Fixed`)
+
+- [ ] **Step 1: `DOCS.md`**
+
+After the paragraph beginning `**A gate that measured nothing is never counted as a gate that passed.**` (ends `…this fires when only *some* gate did.`) and before the ```` ```yaml ```` block, insert:
+
+```markdown
+**A FAIL's cause is read off the facts, not inferred.** Every budget enters the prompt with its status beside its limit — `breached`, `within`, `measured nothing`, or over its limit but not confirmed at the sample size — together with the `failed_budgets` list (overall and slice rows, named as the decision prose names them) and, when the decision carries one, its `reason`. The instruction allows only a breached budget to be named as why the run failed or as something to fix. A narrative once explained a FAIL as "failed to meet the budget for Trace-rule violations" on a run where that budget held and only the latency ceiling was breached: the prompt had listed limits without results, so the model guessed. On a `fail` the verdict summary and recommendation are also scanned for a held budget that shares a clause with a blame word (breached, exceeded, failed, violated, address…) and is not negated; a match rejects the generation like an invented number, the retry names the misblamed budgets, and two rejections ship the templated prose, which names the breached budget itself. The scan is a safety net, not a parser: it catches the shipped phrasing and its close variants, and a false match costs one retry. A narrative is cached per run (see below), so an existing run keeps its old prose until its `insights.json` is deleted.
+```
+
+- [ ] **Step 2: `llms-full.txt`**
+
+After the `- A BLIND GATE is not a passed gate.` bullet (ends `…this one fires when only some gate died.`) insert, keeping the file's two-space continuation indent:
+
+```
+- A FAIL's CAUSE is a fact, not an inference. Each `budget "<label>": limit <x>, <status>`
+  line carries status breached | within | measured nothing | over its limit but not
+  confirmed at this sample size; `failed_budgets: <labels>` lists the breached rows
+  (overall and slice, as decision prose names them); `verdict_reason: <text>` carries
+  MigrationDecision.reason when set (its figures join the allow-list). Instruction: only a
+  "breached" budget may be named as why the run failed or as something to fix; a "within"
+  budget is never breached/exceeded/failed/violated/to be addressed; verdict_summary must
+  agree with verdict_reason. On verdict fail, verdict_summary and recommendation are
+  scanned (generator.validate_blame): a "within" label sharing a clause (split on sentence
+  punctuation, while/but/whereas/although/though/however, ", and" / ", but") with a
+  non-negated blame word (breach*, exceed*, fail*, violat*, address*, miss*, unmet, not
+  met, over/above the/its, broke/broken) rejects the generation; the retry names the
+  misblamed labels; 2 rejections -> templated prose. Heuristic by design: it catches the
+  shipped phrasing and close variants. Cached narratives do not regenerate: delete
+  insights.json to rewrite an existing run's prose.
+```
+
+- [ ] **Step 3: `docs/faq.md`**
+
+In the answer to `## What is the summary at the top of the report, and can I trust its numbers?`, after the sentence ending `…or it is not there at all.` add a new paragraph:
+
+```markdown
+The same goes for the cause of a FAIL. The model is told which budgets were
+breached and which held, and on a failed run a summary or recommendation that
+blames a budget that held is rejected and retried the same way, then replaced
+by the templated prose.
+```
+
+- [ ] **Step 4: `CHANGELOG.md`**
+
+Under `## [Unreleased]` → `### Fixed`, after the last existing bullet, add:
+
+```markdown
+- The run-insights narrative no longer guesses why a run failed. The prompt listed each
+  budget's limit but not its result, so a FAIL on the latency ceiling alone was explained
+  as "failed to meet the budget for Trace-rule violations" — a budget that held. Every
+  budget now enters the prompt with its status, the breached ones are listed as
+  `failed_budgets`, the decision's `reason` travels with them, and on a FAIL a summary or
+  recommendation that blames a budget that held is rejected and retried, then replaced by
+  the templated prose. Narratives are cached: delete a run's `insights.json` and re-run
+  `report` to rewrite an existing one.
+```
+
+- [ ] **Step 5: Check the doc tripwires, then commit**
+
+Run: `uv run pytest -q -k "docs or llms or currency" && uv run --with pre-commit pre-commit run --all-files`
+Expected: green.
+
+```bash
+WT=/home/lukas/repos/evalshift/evalshift-cli
+git -C $WT branch --show-current   # fix/insight-budget-status
+git -C $WT add DOCS.md llms-full.txt docs/faq.md CHANGELOG.md
+cd $WT && uv run --with pre-commit git commit -m "docs(insights): a FAIL's cause is a fact the narrative is given
+
+Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 5: Verify on the converter run, then PR
+
+**Files:** none changed (a backup in the scratchpad).
+
+- [ ] **Step 1: Regenerate the shipped narrative with the branch build**
+
+```bash
+WT=/home/lukas/repos/evalshift/evalshift-cli
+RUN=/home/lukas/repos/testApp/.evalshift/runs/r_20261012_converter_d418e5
+cp "$RUN/insights.json" "$SCRATCH/converter-insights.before.json"
+rm "$RUN/insights.json"            # the cache key does not change with the CLI
+cd /home/lukas/repos/testApp && uv run --project $WT evalshift report r_20261012_converter_d418e5
+```
+
+`$SCRATCH` is the session scratchpad. The global `evalshift` on PATH is the PyPI 1.4.1 wheel, so it **must** be `uv run --project $WT`. The narrative model is `gemini-3.1-flash-lite-preview`; if `report` warns `skipping insights: no API key`, ask the user to run the last line with `!` in their shell.
+
+Expected in the new `insights.json`: `verdict_summary` and `recommendation` attribute the FAIL to latency only; "Trace-rule violations" appears nowhere as a cause (it may appear as "within budget"). If `insight.model == "none"`, the generation was rejected twice and the templated `recommendation` reads `Do not migrate under the configured policy — the latency increase budget was breached. …` — also a pass for this check; note it in the PR.
+
+- [ ] **Step 2: Full CI mirror**
+
+Run: `cd $WT && make ci`
+Expected: ruff, format, mypy, pytest all green; coverage ≥ 90.
+
+- [ ] **Step 3: Push and open the PR** (only after the user approves pushing)
+
+```bash
+cd $WT && git add -f docs/superpowers/plans/2026-10-12-insight-budget-status.md
+uv run --with pre-commit git commit -m "docs(plan): insight budget status
+
+Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>"
+uv run --with pre-commit git push -u origin fix/insight-budget-status
+gh -R evalshift/evalshift-cli pr create --base main --head fix/insight-budget-status \
+  --title "fix(insights): the narrative names the budget that failed the run" \
+  --body-file "$SCRATCH/pr-body.md"
+```
+
+The PR body follows `.github/PULL_REQUEST_TEMPLATE.md`: what changes (status lines, `failed_budgets`, `verdict_reason`, the instruction rule, `validate_blame` + retry + template floor), why (the converter run's before/after narrative, quoted), the test plan with the gate ticked, a note that the scan is heuristic and the prompt change is the primary fix, the cache caveat (delete `insights.json` to regenerate), and it ends with `🤖 Generated with [Claude Code](https://claude.com/claude-code)`. Release as 1.4.2 together with PR #50 via a separate `chore(release): 1.4.2` PR after merge.
diff --git a/llms-full.txt b/llms-full.txt
index d8515ab..1a19412 100644
--- a/llms-full.txt
+++ b/llms-full.txt
@@ -1199,6 +1199,59 @@ Model: defaults.insights_model, falling back to defaults.judge_model.
   they scored zero rows - the "advisory:" note on the synthesized comparison carries the
   flag their absent records cannot. Orthogonal to the absent-rate rule above: that one needs
   n_records == 0, this one fires when only some gate died.
+- A FAIL's CAUSE is a fact, not an inference. Every gating budget (overall and slice rows)
+  enters FACTS as `budget "<label>": limit <x>, <status>`, status breached | within |
+  measured nothing | over its limit but not confirmed at this sample size
+  (facts._budget_status: not measured -> measured nothing, passed -> within, conclusive ->
+  breached, else unconfirmed). `failed_budgets: <labels>` lists the breached rows (overall
+  and slice, as decision prose names them: "'security' slice overall regression rate");
+  `verdict_reason: <text>` carries MigrationDecision.reason when set, plain-worded by
+  facts._plain_reason (no config keys: migration_policy.max_invariant_violations -> "the
+  trace-rule violations budget", likewise every budget key; quoted beside a slice's limit
+  ("in the 'security' slice, over the 0 allowed by ...") -> the slice row's own label, "the
+  'security' slice trace-rule violations budget"; fail_on_dropped_params and (drop_params)
+  put into words); its figures join the allow-list. Both keys are banned identifiers in
+  prose. Instruction: "breached" is the only status that may be blamed - only a breached
+  budget may be named as why the run failed or as something to fix; a "within" budget is
+  never breached/exceeded/failed/missed/violated/to be addressed; verdict_summary must agree
+  with verdict_reason. On verdict fail only, verdict_summary and recommendation are scanned
+  (generator.validate_blame). Clauses split on sentence punctuation (. ; : ! ?),
+  while/but/whereas/although/though/however, ", and" / ", but" / ", with" / ", however,",
+  and an em or en dash; a bare "and" or bare comma does not split. Every budget label, held
+  or not, is located longest-first and masked (case-insensitive; hyphens, whitespace and
+  quote characters folded, so "checkout slice cost increase" still matches the slice label).
+  A "within" label sharing a clause with a non-negated blame word (breach*, exceed*, fail*,
+  violat*, address*, miss/missed/misses/missing, unmet, not met, broke, broken,
+  over/above/beyond + a limit phrase: optional the/its/their, at most 2 comma-free words or
+  figures, then a limit noun (limit, budget, ceiling, threshold, maximum, allowance, policy;
+  singular or plural), e.g. "over budget", "over the +200% cost limit"; so "+102% over the
+  source" is not blame; negated: not|no|never|without within the 24 chars before it in the
+  clause) blames it unless every mention of it in the clause is excused (generator._excused,
+  per occurrence): (a) negated mention - not|no|never|without directly before it, only other
+  labels/or/and/nor/commas between, and the label (plus any labels chained to it) followed
+  by a comma, clause end or or/and/nor/but ("not Cost increase or Trace-rule violations"
+  passes; "no Cost increase headroom left" is blamed); (b) limit-relative holding phrase
+  after it - within/inside/under/below + that same limit phrase ("within policy", "within
+  budget", "under their limits", "under the +200% cost limit"), or a bare held/holds/passed
+  with only punctuation after it to the clause end - itself un-negated, no un-negated blame
+  word between, no other label between unless joined by and/or/nor/comma ("as Cost increase
+  and Trace-rule violations all stayed within budget" passes; a verb or preposition alone
+  does not hold, so "remained above the +200% limit", "held at +250%, exceeding its limit",
+  "under the target model breached its ceiling", "within hours, broke its ceiling",
+  "exceeded its limit and stayed within budget" and "failed on Cost increase as Latency
+  increase stayed within its ceiling" are blamed). Accepted misses: "stayed within budget at
+  first, then exceeded it", "Address Cost increase so it stays within budget", "below the
+  target's ceiling failed the run" and "below the ceiling on 3 prompts, failed on the rest"
+  pass. A blamed label rejects the generation; the retry names the misblamed labels ("Your
+  previous answer blamed budgets that held: ..."; "No budget was breached" when
+  failed_budgets is empty); 2 rejections -> templated prose (templates._recommendation):
+  names the breached budget, else the overall blocking regressions, else points at the
+  decision's recommendations and budget table.
+  Heuristic safety net by design: it catches the shipped phrasing and close variants, the
+  prompt rule is the primary fix; a false match costs the retry (shared with invented-number
+  rejections) and a repeated one ships the templated prose, which has no findings. Cached
+  narratives do not regenerate (key = config_hash + model, not the CLI version): delete
+  insights.json to rewrite an existing run's prose.
 - Prompt input: the pre-rendered FACTS block plus the worst 8 regressions by worst_delta_score
   (input + both outputs, each truncated to 2000 chars). Same data exposure as llm_judge.
 - Cost: 1 model call per run (2 on a rejected generation). Cached in insights.json keyed on
diff --git a/src/evalshift_cli/insights/facts.py b/src/evalshift_cli/insights/facts.py
index e68fec1..616de95 100644
--- a/src/evalshift_cli/insights/facts.py
+++ b/src/evalshift_cli/insights/facts.py
@@ -11,6 +11,7 @@
 
 from __future__ import annotations
 
+import re
 import statistics
 from collections.abc import Iterable, Sequence
 from dataclasses import dataclass, field
@@ -83,6 +84,14 @@
 #: The budgets that are plain counts.
 _COUNT_BUDGETS: frozenset[str] = frozenset({"max_critical_regressions", "max_invariant_violations"})
 
+#: Budget status words, rendered beside each budget's limit in the FACTS
+#: block. Digit-free plain English — the model copies them into prose — and
+#: the only vocabulary the blame validator keys on.
+BUDGET_BREACHED = "breached"
+BUDGET_WITHIN = "within"
+BUDGET_UNMEASURED = "measured nothing"
+BUDGET_UNCONFIRMED = "over its limit but not confirmed at this sample size"
+
 
 @dataclass(frozen=True, slots=True)
 class ExampleFact:
@@ -158,6 +167,19 @@ class Facts:
     #: naming it as why a run failed would be false. ``blocking_evaluators``
     #: keeps every scope, for the prose that lists them rather than blames them.
     overall_blocking_evaluators: list[str] = field(default_factory=list)
+    #: One ``(display label, rendered limit, status)`` per gating budget row —
+    #: the overall rows and the distinct slice rows, in policy order. Handed to
+    #: the model beside each limit so a FAIL's cause is read off the line, not
+    #: guessed: a narrative once blamed "Trace-rule violations" on a run where
+    #: that budget held and only the latency ceiling was breached, because the
+    #: prompt listed limits without results.
+    budget_statuses: list[tuple[str, str, str]] = field(default_factory=list)
+    #: The decision's own explanation of its verdict
+    #: (``MigrationDecision.reason``), or ``""`` when it carries none — with the
+    #: config keys it quotes put into words, scoped to the slice where the
+    #: reason names one, so the model can copy it without echoing internal
+    #: identifiers.
+    verdict_reason: str = ""
 
 
 def build_facts(
@@ -218,10 +240,15 @@ def build_facts(
         _COVERAGE_BASIS_UNMEASURED if (unmeasured_budgets or unmeasured_evaluators) else ""
     )
     failed_budgets = _unique(
-        _failed_budget_label(b)
+        _scoped_budget_label(b)
         for b in gating_budget_results(decision)
         if not b.passed and b.conclusive
     )
+    budget_statuses = [
+        (_scoped_budget_label(b), _budget_limit(b.name, b.allowed), _budget_status(b))
+        for b in gating_budget_results(decision)
+    ]
+    verdict_reason = _plain_reason(decision.reason or "")
 
     rendered: dict[str, str] = {
         "verdict": decision.verdict.replace("_", " ").upper(),
@@ -286,6 +313,8 @@ def build_facts(
         allowed_numbers=_allowed_numbers(
             rendered=rendered,
             budget_limits=budget_limits,
+            slice_limits=[limit for _, limit, _ in budget_statuses],
+            verdict_reason=verdict_reason,
             failure_categories=failure_categories,
             model_ids=(state.models.source, state.models.target),
             n_examples=len(examples),
@@ -308,6 +337,8 @@ def build_facts(
         overall_blocking_evaluators=_unique(
             r.evaluator_name for r in decision.blocking_regressions if r.slice_name == ALL_SLICE
         ),
+        budget_statuses=budget_statuses,
+        verdict_reason=verdict_reason,
     )
 
 
@@ -357,18 +388,23 @@ def _p_value(value: float) -> str:
     return f"< {P_VALUE_FLOOR}" if value < P_VALUE_FLOOR else f"{value:.4f}"
 
 
-def _failed_budget_label(budget: BudgetResult) -> str:
-    """A breached budget's display name, scoped when it is a slice's own row.
+def _scoped_budget_label(budget: BudgetResult) -> str:
+    """A budget's display name, scoped when it is a slice's own row.
 
-    A bare "overall regression rate" for a slice breach would send the reader
-    to the overall row — green in exactly the run this names. Worded so the
+    A bare "overall regression rate" for a slice row would send the reader to
+    the overall row — green in exactly the run that names it. Worded so the
     templated advice reads "the 'security' slice overall regression rate
-    budget was breached".
+    budget was breached" and the FACTS block lists the row under that name.
     """
-    label = BUDGET_LABELS.get(budget.name, budget.name)
-    if budget.scope == "overall":
+    return _scoped_label(budget.name, budget.scope)
+
+
+def _scoped_label(name: str, scope: str) -> str:
+    """The display name for budget ``name`` on ``scope`` — see :func:`_scoped_budget_label`."""
+    label = BUDGET_LABELS.get(name, name)
+    if scope == "overall":
         return label
-    return f"'{budget.scope}' slice {label[:1].lower()}{label[1:]}"
+    return f"'{scope}' slice {label[:1].lower()}{label[1:]}"
 
 
 def _budget_limit(name: str, allowed: float) -> str:
@@ -379,6 +415,21 @@ def _budget_limit(name: str, allowed: float) -> str:
     return _rate_pct(allowed)
 
 
+def _budget_status(budget: BudgetResult) -> str:
+    """Which of the four things a budget row says, as a word the prose may use.
+
+    ``measured`` first: the ``0/0`` default passes by arithmetic, and calling
+    it ``within`` is the clean-sweep claim the coverage facts exist to stop.
+    """
+    if not budget.measured:
+        return BUDGET_UNMEASURED
+    if budget.passed:
+        return BUDGET_WITHIN
+    if budget.conclusive:
+        return BUDGET_BREACHED
+    return BUDGET_UNCONFIRMED
+
+
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------
@@ -408,6 +459,44 @@ def _regression_samples(examples: Sequence[ExampleFact]) -> list[RegressionSampl
     ]
 
 
+#: A config key quoted as the source of a slice's limit, as
+#: ``policy._invariant_reason`` words it: "in the 'security' slice, over the 0
+#: allowed by migration_policy.max_invariant_violations".
+_SLICE_KEY_RE = re.compile(
+    r"(?P<lead>in the '(?P<scope>.+?)' slice, over the \S+ allowed by )"
+    r"migration_policy\.(?P<key>" + "|".join(map(re.escape, BUDGET_LABELS)) + r")\b"
+)
+
+
+def _plain_reason(reason: str) -> str:
+    """The decision's reason with the config keys it quotes put into words.
+
+    The reason enters a FACTS block the model is told to copy verbatim, and the
+    policy's own prose quotes ``evalshift.yaml`` keys the narrative may not
+    show — a banned one costs a faithful generation its retry, an unbanned one
+    ships to readers as config vocabulary. Figures are left untouched.
+
+    A key quoted beside a slice's limit is named for that slice, in the label
+    the FACTS block lists the slice row under: "in the 'security' slice, over
+    the 0 allowed by the trace-rule violations budget" pins the slice's 0 on
+    the overall budget, which may have held — and a summary that copies the
+    reason, as instructed, would then blame it.
+    """
+    reason = _SLICE_KEY_RE.sub(
+        lambda m: f"{m.group('lead')}the {_scoped_label(m.group('key'), m.group('scope'))} budget",
+        reason,
+    )
+    for key, label in BUDGET_LABELS.items():
+        reason = reason.replace(
+            f"migration_policy.{key}", f"the {label[:1].lower()}{label[1:]} budget"
+        )
+    reason = reason.replace(
+        "migration_policy.fail_on_dropped_params",
+        "the policy's fail-on-dropped-parameters setting",
+    )
+    return reason.replace("(drop_params)", "(parameters dropped)")
+
+
 def _bounded(text: str | None) -> str:
     return (text or "")[:MAX_SAMPLE_TEXT_CHARS]
 
@@ -416,6 +505,8 @@ def _allowed_numbers(
     *,
     rendered: dict[str, str],
     budget_limits: dict[str, str],
+    slice_limits: Sequence[str],
+    verdict_reason: str,
     failure_categories: Sequence[tuple[str, int]],
     model_ids: tuple[str, ...],
     n_examples: int,
@@ -424,14 +515,18 @@ def _allowed_numbers(
 
     Beyond the rendered figures themselves this admits each one's bare-numeral
     form (``+102%`` also admits ``102``), the counts behind the budget table
-    and failure categories, the numerals inside the model ids — writing
-    ``gemini-3.1-flash`` must not read as an invented figure — and every
-    integer up to ``n_examples`` so the model can write "15 of 21".
+    and failure categories, the slice budgets' limits (rendered only in the
+    status lines) and the decision reason's own figures, the numerals inside
+    the model ids — writing ``gemini-3.1-flash`` must not read as an invented
+    figure — and every integer up to ``n_examples`` so the model can write
+    "15 of 21".
     """
     allowed: set[str] = {str(index) for index in range(n_examples + 1)}
     sources: list[str] = [
         *rendered.values(),
         *budget_limits.values(),
+        *slice_limits,
+        verdict_reason,
         *(str(count) for _, count in failure_categories),
         *model_ids,
     ]
@@ -449,6 +544,10 @@ def _unique(values: Iterable[str]) -> list[str]:
 
 
 __all__ = [
+    "BUDGET_BREACHED",
+    "BUDGET_UNCONFIRMED",
+    "BUDGET_UNMEASURED",
+    "BUDGET_WITHIN",
     "NOT_AVAILABLE",
     "NOT_COMPARABLE",
     "NOT_MEASURED",
diff --git a/src/evalshift_cli/insights/generator.py b/src/evalshift_cli/insights/generator.py
index d3d2b66..fb2ab73 100644
--- a/src/evalshift_cli/insights/generator.py
+++ b/src/evalshift_cli/insights/generator.py
@@ -6,7 +6,9 @@
 means the model calculated something, and in a report that gates merges a
 derived number is a defect even when it happens to be right.
 
-Two attempts, then :func:`evalshift_cli.insights.templates.fallback_insight`. The
+Three checks on the way out — invented figures, echoed identifiers, and on a
+FAIL a held budget blamed for the verdict (:func:`validate_blame`). Two
+attempts, then :func:`evalshift_cli.insights.templates.fallback_insight`. The
 prose is never load-bearing enough to fail a run over — every headline figure on
 the report is rendered from data, and this module only writes the sentences
 around them.
@@ -17,12 +19,13 @@
 import json
 import logging
 import re
+from collections.abc import Sequence
 from datetime import UTC, datetime
 from typing import Any, cast
 
 from evalshift_cli.analysis.policy import BUDGET_LABELS
 from evalshift_cli.evaluators.failures import CATEGORY_LABELS, category_label
-from evalshift_cli.insights.facts import Facts, RegressionSample
+from evalshift_cli.insights.facts import BUDGET_WITHIN, Facts, RegressionSample
 from evalshift_cli.insights.models import (
     INSIGHT_KINDS,
     MAX_FINDING_DETAIL_CHARS,
@@ -71,6 +74,101 @@
 #: outermost braces of a fenced or prose-wrapped object.
 _JSON_OBJECT_RE = re.compile(r"\{.*\}", re.DOTALL)
 
+#: A budget's limit as prose names it — "budget", "policy", "their limits",
+#: "the +200% cost limit": an optional the/its/their, at most two words or
+#: figures (none with a comma), then a limit noun — limit, budget, ceiling,
+#: threshold, maximum, allowance or policy, singular or plural. Shared by the
+#: blame words ("over budget") and the holding words ("within policy"), so
+#: the two can never disagree about what a limit is.
+_LIMIT_PHRASE = (
+    r"(?:(?:the|its|their) )?(?:[^\s,]+ ){0,2}?"
+    r"(?:(?:limit|budget|ceiling|threshold|maximum|allowance)s?|polic(?:y|ies))"
+)
+
+#: Words that lay a verdict at a budget's door. A budget marked "within" that
+#: shares a clause with one of these, un-negated, is a cause the model
+#: invented: a shipped narrative said a run "failed to meet the budget for
+#: Trace-rule violations" when that budget held and only latency broke.
+#: "over"/"above"/"beyond" accuse only with a limit phrase ("over its +200%
+#: limit", "over budget"): "+102% over the source" measures against the
+#: source model, not against a budget.
+_BLAME_RE = re.compile(
+    r"\b(?:breach\w*|exceed\w*|fail\w*|violat\w*|address\w*|miss(?:ed|es|ing)?|"
+    r"unmet|not met|broke|broken|"
+    r"(?:over|above|beyond) " + _LIMIT_PHRASE + r")\b",
+    re.IGNORECASE,
+)
+
+#: Phrases that say a budget held, measured against its limit. One after a
+#: held label, in its clause, with no blame word between and not itself
+#: negated, describes that label rather than accusing it: "Despite Cost
+#: increase staying within its limit, the run failed on Latency increase."
+#: Only limit-relative phrases count: "within", "inside", "under" or "below"
+#: followed by a limit phrase ("within policy", "under their limits"), or a
+#: bare "held"/"holds"/"passed" with nothing but punctuation after it to the
+#: clause end ("Trace-rule violations held."). A verb or preposition alone
+#: says nothing held — "remained above the limit", "held at +250%, exceeding
+#: its limit", "under the target model breached its ceiling", "within hours,
+#: broke its ceiling" all accuse.
+_HOLDING_RE = re.compile(
+    r"\b(?:(?:within|inside|under|below) " + _LIMIT_PHRASE + r"|"
+    r"(?:held|holds|passed)(?=[^\w\x00]*$))\b",
+    re.IGNORECASE,
+)
+
+#: Stands in for every located label in the masked clause. One character, so
+#: the negation window measures what it did when labels were blanked out, and
+#: neither a word character nor whitespace, so no pattern above can match it.
+_MASK = "\x00"
+
+#: A held label right after a negation — with only other labels, "or", "and",
+#: "nor" and commas between — may be named to be cleared: "not Cost increase
+#: or Trace-rule violations". Matched against the masked text before the label.
+_NEGATED_MENTION_RE = re.compile(
+    r"\b(?:not|no|never|without)\b(?:[\s,\x00]|\b(?:or|and|nor)\b)*$",
+    re.IGNORECASE,
+)
+
+#: ...but only when the name stands alone. After the label, and after any
+#: labels chained to it by "or"/"and"/"nor"/commas, must come a comma, the
+#: clause end or a coordinator. Otherwise the label modifies the noun after it
+#: and the negation is that noun's: "no Cost increase headroom left" denies the
+#: headroom, not the budget's blame. Matched against the masked text after the
+#: label; the chain is possessive so it cannot back off a trailing noun.
+_STANDS_ALONE_RE = re.compile(
+    r"(?:(?:\s*,\s*(?:(?:or|and|nor)\s+)?|\s+(?:or|and|nor)\s+)\x00)*+"
+    r"(?:\s*,|\s+(?:or|and|nor|but)\b|[^\w\x00]*$)",
+    re.IGNORECASE,
+)
+
+#: What may join two labels that share one holding word: "Cost increase and
+#: Trace-rule violations all stayed within budget". Anything else between them
+#: ("Cost increase as Latency increase stayed within") gives the holding word
+#: to the nearer label.
+_COORDINATION_RE = re.compile(r"(?:[\s,\x00]|\b(?:or|and|nor)\b)*", re.IGNORECASE)
+
+#: A blame word shortly after one of these is a denial ("was not breached",
+#: "no breach of"), not an accusation. Bounded so a "not" three clauses back
+#: cannot excuse an accusation.
+_NEGATION_RE = re.compile(r"\b(?:not|no|never|without)\b[^.;,]{0,24}$", re.IGNORECASE)
+
+#: Clause boundaries. A contrast word starts a new claim, so "latency was
+#: exceeded while Trace-rule violations stayed within budget" blames only
+#: latency. A bare "and" is deliberately not one: "exceeded latency and failed
+#: to meet Trace-rule violations" is the shipped sentence, and both halves
+#: accuse; nor is a bare comma. ", with" is, because the retry hint invites
+#: "…exceeded its ceiling, with Cost increase within policy", and so are a
+#: parenthetical ", however," and a dash.
+_CLAUSE_RE = re.compile(
+    r"[.;:!?]\s+|\s(?:while|but|whereas|although|though|however)\s|,\s*(?:and|but)\s"
+    r"|,\s*with\s|,\s*however,?\s|\s*[\u2014\u2013]\s*",
+    re.IGNORECASE,
+)
+
+#: Straight and curly quotes, folded out of labels and prose alike before the
+#: blame scan matches one against the other.
+_QUOTE_RE = re.compile(r"[\"'\u2018\u2019\u201c\u201d]")
+
 _INSTRUCTION = """\
 You are writing the explanation section of a model-migration report. The reader
 is an engineer deciding whether to switch their production model to the target.
@@ -93,6 +191,12 @@
   fact is present, never write that all budgets passed, that every constraint
   or requirement is met, or that the migration is safe — name the blind gates
   and say their silence is unknown.
+- Every "budget" line ends with its status. Only a budget whose status is
+  "breached" — the same ones listed under "failed_budgets" — may be named as
+  why the run failed or as something to fix. A budget marked "within" held:
+  never write that it was breached, exceeded, failed, missed, violated or
+  must be addressed. When "verdict_reason" is present it is the decision's
+  own explanation of the verdict, and your verdict summary must agree with it.
 - Findings describe BEHAVIORAL changes visible in the sampled outputs — what the
   target does differently from the source. They are not restatements of the
   statistics; the report already renders those.
@@ -122,11 +226,20 @@ class GenerationError(Exception):
         tokens: Offending tokens — invented figures or echoed internal
             identifiers — fed back into the retry so the second attempt can
             correct them. Empty for every other kind of rejection.
+        misblamed: Display labels of budgets that held but were blamed for
+            the verdict — fed back the same way, under their own hint.
     """
 
-    def __init__(self, message: str, *, tokens: list[str] | None = None) -> None:
+    def __init__(
+        self,
+        message: str,
+        *,
+        tokens: list[str] | None = None,
+        misblamed: list[str] | None = None,
+    ) -> None:
         super().__init__(message)
         self.tokens = tokens or []
+        self.misblamed = misblamed or []
 
 
 #: FACTS field names that are not ``rendered`` keys but appear in the prompt
@@ -139,6 +252,8 @@ def __init__(self, message: str, *, tokens: list[str] | None = None) -> None:
         "worst_evaluator",
         "rates_basis",
         "coverage_basis",
+        "failed_budgets",
+        "verdict_reason",
         "blocking_evaluators",
         "unmeasured_budgets",
         "unmeasured_evaluators",
@@ -191,6 +306,156 @@ def validate_numbers(text: str, allowed: frozenset[str]) -> list[str]:
     return [token for token in NUMERIC_TOKEN_RE.findall(text) if not _is_allowed(token, allowed)]
 
 
+def validate_blame(text: str, within: Sequence[str], *, others: Sequence[str] = ()) -> list[str]:
+    """Return the budgets in ``within`` that ``text`` blames for the verdict.
+
+    A budget that held may be mentioned — "Trace-rule violations stayed within
+    budget" is accurate — but not accused: it may not share a clause with a
+    blame word unless that word is negated, or unless each of its mentions in
+    that clause is excused. A mention is excused by a negation right before a
+    name that stands alone ("not Cost increase or Trace-rule violations", but
+    not "no Cost increase headroom"), or by a limit-relative holding phrase
+    after it that describes it ("Cost increase stayed within its limit" beside
+    "the run failed on Latency increase", but not "remained above the limit"
+    or "within hours, broke its ceiling")
+    — see :func:`_excused`. A plain-English accusation carries no digit for
+    :func:`validate_numbers` and no identifier for :func:`validate_identifiers`,
+    so this is the only check that sees it.
+
+    A safety net, not a parser: it catches the shipped phrasing and its close
+    variants. A false match costs the retry — the one retry, shared with
+    invented-number rejections — and a repeated one ships the templated prose,
+    which has no findings. Two misses are accepted: a holding phrase excuses
+    the label before it whatever follows, so "Cost increase stayed within
+    budget at first, then exceeded it" and "Address Cost increase so it stays
+    within budget" pass — telling their blame word's subject from the one in
+    "staying within its limit, the run failed on Latency increase" takes a
+    parser. For the same reason "Cost increase below the target's ceiling
+    failed the run" and "Cost increase, below the ceiling on 3 prompts, failed
+    on the rest" pass. Labels are matched case-insensitively with hyphens and runs of
+    whitespace folded to one space.
+    Every label — held or not — is located longest first and masked before the
+    scan: "'checkout' slice cost increase" contains "cost increase", and
+    "Trace-rule violations" contains a blame word, and neither may accuse a
+    held budget by containment.
+
+    Args:
+        text: One prose field of a generation.
+        within: Display labels of the budgets whose status is
+            :data:`~evalshift_cli.insights.facts.BUDGET_WITHIN`.
+        others: Display labels of the gating budgets that did not hold. Never
+            reported, only located: a span one of them claims cannot also
+            match a shorter held label, and its words are not blame words.
+
+    Returns:
+        The wrongly blamed labels, each once, in ``within`` order. Empty means
+        valid.
+    """
+    held = set(within)
+    # Longest first, so a position a longer label covers cannot also match a
+    # shorter one it contains. ``sorted`` is stable: on a tie, held labels win.
+    needles = sorted(
+        ((label, _normalise(label)) for label in (*within, *others)),
+        key=lambda pair: -len(pair[1]),
+    )
+    blamed: set[str] = set()
+    for clause in (_normalise(c) for c in _CLAUSE_RE.split(text)):
+        spans = _locate_labels(clause, needles)
+        if not any(label in held for _, _, label in spans):
+            continue
+        # Every located label comes out before the scan, not just the one
+        # under test: "Trace-rule violations" would otherwise read as a
+        # violation of whichever budget shares its clause.
+        rest, cursor = "", 0
+        marks: list[tuple[int, str]] = []
+        for start, end, label in sorted(spans):
+            rest += clause[cursor:start]
+            marks.append((len(rest), label))
+            rest += _MASK
+            cursor = end
+        rest += clause[cursor:]
+        blames = [
+            m.start()
+            for m in _BLAME_RE.finditer(rest)
+            if not _NEGATION_RE.search(rest[: m.start()])
+        ]
+        if not blames:
+            continue
+        positions = [position for position, _ in marks]
+        blamed.update(
+            label
+            for position, label in marks
+            if label in held and not _excused(rest, position, blames, positions)
+        )
+    return [label for label in within if label in blamed]
+
+
+def _excused(rest: str, position: int, blames: list[int], marks: list[int]) -> bool:
+    """Whether the masked label at ``position`` is mentioned rather than accused.
+
+    Two ways out, judged per occurrence. A negation right before it ("not
+    Cost increase or Trace-rule violations") names it to clear it — provided
+    the name stands alone: it, and any labels chained to it, must be followed
+    by a comma, the clause end or "or"/"and"/"nor"/"but" ("no Cost increase
+    headroom left" negates the headroom and still accuses). Or a holding
+    phrase after it ("Cost increase stayed within its limit") describes it —
+    provided the phrase is limit-relative (see :data:`_HOLDING_RE`: within,
+    inside, under or below need a limit phrase after them, so "remained above
+    the limit" and "within hours" are not), it is not negated, no un-negated
+    blame word
+    stands between the two ("exceeded its limit and stayed within budget"
+    still accuses), and no other label does unless joined by
+    "and"/"or"/"nor"/a comma ("as Latency increase stayed within" describes
+    latency).
+
+    Args:
+        rest: The clause with every located label replaced by :data:`_MASK`.
+        position: Where the label under judgement sits in ``rest``.
+        blames: Start of each un-negated blame word in ``rest``.
+        marks: Where every located label sits in ``rest``, in order.
+    """
+    if _NEGATED_MENTION_RE.search(rest[:position]) and _STANDS_ALONE_RE.match(rest, position + 1):
+        return True
+    for holding in _HOLDING_RE.finditer(rest, position + 1):
+        at = holding.start()
+        if _NEGATION_RE.search(rest[:at]):
+            continue
+        if any(position < blame < at for blame in blames):
+            continue
+        between = [mark for mark in marks if position < mark < at]
+        if between and not _COORDINATION_RE.fullmatch(rest, position + 1, between[-1]):
+            continue
+        return True
+    return False
+
+
+def _locate_labels(clause: str, needles: list[tuple[str, str]]) -> list[tuple[int, int, str]]:
+    """Claim non-overlapping spans of ``clause`` for ``needles``, in the order given.
+
+    Returns:
+        One ``(start, end, label)`` per claimed span.
+    """
+    spans: list[tuple[int, int, str]] = []
+    for label, needle in needles:
+        start = clause.find(needle)
+        while start != -1:
+            end = start + len(needle)
+            if all(end <= s or start >= e for s, e, _ in spans):
+                spans.append((start, end, label))
+            start = clause.find(needle, start + 1)
+    return spans
+
+
+def _normalise(text: str) -> str:
+    """Lower-case, quotes dropped, hyphens and whitespace runs folded, for label matching.
+
+    Quotes go because a slice label reaches the model as "'checkout' slice
+    cost increase" and comes back bare or curly-quoted; left in, the held
+    "cost increase" inside it would claim the span.
+    """
+    return re.sub(r"[-\s]+", " ", _QUOTE_RE.sub("", text.lower()))
+
+
 async def generate_insight(facts: Facts, *, model: str, client: ModelClient) -> Insight:
     """Write the run's narrative, or fall back to deterministic prose.
 
@@ -207,10 +472,11 @@ async def generate_insight(facts: Facts, *, model: str, client: ModelClient) ->
         :data:`MAX_ATTEMPTS` unusable generations.
     """
     invented: list[str] = []
+    misblamed: list[str] = []
     for attempt in range(1, MAX_ATTEMPTS + 1):
         response = await client.complete(
             model=model,
-            prompt=build_prompt(facts, invented=invented),
+            prompt=build_prompt(facts, invented=invented, misblamed=misblamed),
             temperature=0.0,
         )
         log.debug(
@@ -224,6 +490,7 @@ async def generate_insight(facts: Facts, *, model: str, client: ModelClient) ->
         except GenerationError as exc:
             log.warning("insights generation attempt %d rejected: %s", attempt, exc)
             invented = exc.tokens
+            misblamed = exc.misblamed
     log.warning(
         "insights generation produced nothing usable in %d attempts; using templated prose",
         MAX_ATTEMPTS,
@@ -231,7 +498,12 @@ async def generate_insight(facts: Facts, *, model: str, client: ModelClient) ->
     return fallback_insight(facts)
 
 
-def build_prompt(facts: Facts, *, invented: list[str] | None = None) -> str:
+def build_prompt(
+    facts: Facts,
+    *,
+    invented: list[str] | None = None,
+    misblamed: list[str] | None = None,
+) -> str:
     """Assemble the instruction, the FACTS block and the regression samples.
 
     Args:
@@ -240,6 +512,9 @@ def build_prompt(facts: Facts, *, invented: list[str] | None = None) -> str:
             or echoed internal identifiers. Present only on a retry, where
             naming them is the whole reason the second call is worth paying
             for.
+        misblamed: Budgets that held but a previous attempt blamed for the
+            verdict. Named separately from ``invented``: the label itself is
+            allowed in prose, the accusation is not.
     """
     sections = [
         _INSTRUCTION.format(
@@ -257,6 +532,21 @@ def build_prompt(facts: Facts, *, invented: list[str] | None = None) -> str:
             + ". Figures must be copied verbatim from FACTS; internal "
             "identifiers must be rewritten as plain language."
         )
+    if misblamed:
+        # A FAIL from severity or dropped parameters breached no budget, and
+        # its FACTS block has no failed_budgets line to point at.
+        breached = (
+            "Only the budgets under failed_budgets were breached"
+            if facts.failed_budgets
+            else "No budget was breached"
+        )
+        sections.append(
+            "Your previous answer blamed budgets that held: "
+            + ", ".join(dict.fromkeys(misblamed))
+            + f". {breached}; a budget marked within may be described as within "
+            "policy or left out, never as a cause of the verdict or as something "
+            "to address."
+        )
     return "\n\n".join(section for section in sections if section)
 
 
@@ -280,11 +570,17 @@ def _facts_block(facts: Facts) -> str:
         lines.append(f"unmeasured_evaluators: {', '.join(facts.unmeasured_evaluators)}")
     if facts.coverage_basis:
         lines.append(f"coverage_basis: {facts.coverage_basis}")
+    if facts.failed_budgets:
+        lines.append(f"failed_budgets: {', '.join(facts.failed_budgets)}")
+    if facts.verdict_reason:
+        lines.append(f"verdict_reason: {facts.verdict_reason}")
     # Budgets and categories reach the model under their display names: it is
     # told to copy tokens verbatim, so whatever appears here is what a reader
-    # may end up seeing in the narrative.
-    for name, limit in facts.budget_limits.items():
-        lines.append(f'budget "{BUDGET_LABELS.get(name, name)}": {limit}')
+    # may end up seeing in the narrative. Each budget carries its status, so
+    # the cause of a FAIL is read off the line rather than guessed from the
+    # limit — a narrative once blamed a budget that held.
+    for label, limit, status in facts.budget_statuses:
+        lines.append(f'budget "{label}": limit {limit}, {status}')
     for category, count in facts.failure_categories:
         lines.append(f'failure_category "{category_label(category)}": {count}')
     body = "\n".join(lines)
@@ -333,10 +629,27 @@ def _build_insight(text: str, *, facts: Facts, model: str) -> Insight:
     for field in (*prose.values(), *(t for f in findings for t in (f.title, f.detail))):
         offending.extend(validate_numbers(field, facts.allowed_numbers))
         offending.extend(t for t in validate_identifiers(field, banned) if t not in offending)
-    if offending:
+    # Only a FAIL assigns a cause, and only its verdict summary and
+    # recommendation do the assigning; the advisory and economics summaries
+    # describe signals, and findings describe behaviour.
+    misblamed: list[str] = []
+    if facts.verdict == "fail":
+        held = [label for label, _, status in facts.budget_statuses if status == BUDGET_WITHIN]
+        others = [label for label, _, status in facts.budget_statuses if status != BUDGET_WITHIN]
+        for field in (prose["verdict_summary"], prose["recommendation"]):
+            misblamed.extend(
+                t for t in validate_blame(field, held, others=others) if t not in misblamed
+            )
+    if offending or misblamed:
+        problems: list[str] = []
+        if offending:
+            problems.append(f"tokens that may not be shown: {', '.join(offending)}")
+        if misblamed:
+            problems.append(f"budgets blamed although they held: {', '.join(misblamed)}")
         raise GenerationError(
-            f"response contained tokens that may not be shown: {', '.join(offending)}",
+            "response contained " + "; ".join(problems),
             tokens=offending,
+            misblamed=misblamed,
         )
 
     return Insight(
@@ -428,5 +741,6 @@ def _is_allowed(token: str, allowed: frozenset[str]) -> bool:
     "GenerationError",
     "build_prompt",
     "generate_insight",
+    "validate_blame",
     "validate_numbers",
 ]
diff --git a/tests/unit/insights_factories.py b/tests/unit/insights_factories.py
index 7e2e566..1db6f33 100644
--- a/tests/unit/insights_factories.py
+++ b/tests/unit/insights_factories.py
@@ -12,6 +12,7 @@
 from __future__ import annotations
 
 import json
+from dataclasses import replace
 from datetime import UTC, datetime
 from typing import Any
 
@@ -21,6 +22,8 @@
     FailureCategoryCount,
     MigrationDecision,
     PolicyMetricSummary,
+    SliceDecision,
+    _invariant_reason,
 )
 from evalshift_cli.analysis.statistics import UNMEASURED_NOTE_PREFIX, ComparisonResult
 from evalshift_cli.evaluators.base import EvalRecord
@@ -256,6 +259,74 @@ def unmeasured_budget(name: str = "max_tool_divergence") -> BudgetResult:
     )
 
 
+#: A severity-only fail's ``MigrationDecision.reason``, as the policy words it.
+#: Carries figures: a generation that copies them must not be rejected.
+SEVERITY_REASON = (
+    "semantic.cosine regressed at critical severity on prompt replay "
+    "(effect size -2.15, adjusted p 0.0004). A critical or high regression from a "
+    "blocking evaluator fails the run on its own, whatever the budgets say."
+)
+
+
+def converter_decision() -> MigrationDecision:
+    """r_20261012_converter_d418e5: the latency ceiling breached, every other budget held.
+
+    The run whose narrative blamed "Trace-rule violations" — a budget that
+    passed at 0 against a limit of 1 — because the prompt listed each budget's
+    limit without its result. Six held budgets, one breached, one blind.
+    """
+    return decision(
+        verdict="fail",
+        budget_results=[
+            *budgets()[:5],
+            BudgetResult(name="max_latency_increase", observed=1.753, allowed=0.30, passed=False),
+            BudgetResult(name="max_invariant_violations", observed=0.0, allowed=1.0, passed=True),
+            unmeasured_budget(),
+        ],
+    )
+
+
+def slice_invariant_decision() -> MigrationDecision:
+    """A trace rule broke in the 'security' slice only; the overall budget held.
+
+    Overall ``max_invariant_violations`` 5 with 1 observed (within); the
+    'security' slice allows 0 and saw 1 of 4 (breached). The reason is the
+    policy's own sentence for that slice row, so it names the slice's limit —
+    and a rewrite that attached it to the overall budget would put a held
+    budget in the verdict's mouth.
+    """
+    base = decision(
+        verdict="fail",
+        budget_results=[
+            *budgets(),
+            BudgetResult(
+                name="max_invariant_violations",
+                observed=1.0,
+                allowed=5.0,
+                passed=True,
+                denominator=10,
+            ),
+        ],
+    )
+    slice_row = BudgetResult(
+        name="max_invariant_violations",
+        observed=1.0,
+        allowed=0.0,
+        passed=False,
+        scope="security",
+        denominator=4,
+    )
+    return replace(
+        base,
+        slices={
+            "security": SliceDecision(
+                name="security", verdict="fail", metrics=base.overall, budget_results=[slice_row]
+            )
+        },
+        reason=_invariant_reason([slice_row]),
+    )
+
+
 def unmeasured_comparison(evaluator_name: str) -> ComparisonResult:
     """An evaluator that was handed pairs and produced no comparable row.
 
diff --git a/tests/unit/test_insight_facts.py b/tests/unit/test_insight_facts.py
index e7db20a..7b99ed2 100644
--- a/tests/unit/test_insight_facts.py
+++ b/tests/unit/test_insight_facts.py
@@ -6,28 +6,42 @@
 
 from __future__ import annotations
 
+from dataclasses import replace
 from typing import Any
 
 from evalshift_cli.analysis.policy import (
     BlockingRegression,
     BudgetResult,
     FailureCategoryCount,
+    _dropped_params_reason,
+    _invariant_reason,
     evaluate_migration_policy,
 )
 from evalshift_cli.analysis.statistics import ComparisonResult
 from evalshift_cli.config.models import MigrationPolicy, SliceMigrationPolicy
 from evalshift_cli.evaluators.base import EvalRecord
-from evalshift_cli.insights.facts import build_facts
+from evalshift_cli.insights.facts import (
+    BUDGET_BREACHED,
+    BUDGET_UNCONFIRMED,
+    BUDGET_UNMEASURED,
+    BUDGET_WITHIN,
+    _scoped_budget_label,
+    build_facts,
+)
+from evalshift_cli.insights.generator import banned_identifiers
 from evalshift_cli.insights.templates import fallback_insight
 from evalshift_cli.reports.economics import PromptEconomics
 from evalshift_cli.runner.models import Call
 from tests.unit.insights_factories import (
     COST_TARGET,
+    SEVERITY_REASON,
     budgets,
     comparisons,
+    converter_decision,
     decision,
     records,
     role,
+    slice_invariant_decision,
     unmeasured_budget,
     unmeasured_comparison,
 )
@@ -677,3 +691,160 @@ def test_the_critical_count_reads_the_blocking_regressions(sample_run: dict[str,
     facts = build_facts(**sample_run)
     assert facts.rendered["critical_regressions"] == "1"
     assert "1 blocking regression (1 critical)" in fallback_insight(facts).verdict_summary
+
+
+# ---------------------------------------------------------------------------
+# Budget status and the decision's reason — what a FAIL's cause is read from
+# ---------------------------------------------------------------------------
+
+
+def _status_of(facts_statuses: list[tuple[str, str, str]], label: str) -> tuple[str, str]:
+    (hit,) = [(limit, status) for name, limit, status in facts_statuses if name == label]
+    return hit
+
+
+def test_every_gating_budget_carries_a_status(sample_run: dict[str, Any]) -> None:
+    """The converter run: one breached, one blind, the rest held."""
+    sample_run["decision"] = converter_decision()
+    facts = build_facts(**sample_run)
+
+    assert len(facts.budget_statuses) == 8
+    assert _status_of(facts.budget_statuses, "Latency increase") == ("+30%", BUDGET_BREACHED)
+    assert _status_of(facts.budget_statuses, "Trace-rule violations") == ("1", BUDGET_WITHIN)
+    assert _status_of(facts.budget_statuses, "Cost increase") == ("+200%", BUDGET_WITHIN)
+    assert _status_of(facts.budget_statuses, "Tool-selection divergence") == (
+        "20%",
+        BUDGET_UNMEASURED,
+    )
+    assert facts.failed_budgets == ["Latency increase"]
+
+
+def test_an_unconfirmed_breach_has_its_own_status(sample_run: dict[str, Any]) -> None:
+    over = BudgetResult(
+        name="max_overall_regression_rate",
+        observed=0.1,
+        allowed=0.03,
+        passed=False,
+        conclusive=False,
+        ci_low=0.0,
+        ci_high=0.3,
+    )
+    sample_run["decision"] = decision(verdict="inconclusive", budget_results=[over, *budgets()[1:]])
+    facts = build_facts(**sample_run)
+    assert _status_of(facts.budget_statuses, "Overall regression rate") == (
+        "3%",
+        BUDGET_UNCONFIRMED,
+    )
+    assert facts.failed_budgets == []
+
+
+def test_a_slice_budget_is_listed_under_its_scope(sample_run: dict[str, Any]) -> None:
+    """A slice row is a gating budget too, and its limit is a copyable figure."""
+    # A slice limit no overall figure shares, so only the status lines can
+    # have admitted it to the allow-list.
+    policy = MigrationPolicy(
+        max_overall_regression_rate=0.5,
+        min_equivalence_rate=0.0,
+        slices={"security": SliceMigrationPolicy(max_overall_regression_rate=0.07)},
+    )
+    facts = build_facts(**_slice_budget_run(sample_run, extra=[], policy=policy))
+    assert _status_of(facts.budget_statuses, "'security' slice overall regression rate") == (
+        "7%",
+        BUDGET_BREACHED,
+    )
+    assert "7%" not in facts.budget_limits.values()
+    assert {"7%", "7"} <= facts.allowed_numbers
+
+
+def test_the_decision_reason_travels_with_the_facts(sample_run: dict[str, Any]) -> None:
+    sample_run["decision"] = replace(decision(verdict="fail"), reason=SEVERITY_REASON)
+    facts = build_facts(**sample_run)
+    assert facts.verdict_reason == SEVERITY_REASON
+    # Its figures are facts the model may copy.
+    assert {"-2.15", "2.15", "0.0004"} <= facts.allowed_numbers
+
+
+def test_a_decision_without_a_reason_renders_none(sample_run: dict[str, Any]) -> None:
+    assert build_facts(**sample_run).verdict_reason == ""
+
+
+def test_a_trace_rule_reason_reaches_the_facts_without_its_config_key(
+    sample_run: dict[str, Any],
+) -> None:
+    """The policy quotes ``migration_policy.max_invariant_violations``; the facts must not.
+
+    The reason lands in a copy-verbatim block, and that key is a banned
+    identifier — a faithful copy would be rejected on exactly these runs.
+    """
+    breach = BudgetResult(
+        name="max_invariant_violations", observed=2.0, allowed=1.0, passed=False, denominator=10
+    )
+    sample_run["decision"] = replace(decision(verdict="fail"), reason=_invariant_reason([breach]))
+    facts = build_facts(**sample_run)
+
+    assert "the trace-rule violations budget" in facts.verdict_reason
+    assert "migration_policy." not in facts.verdict_reason
+    assert not [t for t in banned_identifiers(facts) if t in facts.verdict_reason]
+    assert {"2", "10", "1"} <= facts.allowed_numbers
+
+
+def test_a_slice_trace_rule_reason_names_the_slice_budget_not_the_overall_one(
+    sample_run: dict[str, Any],
+) -> None:
+    """The policy quotes the overall key beside the slice's limit; the facts must scope it.
+
+    Overall limit 5 held; the 'security' slice's 0 broke. Rewritten as "the
+    trace-rule violations budget", the reason pins the slice's 0 on the overall
+    row — the one the FACTS block marks ``within`` — and a summary that copies
+    the reason, as instructed, blames a budget that held.
+    """
+    sample_run["decision"] = slice_invariant_decision()
+    facts = build_facts(**sample_run)
+
+    assert (
+        "in the 'security' slice, over the 0 allowed by the 'security' slice "
+        "trace-rule violations budget." in facts.verdict_reason
+    )
+    assert "allowed by the trace-rule violations budget" not in facts.verdict_reason
+    assert "migration_policy." not in facts.verdict_reason
+    # Exactly the label the FACTS block lists the slice row under.
+    assert "'security' slice trace-rule violations" in facts.failed_budgets
+    assert ("Trace-rule violations", "5", BUDGET_WITHIN) in facts.budget_statuses
+
+
+def test_a_slice_whose_name_has_an_apostrophe_keeps_its_scoped_budget(
+    sample_run: dict[str, Any],
+) -> None:
+    """The scope is read up to "' slice, over", not up to the first quote.
+
+    Stopping at the first quote, scope "o'brien" fell back to the overall
+    wording and pinned the slice's limit on the overall row.
+    """
+    row = BudgetResult(
+        name="max_invariant_violations",
+        observed=1.0,
+        allowed=0.0,
+        passed=False,
+        scope="o'brien",
+        denominator=4,
+    )
+    sample_run["decision"] = replace(decision(verdict="fail"), reason=_invariant_reason([row]))
+    facts = build_facts(**sample_run)
+
+    assert f"{_scoped_budget_label(row)} budget" in facts.verdict_reason
+    assert "'o'brien' slice trace-rule violations budget" in facts.verdict_reason
+    assert "allowed by the trace-rule violations budget" not in facts.verdict_reason
+    assert "migration_policy." not in facts.verdict_reason
+
+
+def test_a_dropped_params_reason_reaches_the_facts_in_plain_words(
+    sample_run: dict[str, Any],
+) -> None:
+    """Config vocabulary is not banned, so it would otherwise ship to readers."""
+    reason = _dropped_params_reason({"anthropic/claude-sonnet-5-5": ["temperature"]})
+    sample_run["decision"] = replace(decision(verdict="fail"), reason=reason)
+    facts = build_facts(**sample_run)
+
+    assert "migration_policy." not in facts.verdict_reason
+    assert "drop_params" not in facts.verdict_reason
+    assert "anthropic/claude-sonnet-5-5 dropped temperature" in facts.verdict_reason
diff --git a/tests/unit/test_insight_generator.py b/tests/unit/test_insight_generator.py
index 30ad1a9..3e538e8 100644
--- a/tests/unit/test_insight_generator.py
+++ b/tests/unit/test_insight_generator.py
@@ -8,18 +8,27 @@
 from __future__ import annotations
 
 import json
+from dataclasses import replace
 from typing import Any, cast
 
 import pytest
 
-from evalshift_cli.analysis.policy import BlockingRegression, FailureCategoryCount
+from evalshift_cli.analysis.policy import (
+    BlockingRegression,
+    BudgetResult,
+    FailureCategoryCount,
+    SliceDecision,
+)
 from evalshift_cli.insights.facts import Facts, build_facts
-from evalshift_cli.insights.generator import generate_insight, validate_numbers
+from evalshift_cli.insights.generator import generate_insight, validate_blame, validate_numbers
 from evalshift_cli.models.client import ModelClient
 from tests.unit.insights_factories import (
+    SEVERITY_REASON,
     FakeModelClient,
     budgets,
+    converter_decision,
     decision,
+    slice_invariant_decision,
     unmeasured_budget,
     unmeasured_comparison,
 )
@@ -421,7 +430,7 @@ async def test_the_prompt_names_the_blocking_evaluators_and_failure_categories(
     # Categories and budgets reach the model already humanised, so the tokens
     # it can copy into prose are the ones a reader may see.
     assert 'failure_category "Missing field": 15' in prompt
-    assert 'budget "Cost increase": +200%' in prompt
+    assert 'budget "Cost increase": limit +200%, within' in prompt
     assert "failure_category.missing_field" not in prompt
     assert "max_cost_increase" not in prompt
 
@@ -516,3 +525,646 @@ async def test_a_fully_measured_run_carries_no_coverage_facts(
     assert "\nunmeasured_budgets: " not in prompt
     assert "\nunmeasured_evaluators: " not in prompt
     assert "\ncoverage_basis: " not in prompt
+
+
+# ---------------------------------------------------------------------------
+# A FAIL's cause is a fact, not an inference
+# ---------------------------------------------------------------------------
+
+
+async def test_each_budget_line_carries_its_status(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    """The converter run: the model is told which budget broke and which held.
+
+    The shipped narrative blamed "Trace-rule violations" because every budget
+    line read as a bare limit — nothing said which one the run had failed on.
+    """
+    sample_run["decision"] = converter_decision()
+    fake_client.queue_responses(_payload())
+    await _generate(build_facts(**sample_run), fake_client)
+
+    prompt = fake_client.prompts[0]
+    assert '\nbudget "Latency increase": limit +30%, breached\n' in prompt
+    assert '\nbudget "Trace-rule violations": limit 1, within\n' in prompt
+    assert '\nbudget "Tool-selection divergence": limit 20%, measured nothing\n' in prompt
+    assert "\nfailed_budgets: Latency increase\n" in prompt
+
+
+async def test_a_passing_run_lists_no_failed_budgets_and_no_reason(
+    fake_client: FakeModelClient, sample_facts: Facts
+) -> None:
+    fake_client.queue_responses(_payload())
+    await _generate(sample_facts, fake_client)
+
+    prompt = fake_client.prompts[0]
+    assert "\nfailed_budgets: " not in prompt
+    assert "\nverdict_reason: " not in prompt
+    assert '\nbudget "Cost increase": limit +200%, within\n' in prompt
+
+
+async def test_the_verdict_reason_reaches_the_prompt(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    sample_run["decision"] = replace(decision(verdict="fail"), reason=SEVERITY_REASON)
+    fake_client.queue_responses(_payload())
+    await _generate(build_facts(**sample_run), fake_client)
+
+    assert f"\nverdict_reason: {SEVERITY_REASON}\n" in fake_client.prompts[0]
+
+
+async def test_a_copied_reason_figure_is_not_an_invented_number(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    """The reason's own figures are facts; copying them must not cost a retry."""
+    sample_run["decision"] = replace(decision(verdict="fail"), reason=SEVERITY_REASON)
+    fake_client.queue_responses(
+        _payload(verdict_summary="semantic.cosine regressed with effect size -2.15 (p 0.0004).")
+    )
+    insight = await _generate(build_facts(**sample_run), fake_client)
+
+    assert insight.verdict_summary.endswith("(p 0.0004).")
+    assert fake_client.call_count == 1
+
+
+async def test_the_instruction_rules_on_budget_status(
+    fake_client: FakeModelClient, sample_facts: Facts
+) -> None:
+    """A plain-English accusation carries no digit; the rule has to be spelled out."""
+    fake_client.queue_responses(_payload())
+    await _generate(sample_facts, fake_client)
+
+    instruction = fake_client.prompts[0].split("FACTS (")[0]
+    assert '"breached"' in instruction
+    assert '"within"' in instruction
+    assert "failed_budgets" in instruction
+    assert "verdict_reason" in instruction
+
+
+async def test_an_echoed_failed_budgets_key_is_rejected_and_retried(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    sample_run["decision"] = converter_decision()
+    fake_client.queue_responses(
+        _payload(verdict_summary="failed_budgets: Latency increase."),
+        _payload(verdict_summary="The latency ceiling of +30% was exceeded."),
+    )
+    insight = await _generate(build_facts(**sample_run), fake_client)
+
+    assert insight.verdict_summary == "The latency ceiling of +30% was exceeded."
+    assert fake_client.call_count == 2
+
+
+# ---------------------------------------------------------------------------
+# The blame validator
+# ---------------------------------------------------------------------------
+
+_HELD = ["Trace-rule violations", "Cost increase"]
+
+
+def test_blame_catches_the_shipped_sentence() -> None:
+    text = (
+        "The migration failed because the target model exceeded the latency ceiling "
+        "of +30% and failed to meet the budget for Trace-rule violations."
+    )
+    assert validate_blame(text, _HELD) == ["Trace-rule violations"]
+
+
+def test_blame_catches_advice_to_address_a_held_budget() -> None:
+    text = (
+        "Investigate the cause of the latency increase and address the Trace-rule "
+        "violations before re-evaluating."
+    )
+    assert validate_blame(text, _HELD) == ["Trace-rule violations"]
+
+
+def test_a_held_budget_may_be_called_within() -> None:
+    assert validate_blame("Trace-rule violations stayed within budget.", _HELD) == []
+
+
+def test_a_contrast_clause_separates_the_blame() -> None:
+    text = "Latency increase was exceeded while Trace-rule violations stayed within budget."
+    assert validate_blame(text, _HELD) == []
+
+
+def test_a_sentence_boundary_separates_the_blame() -> None:
+    text = "The latency ceiling was exceeded. Trace-rule violations and Cost increase held."
+    assert validate_blame(text, _HELD) == []
+
+
+def test_a_negated_blame_is_not_blame() -> None:
+    assert validate_blame("The Trace-rule violations budget was not breached.", _HELD) == []
+    assert validate_blame("No breach of Cost increase was observed.", _HELD) == []
+
+
+def test_blame_matches_case_and_hyphen_variants() -> None:
+    assert validate_blame("the run failed on trace rule violations", _HELD) == [
+        "Trace-rule violations"
+    ]
+
+
+def test_a_budget_not_in_the_held_list_may_be_blamed() -> None:
+    assert validate_blame("Latency increase was breached.", _HELD) == []
+
+
+def test_every_misblamed_budget_is_returned_once_in_list_order() -> None:
+    text = (
+        "Cost increase was exceeded and Trace-rule violations were violated; Cost increase failed."
+    )
+    assert validate_blame(text, _HELD) == ["Trace-rule violations", "Cost increase"]
+
+
+def test_a_breached_slice_label_does_not_accuse_its_held_overall_row() -> None:
+    """The slice label contains the overall one; the longer match owns its span."""
+    held = ["Cost increase"]
+    others = ["'checkout' slice cost increase"]
+    assert (
+        validate_blame(
+            "The 'checkout' slice cost increase budget was breached.", held, others=others
+        )
+        == []
+    )
+    assert (
+        validate_blame(
+            "The run failed because the 'checkout' slice cost increase exceeded its +10% limit.",
+            held,
+            others=others,
+        )
+        == []
+    )
+
+
+def test_a_breached_label_with_a_blame_word_does_not_accuse_its_neighbour() -> None:
+    """ "violations" is part of a label, not an accusation, once the label is masked.
+
+    The bare "and" keeps both labels in one clause, so the masking alone saves
+    it — without ``others`` the same sentence accuses "Cost increase". The
+    held label carries no holding word here, so nothing but the masking can
+    clear it ("stayed inside its limit" would, on its own).
+    """
+    text = "Trace-rule violations rose to 3 and cost increase came in at +102%."
+    assert validate_blame(text, ["Cost increase"], others=["Trace-rule violations"]) == []
+    assert validate_blame(text, ["Cost increase"]) == ["Cost increase"]
+    # The original sentence, which a holding word now clears even unmasked.
+    text = "Trace-rule violations rose to 3 and cost increase stayed inside its limit."
+    assert validate_blame(text, ["Cost increase"], others=["Trace-rule violations"]) == []
+    assert validate_blame(text, ["Cost increase"]) == []
+
+
+def test_a_slice_label_matches_whatever_quotes_the_model_used() -> None:
+    """The model may drop the slice's quotes or swap them; the slice still owns its span."""
+    others = ["'checkout' slice cost increase"]
+    for text in (
+        "The checkout slice cost increase budget was breached.",
+        "The \u2018checkout\u2019 slice cost increase budget was breached.",
+        'The "checkout" slice cost increase budget was breached.',
+    ):
+        assert validate_blame(text, ["Cost increase"], others=others) == [], text
+
+
+def test_the_retry_hints_own_phrasing_is_not_blame() -> None:
+    """The hint invites "within policy"; a reply phrased that way must pass."""
+    text = (
+        "The run failed because latency exceeded its ceiling, with Cost increase and "
+        "Trace-rule violations within policy."
+    )
+    assert validate_blame(text, _HELD) == []
+
+
+def test_a_dash_or_however_separates_the_blame() -> None:
+    assert validate_blame("Latency breached its ceiling — Cost increase held.", _HELD) == []
+    assert validate_blame("Latency was exceeded, however, Cost increase held.", _HELD) == []
+
+
+def test_over_or_above_the_source_is_a_comparison_not_blame() -> None:
+    """ "over the" alone measures against the source model; only a limit noun accuses."""
+    for text in (
+        "Cost increase was +102% over the source, within its +200% limit.",
+        "Cost increase came in at +102% over the source model, inside the +200% budget.",
+        "Cost increase of +102% above the source stayed within the +200% ceiling.",
+    ):
+        assert validate_blame(text, _HELD) == [], text
+
+
+def test_over_or_above_a_limit_noun_is_blame() -> None:
+    assert validate_blame("Cost increase went over its budget.", _HELD) == ["Cost increase"]
+    assert validate_blame("Cost increase was above the ceiling.", _HELD) == ["Cost increase"]
+    assert validate_blame("Cost increase went beyond its +200% limit.", _HELD) == ["Cost increase"]
+
+
+def test_a_held_budget_that_stayed_within_is_excused_beside_a_run_level_failure() -> None:
+    """The run failed — on another budget; a holding word clears the held one."""
+    for text in (
+        "Despite Cost increase staying within its limit, the run failed on Latency increase.",
+        "The migration failed on Latency increase alone, as Cost increase and Trace-rule "
+        "violations all stayed within budget.",
+        "Do not migrate until the latency regression is addressed and Cost increase remains "
+        "within its limit.",
+    ):
+        assert validate_blame(text, _HELD, others=["Latency increase"]) == [], text
+        assert validate_blame(text, _HELD) == [], text
+
+
+def test_a_negated_mention_of_a_held_budget_is_excused() -> None:
+    text = (
+        "The run failed only because of Latency increase, not Cost increase or "
+        "Trace-rule violations."
+    )
+    assert validate_blame(text, _HELD, others=["Latency increase"]) == []
+    assert validate_blame(text, _HELD) == []
+
+
+def test_a_blame_word_before_the_holding_word_still_accuses() -> None:
+    """The holding word excuses only a label it describes unaccused."""
+    text = "Cost increase exceeded its limit and stayed within budget."
+    assert validate_blame(text, _HELD) == ["Cost increase"]
+
+
+def test_a_negated_holding_word_does_not_excuse() -> None:
+    """ "not within" is the accusation, not the excuse."""
+    text = "Cost increase was not within budget, it was exceeded."
+    assert validate_blame(text, _HELD) == ["Cost increase"]
+
+
+def test_another_budgets_holding_word_does_not_excuse() -> None:
+    """ "stayed within" belongs to the label it follows, not to one further back."""
+    text = "The run failed on Cost increase as Latency increase stayed within its ceiling."
+    assert validate_blame(text, _HELD, others=["Latency increase"]) == ["Cost increase"]
+
+
+def test_each_occurrence_is_judged_on_its_own() -> None:
+    """One excused mention does not clear an accusing one in the same clause."""
+    text = (
+        "Cost increase stayed within its limit at first and the run failed because "
+        "Cost increase was exceeded."
+    )
+    assert validate_blame(text, _HELD) == ["Cost increase"]
+
+
+def test_a_holding_verb_without_a_limit_phrase_does_not_excuse() -> None:
+    """A verb alone says nothing held: "remained above the limit" is the accusation.
+
+    Only a limit-relative phrase counts — "within", "inside/under/below the
+    … limit", or a bare "held"/"holds"/"passed" that ends its clause.
+    """
+    for text in (
+        "Cost increase remained above the +200% limit.",
+        "Cost increase remains over its budget.",
+        "Cost increase stayed above its ceiling, failing the run.",
+        "Cost increase held at +250%, exceeding its limit.",
+        "Cost increase held steady and breached the ceiling.",
+        "Cost increase passed the +200% limit, failing the run.",
+        "The run failed because Cost increase, which held for most prompts, exceeded its limit.",
+    ):
+        assert validate_blame(text, _HELD, others=["Latency increase"]) == ["Cost increase"], text
+        assert validate_blame(text, _HELD) == ["Cost increase"], text
+
+
+def test_under_or_inside_something_other_than_a_limit_does_not_excuse() -> None:
+    """ "under the target model" places the label; it does not say the budget held."""
+    for text in (
+        "Cost increase under the target model breached its ceiling.",
+        "Cost increase, under the target model, breached its ceiling.",
+        "Cost increase inside the checkout flow exceeded its limit.",
+    ):
+        assert validate_blame(text, _HELD, others=["Latency increase"]) == ["Cost increase"], text
+        assert validate_blame(text, _HELD) == ["Cost increase"], text
+
+
+def test_a_limit_relative_phrase_still_excuses() -> None:
+    for text in (
+        "The latency ceiling of +30% was exceeded; Trace-rule violations stayed within budget.",
+        "Despite Cost increase staying below its +200% limit, the run failed on Latency increase.",
+        "Despite Cost increase staying under the ceiling, the run failed on Latency increase.",
+        "The run failed on Latency increase as Cost increase held.",
+        "The run failed on Latency increase as Trace-rule violations passed.",
+    ):
+        assert validate_blame(text, _HELD, others=["Latency increase"]) == [], text
+        assert validate_blame(text, _HELD) == [], text
+
+
+def test_accepted_gaps_a_holding_phrase_before_a_later_accusation() -> None:
+    """Known misses: the holding phrase excuses the label it follows, and the
+    scan cannot tell that a blame word after it has the same subject — "the run
+    failed on Latency increase" after "staying within its limit" must stay
+    clean, and nothing in the words separates the two. These assert today's
+    result; a design that catches them should flip them to ["Cost increase"].
+    """
+    # Accepted gap: should ideally be ["Cost increase"].
+    assert (
+        validate_blame("Cost increase stayed within budget at first, then exceeded it.", _HELD)
+        == []
+    )
+    # Accepted gap: should ideally be ["Cost increase"].
+    assert validate_blame("Address Cost increase so it stays within budget.", _HELD) == []
+    # Accepted gaps: "below the ceiling" is a limit phrase, so it excuses the
+    # label before it even when the words after it say something else held
+    # the ceiling ("the target's") or held it only in part ("on 3 prompts").
+    # Should ideally be ["Cost increase"].
+    assert (
+        validate_blame("Cost increase, below the ceiling on 3 prompts, failed on the rest.", _HELD)
+        == []
+    )
+    # Accepted gap: should ideally be ["Cost increase"].
+    assert validate_blame("Cost increase below the target's ceiling failed the run.", _HELD) == []
+
+
+def test_within_says_nothing_held_unless_a_limit_follows() -> None:
+    """ "within" places the label in time or scope just as easily as under a limit."""
+    for text in (
+        "Cost increase within the checkout flow exceeded its limit.",
+        "Cost increase, within hours, broke its ceiling.",
+        "Cost increase was within reach of its limit before it broke.",
+        "Cost increase was within +250% of its limit, which it exceeded.",
+        "Address Cost increase within the next sprint.",
+    ):
+        assert validate_blame(text, _HELD, others=["Latency increase"]) == ["Cost increase"], text
+        assert validate_blame(text, _HELD) == ["Cost increase"], text
+
+
+def test_within_a_slice_is_not_a_limit() -> None:
+    """Ambiguous: "within the security slice" may scope the budget rather than
+    clear it. The rule reads no limit noun after "within", so the blame word
+    accuses — pinned as the rule's result, not as a judgement on the sentence.
+    """
+    text = "Cost increase within the security slice breached its ceiling."
+    assert validate_blame(text, _HELD) == ["Cost increase"]
+
+
+def test_a_limit_phrase_may_be_plural_their_bare_or_two_words_long() -> None:
+    for text in (
+        "The run failed on Latency increase, and Cost increase and Trace-rule violations "
+        "stayed under their limits.",
+        "Latency increase broke its ceiling and Cost increase stayed under the +200% cost limit.",
+        "The run failed because Latency increase exceeded its ceiling, with Cost increase and "
+        "Trace-rule violations within policy.",
+        "The run failed on Latency increase as Cost increase stayed within budget.",
+        "The run failed on Latency increase as Cost increase stayed below their limits.",
+    ):
+        assert validate_blame(text, _HELD, others=["Latency increase"]) == [], text
+        assert validate_blame(text, _HELD) == [], text
+
+
+def test_over_a_bare_or_their_limit_noun_is_blame() -> None:
+    """The limit phrase is shared, so the blame side widens with the holding side."""
+    assert validate_blame("Cost increase went over budget.", _HELD) == ["Cost increase"]
+    assert validate_blame("Cost increase went over their limits.", _HELD) == ["Cost increase"]
+    assert validate_blame("Cost increase went over the +200% cost limit.", _HELD) == [
+        "Cost increase"
+    ]
+
+
+def test_a_negation_before_a_label_used_as_a_modifier_does_not_excuse() -> None:
+    """ "no Cost increase headroom" negates the headroom, not the budget's blame."""
+    for text in (
+        "Without Cost increase under control, the run failed.",
+        "The run failed with no Cost increase headroom left.",
+        "The run failed and no Cost increase margin remained.",
+    ):
+        assert validate_blame(text, _HELD, others=["Latency increase"]) == ["Cost increase"], text
+        assert validate_blame(text, _HELD) == ["Cost increase"], text
+
+
+def test_a_negated_chain_of_labels_is_excused_only_when_it_stands_alone() -> None:
+    clean = (
+        "The run failed on Latency increase, not Cost increase, as the target slowed down.",
+        "The run failed on Latency increase and not Cost increase and Trace-rule violations.",
+        "The run failed on Latency increase, not Cost increase nor Trace-rule violations, "
+        "as the target slowed down.",
+    )
+    for text in clean:
+        assert validate_blame(text, _HELD, others=["Latency increase"]) == [], text
+    # The chain ends on a noun it modifies: the last label is not standing alone.
+    text = "The run failed with no Cost increase or Trace-rule violations headroom left."
+    assert validate_blame(text, _HELD) == ["Trace-rule violations", "Cost increase"]
+
+
+# ---------------------------------------------------------------------------
+# Blame in a generation: retry with the labels named, then the template
+# ---------------------------------------------------------------------------
+
+_SHIPPED_SUMMARY = (
+    "The migration failed because the target model exceeded the latency ceiling of "
+    "+30% and failed to meet the budget for Trace-rule violations."
+)
+
+
+async def test_a_fail_that_blames_a_held_budget_is_rejected_and_retried(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    sample_run["decision"] = converter_decision()
+    fake_client.queue_responses(
+        _payload(verdict_summary=_SHIPPED_SUMMARY),
+        _payload(verdict_summary="The migration failed because the latency ceiling was exceeded."),
+    )
+    insight = await _generate(build_facts(**sample_run), fake_client)
+
+    assert insight.verdict_summary.endswith("latency ceiling was exceeded.")
+    assert fake_client.call_count == 2
+    assert (
+        "Your previous answer blamed budgets that held: Trace-rule violations."
+        in fake_client.prompts[1]
+    )
+
+
+async def test_the_misblame_hint_points_at_failed_budgets_when_one_was_breached(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    sample_run["decision"] = converter_decision()
+    fake_client.queue_responses(_payload(verdict_summary=_SHIPPED_SUMMARY), _payload())
+    await _generate(build_facts(**sample_run), fake_client)
+
+    assert (
+        "Your previous answer blamed budgets that held: Trace-rule violations. Only the "
+        "budgets under failed_budgets were breached; a budget marked within may be "
+        "described as within policy or left out, never as a cause of the verdict or as "
+        "something to address." in fake_client.prompts[1]
+    )
+
+
+async def test_the_misblame_hint_says_no_budget_broke_on_a_severity_only_fail(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    """No budget was breached, so there is no failed_budgets line to point at."""
+    sample_run["decision"] = replace(decision(verdict="fail"), reason=SEVERITY_REASON)
+    facts = build_facts(**sample_run)
+    assert facts.failed_budgets == []
+    fake_client.queue_responses(
+        _payload(verdict_summary="The run failed because Cost increase was exceeded."),
+        _payload(verdict_summary="semantic.cosine regressed at critical severity."),
+    )
+    await _generate(facts, fake_client)
+
+    retry = fake_client.prompts[1]
+    assert (
+        "Your previous answer blamed budgets that held: Cost increase. No budget was "
+        "breached; a budget marked within may be described as within policy or left out, "
+        "never as a cause of the verdict or as something to address." in retry
+    )
+    assert "failed_budgets" not in retry.split("FACTS (")[1]
+
+
+async def test_a_misblaming_recommendation_is_rejected(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    sample_run["decision"] = converter_decision()
+    fake_client.queue_responses(
+        _payload(recommendation="Address the Trace-rule violations before re-evaluating."),
+        _payload(recommendation="Bring latency back under the ceiling, then re-run."),
+    )
+    insight = await _generate(build_facts(**sample_run), fake_client)
+
+    assert insight.recommendation == "Bring latency back under the ceiling, then re-run."
+    assert fake_client.call_count == 2
+
+
+async def test_two_misblaming_generations_fall_back_to_the_template(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    """The template already names the breached budget, so it is the safe floor."""
+    sample_run["decision"] = converter_decision()
+    bad = _payload(recommendation="Address the Trace-rule violations before re-evaluating.")
+    fake_client.queue_responses(bad, bad)
+    insight = await _generate(build_facts(**sample_run), fake_client)
+
+    assert insight.model == "none"
+    assert insight.recommendation.startswith(
+        "Do not migrate under the configured policy — the latency increase budget was breached."
+    )
+
+
+async def test_a_fail_may_mention_a_held_budget_without_blaming_it(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    sample_run["decision"] = converter_decision()
+    fake_client.queue_responses(
+        _payload(
+            verdict_summary=(
+                "The latency ceiling of +30% was exceeded; Trace-rule violations stayed "
+                "within budget."
+            )
+        )
+    )
+    await _generate(build_facts(**sample_run), fake_client)
+
+    assert fake_client.call_count == 1
+
+
+async def test_a_fail_that_clears_the_held_budgets_by_name_ships_first_time(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    """A run-level "failed" beside held budgets that "stayed within" is not an accusation.
+
+    Rejected twice, a faithful narrative like this one shipped the templated
+    prose — which carries no findings.
+    """
+    sample_run["decision"] = converter_decision()
+    fake_client.queue_responses(
+        _payload(
+            verdict_summary=(
+                "The migration failed on Latency increase alone, as Cost increase and "
+                "Trace-rule violations all stayed within budget."
+            ),
+            recommendation=(
+                "Do not migrate until the latency regression is addressed and Cost "
+                "increase remains within its limit."
+            ),
+        )
+    )
+    insight = await _generate(build_facts(**sample_run), fake_client)
+
+    assert fake_client.call_count == 1
+    assert insight.model == "m"
+
+
+async def test_blame_is_not_checked_outside_a_fail(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    """The scan is scoped to a FAIL (Global Constraints): only a FAIL assigns a cause.
+
+    The sentence is false on a pass, but it accuses no budget of failing a
+    run that did not fail; the scope is pinned here so widening it is a
+    deliberate change.
+    """
+    fake_client.queue_responses(
+        _payload(verdict_summary="PASS although the Cost increase budget was exceeded.")
+    )
+    await _generate(build_facts(**sample_run), fake_client)
+
+    assert fake_client.call_count == 1
+
+
+async def test_an_invented_number_and_a_misblame_are_both_named_on_retry(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    sample_run["decision"] = converter_decision()
+    fake_client.queue_responses(
+        _payload(verdict_summary=_SHIPPED_SUMMARY, economics_summary="Cost rose +43%."),
+        _payload(),
+    )
+    await _generate(build_facts(**sample_run), fake_client)
+
+    retry = fake_client.prompts[1]
+    assert "+43%" in retry
+    assert "blamed budgets that held: Trace-rule violations" in retry
+
+
+async def test_a_slice_budget_fail_may_name_the_breached_slice_budget(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    """The overall "Cost increase" held; its 'checkout' slice row broke.
+
+    The slice label contains the held overall one, so a substring match would
+    accuse the overall row in every run a slice budget failed.
+    """
+    base = decision(verdict="fail")
+    slice_row = BudgetResult(
+        name="max_cost_increase", observed=1.02, allowed=0.10, passed=False, scope="checkout"
+    )
+    sample_run["decision"] = replace(
+        base,
+        slices={
+            "checkout": SliceDecision(
+                name="checkout", verdict="fail", metrics=base.overall, budget_results=[slice_row]
+            )
+        },
+    )
+    facts = build_facts(**sample_run)
+    assert facts.failed_budgets == ["'checkout' slice cost increase"]
+    fake_client.queue_responses(
+        _payload(
+            verdict_summary=(
+                "The run failed because the 'checkout' slice cost increase exceeded its +10% limit."
+            ),
+            recommendation="Bring the 'checkout' slice cost increase under its limit.",
+        )
+    )
+    await _generate(facts, fake_client)
+
+    assert fake_client.call_count == 1
+
+
+async def test_a_summary_that_copies_a_slice_trace_rule_reason_ships_first_time(
+    fake_client: FakeModelClient, sample_run: dict[str, Any]
+) -> None:
+    """The instruction says the summary must agree with ``verdict_reason``; copying it is safe.
+
+    The overall trace-rule budget held at 5 and only the 'security' slice's 0
+    broke. A reason that pinned the slice's limit on the overall budget made
+    every faithful copy a misblame, and two of those ship no findings.
+    """
+    sample_run["decision"] = slice_invariant_decision()
+    facts = build_facts(**sample_run)
+    fake_client.queue_responses(
+        _payload(
+            verdict_summary=facts.verdict_reason,
+            recommendation=(
+                "Keep security on the source model until the 'security' slice "
+                "trace-rule violations budget holds."
+            ),
+        )
+    )
+    insight = await _generate(facts, fake_client)
+
+    assert fake_client.call_count == 1
+    assert insight.verdict_summary == facts.verdict_reason