diff --git a/docs/architecture.md b/docs/architecture.md
index 9979eea..6f6e6e8 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -190,8 +190,9 @@ The modules below live in the skill's [`scripts/`](../plugin/skills/behavior-dif
 - **Model-based interpretation:** `decisions.py` reads the task, trial actions,
   final answers, and numbered instruction-diff hunks. A separate model extracts
   choices with named trial assignments, a primary result, supported implications,
-  links to edits, plain-language Summary text, the edit's likely aim, and short
-  per-group trial summaries in the same call. New raw branches supply `trials`,
+  links to edits, plain-language Summary text, the edit's likely aim, short
+  per-group trial summaries, and an optional change explanation in the same call.
+  New raw branches supply `trials`,
   not aggregate counts. The script requires each completed trial exactly once
   per side of every row, derives `n`, and retains both in `decisions.json`.
   Foreign, duplicate, incomplete, or missing assignments invalidate the row.
@@ -215,9 +216,19 @@ The modules below live in the skill's [`scripts/`](../plugin/skills/behavior-dif
   validated inference whose stored diff matches the current instruction diff.
   `reporting/trial_summary.py` validates bounded plain-text trial summaries
   against exact positional record identities; duplicates and invalid entries
-  are omitted without losing raw evidence. Extraction and loading share
+  are omitted without losing raw evidence. `reporting/explanation.py` validates
+  the immutable middle-layer explanation: headline, overview, annotated
+  Before/After steps with practical meaning, unchanged claims, limits, and
+  optional exact final-answer excerpts. Step and claim citations are nonempty,
+  unique decision-row references, remapped when extraction sorts or drops rows.
+  Unchanged claims cannot cite diverging rows. Excerpts must be contiguous,
+  bounded text from the exact named trial on the declared side; formulas and
+  code retain their source formatting. Invalid optional extraction is omitted
+  without discarding valid comparisons. Canonical report-data parsing rejects
+  invalid persisted explanation data. Extraction and loading share
   `read_trial_trace` so they read the same source fields.
-  Together these modules build schema-v8 `ReportData` in `reporting/schema.py`.
+  Together these modules build schema-v9 `ReportData` in `reporting/schema.py`;
+  `decisions.explanation` is explicitly null when unavailable.
   Summary counts come from existing decision rows.
 
 Command flow comes from recorded events. Decision comparisons come from model
@@ -231,7 +242,7 @@ distinct. Links between decisions and edits do not prove causality.
 
 | Artifact | Purpose |
 | --- | --- |
-| `report.html` | Local browser report with Summary, Instruction changes, Behavior diff, Flow diff, and Trial evidence tabs. |
+| `report.html` | Local browser report with Summary, Understand the change, Behavior diff, Flow diff, Instruction changes, and Trial evidence tabs. |
 | `report.md` | Markdown version for reading and sharing after review. |
 | `report-data.json` | Structured, versioned report data. |
 | `report-artifact.html` | Embeddable HTML body. |
@@ -256,16 +267,31 @@ in its selected branch; counts or citations from other rows cannot supply member
 An instruction's gate is distinct from an observed gate, which may already appear
 in Before. These are extraction policies, not deterministic semantic guarantees;
 the existing validator checks references, choice coverage, and evidence anchors.
-No schema field or keyword-based semantic check is added; fallback ranking is unchanged.
+Explanation validation additionally checks bounded narrative, row citations,
+unchanged-row status, and exact example excerpts; it does not prove semantic
+interpretation truth. Summary fallback ranking is unchanged.
 Changed explanations, citations, or presentation must not be described as changed
 actions. When the selected lead is not the primary
 result, `content.primary_result_context` exposes the primary status and full
 distribution beside the cards in both formats. Missing or incomplete evidence
-cannot become an unchanged-result claim. This is derived presentation, not a
-new serialized report field; schema v8 is unchanged.
-The primary-result block is context, not a second navigation choice. One
-**View behavior comparisons** link opens Behavior diff for the selected
-comparison and the primary result; unavailable evidence links to trial records.
+cannot become an unchanged-result claim. The primary-result block remains
+derived presentation, not a separate serialized report field.
+The primary-result block is context, not a second navigation choice.
+**Understand the change**, under the Summary's evidence section, opens a new
+top-level explanation tab. This middle layer explains the specific distinction,
+its practical implications, important unchanged behavior, consistency and
+minorities, and concrete limits, with links to decision rows and named trials.
+Annotated Before/After steps support workflow timing, formulas/code, keep/delete,
+wording, and unchanged choices without assuming every change is a workflow.
+Timing is shown only when established by the evidence. Examples are selected
+exact excerpts, not raw transcript dumps. Both formats retain the same
+explanation and source links; only HTML adds the visual walkthrough.
+Behavior diff, Flow diff, Instruction changes, and Trial evidence remain
+separate top-level tabs. Unavailable explanations link to retained evidence
+instead of inferring a no-difference claim or making a new model call.
+Both explanation renderers reuse the Summary's completeness guard: blocked,
+missing, invalid, or dropped trial evidence withholds the saved interpretation
+and shows an explicit coverage notice while retaining evidence navigation.
 Plans are not presented as executions. `content.additional_findings` selects
 at most three compact comparisons; full comparisons stay in Behavior diff.
 Markdown shares the same story and findings without illustrations.
@@ -290,7 +316,7 @@ names blocks by section and line range. Selecting a block highlights only its
 changed lines and scrolls to its stable anchor. Missing or unparseable diffs
 do not acquire invented counts.
 
-All five tabs remain available. Missing extraction and uncaptured command flow
+All six tabs remain available. Missing extraction and uncaptured command flow
 have explicit unavailable states, with links to the retained trial evidence.
 Flow groups only identical complete command sequences within each side.
 Trial evidence aligns the saved Before/After lists by position into numbered
@@ -326,11 +352,11 @@ All output formats share `ReportData`. Only the HTML branch uses
 ```text
 +-----------------------------------------------------+
 | Saved run: configuration, grades, traces, snapshots |
-| Optional decisions.json                             |
+| Optional decisions.json (including explanation)    |
 +--------------------------+--------------------------+
                            |
                            v
-                     load_report()
+           load_report() + evidence validation
                            |
                            v
                     +------------+
diff --git a/plugin/skills/behavior-diff/scripts/decisions.py b/plugin/skills/behavior-diff/scripts/decisions.py
index 6b41071..a08f11c 100755
--- a/plugin/skills/behavior-diff/scripts/decisions.py
+++ b/plugin/skills/behavior-diff/scripts/decisions.py
@@ -48,6 +48,7 @@
 from dataclasses import asdict
 
 from codex_model import CodexModelError, resolve_codex_model
+from reporting.explanation import parse_explanation
 from reporting.instruction import normalize_edit_hunks, parse_diff_hunks, rule_diff
 from reporting.load import read_trial_trace
 from reporting.summary import parse_intent, parse_narrative
@@ -108,6 +109,29 @@
       "after": "<one short sentence about this after record, or empty if absent>",
       "caveat": "<optional concrete evidence limit, or empty>"}}
   ],
+  "explanation": {{
+    "headline": "<specific distinction, plain text, at most 120 characters>",
+    "overview": "<reader-oriented explanation, at most 600 characters>",
+    "steps": [
+      {{"title": "<the decision point, at most 120 characters>",
+        "before": "<what Before does or says, at most 480 characters>",
+        "after": "<what After does or says, at most 480 characters>",
+        "meaning": "<why this distinction matters, at most 480 characters>",
+        "decisions": [<1-based indexes of supporting chain rows>]}}
+    ],
+    "unchanged": [
+      {{"text": "<supported unchanged behavior, at most 480 characters>",
+        "decisions": [<1-based indexes of unchanged chain rows>]}}
+    ],
+    "limits": [
+      {{"text": "<consistency, minority, or evidence limit, at most 480 characters>",
+        "decisions": [<1-based indexes of supporting chain rows>]}}
+    ],
+    "examples": [
+      {{"side": "before"|"after", "trial": "<EXACT trial name on that side>",
+        "text": "<EXACT contiguous final-answer excerpt, at most 1200 characters>"}}
+    ]
+  }}|null,
   "summary": {{
     "decision": <1-based selected lead row index>,
     "headline": "<plain-language takeaway, at most 12 words>",
@@ -283,6 +307,43 @@
 - Keep "caveat" empty unless a concrete limit is needed to avoid misreading this
   specific group; do not repeat general interpretation disclaimers in every entry.
   Use [] if no faithful group summaries are available.
+- In the SAME reply, optionally provide "explanation", or null when the records
+  do not support a faithful interpretation. This is the middle layer between
+  the concise Summary and source evidence, not another comparison table or a
+  raw transcript dump. Explain the specific distinction and why it matters.
+- Use 1 to 8 annotated Before/After "steps" about the same decision point.
+  Explain the operative condition, timing, prerequisite, scope, formula, code,
+  keep/delete choice, or wording distinction actually shown by these records.
+  Use supported units, intervals, triggers, and exceptions; never invent a
+  timeline or make a timing diagram from command order. A step title may name a
+  time only when the evidence establishes that time. Do not force every change
+  into a workflow or treat wording alone as a changed action.
+- The "meaning" explains supported practical implications, not an automatic
+  success verdict. Preserve distinctions between stated plans, final-answer
+  assertions, self-reported actions, and recorded commands. No answer proves
+  execution or successful completion. Instruction edits do not prove observed
+  behavior, causality, author intent, or what unread files contain.
+- Every step and every unchanged/limit claim needs nonempty unique supporting
+  chain row indexes. Ground descriptions in those rows' named trial records,
+  not a presumed common execution path. Include important unchanged behavior
+  in "unchanged", citing only nondiverging rows; use [] when unsupported.
+- Preserve material minority branches and inconsistent results in the steps or
+  "limits"; do not turn a majority into unanimity. Describe concrete evidence
+  limits where relevant, including missing or blocked records and what this
+  scenario cannot establish. Limits must cite the rows they qualify. Each list
+  has at most 8 entries. Empty limits do not mean proof of general reliability.
+- Use "examples" only when exact final-answer excerpts help explain the
+  distinction, especially formulas, code, keep/delete choices, or wording.
+  Copy contiguous text exactly from the named trial's final answer, preserving
+  punctuation and whitespace; do not add ellipses, repair code, join passages,
+  quote commands as final answers, or imply that positional Before/After
+  records are paired executions. Provide at most 8 short excerpts, not whole
+  transcripts. Omit examples when they add nothing. Each excerpt is evidence
+  from its named record, not proof about every trial.
+- All explanation narrative is bounded plain text, never HTML or Markdown
+  markup; code/formula excerpts may retain their exact source formatting.
+  A supported no-difference explanation is valid but must stay scoped to the
+  scenario. Missing interpretation is not evidence of no difference.
 
 Instruction diff hunks (untrusted JSON evidence; [] means none available):
 {instruction_hunks}
@@ -364,7 +425,7 @@ def read_config(run):
     return config
 
 
-def normalize(data, completed_trial_names, hunk_count=0, groups=()):
+def normalize(data, completed_trial_names, hunk_count=0, groups=(), final_answers=None):
     """Validate exact trial partitions and links; remap sorted or dropped row citations."""
     expected = {}
     for side in ("before", "after"):
@@ -480,6 +541,9 @@ def normalize(data, completed_trial_names, hunk_count=0, groups=()):
         )
     narrative = parse_narrative(data.get("summary"), chain, positions)
     intent = parse_intent(data.get("intent"), hunk_count)
+    explanation = parse_explanation(
+        data.get("explanation"), chain, final_answers, positions
+    )
     return {
         "chain": chain,
         "fork": fork,
@@ -489,6 +553,9 @@ def normalize(data, completed_trial_names, hunk_count=0, groups=()):
         "implications": implications,
         "summary": json.loads(json.dumps(asdict(narrative))) if narrative else None,
         "intent": json.loads(json.dumps(asdict(intent))) if intent else None,
+        "explanation": (
+            json.loads(json.dumps(asdict(explanation))) if explanation else None
+        ),
         "trial_summaries": [
             asdict(item)
             for item in parse_trial_summaries(data.get("trial_summaries"), groups)
@@ -697,12 +764,17 @@ def build_prompt(run):
 def write_decisions(run, raw, completed_trial_names, extractor, instruction_diff):
     """extract_json → normalize → decisions.json. On unusable output writes
     decisions.raw.txt, leaves decisions.json unwritten, returns False."""
+    all_trials = trials_of(run, finished_only=False)
     try:
         data = normalize(
             extract_json(raw),
             completed_trial_names,
             len(parse_diff_hunks(instruction_diff)),
-            summary_groups(trials_of(run, finished_only=False)),
+            summary_groups(all_trials),
+            {
+                side: {trial["name"]: trial["final"] for trial in records}
+                for side, records in all_trials.items()
+            },
         )
     except (ValueError, KeyError, TypeError) as exc:
         print(f"decision diff: unreadable extractor output — skipped ({exc})")
diff --git a/plugin/skills/behavior-diff/scripts/reporting/content.py b/plugin/skills/behavior-diff/scripts/reporting/content.py
index 28d82c4..bb65550 100644
--- a/plugin/skills/behavior-diff/scripts/reporting/content.py
+++ b/plugin/skills/behavior-diff/scripts/reporting/content.py
@@ -401,6 +401,41 @@ def trial_summary_for_group(decisions, before, after):
     return matches[0] if len(matches) == 1 else None
 
 
+CHANGE_EXPLANATION_UNAVAILABLE = (
+    "A change explanation is unavailable in the saved evidence. "
+    "No new interpretation is generated when this report is opened. "
+    "Inspect the retained comparisons and trial records below."
+)
+
+CHANGE_EXPLANATION_INCOMPLETE = (
+    "Trial evidence is incomplete, blocked, invalid, or dropped. "
+    "The saved explanation is withheld because it cannot establish a complete "
+    "Before/After comparison. Inspect the retained comparisons and trial records."
+)
+
+
+def explanation_comparisons(report, indexes):
+    """Describe every saved branch, including minorities, without inferring counts."""
+    comparisons = []
+    for index in indexes:
+        row = report.decisions.rows[index - 1]
+        sides = []
+        for label, choices, total in (
+            ("Before", row.before, report.decisions.before_count),
+            ("After", row.after, report.decisions.after_count),
+        ):
+            branches = (
+                "; ".join(
+                    "{0} ({1})".format(choice.choice, trial_count(choice.count, total))
+                    for choice in choices
+                )
+                or NO_EXTRACTED_CHOICE
+            )
+            sides.append((label, branches))
+        comparisons.append((index, row.topic or row.decision, tuple(sides)))
+    return tuple(comparisons)
+
+
 def command_progressions(variant):
     """Group complete recorded sequences without normalizing or joining paths."""
     groups = {}
diff --git a/plugin/skills/behavior-diff/scripts/reporting/explanation.py b/plugin/skills/behavior-diff/scripts/reporting/explanation.py
new file mode 100644
index 0000000..3a7c579
--- /dev/null
+++ b/plugin/skills/behavior-diff/scripts/reporting/explanation.py
@@ -0,0 +1,151 @@
+"""Validate optional, evidence-linked explanations without generating new evidence."""
+
+import re
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Tuple
+
+if TYPE_CHECKING:
+    from reporting.schema import EvidenceClaimData
+
+
+@dataclass(frozen=True)
+class ExplanationStepData:
+    title: str
+    before: str
+    after: str
+    meaning: str
+    decisions: Tuple[int, ...]
+
+
+@dataclass(frozen=True)
+class ExplanationExampleData:
+    side: str
+    trial: str
+    text: str
+
+
+@dataclass(frozen=True)
+class ChangeExplanationData:
+    headline: str
+    overview: str
+    steps: Tuple[ExplanationStepData, ...]
+    unchanged: Tuple["EvidenceClaimData", ...]
+    limits: Tuple["EvidenceClaimData", ...]
+    examples: Tuple[ExplanationExampleData, ...]
+
+
+# Comparison operators and formula punctuation are plain text, not markup.
+_MARKUP = re.compile(
+    r"</?[A-Za-z][^>]*>|<!--|```|`|\*\*|__|\[[^\]]*\]\([^)]*\)|^\s{0,3}#{1,6}\s",
+    re.MULTILINE,
+)
+
+
+def _text(value, limit, excerpt=False):
+    if type(value) is not str or not value.strip() or len(value) > limit:
+        raise ValueError("invalid explanation text")
+    if any(
+        (ord(char) < 32 and (not excerpt or char not in "\n\t"))
+        or 127 <= ord(char) <= 159
+        for char in value
+    ):
+        raise ValueError("unsafe explanation control character")
+    if not excerpt and _MARKUP.search(value):
+        raise ValueError("explanation narrative must be plain text")
+    return value if excerpt else value.strip()
+
+
+def _items(raw, name, minimum=0):
+    values = raw[name]
+    if type(values) is not list or not minimum <= len(values) <= 8:
+        raise ValueError("invalid explanation list")
+    if any(type(value) is not dict for value in values):
+        raise ValueError("invalid explanation entry")
+    return values
+
+
+def _changed(row):
+    from reporting.content import choices_changed
+
+    # Extraction has already recomputed this flag; serialized report rows must
+    # be checked from their actual distributions rather than a supplied flag.
+    if type(row) is dict:
+        return row["diverges"]
+    return choices_changed(row.before, row.after)
+
+
+def _references(raw, positions):
+    refs = raw["decisions"]
+    if (
+        type(refs) is not list
+        or not refs
+        or any(type(ref) is not int or ref not in positions for ref in refs)
+        or len(set(refs)) != len(refs)
+    ):
+        raise ValueError("invalid explanation references")
+    return tuple(positions[ref] for ref in refs)
+
+
+def parse_explanation(raw, rows, final_answers, positions=None):
+    """Omit malformed interpretation; validate quotes against their named source.
+
+    ``final_answers`` maps side to exact trial name to the recorded final answer.
+    ``positions`` maps extractor row indexes to surviving, sorted row indexes.
+    An absent explanation is unavailable, not evidence of unchanged behavior.
+    """
+    from reporting.schema import EvidenceClaimData
+
+    if type(raw) is not dict:
+        return None
+    if positions is None:
+        positions = {index: index for index in range(1, len(rows) + 1)}
+    try:
+        steps = tuple(
+            ExplanationStepData(
+                _text(item["title"], 120),
+                _text(item["before"], 480),
+                _text(item["after"], 480),
+                _text(item["meaning"], 480),
+                _references(item, positions),
+            )
+            for item in _items(raw, "steps", minimum=1)
+        )
+        claims = {}
+        for name in ("unchanged", "limits"):
+            values = []
+            for item in _items(raw, name):
+                refs = _references(item, positions)
+                if name == "unchanged" and any(_changed(rows[ref - 1]) for ref in refs):
+                    raise ValueError("unchanged claim cites changed behavior")
+                values.append(EvidenceClaimData(_text(item["text"], 480), refs))
+            claims[name] = tuple(values)
+        examples = []
+        seen = set()
+        for item in _items(raw, "examples"):
+            side, trial = item["side"], item["trial"]
+            if (
+                type(side) is not str
+                or side not in ("before", "after")
+                or type(trial) is not str
+                or not trial.startswith(side + "-")
+                or type(final_answers) is not dict
+                or type(final_answers.get(side)) is not dict
+            ):
+                raise ValueError("invalid explanation example source")
+            final = final_answers[side].get(trial)
+            text = _text(item["text"], 1200, excerpt=True)
+            identity = (side, trial, text)
+            if type(final) is not str or text not in final or identity in seen:
+                raise ValueError("explanation example is not an exact final excerpt")
+            seen.add(identity)
+            examples.append(ExplanationExampleData(side, trial, text))
+        return ChangeExplanationData(
+            _text(raw["headline"], 120),
+            _text(raw["overview"], 600),
+            steps,
+            claims["unchanged"],
+            claims["limits"],
+            tuple(examples),
+        )
+    except (KeyError, TypeError, ValueError, IndexError):
+        return None
diff --git a/plugin/skills/behavior-diff/scripts/reporting/load.py b/plugin/skills/behavior-diff/scripts/reporting/load.py
index 05f7d20..21b0567 100644
--- a/plugin/skills/behavior-diff/scripts/reporting/load.py
+++ b/plugin/skills/behavior-diff/scripts/reporting/load.py
@@ -7,6 +7,7 @@
 from typing import Optional
 
 from reporting import content
+from reporting.explanation import parse_explanation
 from reporting.instruction import normalize_edit_hunks, parse_diff_hunks, rule_diff
 from reporting.schema import (
     SCHEMA_VERSION,
@@ -47,6 +48,10 @@ def load_report(
             (trial.name for trial in before.trials),
             (trial.name for trial in after.trials),
         ),
+        {
+            side: {trial.name: trial.final for trial in variant.trials}
+            for side, variant in (("before", before), ("after", after))
+        },
     )
     task = _task(run, capsule)
     report_content = content.build_content(
@@ -373,20 +378,24 @@ def _common_prefix(sequences):
     return tuple(prefix)
 
 
-def _read_decisions(run, before_default, after_default, instruction_diff, groups=()):
+def _read_decisions(
+    run, before_default, after_default, instruction_diff, groups=(), final_answers=None
+):
     path = run / "decisions.json"
     if not path.exists():
         return _empty_decisions(before_default, after_default)
     try:
         raw = json.loads(path.read_text())
         return _convert_decisions(
-            raw, before_default, after_default, instruction_diff, groups
+            raw, before_default, after_default, instruction_diff, groups, final_answers
         )
     except (TypeError, ValueError, KeyError):
         return _empty_decisions(before_default, after_default)
 
 
-def _convert_decisions(raw, before_default, after_default, instruction_diff, groups=()):
+def _convert_decisions(
+    raw, before_default, after_default, instruction_diff, groups=(), final_answers=None
+):
     if type(raw) is not dict or type(raw.get("chain")) is not list:
         raise ValueError("malformed decisions")
     counts = raw.get("counts", {})
@@ -451,6 +460,7 @@ def _convert_decisions(raw, before_default, after_default, instruction_diff, gro
         parse_narrative(raw.get("summary"), rows),
         parse_intent(raw.get("intent"), hunk_count),
         parse_trial_summaries(raw.get("trial_summaries"), groups),
+        parse_explanation(raw.get("explanation"), rows, final_answers),
     )
 
 
diff --git a/plugin/skills/behavior-diff/scripts/reporting/render_html.py b/plugin/skills/behavior-diff/scripts/reporting/render_html.py
index c879abd..0aa61b9 100644
--- a/plugin/skills/behavior-diff/scripts/reporting/render_html.py
+++ b/plugin/skills/behavior-diff/scripts/reporting/render_html.py
@@ -528,6 +528,98 @@ def _primary_result_context(report) -> str:
     )
 
 
+def _change_explanation(report: ReportData) -> str:
+    explanation = report.decisions.explanation
+    navigation = (
+        '<nav class="evidence-nav" aria-label="Change explanation evidence">'
+        '<a href="#panel-decision">View behavior comparisons</a>'
+        '<a href="#panel-flow">View recorded command flow</a>'
+        '<a href="#instruction-diff">View instruction changes</a>'
+        '<a href="#panel-trials">Inspect trial evidence</a></nav>'
+    )
+    complete = content.complete_trial_evidence(report)
+    if explanation is None or not complete:
+        notice = (
+            content.CHANGE_EXPLANATION_UNAVAILABLE
+            if complete
+            else content.CHANGE_EXPLANATION_INCOMPLETE
+        )
+        return (
+            "<h2>Understand the change</h2>"
+            '<div class="empty-state"><h3>Change explanation unavailable</h3>'
+            f"<p>{html.escape(notice)}</p></div>" + navigation
+        )
+    parts = [
+        '<div class="change-explanation"><p class="explanation-kicker">Understand the change</p>',
+        f'<h2 class="explanation-headline">{html.escape(explanation.headline)}</h2>',
+        f'<p class="explanation-overview">{html.escape(explanation.overview)}</p>',
+        f'<p class="note">{html.escape(content.INTERPRETATION_NOTE)}</p>',
+        '<ol class="explanation-steps" role="list">',
+    ]
+    references = []
+    for number, step in enumerate(explanation.steps, 1):
+        references.extend(step.decisions)
+        parts.append(
+            '<li class="explanation-step">'
+            f'<h3><span class="explanation-number" aria-hidden="true">{number}</span>'
+            f'{html.escape(step.title)}</h3><div class="explanation-pair">'
+            f'<section class="explanation-side before"><h4>Before</h4><p>{html.escape(step.before)}</p></section>'
+            f'<section class="explanation-side after"><h4>After</h4><p>{html.escape(step.after)}</p></section>'
+            '</div><div class="explanation-meaning"><h4>What this means</h4>'
+            f"<p>{html.escape(step.meaning)}</p>"
+            f'<span class="evidence-links">{_decision_links(step.decisions)}</span></div></li>'
+        )
+    parts.append("</ol>")
+    for heading, claims in (
+        ("What stays the same", explanation.unchanged),
+        ("What this evidence cannot establish", explanation.limits),
+    ):
+        if claims:
+            parts.append(f'<section class="explanation-claims"><h3>{heading}</h3><ul>')
+            for claim in claims:
+                references.extend(claim.decisions)
+                parts.append(
+                    f"<li>{html.escape(claim.text)}"
+                    f'<span class="evidence-links">{_decision_links(claim.decisions)}</span></li>'
+                )
+            parts.append("</ul></section>")
+    comparisons = content.explanation_comparisons(
+        report, tuple(dict.fromkeys(references))
+    )
+    if comparisons:
+        parts.append(
+            '<section class="explanation-consistency"><h3>Consistency across trials</h3>'
+            '<p class="note">All extracted branches for the cited comparisons are shown, '
+            "including minority choices. Before and After trials are independent; "
+            "these counts are model extractions, not causal proof.</p>"
+        )
+        for index, title, sides in comparisons:
+            parts.append(f"<h4>{html.escape(title)}</h4>")
+            parts.extend(
+                f"<p><strong>{label}:</strong> {html.escape(text)}</p>"
+                for label, text in sides
+            )
+            parts.append(
+                f'<span class="evidence-links">{_decision_links((index,))}</span>'
+            )
+        parts.append("</section>")
+    if explanation.examples:
+        parts.append(
+            '<section class="explanation-examples"><h3>From the final answers</h3>'
+        )
+        for example in explanation.examples:
+            anchor = html.escape(content.trial_anchor(example.side, example.trial))
+            parts.append(
+                f'<figure class="explanation-excerpt {example.side}">'
+                f"<figcaption>{example.side.capitalize()} · {html.escape(example.trial)} · "
+                f'<a href="#{anchor}">View full trial evidence</a></figcaption>'
+                f"<pre>{html.escape(example.text)}</pre></figure>"
+            )
+        parts.append("</section>")
+    parts.append(navigation + "</div>")
+    return "".join(parts)
+
+
 def _short_story_summary(report: ReportData) -> str:
     summary = report.summary
     intent = report.intent
@@ -550,14 +642,9 @@ def _short_story_summary(report: ReportData) -> str:
                 f'<span class="evidence-links">{_decision_links(claim.decisions)}</span>'
                 "</div>"
             )
-    comparison_available = (
-        summary.decision is not None and summary.status != "unavailable"
-    )
-    destination = "#panel-decision" if comparison_available else "#panel-trials"
     lead_link = (
-        f'<a class="summary-evidence-button" href="{destination}">'
-        f"{'View behavior comparisons' if comparison_available else 'View available trial records'}"
-        ' <span aria-hidden="true">→</span></a>'
+        '<a class="summary-evidence-button" href="#panel-explanation">'
+        'Understand the change <span aria-hidden="true">→</span></a>'
     )
     notices = "".join(f"<li>{html.escape(note)}</li>" for note in summary.notices)
     scenario = (
@@ -880,6 +967,7 @@ def render_artifact(report: ReportData, css: str) -> str:
 
     tabs = [
         ("summary", "Summary", "", summary_html),
+        ("explanation", "Understand the change", "", _change_explanation(report)),
         ("instruction", "Instruction changes", "", _instruction_edit(report)),
         (
             "decision",
diff --git a/plugin/skills/behavior-diff/scripts/reporting/render_markdown.py b/plugin/skills/behavior-diff/scripts/reporting/render_markdown.py
index e0f12ae..4a47ecb 100644
--- a/plugin/skills/behavior-diff/scripts/reporting/render_markdown.py
+++ b/plugin/skills/behavior-diff/scripts/reporting/render_markdown.py
@@ -270,7 +270,7 @@ def _summary_markdown(report):
     ]
     markdown += [
         "[View instruction changes](#instruction-diff)\n",
-        "### 2. What was observed\n",
+        "### 2. What the evidence shows\n",
     ]
     if summary.scenario:
         markdown.append(_text(summary.scenario) + "\n")
@@ -291,18 +291,8 @@ def _summary_markdown(report):
         for label, text in context.sides:
             markdown.append(f"**{label}:** {_text(text)}\n")
         markdown.append(_text(context.note) + "\n")
-    target = (
-        "panel-decision"
-        if summary.decision is not None and summary.status != "unavailable"
-        else "panel-trials"
-    )
-    label = (
-        "View behavior comparisons"
-        if target != "panel-trials"
-        else "View available trial records"
-    )
-    markdown.append(f"[{label}](#{target})\n")
-    markdown.append("### 3. What this does — and does not — establish\n")
+    markdown.append("[Understand the change](#panel-explanation)\n")
+    markdown.append("### 3. What this means\n")
     for label, claim in (
         ("Why it matters", summary.why),
         ("Watch out", summary.caution),
@@ -316,6 +306,86 @@ def _summary_markdown(report):
     return markdown
 
 
+def _explanation_markdown(report):
+    explanation = report.decisions.explanation
+    markdown = [
+        '<a id="panel-explanation"></a>\n',
+        "## Understand the change\n",
+    ]
+    complete = content.complete_trial_evidence(report)
+    if explanation is None or not complete:
+        notice = (
+            content.CHANGE_EXPLANATION_UNAVAILABLE
+            if complete
+            else content.CHANGE_EXPLANATION_INCOMPLETE
+        )
+        markdown += [
+            "### Change explanation unavailable\n",
+            _text(notice) + "\n",
+        ]
+    else:
+        markdown += [
+            f"### {_text(explanation.headline)}\n",
+            _text(explanation.overview) + "\n",
+            _text(content.INTERPRETATION_NOTE) + "\n",
+        ]
+        references = []
+        for number, step in enumerate(explanation.steps, 1):
+            references.extend(step.decisions)
+            markdown += [
+                f"### {number}. {_text(step.title)}\n",
+                "#### Before\n",
+                _text(step.before) + "\n",
+                "#### After\n",
+                _text(step.after) + "\n",
+                "#### What this means\n",
+                _text(step.meaning) + "\n",
+                _decision_links(step.decisions) + "\n",
+            ]
+        for heading, claims in (
+            ("What stays the same", explanation.unchanged),
+            ("What this evidence cannot establish", explanation.limits),
+        ):
+            if claims:
+                markdown.append(f"### {heading}\n")
+                for claim in claims:
+                    references.extend(claim.decisions)
+                    markdown.append(
+                        f"- {_text(claim.text)} {_decision_links(claim.decisions)}"
+                    )
+                markdown.append("")
+        comparisons = content.explanation_comparisons(
+            report, tuple(dict.fromkeys(references))
+        )
+        if comparisons:
+            markdown += [
+                "### Consistency across trials\n",
+                "All extracted branches for the cited comparisons are shown, "
+                "including minority choices. Before and After trials are independent; "
+                "these counts are model extractions, not causal proof.\n",
+            ]
+            for index, title, sides in comparisons:
+                markdown.append(f"#### {_text(title)}\n")
+                markdown += [f"**{label}:** {_text(text)}\n" for label, text in sides]
+                markdown.append(_decision_links((index,)) + "\n")
+        if explanation.examples:
+            markdown.append("### From the final answers\n")
+            for example in explanation.examples:
+                anchor = content.trial_anchor(example.side, example.trial)
+                markdown += [
+                    f"**{example.side.capitalize()} · {_text(example.trial)}** · "
+                    f"[View full trial evidence](#{anchor})\n",
+                    "<pre>" + html.escape(example.text) + "</pre>\n",
+                ]
+    markdown += [
+        "[View behavior comparisons](#panel-decision) · "
+        "[View recorded command flow](#panel-flow) · "
+        "[View instruction changes](#instruction-diff) · "
+        "[Inspect trial evidence](#panel-trials)\n",
+    ]
+    return markdown
+
+
 def render_markdown(report: ReportData) -> str:
     """Return the complete Markdown report without accessing external state."""
     metadata = report.metadata
@@ -347,6 +417,7 @@ def render_markdown(report: ReportData) -> str:
     markdown += [f"- {_text(limit)}" for limit in result.limits]
     markdown.append("")
     markdown.append("</details>\n")
+    markdown += _explanation_markdown(report)
     markdown.append('<a id="panel-instruction"></a>\n')
     markdown.append('<a id="instruction-diff"></a>\n')
     markdown.append("## Instruction changes\n")
diff --git a/plugin/skills/behavior-diff/scripts/reporting/report.css b/plugin/skills/behavior-diff/scripts/reporting/report.css
index a4d84f8..8ec7084 100644
--- a/plugin/skills/behavior-diff/scripts/reporting/report.css
+++ b/plugin/skills/behavior-diff/scripts/reporting/report.css
@@ -231,6 +231,7 @@ details { margin-bottom:.25rem; }
 .panel:target, .panel:has(:target) { display:block; }
 .tabs:not(:has(.panel:target, .panel :target)) .tabbar a[href="#panel-summary"],
 .tabs:has(#panel-summary:target, #panel-summary :target) .tabbar a[href="#panel-summary"],
+.tabs:has(#panel-explanation:target, #panel-explanation :target) .tabbar a[href="#panel-explanation"],
 .tabs:has(#panel-instruction:target, #panel-instruction :target) .tabbar a[href="#panel-instruction"],
 .tabs:has(#panel-decision:target, #panel-decision :target) .tabbar a[href="#panel-decision"],
 .tabs:has(#panel-flow:target, #panel-flow :target) .tabbar a[href="#panel-flow"],
@@ -478,3 +479,47 @@ details { margin-bottom:.25rem; }
   .summary-caution p { margin-top:5px; }
   .summary-details { margin:12px 0; }
 }
+
+.change-explanation { max-width:950px; margin:0 auto 2rem; overflow-wrap:anywhere; }
+.explanation-kicker { color:var(--accent); font-size:.75rem; font-weight:700;
+  letter-spacing:.1em; text-transform:uppercase; margin:0 0 .5rem; }
+.explanation-headline { font-size:1.7rem; line-height:1.3; text-wrap:balance; }
+.explanation-overview { font-size:1.1rem; max-width:80ch; }
+.explanation-steps { list-style:none; padding:0; margin:1.5rem 0; }
+.explanation-step { background:var(--panel); border:1px solid var(--border);
+  border-radius:10px; margin:1rem 0; padding:1.2rem; }
+.explanation-step > h3 { display:flex; align-items:baseline; gap:.65rem;
+  font-size:1.05rem; margin:0 0 1rem; }
+.explanation-number { flex:none; color:var(--accent); font-variant-numeric:tabular-nums; }
+.explanation-pair { display:grid; grid-template-columns:repeat(2, minmax(0, 1fr));
+  gap:1rem; }
+.explanation-side { min-width:0; border:1px solid; border-radius:7px; padding:1rem; }
+.explanation-side.before, .explanation-excerpt.before { background:var(--before-soft);
+  border-color:var(--before-border); }
+.explanation-side.after, .explanation-excerpt.after { background:var(--after-soft);
+  border-color:var(--after-border); }
+.explanation-side h4 { margin:0 0 .5rem; font-size:.8rem; }
+.explanation-side.before h4 { color:var(--before); }
+.explanation-side.after h4 { color:var(--after); }
+.explanation-side p { margin:0; }
+.explanation-meaning { border-left:3px solid var(--accent); margin-top:1rem;
+  padding:.2rem 0 .2rem 1rem; }
+.explanation-meaning h4 { margin:0; font-size:.85rem; }
+.explanation-meaning p { margin:.4rem 0; }
+.explanation-claims, .explanation-consistency, .explanation-examples { margin:1.5rem 0; }
+.explanation-claims h3, .explanation-consistency h3, .explanation-examples h3 {
+  font-size:1.05rem; }
+.explanation-claims li + li { margin-top:.7rem; }
+.explanation-consistency { border-top:1px solid var(--border); padding-top:.5rem; }
+.explanation-consistency h4 { margin:1rem 0 .4rem; }
+.explanation-consistency p { margin:.4rem 0; }
+.explanation-excerpt { margin:1rem 0; padding:1rem; border:1px solid;
+  border-radius:7px; }
+.explanation-excerpt figcaption { font-size:.85rem; font-weight:600; }
+.explanation-excerpt pre { background:var(--panel); }
+@media (max-width:680px) {
+  .explanation-pair { grid-template-columns:minmax(0, 1fr); gap:.7rem; }
+  .explanation-step { padding:.9rem; }
+  .explanation-side { padding:.8rem; }
+  .explanation-headline { font-size:1.4rem; }
+}
diff --git a/plugin/skills/behavior-diff/scripts/reporting/schema.py b/plugin/skills/behavior-diff/scripts/reporting/schema.py
index 8b4090a..2c14cf2 100644
--- a/plugin/skills/behavior-diff/scripts/reporting/schema.py
+++ b/plugin/skills/behavior-diff/scripts/reporting/schema.py
@@ -4,6 +4,12 @@
 from dataclasses import asdict, dataclass
 from typing import Dict, Optional, Tuple, Union
 
+from reporting.explanation import (
+    ChangeExplanationData,
+    ExplanationExampleData as ExplanationExampleData,
+    ExplanationStepData as ExplanationStepData,
+    parse_explanation,
+)
 from reporting.instruction import parse_diff_hunks
 from reporting.summary import (
     ICONS,
@@ -21,7 +27,7 @@
     trial_group_names,
 )
 
-SCHEMA_VERSION = 8
+SCHEMA_VERSION = 9
 RESULT_KINDS = ("good", "bad", "neutral")
 
 
@@ -116,6 +122,7 @@ class DecisionData:
     narrative: Optional[NarrativeData] = None
     intent: Optional[EditIntentData] = None
     trial_summaries: Tuple[TrialSummaryData, ...] = ()
+    explanation: Optional[ChangeExplanationData] = None
 
 
 @dataclass(frozen=True)
@@ -234,6 +241,13 @@ def from_dict(cls, data: Dict[str, object]) -> "ReportData":
                 (trial.name for trial in variants.before.trials),
                 (trial.name for trial in variants.after.trials),
             ),
+            {
+                side: {trial.name: trial.final for trial in variant.trials}
+                for side, variant in (
+                    ("before", variants.before),
+                    ("after", variants.after),
+                )
+            },
         )
         result = _result(
             _field(data, "result", "report-data"), "result", len(decisions.rows)
@@ -455,7 +469,7 @@ def _flow_path(value, path):
     )
 
 
-def _decisions(value, path, hunk_count, groups=None):
+def _decisions(value, path, hunk_count, groups=None, final_answers=None):
     value = _expect_dict(value, path)
     rows = _expect_list(_field(value, "rows", path), path + ".rows")
     parsed_rows = tuple(
@@ -485,6 +499,12 @@ def _decisions(value, path, hunk_count, groups=None):
     trial_summaries = parse_trial_summaries(raw_trial_summaries, groups)
     if [asdict(item) for item in trial_summaries] != raw_trial_summaries:
         _invalid(path + ".trial_summaries", "valid canonical trial group summaries")
+    raw_explanation = _field(value, "explanation", path)
+    explanation = parse_explanation(raw_explanation, parsed_rows, final_answers)
+    if raw_explanation is not None and (
+        explanation is None or _json_value(asdict(explanation)) != raw_explanation
+    ):
+        _invalid(path + ".explanation", "valid canonical change explanation")
     decisions = DecisionData(
         rows=parsed_rows,
         fork=_optional_reference(
@@ -504,6 +524,7 @@ def _decisions(value, path, hunk_count, groups=None):
         narrative=narrative,
         intent=intent,
         trial_summaries=trial_summaries,
+        explanation=explanation,
     )
     from reporting.content import valid_decision_choices
 
diff --git a/tests/explanation_contract.py b/tests/explanation_contract.py
new file mode 100644
index 0000000..f8bef53
--- /dev/null
+++ b/tests/explanation_contract.py
@@ -0,0 +1,296 @@
+"""Deterministic contracts for authored synthetic change explanations."""
+
+import copy
+import html
+import json
+from html.parser import HTMLParser
+from unittest.mock import patch
+
+
+class ExplanationPanel(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self.depth = 0
+        self.text = []
+        self.targets = []
+        self.tabs = set()
+        self.in_tabbar = False
+
+    def handle_starttag(self, tag, attrs):
+        attrs = dict(attrs)
+        if tag == "nav" and "tabbar" in attrs.get("class", "").split():
+            self.in_tabbar = True
+        if tag == "a" and self.in_tabbar:
+            self.tabs.add(attrs.get("href", "").removeprefix("#"))
+        if attrs.get("id") == "panel-explanation":
+            self.depth = 1
+        elif self.depth and tag not in ("br", "hr", "img", "input", "meta", "link"):
+            self.depth += 1
+        if self.depth and tag == "a":
+            self.targets.append(attrs.get("href"))
+
+    def handle_endtag(self, tag):
+        if tag == "nav":
+            self.in_tabbar = False
+        if self.depth:
+            self.depth -= 1
+
+    def handle_data(self, text):
+        if self.depth:
+            self.text.append(text)
+
+
+def assert_change_explanations(
+    reports, root, assert_round_trip, assert_evidence_links, assert_unchanged_scripts
+):
+    from reporting import content
+    import decisions
+    from reporting.load import load_report
+    from reporting.render_html import render_artifact
+    from reporting.render_markdown import render_markdown
+    from reporting.schema import ReportData
+
+    for name in ("timing-rule", "formula-writing"):
+        report = reports[name]
+        explanation = report.decisions.explanation
+        assert explanation is not None, name
+        assert assert_round_trip(report.to_dict()) == report
+        assert isinstance(explanation.steps, tuple)
+        assert isinstance(explanation.unchanged, tuple)
+        assert isinstance(explanation.examples, tuple)
+        page = render_artifact(report, "")
+        markdown = render_markdown(report)
+        panel = ExplanationPanel()
+        panel.feed(page)
+        assert set(panel.tabs) == {
+            "panel-summary",
+            "panel-explanation",
+            "panel-decision",
+            "panel-flow",
+            "panel-instruction",
+            "panel-trials",
+        }, "Explanation must not replace or nest another top-level tab."
+        plain = "".join(panel.text)
+        md_plain = html.unescape(markdown).replace("\\", "")
+        for text in (
+            explanation.headline,
+            explanation.overview,
+            *(
+                value
+                for step in explanation.steps
+                for value in (
+                    step.title,
+                    step.before,
+                    step.after,
+                    step.meaning,
+                )
+            ),
+            *(claim.text for claim in (*explanation.unchanged, *explanation.limits)),
+            *(example.text for example in explanation.examples),
+        ):
+            assert text in plain, (name, text)
+            assert text in md_plain, (name, text)
+        references = {
+            index
+            for item in (
+                *explanation.steps,
+                *explanation.unchanged,
+                *explanation.limits,
+            )
+            for index in item.decisions
+        }
+        for index in references:
+            assert f"#decision-{index}" in panel.targets
+            assert f"](#decision-{index})" in markdown
+        for example in explanation.examples:
+            variant = getattr(report.variants, example.side)
+            final = next(
+                trial.final for trial in variant.trials if trial.name == example.trial
+            )
+            assert example.text in final
+            assert (
+                f"#{content.trial_anchor(example.side, example.trial)}" in panel.targets
+            )
+        assert_evidence_links(report)
+
+    formula = reports["formula-writing"]
+    assert formula.decisions.rows[0].diverges is False
+    assert formula.decisions.rows[3].diverges is False
+    assert [choice.count for choice in formula.decisions.rows[1].after] == [2, 1]
+    assert formula.summary.status == "mixed"
+    timing = reports["timing-rule"]
+    assert timing.summary.status == "mixed"
+    assert [choice.count for choice in timing.decisions.rows[0].after] == [2, 1]
+    assert [choice.count for choice in timing.decisions.rows[1].after] == [2, 1]
+
+    run = root / "formula-writing"
+    path = run / "decisions.json"
+    original = path.read_text()
+    saved = json.loads(original)
+    valid = saved["explanation"]
+    extraction = json.loads((run / "extraction.json").read_text())
+    finals = {
+        side: {
+            trial.name: trial.final for trial in getattr(formula.variants, side).trials
+        }
+        for side in ("before", "after")
+    }
+    names = {side: list(answers) for side, answers in finals.items()}
+    normalized = decisions.normalize(
+        extraction, names, hunk_count=1, final_answers=finals
+    )
+    assert normalized["explanation"] == valid
+    canonical_missing = formula.to_dict()
+    del canonical_missing["decisions"]["explanation"]
+    try:
+        ReportData.from_dict(canonical_missing)
+    except ValueError:
+        pass
+    else:
+        raise AssertionError(
+            "Canonical report omitted its explanation availability field."
+        )
+    malformed = []
+    for field, value in (
+        ("steps", []),
+        ("headline", ""),
+        ("steps", "not steps"),
+        ("headline", "<script>synthetic</script>"),
+        ("overview", "x" * 601),
+        (
+            "examples",
+            [{"side": "after", "trial": "after-1", "text": "bad\u0000excerpt"}],
+        ),
+        (
+            "examples",
+            [{"side": "after", "trial": "after-1", "text": "Invented formula"}],
+        ),
+        (
+            "examples",
+            [
+                {
+                    "side": "before",
+                    "trial": "after-1",
+                    "text": valid["examples"][1]["text"],
+                }
+            ],
+        ),
+        (
+            "examples",
+            [
+                {
+                    "side": "after",
+                    "trial": "after-missing",
+                    "text": valid["examples"][1]["text"],
+                }
+            ],
+        ),
+        (
+            "examples",
+            [
+                {
+                    "side": "after",
+                    "trial": "after-3",
+                    "text": valid["examples"][1]["text"],
+                }
+            ],
+        ),
+    ):
+        malformed.append(dict(valid, **{field: value}))
+    for field, refs in (
+        ("steps", [99]),
+        ("steps", [True]),
+        ("steps", []),
+        ("steps", [2, 2]),
+        ("unchanged", [2]),
+    ):
+        value = copy.deepcopy(valid)
+        value[field][0]["decisions"] = refs
+        malformed.append(value)
+    try:
+        for value in malformed:
+            normalized = decisions.normalize(
+                dict(extraction, explanation=value),
+                names,
+                hunk_count=1,
+                final_answers=finals,
+            )
+            assert normalized["explanation"] is None
+            assert len(normalized["chain"]) == len(formula.decisions.rows)
+            path.write_text(json.dumps(dict(saved, explanation=value)))
+            loaded = load_report(run, run, "synthetic/authored", run / "config.json")
+            assert loaded.decisions.explanation is None
+            assert loaded.decisions.rows == formula.decisions.rows
+            assert loaded.variants == formula.variants
+            assert loaded.summary == formula.summary
+            canonical = formula.to_dict()
+            canonical["decisions"]["explanation"] = value
+            try:
+                ReportData.from_dict(canonical)
+            except ValueError:
+                pass
+            else:
+                raise AssertionError("Malformed stored explanation was accepted.")
+        path.write_text(
+            json.dumps(
+                {key: value for key, value in saved.items() if key != "explanation"}
+            )
+        )
+        missing = load_report(run, run, "synthetic/authored", run / "config.json")
+        assert missing.decisions.explanation is None
+        assert missing.decisions.rows == formula.decisions.rows
+        with patch(
+            "subprocess.run",
+            side_effect=AssertionError("Offline rendering invoked a process"),
+        ):
+            for render in (lambda report: render_artifact(report, ""), render_markdown):
+                rendered = render(missing)
+                assert content.CHANGE_EXPLANATION_UNAVAILABLE in html.unescape(
+                    rendered
+                ).replace("\\", "")
+                assert "decision-2" in rendered
+        assert reports["blocked"].summary.status == "unavailable"
+        assert reports["blocked"].decisions.explanation is None
+        assert reports["missing-extraction"].decisions.explanation is None
+    finally:
+        path.write_text(original)
+
+    grades = run / "grades.tsv"
+    original_grades = grades.read_text()
+    try:
+        grades.write_text(
+            original_grades + "after-4\tBLOCKED\tSynthetic unavailable trial\n"
+        )
+        incomplete = load_report(run, run, "synthetic/authored", run / "config.json")
+        assert incomplete.decisions.explanation is not None
+        assert not content.complete_trial_evidence(incomplete)
+        for render in (lambda report: render_artifact(report, ""), render_markdown):
+            rendered = render(incomplete)
+            plain = html.unescape(rendered).replace("\\", "")
+            assert incomplete.decisions.explanation.headline not in plain
+            assert "Trial evidence is incomplete" in plain
+            assert "panel-trials" in rendered
+    finally:
+        grades.write_text(original_grades)
+
+    unsafe = formula.to_dict()
+    payload = (
+        '<script>alert("synthetic")</script>|[link](javascript:alert(1)) & value < 3'
+    )
+    unsafe["variants"]["before"]["trials"][0]["final"] += "\n" + payload
+    unsafe["decisions"]["explanation"]["examples"] = [
+        {"side": "before", "trial": "before-1", "text": payload}
+    ]
+    escaped = ReportData.from_dict(unsafe)
+    for render in (lambda report: render_artifact(report, ""), render_markdown):
+        baseline = render(formula)
+        rendered = render(escaped)
+        assert_unchanged_scripts(baseline, rendered)
+        assert "&lt;script&gt;" in rendered
+        assert "&lt; 3" in rendered
+        panel = ExplanationPanel()
+        panel.feed(rendered)
+        assert not any(
+            target and target.lower().startswith("javascript:")
+            for target in panel.targets
+        )
diff --git a/tests/live-report-contract.sh b/tests/live-report-contract.sh
index 5b8a331..57c82c4 100755
--- a/tests/live-report-contract.sh
+++ b/tests/live-report-contract.sh
@@ -307,8 +307,6 @@ require_output 'commands it ran:' "$captured_prompt" \
   'captured decision prompt does not label captured command entries'
 require_output 'actually did and said' "$captured_prompt" \
   'captured decision prompt lost its performed-action evidence clause'
-reject_output 'self-reported' "$captured_prompt" \
-  'captured decision prompt uses self-reported source wording'
 require_output \
   'A decision is not a command; some decisions leave no command' \
   "$captured_prompt" 'captured prompt lost its command evidence noun'
diff --git a/tests/report-schema-test.py b/tests/report-schema-test.py
index d22fbfa..078ff8a 100755
--- a/tests/report-schema-test.py
+++ b/tests/report-schema-test.py
@@ -32,11 +32,12 @@
     trial_group_names,
 )
 from report_fixtures import SCENARIOS, build_reports  # noqa: E402
+from explanation_contract import assert_change_explanations  # noqa: E402
 
 
 def synthetic_raw():
     raw = {
-        "schema_version": 8,
+        "schema_version": 9,
         "metadata": {
             "model": "synthetic/model",
             "mode": "review",
@@ -199,6 +200,7 @@ def synthetic_raw():
             ],
             "narrative": None,
             "intent": None,
+            "explanation": None,
             "trial_summaries": [
                 {
                     "before_trial": "before-1",
@@ -608,7 +610,14 @@ def handle_endtag(self, tag):
     ):
         evidence = Evidence()
         evidence.feed(rendered)
-        for panel in ("summary", "instruction", "decision", "flow", "trials"):
+        for panel in (
+            "summary",
+            "explanation",
+            "instruction",
+            "decision",
+            "flow",
+            "trials",
+        ):
             assert f"panel-{panel}" in evidence.ids
         assert [
             anchor
@@ -631,12 +640,9 @@ def handle_endtag(self, tag):
             "Domain run terminology was rewritten."
         )
         if is_html:
-            assert evidence.primary_targets == [
-                "#panel-decision"
-                if report.summary.decision is not None
-                and report.summary.status != "unavailable"
-                else "#panel-trials"
-            ], "The Summary must have one primary evidence destination."
+            assert evidence.primary_targets == ["#panel-explanation"], (
+                "The Summary must open the dedicated explanation."
+            )
 
     # Independently retained records remain navigable without an extraction.
     unavailable = replace(
@@ -1236,15 +1242,9 @@ def with_primary(row=original, **changes):
         assert "<a " not in block, (
             "Primary-result context must not add a competing link."
         )
-        target = (
-            "panel-decision"
-            if report.summary.decision is not None
-            and report.summary.status != "unavailable"
-            else "panel-trials"
-        )
-        assert re.findall(r"\]\(#(?:panel-decision|panel-trials)\)", md_block) == [
-            f"](#{target})"
-        ], "The observed comparison has one shared evidence destination."
+        assert re.findall(r"\]\(#panel-explanation\)", md_block) == [
+            "](#panel-explanation)"
+        ], "The observed comparison opens the shared explanation destination."
         if context.decision is None:
             assert not context.sides
         else:
@@ -1487,6 +1487,7 @@ def assert_gallery_reports():
         "intent-unchanged": ("unchanged", "unavailable"),
         "planned-actions": ("changed", "unavailable"),
         "timing-rule": ("varies", "unavailable"),
+        "formula-writing": ("unchanged", "unchanged"),
     }
     with tempfile.TemporaryDirectory() as directory:
         root = Path(directory)
@@ -1588,6 +1589,13 @@ def assert_gallery_reports():
         assert_additional_findings(reports)
         assert_intent_reports(reports, root)
         assert_saved_scenario_task(root)
+        assert_change_explanations(
+            reports,
+            root,
+            assert_round_trip,
+            assert_evidence_links,
+            assert_unchanged_scripts,
+        )
 
     with tempfile.TemporaryDirectory() as directory:
         root = Path(directory)
diff --git a/tests/report_fixtures.py b/tests/report_fixtures.py
index 01dc873..07cdff8 100644
--- a/tests/report_fixtures.py
+++ b/tests/report_fixtures.py
@@ -105,6 +105,11 @@ class Scenario:
         "Retry timing leads alongside mixed recommendations",
         "Planned intervals and deadlines change; signoff remains required in both answers.",
     ),
+    Scenario(
+        "formula-writing",
+        "Formula and writing choices vary without changing the verdict",
+        "Two after answers simplify a formula and use bullets; source reads and approval stay the same.",
+    ),
 )
 
 
@@ -270,6 +275,7 @@ def _write_extraction(
     summary=None,
     intent=None,
     trial_summaries=(),
+    explanation=None,
 ):
     positions = {row["topic"]: index for index, row in enumerate(rows, 1)}
     _write_json(
@@ -286,6 +292,7 @@ def _write_extraction(
             "summary": summary,
             "intent": intent,
             "trial_summaries": list(trial_summaries),
+            "explanation": explanation,
         },
     )
 
@@ -1363,6 +1370,142 @@ def _timing_rule(run, scenario):
                 ),
             ],
         ),
+        explanation={
+            "headline": "The retry window extends, but a minority proposes only one check.",
+            "overview": "The answers describe future plans rather than executed polling.",
+            "steps": [
+                {
+                    "title": "After signoff",
+                    "before": "All three plan five-minute polling until 15 minutes.",
+                    "after": "Two plan ten-minute polling until 30 minutes; one plans one deadline check.",
+                    "meaning": "The longer window is consistent; repeated polling is not.",
+                    "decisions": [1],
+                },
+            ],
+            "unchanged": [],
+            "limits": [
+                {
+                    "text": "No polling or signoff is recorded; recommendations remain mixed.",
+                    "decisions": [1, 2],
+                },
+            ],
+            "examples": [
+                {"side": side, "trial": f"{side}-1", "text": trials[side][0].final}
+                for side in ("before", "after")
+            ],
+        },
+    )
+
+
+def _formula_writing(run, scenario):
+    rules = {
+        "before": "# Review\nExplain the bounded availability formula in a paragraph.\n",
+        "after": "# Review\nPrefer a concise equivalent formula and evidence bullets.\n",
+    }
+    trials = {"before": [], "after": []}
+    for side in trials:
+        for number in range(1, 4):
+            simplified = side == "after" and number < 3
+            formula = (
+                "max(stock - reserved, 0)"
+                if simplified
+                else ("stock - reserved if stock >= reserved else 0")
+            )
+            final = (
+                f"- Formula: {formula}\n- Verdict: APPROVE"
+                if simplified
+                else f"Formula: {formula}. Verdict: APPROVE."
+            )
+            trials[side].append(
+                _Trial(
+                    actions=(
+                        ("cat availability.py", "return max(stock - reserved, 0)\n"),
+                    ),
+                    final=final,
+                    choices={
+                        "Source inspection": "Read availability.py",
+                        "Formula representation": formula,
+                        "Answer presentation": "Evidence bullets"
+                        if simplified
+                        else "Paragraph",
+                        "Review verdict": "APPROVE",
+                    },
+                    summary="Reads the implementation and returns APPROVE.",
+                )
+            )
+    _write_sources(
+        run,
+        scenario,
+        "Synthetic task: Explain bounded availability for non-negative integer inputs.",
+        rules,
+        {"availability.py": "return max(stock - reserved, 0)\n"},
+        trials,
+    )
+    rows = [
+        _row("Source inspection", "Which source was inspected?", 1, trials),
+        _row("Formula representation", "Which formula is written?", "answer", trials),
+        _row("Answer presentation", "How is the evidence presented?", "answer", trials),
+        _row("Review verdict", "What verdict is returned?", "answer", trials),
+    ]
+    rows[1]["edit_hunks"] = [1]
+    rows[2]["edit_hunks"] = [1]
+    _write_extraction(
+        run,
+        rows,
+        primary="Review verdict",
+        trial_summaries=_trial_summaries(
+            trials,
+            [
+                (
+                    "After uses max notation and bullets; both return APPROVE.",
+                    "The answers do not establish behavior outside the stated inputs.",
+                ),
+                (
+                    "After uses max notation and bullets; both return APPROVE.",
+                    "The answers do not establish behavior outside the stated inputs.",
+                ),
+                (
+                    "Both retain conditional notation, paragraph presentation and APPROVE.",
+                    "This trial does not adopt the proposed presentation change.",
+                ),
+            ],
+        ),
+        explanation={
+            "headline": "Two answers simplify notation and switch to bullets.",
+            "overview": "This is a presentation distinction, not a changed availability result.",
+            "steps": [
+                {
+                    "title": "Formula notation",
+                    "before": "All three answers write an explicit conditional.",
+                    "after": "Two use max(stock - reserved, 0); one retains the conditional.",
+                    "meaning": "Both formulas clamp subtraction at zero for the stated inputs.",
+                    "decisions": [2],
+                },
+                {
+                    "title": "Evidence presentation",
+                    "before": "All three answers use a paragraph.",
+                    "after": "Two use bullets; one still uses a paragraph.",
+                    "meaning": "The format change is not consistent across all trials.",
+                    "decisions": [3],
+                },
+            ],
+            "unchanged": [
+                {
+                    "text": "Every trial reads availability.py and returns APPROVE.",
+                    "decisions": [1, 4],
+                },
+            ],
+            "limits": [
+                {
+                    "text": "These answers do not establish behavior for negative or non-integer inputs.",
+                    "decisions": [2],
+                },
+            ],
+            "examples": [
+                {"side": side, "trial": f"{side}-1", "text": trials[side][0].final}
+                for side in ("before", "after")
+            ],
+        },
     )
 
 
@@ -1394,6 +1537,8 @@ def build_reports(root: Path) -> None:
             _planned_actions(run, scenario)
         elif scenario.name == "timing-rule":
             _timing_rule(run, scenario)
+        elif scenario.name == "formula-writing":
+            _formula_writing(run, scenario)
         elif scenario.name in {"flow-changed", "flow-mixed"}:
             _availability_review(run, scenario)
         elif scenario.name in {"intent-flip", "intent-unchanged"}: