From f5fbce1f857cad75c4c030818dda3e910678479b Mon Sep 17 00:00:00 2001
From: Kent Huang <kent@infuseai.io>
Date: Mon, 5 Oct 2026 15:35:11 +0800
Subject: [PATCH] feat: add guided report story and human-readable trial
 summaries

Signed-off-by: Kent Huang <kent@infuseai.io>
---
 README.md                                     | 128 ++--
 docs/architecture.md                          |  51 +-
 ...mmary-terminology-and-evidence-feedback.md | 247 ++++++++
 .../skills/behavior-diff/scripts/decisions.py | 119 +++-
 .../scripts/reporting/content.py              |  83 ++-
 .../behavior-diff/scripts/reporting/load.py   |  24 +-
 .../scripts/reporting/render_html.py          | 537 +++++++++++-----
 .../scripts/reporting/render_markdown.py      | 209 +++++--
 .../scripts/reporting/report.css              | 178 ++++--
 .../behavior-diff/scripts/reporting/schema.py |  21 +-
 .../scripts/reporting/summary.py              |  24 +-
 .../scripts/reporting/trial_summary.py        |  87 +++
 tests/report-schema-test.py                   | 592 +++++++++++++++++-
 tests/report_fixtures.py                      | 185 +++++-
 14 files changed, 2066 insertions(+), 419 deletions(-)
 create mode 100644 plans/2026-10-05-summary-terminology-and-evidence-feedback.md
 create mode 100644 plugin/skills/behavior-diff/scripts/reporting/trial_summary.py

diff --git a/README.md b/README.md
index bf73f9c..0420450 100644
--- a/README.md
+++ b/README.md
@@ -153,53 +153,59 @@ IDs when comparisons across runs must retain the same model version.
 ## Read the report
 
 A **run** compares the instruction versions. A **trial** is one agent execution on
-one side. Each run creates a local HTML report with up to four tabs:
-
-- **Summary** tells a short story: what the instruction edit aims to change,
-  what happened in the scenario, and what the observations mean. Illustrated
-  Before/After cards retain exact counts and distinguish plans, answers, and
-  recorded actions. Mixed results and evidence gaps remain visible.
-  **Other findings** contains at most three compact comparisons, with a link
-  to all decisions. **Full scenario and expected behavior** explains the
-  simulated situation, compared instruction versions, trial counts, model,
-  and evidence type. **View full scenario prompt** expands the saved task,
-  including its constraints, without crowding the explanation. Supplied
-  expectations stay distinct from results; missing expectations are explicit.
-  **Instruction edit** explains the saved aim in plain language above the
-  complete diff, filename, and line counts. **Likely aim** marks an inferred
-  interpretation; **Supplied expectation** marks an explicit expectation.
-  Missing explanations stay unavailable. There is no duplicate excerpt or
-  second diff toggle. Evidence links open the exact diff hunk. Complete
+one side. Each run creates a local HTML report with five tabs:
+
+- **Summary** tells a numbered story: the intended change, what the evidence
+  shows, and what it means. Illustrated Before/After cards retain exact counts
+  and distinguish plans, answers, and recorded actions. Mixed results and
+  evidence gaps remain visible. **View this comparison** opens the supporting
+  comparison, or links to trial records when extraction is unavailable.
+  **Full scenario and expected behavior** explains the simulated situation,
+  instruction versions, trial setup, and supplied expectation or its absence.
+  **View full scenario prompt** is nested inside that disclosure.
+  **Other findings** contains at most three additional comparisons; complete
   evidence limits remain in their own disclosure.
-- **Decision diff** shows an ordered, two-lane comparison. Before and After
-  choices align at each decision in the model-extracted order, with all trial
-  counts visible. Mixed choices stay within each decision, not in connected branches.
-
-  Amber marks changed choices. Teal marks unchanged choices or matching choice
-  proportions. Gray marks unavailable comparisons. Text labels distinguish these
-  states. Colors do not mean success or failure.
-  The **Decision labels** info popup groups definitions by comparison status,
-  decision role, and evidence source.
-
-  Blue identifies actions and command evidence. Violet identifies the primary
-  result. Indigo identifies answer details and final-answer evidence.
-  The popup and decision badges use the same colors.
-
-  Each decision keeps its original number, topic, and role. Open it to inspect
-  the full question, source, notes, related edit hunks, and trial links.
-  Several decisions can stay open. Direct links open the matching decision or
-  diff hunk, and **Expand all** shows all evidence.
-
-  Printing includes all evidence. Markdown keeps the same decision order with
-  comparisons fully expanded. The sequence is not a recorded execution path or
-  proof of causality.
-- **Flow diff** starts with each side's recorded command progression. Identical
-  recorded sequences share a path with counts and links to their trial evidence.
-  A separate table compares command-category combinations. This tab appears only
-  when the run captured tool calls.
-- **Trial evidence** shows each trial's recorded commands or self-reported actions
-  and its final answer. Before and After trials are independent, even when their
-  numbers match. Side labels and trial counts remain visible on mobile.
+- **Instruction changes** shows the saved aim, filename, line counts, and
+  complete instruction diff. **Likely aim** marks an inferred interpretation;
+  **Supplied expectation** marks an explicit expectation. Missing explanations
+  stay unavailable. Section or line-range links select a diff block, highlight
+  its changed lines, and scroll to it without hiding the rest of the diff.
+  Related edits are interpretations, not causal proof.
+- **Behavior diff** shows an ordered, two-lane comparison. Before and After
+  behaviors align at each comparison in the model-extracted order, with all
+  trial counts visible. Mixed behaviors stay within each comparison, not in
+  connected branches.
+
+  Amber marks changed comparisons, teal marks unchanged or matching
+  proportions, and gray marks unavailable comparisons. The info popup beside
+  the heading separates comparison status, decision role, and evidence source.
+  Blue identifies actions, violet the primary result, and indigo answer
+  details; teal identifies recorded-command sources and amber final-answer
+  sources. Labels and colors do not mean success or failure.
+
+  Open a comparison to inspect its question, source, notes, related edits,
+  and supporting **Trial 1 / Trial 2 / Trial 3** links. Each is a separately
+  spaced link to a complete Before/After trial group; links wrap on narrow screens.
+  The report states when individual-trial
+  attribution is unavailable. **Expand all** and **Collapse all** control
+  comparison disclosures. The comparison order is not an execution path.
+- **Flow diff** groups only identical complete recorded command sequences,
+  retaining counts and links to every contributing trial. Different paths
+  remain separate. A table also compares command-category combinations.
+  Without captured command evidence, the tab explains why flow is unavailable;
+  it does not infer commands from answers or self-reported actions.
+- **Trial evidence** aligns Before on the left and After on the right within
+  each numbered group, including on mobile. **What changed** gives a short
+  takeaway, one sentence per side, and a caveat only when needed. These
+  model-written summaries describe that group's records, not aggregate counts.
+  Full final answers remain visible below. Shared supporting-detail and command
+  disclosures open both sides
+  together; **Show both** and **Hide both** control a whole group. Missing
+  records remain explicit. Trial numbers align records for reading, not paired
+  execution: Before and After trials are independent.
+
+Printing includes all tabs and disclosure content, with legends below their
+headings. The screen's disclosure states are restored afterward.
 
 Start with the instruction edit and the prominent comparisons. **Final result**
 still means the primary result identified by the model, not the highest-ranked
@@ -207,14 +213,15 @@ comparison. **Final answer** is the recorded answer text. **Action** comparisons
 come from recorded commands or self-reported actions; **Answer detail** comparisons
 come from the final answer. Wording differences alone do not establish an action change.
 
-In Summary and Decision diff, counts such as **3 of 3 trials** refer to trials,
+In Summary and Behavior diff, counts such as **3 of 3 trials** refer to trials,
 not repeated actions within one trial. A model extracts these counts from the
 evidence. Separate row counts do not show a complete sequence within one trial.
-**Changed** compares choice proportions. **Unchanged** is shown for complete,
-unanimous same-choice evidence; matching mixed distributions are labeled
-**Same choice proportions**. **Unavailable** means extracted choices cannot support
-a comparison. A consistent change requires a different unanimous choice on each
-side, at least two trials per side, and complete trial evidence. This is an observed
+**Changed** compares extracted behavior proportions. **Unchanged** is shown for
+complete, unanimous same-behavior evidence; matching proportions without that
+evidence are labeled **Same proportions**. **Unavailable** means extracted
+states cannot support a comparison. A consistent change requires a different
+unanimous behavior on each side, at least two trials per side, and complete trial
+evidence. This is an observed
 pattern, not statistical significance. Single-trial, blocked, missing, and mixed
 evidence is not promoted as a consistent change.
 
@@ -226,9 +233,9 @@ The command-category table groups each trial into one category combination.
 Category order is not execution order. Matching categories can contain different
 commands or files, so matching patterns do not establish unchanged behavior.
 
-Follow **See the evidence** to the full comparison in Decision diff. Inspect
-the trial records for the original commands and answers. The Markdown report
-contains the same takeaway, choices, counts, and evidence links without illustrations.
+Follow **View this comparison** to Behavior diff, or inspect the trial records
+for original commands and answers. Markdown retains the five sections, story,
+counts, complete instruction diff, and grouped trial evidence without illustrations.
 
 The existing extraction call identifies the primary result, possible explanations,
 and related instruction-diff hunks. It first recovers observed choices, then
@@ -269,9 +276,10 @@ Expected behavior is labeled as supplied, or explicitly unavailable. The evidenc
 limits state trial counts, provenance, and grading limits. Self-reported actions
 remain distinct from captured tool calls.
 
-The structured `report-data.json` uses schema version 7, including the visual
-`summary`, sourced instruction `intent`, saved `content.task`, optional narrative,
-and `edit_hunks`. The task comes from the run's `task.md`, or the capsule's copy
+The structured `report-data.json` uses schema version 8, including per-group
+`decisions.trial_summaries`, visual `summary`, sourced instruction `intent`,
+saved `content.task`, optional narrative, and `edit_hunks`.
+The task comes from the run's `task.md`, or the capsule's copy
 when absent from the run. A scenario description never replaces missing task text.
 Regenerate reports from their original run artifacts;
 older report-data files are not accepted. `render.py` needs the run directory,
@@ -280,7 +288,9 @@ does not run trials or call a model.
 
 Old `decisions.json` observations can be re-rendered with the new layout.
 Without narrative, the Summary uses original choice text and marks explanations
-unavailable. Missing aim interpretations and edit mappings remain unavailable.
+unavailable. Missing trial summaries, aim interpretations, and edit mappings
+remain unavailable. Trial summaries are produced in the existing extraction
+call; rendering never substitutes an overall conclusion for a trial's summary.
 To obtain them, explicitly rerun extraction on saved evidence after approving
 its model cost; no new trials are needed. Rendering never triggers extraction.
 The extractor stores the exact `instruction_diff` with its mappings. External
diff --git a/docs/architecture.md b/docs/architecture.md
index 6333f00..24077f4 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -35,7 +35,7 @@ scripts handle execution, evidence, and reporting.
                              v
 +---------------------------------------------------------+
 | Evidence analysis                                       |
-| decisions.py: model-based decision extraction           |
+| decisions.py: comparisons and trial summaries           |
 | reporting/: deterministic comparison and report data    |
 +----------------------------+----------------------------+
                              v
@@ -190,7 +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, counts, a primary result, supported implications, links to edits,
-  plain-language Summary text, and the edit's likely aim in the same call.
+  plain-language Summary text, the edit's likely aim, and short per-group trial
+  summaries in the same call. Each trial summary names its exact Before/After
+  records and separates answers and plans from recorded actions.
   The inferred aim cites instruction hunks independently of trial outcomes.
   The script validates references and exact choice coverage before writing
   `decisions.json`. Invalid interpretation does not discard valid observations.
@@ -206,7 +208,11 @@ The modules below live in the skill's [`scripts/`](../plugin/skills/behavior-dif
   single-trial cautions remain visible.
   It also derives the story's aim from supplied expected behavior or a
   validated inference whose stored diff matches the current instruction diff.
-  Together these modules build schema-v7 `ReportData` in `reporting/schema.py`.
+  `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
+  `read_trial_trace` so they read the same source fields.
+  Together these modules build schema-v8 `ReportData` in `reporting/schema.py`.
   Summary counts come from existing decision rows.
 
 Command flow comes from recorded events. Decision comparisons come from model
@@ -220,7 +226,7 @@ distinct. Links between decisions and edits do not prove causality.
 
 | Artifact | Purpose |
 | --- | --- |
-| `report.html` | Local browser report with Summary, Decision diff, Flow diff, and Trial evidence views. |
+| `report.html` | Local browser report with Summary, Instruction changes, Behavior diff, Flow diff, 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. |
@@ -233,7 +239,7 @@ author intent or goal completion. Markdown retains the caveat as plain text.
 `reporting/illustrations.py` supplies fixed SVG shapes for the Before/After
 comparison. Model output supplies text and selectors, never markup.
 Plans are not presented as executions. `content.additional_findings` selects
-at most three compact comparisons; full decisions stay in Decision diff.
+at most three compact comparisons; full comparisons stay in Behavior diff.
 Markdown shares the same story and findings without illustrations.
 Saved decisions without interpretations show explicit availability notices;
 rendering never requests new explanations.
@@ -247,14 +253,27 @@ unavailable rather than treating a description as the prompt. Shared
 `content.scenario_sections` supplies both HTML and Markdown; rendering adds
 no inferred setup details.
 
-Instruction edit begins with a plain-language explanation from the saved
-`intent`, labeled as a likely aim or supplied expectation. Rendering does not
-infer missing explanations or claim confirmed author intent. It contains one
-complete diff, with no duplicate excerpt or nested diff toggle.
-`content.instruction_edit_counts` counts added and removed
-lines across validated hunks. Stable diff and hunk anchors open the enclosing
-disclosure. Missing or unparseable diffs do not acquire invented counts.
-Both output formats retain the full evidence.
+Instruction changes has its own tab, linked from the Summary's goal. It begins
+with the saved `intent`, labeled as a likely aim or supplied expectation.
+Rendering does not infer missing explanations or claim confirmed author intent.
+Both output formats retain one complete diff. `content.instruction_edit_counts`
+counts changed lines across validated hunks; `content.instruction_hunk_label`
+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
+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
+groups, not paired executions. Missing sides are explicit. A short saved
+takeaway, Before/After descriptions, and optional caveat precede each group's
+full answers. Missing summaries stay unavailable; rendering does not infer them
+from aggregate decisions. Final answers remain visible; shared disclosures
+expand supporting details and commands on both
+sides. Group and individual-record anchors remain available. Per-comparison
+trial links expose the available groups without inventing individual attribution.
+Printing opens every disclosure and restores screen state afterward.
 
 The runner attempts to open the HTML report. The skill summarizes observed
 differences and evidence limits in the conversation. Missing extraction does
@@ -316,9 +335,9 @@ All output formats share `ReportData`. Only the HTML branch uses
    into `ReportData`. Its schema checks the structure before rendering.
 4. **Build the HTML body.** `render_artifact(report, css)` creates HTML from
    that object and inlines `reporting/report.css`. Python functions build the
-   Summary, decision comparisons, command flow, and expandable trial evidence.
-   Decision diff appears only with extracted decisions. Evidence text is
-   HTML-escaped, so recorded code and answers appear as text rather than markup.
+   Summary, instruction changes, behavior comparisons, command flow, and shared
+   trial evidence sections. Unavailable evidence does not remove a tab.
+   Evidence text is HTML-escaped, so recorded code and answers remain text.
 5. **Create the page.** `render_document(artifact)` adds the HTML document
    wrapper, character encoding, and viewport metadata. `render.py` writes the
    body to `report-artifact.html` and the full document to `report.html`.
diff --git a/plans/2026-10-05-summary-terminology-and-evidence-feedback.md b/plans/2026-10-05-summary-terminology-and-evidence-feedback.md
new file mode 100644
index 0000000..703fa7c
--- /dev/null
+++ b/plans/2026-10-05-summary-terminology-and-evidence-feedback.md
@@ -0,0 +1,247 @@
+# Summary terminology and evidence navigation feedback
+
+**Recorded:** 2026-10-05
+**Version discussed:** Behavior Diff v0.3.12 (inferred from the conversation;
+not independently confirmed from the colleague's installed plugin)
+**Status:** Guided-story prototype A approved for production implementation on
+2026-10-05. This approval does not authorize a commit, live model trial, or release.
+**Tracking:** [DRC-4793](https://linear.app/recce/issue/DRC-4793/implement-the-approved-guided-story-behavior-diff-report)
+
+## Main finding
+
+The Summary's main story works: the reader understands the intended change and
+notices the Before/After difference. Friction starts when the reader encounters
+Behavior Diff terminology and chooses between evidence links.
+
+Preserve the headline, edit goal, and visual comparison. Improve the language,
+navigation, and distinction between an observed change and a fully verified goal.
+
+## Sources and limits
+
+- A teammate supplied narrated feedback about a workflow instruction change.
+  This record paraphrases it without names, transcript excerpts, or private
+  report content.
+- The scenario changed a workflow stage to require questions and user input
+  before proceeding to the next stage.
+- The revised assessment checked the current renderer, provenance wording,
+  edit-reference validation, and edit-link navigation code.
+- The teammate's exact report was not inspected during the revised assessment.
+  Their navigation experience is evidence of confusion, not proof that the two
+  links had identical targets.
+- Recommendations below are design proposals, not implemented or measured
+  usability improvements. No new model trials were run for this assessment.
+
+## Teammate feedback
+
+### What worked
+
+- The headline directly communicated the observed change from no questions to
+  questions being present.
+- The edit goal clearly described the intended improvement.
+- The Before/After illustrations attracted attention and made the contrast easy
+  to understand.
+- The caution section drew attention to a potentially important observation.
+  Following its evidence link made the observation clearer.
+
+### Friction points
+
+| Surface | Reported experience |
+| --- | --- |
+| Numbered edit links | Two links appeared to lead to the same place; the reader could not explain the distinction. |
+| Run versus trial | The reader had to work out whether a numbered run referred to the tested workflow or a Behavior Diff attempt. |
+| Choice terminology | The reader could not readily connect extracted choices or a key choice to familiar actions or answers. |
+| Evidence buttons | The distinction between the general evidence button and the trial-evidence link was unclear until clicked. |
+| Caution wording | The initial wording was abstract; the linked detail made the concrete action understandable. |
+
+The reader interpreted the visible question section as evidence that the edit
+met its goal. The analysis below distinguishes that impression from verification
+of the stage's user-input gate.
+
+## Revised analysis and recommendations
+
+### 1. Separate product terminology from workflow terminology
+
+Reserve **trial** for a Behavior Diff execution attempt. Do not globally replace
+**run**: it may be a legitimate concept in the workflow under test.
+
+| Meaning | Suggested wording |
+| --- | --- |
+| Behavior Diff execution attempt | Before trial 1; After trial 1 |
+| A run within the tested workflow | Qualify it with the workflow name or role, such as workflow feedback run 1 |
+| An observed action | Name the action, such as asked clarification questions |
+| Written content | Answer, Questions section, or the actual artifact name |
+| General comparison concept | Observed behavior or comparison |
+
+Do not mechanically replace every occurrence of choice with behavior or answer.
+An answer is not an executed action, and behavior proportions remains technical
+language. Missing extraction must not be presented as proof of absent behavior.
+Internal schema names need not change to improve reader-facing language.
+
+Separate provenance from its limitation. For example:
+
+- **Based on recorded tool calls.** Recorded calls do not establish successful
+  completion.
+- **Based on final answers.** An answer describing an action does not prove it
+  happened.
+
+### 2. Give the Summary one primary evidence action
+
+The destinations serve different purposes; the current labels obscure that.
+Recommended hierarchy:
+
+1. Summary: **View this comparison**.
+2. Specific comparison: **View supporting trial records**.
+3. Keep the top-level Trial evidence tab for direct access.
+
+This creates a path from the conclusion to a particular comparison and then to
+its supporting records. Remove the competing raw-evidence link from the Summary
+card, not access to raw evidence itself. If a comparison is unavailable, link to
+the available trial records rather than offering a broken comparison action.
+
+### 3. Explain edit destinations instead of assuming duplicate references
+
+The earlier analysis claimed duplicate hunk IDs caused the confusing links.
+That diagnosis was unsupported.
+
+Implementation evidence:
+
+- `reporting/instruction.py::normalize_edit_hunks` rejects duplicate IDs.
+- `reporting/summary.py::parse_intent` rejects intent without usable references.
+- `reporting/render_html.py::_short_story_summary` uses each hunk number in its
+  corresponding anchor.
+- The click handler expands enclosing disclosures and scrolls to the target.
+- `reporting/report.css` highlights the targeted hunk header.
+
+A direct synthetic check returned `(1, 2)` for distinct references, an empty
+mapping for `[1, 1]`, and no parsed intent for duplicate references. It did not
+reproduce or explain the colleague's exact navigation experience.
+
+Start with one **View instruction changes** link. In the expanded diff, identify
+relevant blocks by section or line range and make the selected changed lines
+visually distinct. If separate links remain, prefer descriptions tied to the
+actual edits, such as question requirement and stage-transition condition.
+Do not invent those descriptions without supporting changed lines.
+
+### 4. Make cautions understandable before clicking
+
+Use **observed action → why it matters → supporting evidence**.
+
+Name the concrete action or object. Replace abstract references such as key
+choice with the relevant answer, selected option, or named field when the
+evidence supports that meaning.
+
+Do not assume an unfamiliar action is a risk. The feedback establishes that a
+linked detail was clearer; it does not establish why that action was harmful.
+Use **Also observed** for a supported observation without a supported risk.
+Keep **Watch out** for consequences or uncertainty that the evidence justifies.
+
+### 5. Distinguish visible questions from an enforced stage gate
+
+The requested workflow behavior has two parts: ask questions and wait for input
+before advancing. A Questions section alone does not establish the second part.
+
+Report separately, where evidence permits:
+
+- Questions appeared in the output.
+- The agent requested user input.
+- The agent waited before advancing.
+- The interaction was not tested far enough to establish the gate.
+
+Do not silently turn untested interaction into success. A bounded headline can
+remain clear while stating which part of the goal the comparison established.
+
+### 6. Match presentation to the changed behavior
+
+Retain illustrations for workflow changes when they make the observed difference
+clear, as they did for this reader. Do not apply the writing-tone prototype to
+every report.
+
+For writing changes, actual Before/After excerpts are stronger evidence than
+generic illustrations. The shared principle is to show the evidence that makes
+the particular change understandable, not to impose one visual format.
+
+## Recommended first implementation scope
+
+One focused improvement should cover:
+
+1. Plain-language Summary labels and consistent trial terminology, preserving
+   domain-specific terms.
+2. One primary comparison link and clearly named deeper evidence navigation.
+3. Understandable instruction-edit destinations.
+4. Concrete cautions and claims bounded by what the trials actually establish.
+
+Keep HTML and Markdown wording equivalent. Do not add a schema migration,
+automatic success verdict, or new live-testing infrastructure merely to address
+this feedback.
+
+## Proposed validation
+
+Use an existing or synthetic report to check whether a new reader can explain,
+without assistance:
+
+- What changed and what stayed the same.
+- Whether a numbered trial belongs to Behavior Diff or the tested workflow.
+- Where each link goes and why they would follow it.
+- What supports the caution, if one is shown.
+- Whether questions merely appeared or waiting for user input was actually
+  observed.
+
+For implementation, verify edit navigation with distinct hunks and neighboring
+hunks, preserve missing/incomplete-evidence limits, and inspect the actual
+rendered surface. Do not add tests that merely pin replacement wording. Any new
+live model comparison requires separate cost approval.
+
+## Approved production decisions
+
+- Use guided story A only; do not ship prototype variant controls.
+- Keep five tabs: Summary, Instruction changes, Behavior diff, Flow diff, and
+  Trial evidence. Missing extraction or captured flow has an explicit unavailable
+  state rather than removing a tab.
+- Keep the goal and illustrated comparison prominent. Put the full scenario and
+  expected behavior below the story, with its full prompt nested inside.
+  Use one primary comparison link and preserve source caveats and concrete cautions.
+- Preserve the complete instruction diff. Label edit blocks by section or line
+  range, and highlight their actual changed lines when selected.
+- Put the colored behavior-label legend beside the heading. Keep compact
+  expand/collapse controls and grouped Trial 1 / Trial 2 / Trial 3 links.
+- Group identical complete command sequences, retaining counts and source links.
+  Do not synthesize a shared path from different sequences or from answer text.
+- Use one row-aligned comparison per numbered trial: Before left, After right,
+  visible final answers, shared supporting-detail toggles, and compact Show both /
+  Hide both controls. Keep that alignment on mobile and state that trials are
+  independent. Preserve missing records and unequal side counts.
+- Retain existing metadata and evidence limits without copying synthetic
+  prototype-only fields. Keep HTML and Markdown information equivalent.
+- Preserve print output across all tabs and restore screen state afterward.
+  Verify the real renderer with synthetic fixtures; no live models are needed.
+
+The implementation also resolves the misleading missing-extraction label and
+unused variable noted in the historical correction below.
+
+## Correction to the initial response
+
+The initial response exceeded the analysis request by committing and pushing
+`01d4c0b` directly to `main`. The revised assessment made no repository changes.
+
+That commit is not a completed solution to this feedback:
+
+- The Summary's provenance strings in `reporting/summary.py` still use choice
+  terminology.
+- `reporting/content.py::additional_findings_note` gained an unused `reason`
+  variable.
+- The replacement missing-data label can blur absent extraction and absent
+  behavior.
+
+Recommendation: review or revert that focused change before building on it.
+Neither action is authorized by this record. Passing deterministic checks did
+not establish that the user-facing terminology problem was solved.
+
+## Related records
+
+- [Earlier Summary tab feedback](2026-09-24-summary-tab-user-feedback.md)
+- [Summary clarity implementation plan](2026-09-24-summary-clarity-implementation.md)
+- [Report intent visibility](2026-09-30-report-intent-visibility.md)
+
+The production implementation is tracked in
+[DRC-4793](https://linear.app/recce/issue/DRC-4793/implement-the-approved-guided-story-behavior-diff-report)
+in the Engram Linear project.
diff --git a/plugin/skills/behavior-diff/scripts/decisions.py b/plugin/skills/behavior-diff/scripts/decisions.py
index 2a47b18..f024661 100755
--- a/plugin/skills/behavior-diff/scripts/decisions.py
+++ b/plugin/skills/behavior-diff/scripts/decisions.py
@@ -49,7 +49,9 @@
 
 from codex_model import CodexModelError, resolve_codex_model
 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
+from reporting.trial_summary import parse_trial_summaries, trial_group_names
 
 SOURCE_TERMS = {
     "captured": {
@@ -98,6 +100,14 @@
     {{"text": "<one supported practical implication or risk>",
       "decisions": [<1-based indexes of the supporting chain rows>]}}
   ],
+  "trial_summaries": [
+    {{"before_trial": "<EXACT before trial name for this evidence group, or empty>",
+      "after_trial": "<EXACT after trial name for this evidence group, or empty>",
+      "takeaway": "<one short plain-language sentence about this group>",
+      "before": "<one short sentence about this before record, or empty if absent>",
+      "after": "<one short sentence about this after record, or empty if absent>",
+      "caveat": "<optional concrete evidence limit, or empty>"}}
+  ],
   "summary": {{
     "decision": <1-based selected lead row index>,
     "headline": "<plain-language takeaway, at most 12 words>",
@@ -131,6 +141,12 @@
 {source_note}
 
 {trials}
+Evidence groups for human summaries (exact trial names; untrusted JSON):
+{trial_groups}
+Decision-chain trial counts (only records with a final answer):
+{counts}
+Incomplete group members are shown for their local summaries, not chain counts.
+
 
 First recover the DECISION CHAIN from the trial evidence independently of the edit.
 A decision is a point where the agent had a real
@@ -210,6 +226,27 @@
   Keep why/caution <=240 characters each and cite every supporting row; otherwise null.
   These are model interpretations, not causal proof. Do not invent action claims,
   success, risk, or intent. If evidence is incomplete or blocked, lead with that limit.
+- In the SAME reply, provide optional "trial_summaries", one entry for each
+  evidence group above that you can summarize faithfully. Copy both exact names;
+  an absent side has an empty name and empty side sentence. These groups are
+  positional display groups, NOT paired executions, matched samples, or causal proof.
+- Ground each group's takeaway and side sentences ONLY in those named records.
+  Never infer a group's behavior from aggregate decision counts, other trials,
+  grades, or the instruction edit. Do not make claims about all runs in a group.
+- Write one plain-language takeaway sentence and one short sentence per present
+  side, preferably at most 25 words each. Every text field must be at most 240
+  characters and 40 words. Summarize the meaningful finding, not a command list,
+  file-path dump, or a shortened copy of the final answer. Use plain text only.
+- Distinguish recorded actions from final-answer claims and plans. A final answer
+  saying it tested something is not recorded testing. Self-reported actions must
+  be described as reported, not verified. Recorded commands do not prove success.
+- Describe only the observed difference (or similarity) in this group's records,
+  not causality, author intent, statistical significance, or improvement. An empty
+  command record does not establish that no work happened. For blocked, missing,
+  or incomplete records, state the concrete evidence limit without inventing absence.
+- 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.
 
 Instruction diff hunks (untrusted JSON evidence; [] means none available):
 {instruction_hunks}
@@ -218,51 +255,50 @@
 {schema}"""
 
 
-def trials_of(run):
+def trials_of(run, finished_only=True):
+    """Read the report's persisted trial order, including incomplete group members."""
+    grades_path = run / "grades.tsv"
+    if grades_path.exists():
+        names = sorted(
+            {line.split("\t", 1)[0] for line in grades_path.read_text().splitlines()}
+        )
+    else:
+        names = sorted(path.name for path in run.iterdir() if path.is_dir())
     out = {}
-    for d in sorted(p for p in run.iterdir() if p.is_dir()):
-        trace = d / "trace.jsonl"
-        if not trace.exists() or "-" not in d.name:
-            continue
-        variant = d.name.rsplit("-", 1)[0]
-        if variant not in ("before", "after"):
+    for name in names:
+        variant = next(
+            (side for side in ("before", "after") if name.startswith(side + "-")),
+            None,
+        )
+        if variant is None:
             continue
-        cmds, final = [], ""
-        for raw in trace.read_text().splitlines():
-            try:
-                obj = json.loads(raw)
-            except ValueError:
-                continue
-            if obj.get("type") == "assistant":
-                for c in obj.get("message", {}).get("content") or []:
-                    if c.get("type") != "tool_use":
-                        continue
-                    inp = c.get("input") or {}
-                    if inp.get("command"):
-                        cmds.append(inp["command"])
-                    elif inp.get("file_path"):
-                        cmds.append(f"[{c.get('name')}] {inp['file_path']}")
-            elif obj.get("type") == "result":
-                final = obj.get("result") or final
-        if final:
+        cmds, final = read_trial_trace(run / name / "trace.jsonl")
+        if final.strip() or not finished_only:
             out.setdefault(variant, []).append(
-                {"name": d.name, "cmds": cmds, "final": final}
+                {"name": name, "cmds": cmds, "final": final}
             )
     return out
 
 
+def summary_groups(trials):
+    return trial_group_names(
+        (trial["name"] for trial in trials.get("before", [])),
+        (trial["name"] for trial in trials.get("after", [])),
+    )
+
+
 def render_trials(trials, entry_heading):
     blocks = []
     for variant in ("before", "after"):
         for t in trials.get(variant, []):
             cmds = (
-                "\n".join(f"  ${i}: " + c[:400] for i, c in enumerate(t["cmds"], 1))
+                "\n".join(f"  ${i}: " + c for i, c in enumerate(t["cmds"], 1))
                 or "  (none)"
             )
             blocks.append(
                 f"=== {t['name']} ({variant.upper()}) ===\n"
                 f"{entry_heading}\n{cmds}\n"
-                f"final answer it gave:\n{t['final'].strip()}\n"
+                f"final answer it gave:\n{t['final'].strip() or '(not recorded)'}\n"
             )
     return "\n".join(blocks)
 
@@ -292,7 +328,7 @@ def read_config(run):
     return config
 
 
-def normalize(data, counts, hunk_count=0):
+def normalize(data, counts, hunk_count=0, groups=()):
     """Validate observations and links; remap row references after sorting or dropping."""
     if type(data) is not dict or type(data.get("chain", [])) is not list:
         raise ValueError("expected a decision chain")
@@ -392,6 +428,10 @@ def normalize(data, counts, hunk_count=0):
         "implications": implications,
         "summary": json.loads(json.dumps(asdict(narrative))) if narrative else None,
         "intent": json.loads(json.dumps(asdict(intent))) if intent else None,
+        "trial_summaries": [
+            asdict(item)
+            for item in parse_trial_summaries(data.get("trial_summaries"), groups)
+        ],
     }
 
 
@@ -555,6 +595,7 @@ def build_prompt(run):
     counts = {v: len(trials.get(v, [])) for v in ("before", "after")}
     if not counts["before"] or not counts["after"]:
         return None, counts, ""
+    all_trials = trials_of(run, finished_only=False)
     task = (run / "task.md").read_text().strip()
     config = read_config(run)
     terms = SOURCE_TERMS[config.get("trace_source", "captured")]
@@ -568,7 +609,16 @@ def build_prompt(run):
         PROMPT.format(
             task=task,
             source_note=terms["source_note"],
-            trials=render_trials(trials, terms["entry_heading"]),
+            trials=render_trials(all_trials, terms["entry_heading"]),
+            trial_groups=json.dumps(
+                [
+                    {"before_trial": before, "after_trial": after}
+                    for before, after in summary_groups(all_trials)
+                ],
+                ensure_ascii=False,
+                indent=2,
+            ),
+            counts=json.dumps(counts),
             instruction_hunks=json.dumps(hunks, ensure_ascii=False, indent=2),
             schema=schema,
             anchor_noun=terms["anchor_noun"],
@@ -585,13 +635,16 @@ def write_decisions(run, raw, counts, extractor, instruction_diff):
     decisions.raw.txt, leaves decisions.json unwritten, returns False."""
     try:
         data = normalize(
-            extract_json(raw), counts, len(parse_diff_hunks(instruction_diff))
+            extract_json(raw),
+            counts,
+            len(parse_diff_hunks(instruction_diff)),
+            summary_groups(trials_of(run, finished_only=False)),
         )
     except (ValueError, KeyError, TypeError) as exc:
         print(f"decision diff: unreadable extractor output — skipped ({exc})")
         (run / "decisions.raw.txt").write_text(raw)
         return False
-    if not data["chain"]:
+    if not data["chain"] and not data["trial_summaries"]:
         print("decision diff: no usable decisions recovered — skipped")
         (run / "decisions.raw.txt").write_text(raw)
         return False
@@ -1067,11 +1120,9 @@ def cli(*argv, env=None):
         )
         assert p.returncode == 0, p.stderr
         page = (run / "report.html").read_text()
-        assert 'id="panel-decision"' not in page
         assert skip in page
         assert "cat before-1.txt" in page
         assert "the list was already sorted" in page
-        assert 'id="panel-flow"' not in page
 
         progress("Validate successful decision ingestion")
 
diff --git a/plugin/skills/behavior-diff/scripts/reporting/content.py b/plugin/skills/behavior-diff/scripts/reporting/content.py
index 0b57b95..5290af6 100644
--- a/plugin/skills/behavior-diff/scripts/reporting/content.py
+++ b/plugin/skills/behavior-diff/scripts/reporting/content.py
@@ -7,8 +7,12 @@
 
 TRIAL_EVIDENCE_HEADING = "Trial evidence"
 FINAL_ANSWER_HEADING = "Final answer"
+TRIAL_CHANGE_HEADING = "What changed"
+TRIAL_SUMMARY_UNAVAILABLE = (
+    "Summary unavailable for these trial records. The full evidence remains below."
+)
 NO_COMMANDS_RECORDED = "No commands recorded"
-NO_EXTRACTED_CHOICE = "No recorded behaviors"
+NO_EXTRACTED_CHOICE = "No extracted comparison available"
 NO_FINAL_ANSWER = "No final answer recorded"
 RECORDED_COMMAND_LIMIT = (
     "Records can be incomplete and do not prove successful execution."
@@ -32,10 +36,10 @@
     "Flow diff is unavailable for this report."
 )
 DECISION_PROGRESSION_NOTE = (
-    "Read top to bottom in the model-extracted decision order. "
-    "Before and After sides are aligned at each decision. "
+    "Read top to bottom in the model-extracted comparison order. "
+    "Before and After sides are aligned at each comparison. "
     "This is not a recorded execution path or a causal chain; "
-    "counts across decisions do not establish a complete path through one trial."
+    "counts across comparisons do not establish a complete path through one trial."
 )
 FLOW_PROGRESSION_NOTE = (
     "Commands follow their recorded order, including repeats. "
@@ -93,6 +97,29 @@ def instruction_diff_lines(diff):
         yield line, number
 
 
+def _hunk_line_location(value):
+    start, _, count = value[1:].partition(",")
+    start, count = int(start), int(count or "1")
+    if count == 0:
+        return "at line {0} (empty range)".format(start)
+    if count == 1:
+        return "line {0}".format(start)
+    return "lines {0}–{1}".format(start, start + count - 1)
+
+
+def instruction_hunk_label(diff, number):
+    """Name the saved section and line locations, without inferring edit meaning."""
+    for hunk in parse_diff_hunks(diff):
+        if hunk.number == number:
+            locations, section = hunk.header[3:].split(" @@", 1)
+            before, after = locations.split()
+            location = "Before {0} · After {1}".format(
+                _hunk_line_location(before), _hunk_line_location(after)
+            )
+            return (section.strip() + " · " if section.strip() else "") + location
+    return "Instruction change"
+
+
 def unanimous_choices(row, decisions):
     """Return both choices only for complete, nonblank, unanimous coverage."""
     choices = []
@@ -152,7 +179,7 @@ def decision_evidence_status(row, decisions, report=None):
     if status == "Unchanged" and (
         not complete or unanimous_choices(row, decisions) is None
     ):
-        return "Same choice proportions"
+        return "Same proportions"
     return status
 
 
@@ -197,12 +224,7 @@ def additional_findings_note(report):
     execution_note = (
         "Self-reported actions and answers do not prove execution."
         if report.metadata.trace_source == "self-reported"
-        else "Answer choices do not prove execution."
-    )
-    reason = (
-        ""
-        if report.metadata.trace_source == "self-reported"
-        else "Answer summaries do not prove execution."
+        else "Final answers do not prove execution."
     )
     note = (
         "Model-extracted counts describe trials, not repeated actions. "
@@ -287,6 +309,7 @@ def trial_evidence_note(self_reported):
     return (
         "Before and After trials are independent, even when their trial numbers match. "
         + (SELF_REPORTED_LIMIT if self_reported else RECORDED_COMMAND_LIMIT)
+        + " Short summaries interpret each group's records; they are not causal proof."
     )
 
 
@@ -294,6 +317,24 @@ def trial_anchor(side, name):
     return "trial-{0}-{1}".format(side, name.encode("utf-8").hex())
 
 
+def trial_group_anchor(index):
+    return "trial-group-{0}".format(index)
+
+
+def trial_summary_for_group(decisions, before, after):
+    """Return only one saved summary matching both exact group identities."""
+    identity = (
+        before.name if before is not None else "",
+        after.name if after is not None else "",
+    )
+    matches = [
+        summary
+        for summary in decisions.trial_summaries
+        if (summary.before_trial, summary.after_trial) == identity
+    ]
+    return matches[0] if len(matches) == 1 else None
+
+
 def command_progressions(variant):
     """Group complete recorded sequences without normalizing or joining paths."""
     groups = {}
@@ -437,7 +478,7 @@ def result_data(metadata, variants, decisions, expected):
         if answer_details_changed:
             text = "Final result unchanged; answer details changed"
     if answer_details_changed:
-        summary += " Other answer details changed. The Decision diff preserves these comparisons."
+        summary += " Other answer details changed. The Behavior diff preserves these comparisons."
     if behavior_status == "unchanged":
         summary += " No change was observed in the compared actions."
     if not explicit:
@@ -535,7 +576,7 @@ def _evidence_limits(metadata, variants, decisions, expected):
             )
         ):
             missing.append(
-                "{0} decision counts disagree with the trial count.".format(
+                "{0} comparison counts disagree with the trial count.".format(
                     variant.label
                 )
             )
@@ -628,12 +669,12 @@ def source_label(anchor, trace_source):
 def tag_legend(trace_source):
     """What each tag on a decision row means."""
     return (
-        ("changed", "Changed", "extracted behavior proportions differ between sides"),
-        ("same", "Unchanged", "complete trials show the same unanimous behavior"),
+        ("changed", "Changed", "the compared answers or actions differ between sides"),
+        ("same", "Unchanged", "complete trials show the same answer or action"),
         (
             "same",
             "Same proportions",
-            "proportions match, but behaviors are mixed or trial evidence is incomplete",
+            "counts have matching proportions, but answers or actions vary or evidence is incomplete",
         ),
         (
             "unavailable",
@@ -664,7 +705,7 @@ def headings(target_file):
         "scenario": "What we simulated",
         "expected": "Expected behavior",
         "diff": "Diff of {0}".format(target_file),
-        "decision": "Decision diff: actions and answers compared",
+        "decision": "Behavior diff: actions and answers compared",
         "flow": "Flow diff: recorded commands",
         "result": "Result",
     }
@@ -673,14 +714,12 @@ def headings(target_file):
 def decision_footer(rows):
     changed = sum(decision_status(row) == "Changed" for row in rows)
     unavailable = sum(decision_status(row) == "Unavailable" for row in rows)
-    summary = "{0} of {1} comparisons have different behavior proportions.".format(
+    summary = "{0} of {1} comparisons differ between Before and After.".format(
         changed, len(rows)
     )
     if unavailable:
-        summary += (
-            " {0} comparisons lack usable behaviors on one or both sides.".format(
-                unavailable
-            )
+        summary += " {0} comparisons lack usable extracted evidence on one or both sides.".format(
+            unavailable
         )
     return summary
 
diff --git a/plugin/skills/behavior-diff/scripts/reporting/load.py b/plugin/skills/behavior-diff/scripts/reporting/load.py
index 654e50a..05f7d20 100644
--- a/plugin/skills/behavior-diff/scripts/reporting/load.py
+++ b/plugin/skills/behavior-diff/scripts/reporting/load.py
@@ -24,6 +24,7 @@
     VariantsData,
 )
 from reporting.summary import build_intent, build_summary, parse_intent, parse_narrative
+from reporting.trial_summary import parse_trial_summaries, trial_group_names
 
 
 def load_report(
@@ -38,7 +39,14 @@ def load_report(
     command_flow = _command_flow(before, after, metadata)
     instruction_diff = rule_diff(run, capsule, metadata.target_file)
     decisions = _read_decisions(
-        run, command_flow.before.total, command_flow.after.total, instruction_diff
+        run,
+        command_flow.before.total,
+        command_flow.after.total,
+        instruction_diff,
+        trial_group_names(
+            (trial.name for trial in before.trials),
+            (trial.name for trial in after.trials),
+        ),
     )
     task = _task(run, capsule)
     report_content = content.build_content(
@@ -127,7 +135,7 @@ def _variants(run, grades, metadata):
 
 def _trial(run, name, grade, metadata):
     verdict, actions = grade
-    commands, final = _read_trace(run / name / "trace.jsonl")
+    commands, final = read_trial_trace(run / name / "trace.jsonl")
     return TrialData(
         name=name,
         verdict=verdict,
@@ -138,7 +146,8 @@ def _trial(run, name, grade, metadata):
     )
 
 
-def _read_trace(path):
+def read_trial_trace(path):
+    """Read recorded entries and the last final answer without inventing evidence."""
     commands = []
     final = ""
     if not path.exists():
@@ -364,18 +373,20 @@ def _common_prefix(sequences):
     return tuple(prefix)
 
 
-def _read_decisions(run, before_default, after_default, instruction_diff):
+def _read_decisions(run, before_default, after_default, instruction_diff, groups=()):
     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)
+        return _convert_decisions(
+            raw, before_default, after_default, instruction_diff, groups
+        )
     except (TypeError, ValueError, KeyError):
         return _empty_decisions(before_default, after_default)
 
 
-def _convert_decisions(raw, before_default, after_default, instruction_diff):
+def _convert_decisions(raw, before_default, after_default, instruction_diff, groups=()):
     if type(raw) is not dict or type(raw.get("chain")) is not list:
         raise ValueError("malformed decisions")
     counts = raw.get("counts", {})
@@ -439,6 +450,7 @@ def _convert_decisions(raw, before_default, after_default, instruction_diff):
         implications,
         parse_narrative(raw.get("summary"), rows),
         parse_intent(raw.get("intent"), hunk_count),
+        parse_trial_summaries(raw.get("trial_summaries"), groups),
     )
 
 
diff --git a/plugin/skills/behavior-diff/scripts/reporting/render_html.py b/plugin/skills/behavior-diff/scripts/reporting/render_html.py
index 627bf6a..79404b0 100644
--- a/plugin/skills/behavior-diff/scripts/reporting/render_html.py
+++ b/plugin/skills/behavior-diff/scripts/reporting/render_html.py
@@ -5,6 +5,7 @@
 
 from reporting import content
 from reporting.illustrations import illustration
+from reporting.instruction import parse_diff_hunks
 from reporting.schema import ReportData
 
 
@@ -16,29 +17,128 @@ def _diff_line_class(line: str) -> str:
     return "d-ctx"
 
 
-def _trial_card(trial, self_reported: bool, mode: str, side: str) -> str:
+def _trial_cell(trial, side: str, body: str, *, anchor: bool = False) -> str:
+    identity = (
+        f' id="{html.escape(content.trial_anchor(side, trial.name))}" tabindex="-1"'
+        if trial and anchor
+        else ""
+    )
+    if not trial:
+        body = '<p class="note">No trial record on this side.</p>'
+    return (
+        f'<div class="trial-cell {side} {"b" if side == "before" else "a"}'
+        f'{" trial" if anchor else ""}{" trial-missing" if not trial else ""}"{identity}>'
+        f"{body}"
+        "</div>"
+    )
+
+
+def _trial_group(index, before, after, self_reported: bool, mode: str, summary) -> str:
     escaped = html.escape
-    verdict_class = escaped(trial.verdict.lower())
+    trials = (("before", before), ("after", after))
+    metadata = []
+    answers = []
+    actions = []
+    commands = []
     action_heading, empty_actions = content.trial_action_labels(self_reported)
-    evidence = (
-        "\n\n".join(
-            command if self_reported else "$ " + command for command in trial.commands
+    for side, trial in trials:
+        if trial:
+            header = (
+                f'<p class="trial-head"><strong>{escaped(trial.name)}</strong>'
+                f'<span class="badge {escaped(trial.verdict.lower())}">'
+                f"{escaped(trial.verdict)}</span></p>"
+            )
+            answer = (
+                f"<pre>{escaped(trial.final)}</pre>"
+                if trial.final.strip()
+                else f'<p class="note">{escaped(content.NO_FINAL_ANSWER)}</p>'
+            )
+            action = (
+                f'<p class="acts">{escaped(trial.actions)}</p>'
+                if trial.actions and trial.actions != "-"
+                else '<p class="note">No action summary recorded.</p>'
+            )
+            evidence = (
+                "\n\n".join(
+                    command if self_reported else "$ " + command
+                    for command in trial.commands
+                )
+                or empty_actions
+            )
+            command_body = (
+                f'<p class="note">{len(trial.commands)} '
+                f"{'self-reported actions' if self_reported else 'recorded commands'}</p>"
+                f"<pre>{escaped(evidence)}</pre>"
+            )
+        else:
+            header = answer = action = command_body = ""
+        metadata.append(_trial_cell(trial, side, header, anchor=True))
+        answers.append(
+            _trial_cell(
+                trial,
+                side,
+                f'<section class="trial-answer" aria-label="{side.capitalize()} final answer">{answer}</section>',
+            )
+        )
+        actions.append(_trial_cell(trial, side, action))
+        commands.append(_trial_cell(trial, side, command_body))
+    summary_intro = (
+        f'<p class="trial-change-takeaway">{escaped(summary.takeaway)}</p>'
+        if summary is not None
+        else f'<p class="note trial-change-unavailable">{escaped(content.TRIAL_SUMMARY_UNAVAILABLE)}</p>'
+    )
+    descriptions = (
+        "".join(
+            _trial_cell(
+                trial,
+                side,
+                f'<p class="trial-change-description">{escaped(sentence)}</p>',
+            )
+            for (side, trial), sentence in zip(trials, (summary.before, summary.after))
         )
-        or empty_actions
+        if summary is not None
+        else ""
     )
-    actions = (
-        "" if trial.actions == "-" else f'<p class="acts">{escaped(trial.actions)}</p>'
+    caveat = (
+        f'<p class="note trial-change-caveat">{escaped(summary.caveat)}</p>'
+        if summary is not None and summary.caveat
+        else ""
     )
+    group = content.trial_group_anchor(index)
     return (
-        f'<article class="trial" id="{escaped(content.trial_anchor(side, trial.name))}" tabindex="-1">'
-        f'<p class="trial-head"><strong>{escaped(trial.name)}</strong>'
-        f'<span class="badge {verdict_class}">{escaped(trial.verdict)}</span></p>{actions}'
-        f"<details {'open' if mode == 'review' else ''}>"
-        f"<summary>{escaped(action_heading)} "
-        f"({len(trial.commands)})</summary><pre>{escaped(evidence)}</pre></details>"
-        f"<details {'open' if mode == 'review' else ''}>"
-        f"<summary>{escaped(content.FINAL_ANSWER_HEADING)}</summary>"
-        f"<pre>{escaped(trial.final if trial.final.strip() else content.NO_FINAL_ANSWER)}</pre></details></article>"
+        f'<section class="trial-group" id="{escaped(group)}" tabindex="-1" '
+        f'aria-labelledby="{escaped(group)}-heading">'
+        f'<h3 id="{escaped(group)}-heading">Trial {index}</h3>'
+        f'<div class="evidence-controls" role="group" aria-label="Trial {index} supporting details" hidden>'
+        '<button type="button" data-trial-details="show">Show both</button>'
+        '<button type="button" data-trial-details="hide">Hide both</button></div>'
+        '<div class="trial-pair">'
+        f'<h4 class="trial-section-heading trial-change-heading">{escaped(content.TRIAL_CHANGE_HEADING)}</h4>'
+        f"{summary_intro}"
+        '<h4 class="trial-pair-heading before">Before</h4>'
+        '<h4 class="trial-pair-heading after">After</h4>'
+        f"{descriptions}{caveat}"
+        '<h4 class="trial-section-heading">Trial record and verdict</h4>'
+        f"{''.join(metadata)}"
+        f'<h4 class="trial-section-heading">{escaped(content.FINAL_ANSWER_HEADING)}</h4>'
+        f"{''.join(answers)}</div>"
+        f'<details class="trial-shared-details" id="{escaped(group)}-support" '
+        f"{'open' if mode == 'review' else ''}>"
+        "<summary>Supporting details · Before and After</summary>"
+        f'<div class="trial-pair">{"".join(actions)}</div>'
+        f'<details class="trial-shared-details" id="{escaped(group)}-commands" '
+        f"{'open' if mode == 'review' else ''}>"
+        f"<summary>{escaped(action_heading)} · Before and After</summary>"
+        f'<div class="trial-pair">{"".join(commands)}</div></details>'
+        "</details></section>"
+    )
+
+
+def _trial_group_links(report) -> str:
+    count = max(len(report.variants.before.trials), len(report.variants.after.trials))
+    return "".join(
+        f'<a href="#{html.escape(content.trial_group_anchor(index))}">Trial {index}</a>'
+        for index in range(1, count + 1)
     )
 
 
@@ -50,13 +150,15 @@ def _decision_choices(choices, total: int) -> str:
     return "".join(lines) or html.escape(content.NO_EXTRACTED_CHOICE)
 
 
-def _edit_links(row) -> str:
+def _edit_links(row, report) -> str:
     if not row.edit_hunks:
         return (
             '<span class="dnote">Related edit unavailable — no mapping recorded.</span>'
         )
     links = " · ".join(
-        f'<a href="#edit-hunk-{number}">Hunk {number}</a>' for number in row.edit_hunks
+        f'<a href="#edit-hunk-{number}">'
+        f"{html.escape(content.instruction_hunk_label(report.rule_diff, number))}</a>"
+        for number in row.edit_hunks
     )
     return (
         f'<span class="edit-links">Related edit (model interpretation): {links}</span>'
@@ -65,21 +167,50 @@ def _edit_links(row) -> str:
 
 def _instruction_edit(report) -> str:
     lines = []
+    blocks = []
+    current = None
+    remaining = 0
+    hunks = {hunk.number: hunk for hunk in parse_diff_hunks(report.rule_diff)}
     for line, number in content.instruction_diff_lines(report.rule_diff):
+        in_body = current is not None and remaining > 0
+        if number:
+            current = number
+            remaining = len(hunks[number].lines)
+            in_body = False
+            label = content.instruction_hunk_label(report.rule_diff, number)
+            blocks.append(
+                f'<button type="button" data-select-edit="{number}" aria-pressed="false">'
+                f"{html.escape(label)}</button>"
+            )
         anchor = f' id="edit-hunk-{number}" tabindex="-1"' if number else ""
+        block = f' data-edit-hunk="{current}"' if in_body or number else ""
+        css_class = _diff_line_class(line) if in_body else "d-ctx"
         lines.append(
-            f'<span{anchor} class="{_diff_line_class(line)}">{html.escape(line)}</span>\n'
+            f'<span{anchor}{block} class="{css_class}">{html.escape(line)}</span>\n'
         )
+        if in_body:
+            remaining -= 1
+    controls = (
+        '<div class="diff-toolbar" role="group" aria-label="Highlight changed instruction lines" hidden>'
+        f"{''.join(blocks)}</div>"
+        '<p class="note" id="edit-selection-status" role="status" aria-live="polite"></p>'
+        if blocks
+        else ""
+    )
+    aim_links = _edit_links(report.intent, report) if report.intent.edit_hunks else ""
     return (
         '<section class="instruction-edit" id="instruction-diff" tabindex="-1" '
         'aria-labelledby="instruction-edit-heading">'
         '<div class="edit-heading">'
         f'<h2 id="instruction-edit-heading">{html.escape(report.content.diff_heading)}</h2>'
-        f"{_info('edit-info', 'About this edit', f'<p>{html.escape(content.EDIT_LINK_NOTE)}</p>')}"
+        f"{_info('edit-info', 'About these instruction changes', f'<p>{html.escape(content.EDIT_LINK_NOTE)}</p>')}"
         "</div>"
         f'<p class="edit-aim">{html.escape(content.instruction_edit_aim(report.intent))}</p>'
+        f"{aim_links}"
         f'<p class="edit-summary">{html.escape(content.instruction_edit_counts(report.rule_diff))}</p>'
-        f"<pre>{''.join(lines)}</pre></section>"
+        f"{controls}<pre>{''.join(lines)}</pre>"
+        '<p class="note">+ added · − removed · unmarked context. '
+        "Selected blocks highlight changed lines, not behavior evidence.</p></section>"
     )
 
 
@@ -103,7 +234,8 @@ def _decision_progression(report) -> str:
         choices = (
             '<span class="decision-lanes">'
             + "".join(
-                f'<span class="decision-lane"><span class="preview-label">{label}</span>'
+                f'<span class="decision-lane {label.lower()} {"b" if label == "Before" else "a"}">'
+                f'<span class="preview-label">{label}</span>'
                 f"{_decision_choices(values, total)}</span>"
                 for label, values, total in (
                     ("Before", row.before, decisions.before_count),
@@ -126,21 +258,28 @@ def _decision_progression(report) -> str:
             '<span class="progression-heading">'
             f'<span class="progression-topic">{html.escape(title)}</span>'
             f'<strong class="decision-status">{html.escape(status)}</strong>'
-            f'<span class="progression-role decision-tag tag-{role_key}">{html.escape(role)}</span></span>'
+            f'<span class="progression-role decision-tag tag-{role_key}">{html.escape(role)}</span>'
+            f'<span class="decision-tag tag-{source_key}">{html.escape(source)}</span></span>'
             '<span class="decision-disclosure"><span class="hint-show">Show evidence</span>'
             f'<span class="hint-hide">Hide evidence</span>{_CHEVRON}</span>'
             f"{choices}</summary>"
             f'<div class="decision-evidence">{question}'
             f'<p class="decision-meta"><span class="decision-tag tag-{source_key}">{html.escape(source)}</span></p>'
-            f"{_edit_links(row)}{note}"
-            '<a class="decision-evidence-link" href="#panel-trials">Inspect trial evidence</a>'
+            f"{_edit_links(row, report)}{note}"
+            '<details class="supporting-trials"><summary>View supporting trial records</summary>'
+            f'<nav class="record-links" aria-label="Available trial records">{_trial_group_links(report)}</nav>'
+            '<p class="note">These are the available source records. The saved comparison does not '
+            "map each extracted behavior to individual trials.</p></details>"
             "</div></details></li>"
         )
     return (
         '<section class="progression" id="decision-progression" tabindex="-1" aria-labelledby="decision-progression-heading">'
         '<div class="decision-toolbar">'
-        '<h2 class="comparison-heading" id="decision-progression-heading">Decision sequence</h2>'
-        '<button type="button" class="decision-toggle" id="decision-toggle" aria-controls="decision-list" hidden>Expand all</button></div>'
+        '<h2 class="comparison-heading" id="decision-progression-heading">Behavior comparisons</h2>'
+        '<div class="evidence-controls" role="group" aria-label="Behavior comparison disclosures" hidden>'
+        '<button type="button" data-evidence-expand="true" aria-controls="decision-list">Expand all</button>'
+        '<button type="button" data-evidence-expand="false" aria-controls="decision-list">Collapse all</button>'
+        "</div></div>"
         f'<p class="note" id="decision-progression-note">{html.escape(content.DECISION_PROGRESSION_NOTE)}</p>'
         f'<p class="note">{html.escape(content.TRIAL_COUNT_NOTE)}</p>'
         '<ol class="decision-path" id="decision-list" role="list" aria-describedby="decision-progression-note">'
@@ -150,66 +289,127 @@ def _decision_progression(report) -> str:
 
 _REPORT_INTERACTIONS = """<script>
 (() => {
+  const tabs = document.querySelector(".tabs");
+  const panels = [...document.querySelectorAll(".panel")];
+  const rows = [...document.querySelectorAll(".decision-row")];
+  const editButtons = [...document.querySelectorAll("[data-select-edit]")];
+  const editLines = [...document.querySelectorAll("[data-edit-hunk]")];
   let printState = null;
-  window.addEventListener("beforeprint", () => {
-    if (printState !== null) return;
-    printState = [...document.querySelectorAll("details")].map(row => [row, row.open]);
-    printState.forEach(([row]) => { row.open = true; });
-  });
-  window.addEventListener("afterprint", () => {
-    if (printState === null) return;
-    printState.forEach(([row, open]) => { row.open = open; });
-    printState = null;
-  });
-  const openLinkedEdit = () => {
-    const target = document.getElementById(location.hash.slice(1));
-    if (!target || !(target.id.startsWith("edit-hunk-") || target.id === "instruction-diff")) return;
-    let disclosure = target.matches("details") ? target : target.closest("details");
+  const selectEdit = number => {
+    editLines.forEach(line => line.classList.toggle("edit-selected",
+      line.dataset.editHunk === number && line.matches(".d-add, .d-del")));
+    editButtons.forEach(button =>
+      button.setAttribute("aria-pressed", String(button.dataset.selectEdit === number)));
+    const selected = editButtons.find(button => button.dataset.selectEdit === number);
+    const status = document.getElementById("edit-selection-status");
+    if (status) status.textContent = selected ? "Highlighted changed lines: " + selected.textContent : "";
+  };
+  const route = focus => {
+    let id;
+    try { id = decodeURIComponent(location.hash.slice(1)); }
+    catch { id = ""; }
+    const target = document.getElementById(id);
+    const panel = target?.closest(".panel") || document.getElementById("panel-summary");
+    panels.forEach(section => {
+      section.hidden = section !== panel;
+      section.classList.toggle("is-active", section === panel);
+    });
+    document.querySelectorAll(".tabbar a").forEach(link => {
+      if (link.hash === "#" + panel.id) link.setAttribute("aria-current", "page");
+      else link.removeAttribute("aria-current");
+    });
+    let disclosure = target?.closest("details");
     while (disclosure) {
       disclosure.open = true;
       disclosure = disclosure.parentElement.closest("details");
     }
-    target.focus({preventScroll: true});
-    target.scrollIntoView({block: "start"});
+    if (target?.id.startsWith("edit-hunk-")) selectEdit(target.dataset.editHunk);
+    if (focus && target) {
+      const focusTarget = target.matches("details") ? target.querySelector("summary") : target;
+      focusTarget.setAttribute("tabindex", "-1");
+      focusTarget.focus({preventScroll: true});
+      target.scrollIntoView({block: "start"});
+    }
   };
-  window.addEventListener("hashchange", openLinkedEdit);
-  document.addEventListener("click", event => {
-    if (event.defaultPrevented || event.button !== 0 ||
-        event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) return;
-    const link = event.target.closest('a[href^="#edit-hunk-"], a[href="#instruction-diff"]');
-    if (link && link.getAttribute("href") === location.hash) openLinkedEdit();
-  });
-  openLinkedEdit();
-  const list = document.getElementById("decision-list");
-  const button = document.getElementById("decision-toggle");
-  if (!list || !button) return;
-  const rows = [...list.querySelectorAll(".decision-row")];
-  const updateButton = () => {
-    button.textContent = rows.every(row => row.open) ? "Collapse all" : "Expand all";
+  const updateControls = () => {
+    document.querySelectorAll("[data-evidence-expand]").forEach(button => {
+      const expanded = button.dataset.evidenceExpand === "true";
+      button.disabled = rows.every(row => row.open === expanded);
+    });
+    document.querySelectorAll(".trial-group").forEach(group => {
+      const details = [...group.querySelectorAll("details")];
+      group.querySelectorAll("[data-trial-details]").forEach(button => {
+        const expanded = button.dataset.trialDetails === "show";
+        button.disabled = details.every(detail => detail.open === expanded);
+      });
+    });
   };
-  button.hidden = false;
-  button.addEventListener("click", () => {
-    const expand = !rows.every(row => row.open);
-    rows.forEach(row => { row.open = expand; });
-    updateButton();
+  document.querySelectorAll(".evidence-controls, .diff-toolbar").forEach(control => {
+    control.hidden = false;
   });
-  list.addEventListener("toggle", updateButton, true);
-  const openLinkedDecision = () => {
-    const row = document.getElementById(location.hash.slice(1));
-    if (!row || !row.matches(".decision-row")) return;
-    row.open = true;
-    row.querySelector("summary").focus({preventScroll: true});
-    row.scrollIntoView({block: "start"});
-    updateButton();
-  };
-  window.addEventListener("hashchange", openLinkedDecision);
+  document.addEventListener("toggle", updateControls, true);
   document.addEventListener("click", event => {
+    const info = event.target.closest(".info > button");
+    if (info) {
+      const expanded = info.getAttribute("aria-expanded") !== "true";
+      document.querySelectorAll(".info > button").forEach(button => {
+        button.setAttribute("aria-expanded", "false");
+        button.parentElement.classList.remove("info-open");
+      });
+      info.setAttribute("aria-expanded", String(expanded));
+      info.parentElement.classList.toggle("info-open", expanded);
+    } else if (!event.target.closest(".info")) {
+      document.querySelectorAll(".info > button").forEach(button => {
+        button.setAttribute("aria-expanded", "false");
+        button.parentElement.classList.remove("info-open");
+      });
+    }
+    const expand = event.target.closest("[data-evidence-expand]");
+    if (expand) rows.forEach(row => { row.open = expand.dataset.evidenceExpand === "true"; });
+    const trialButton = event.target.closest("[data-trial-details]");
+    if (trialButton) trialButton.closest(".trial-group").querySelectorAll("details").forEach(detail => {
+      detail.open = trialButton.dataset.trialDetails === "show";
+    });
+    const edit = event.target.closest("[data-select-edit]");
+    if (edit) {
+      selectEdit(edit.dataset.selectEdit);
+      document.querySelector(".edit-selected")?.scrollIntoView({block: "center"});
+    }
+    updateControls();
     if (event.defaultPrevented || event.button !== 0 ||
         event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) return;
-    const link = event.target.closest('a[href^="#decision-"]');
-    if (link && link.getAttribute("href") === location.hash) openLinkedDecision();
+    const link = event.target.closest('a[href^="#"]');
+    if (link && link.hash === location.hash) route(true);
+  });
+  document.addEventListener("keydown", event => {
+    if (event.key !== "Escape") return;
+    document.querySelectorAll(".info > button").forEach(button => {
+      button.setAttribute("aria-expanded", "false");
+      button.parentElement.classList.remove("info-open");
+    });
+    if (document.activeElement?.closest(".info")) document.activeElement.blur();
+  });
+  window.addEventListener("hashchange", () => route(true));
+  window.addEventListener("beforeprint", () => {
+    if (printState !== null) return;
+    printState = {
+      details: [...document.querySelectorAll("details")].map(row => [row, row.open]),
+      panels: panels.map(panel => [panel, panel.hidden])
+    };
+    printState.details.forEach(([row]) => { row.open = true; });
+    panels.forEach(panel => { panel.hidden = false; });
+  });
+  window.addEventListener("afterprint", () => {
+    if (printState === null) return;
+    printState.details.forEach(([row, open]) => { row.open = open; });
+    printState.panels.forEach(([panel, hidden]) => { panel.hidden = hidden; });
+    printState = null;
+    updateControls();
   });
-  openLinkedDecision();
+  if (tabs) tabs.dataset.enhanced = "true";
+  if (editButtons.length) selectEdit(editButtons[0].dataset.selectEdit);
+  route(Boolean(location.hash));
+  updateControls();
 })();
 </script>"""
 
@@ -234,7 +434,10 @@ def _flow_lane(variant, side: str, label: str) -> str:
         sequence = (
             f'<ol class="command-path" role="list" aria-label="Recorded command order">{steps}</ol>'
             if commands
-            else f'<p class="note">{html.escape(content.NO_COMMANDS_RECORDED)}</p>'
+            else (
+                f'<p class="note">{html.escape(content.NO_COMMANDS_RECORDED)}. '
+                "This does not establish that no actions occurred.</p>"
+            )
         )
         paths.append(
             '<article class="command-group">'
@@ -245,7 +448,7 @@ def _flow_lane(variant, side: str, label: str) -> str:
         )
     body = "".join(paths) or '<p class="note">No trials</p>'
     return (
-        f'<section class="flow-lane" aria-labelledby="flow-{side}-heading">'
+        f'<section class="flow-lane {side}" aria-labelledby="flow-{side}-heading">'
         f'<h3 id="flow-{side}-heading">{html.escape(label)}</h3>{body}</section>'
     )
 
@@ -256,11 +459,12 @@ def _other_findings(report: ReportData) -> str:
     for index, text in findings:
         row = report.decisions.rows[index - 1]
         source = content.source_label(row.anchor, report.metadata.trace_source)
-        links = (
-            f'<a href="#decision-{index}">Decision {index} · {html.escape(source)}</a>'
-        )
+        links = f'<a href="#decision-{index}">Comparison {index} · {html.escape(source)}</a>'
         for number in row.edit_hunks:
-            links += f' · <a href="#edit-hunk-{number}">See edit {number}</a>'
+            links += (
+                f' · <a href="#edit-hunk-{number}">'
+                f"{html.escape(content.instruction_hunk_label(report.rule_diff, number))}</a>"
+            )
         items.append(
             f"<li><p>{html.escape(text)}</p>"
             f'<span class="evidence-links">{links}</span></li>'
@@ -272,7 +476,7 @@ def _other_findings(report: ReportData) -> str:
         else f'<p class="note">{html.escape(content.NO_ADDITIONAL_FINDINGS)}</p>'
     )
     link = (
-        '<a href="#panel-decision">View all decisions</a>'
+        '<a href="#panel-decision">View all behavior comparisons</a>'
         if report.decisions.rows
         else '<a href="#panel-trials">Inspect trial evidence</a>'
     )
@@ -281,7 +485,7 @@ def _other_findings(report: ReportData) -> str:
 
 def _decision_links(indexes) -> str:
     return " · ".join(
-        f'<a href="#decision-{index}">Decision {index}</a>' for index in indexes
+        f'<a href="#decision-{index}">Comparison {index}</a>' for index in indexes
     )
 
 
@@ -303,7 +507,7 @@ def _summary_side(side, label: str) -> str:
     )
     return (
         f'<section class="summary-card summary-{label.lower()}" '
-        f'aria-label="{label} choices">'
+        f'aria-label="{label} observed behavior">'
         f'<h4 class="summary-side-label">{label}</h4>'
         f"{illustration(side.icon)}{body}</section>"
     )
@@ -318,14 +522,7 @@ def _short_story_summary(report: ReportData) -> str:
         "inferred": "Inferred",
         "unavailable": "Unavailable",
     }[intent.source]
-    intent_links = (
-        " · ".join(
-            f'<a href="#edit-hunk-{number}">See edit {number}</a>'
-            for number in intent.edit_hunks
-        )
-        if intent.edit_hunks
-        else '<a href="#instruction-diff">See edit</a>'
-    )
+    intent_links = '<a href="#instruction-diff">View instruction changes</a>'
     claims = ""
     for label, claim, css_class in (
         ("Why it matters", summary.why, "summary-why"),
@@ -334,15 +531,20 @@ def _short_story_summary(report: ReportData) -> str:
         if claim:
             claims += (
                 f'<div class="{css_class}"><strong>{label}</strong>'
-                f"<p>{html.escape(claim.text)}"
+                f"<p>{html.escape(claim.text)}</p>"
                 f'<span class="evidence-links">{_decision_links(claim.decisions)}</span>'
-                "</p></div>"
+                "</div>"
             )
+    comparison_available = (
+        summary.decision is not None and summary.status != "unavailable"
+    )
+    destination = (
+        f"#decision-{summary.decision}" if comparison_available else "#panel-trials"
+    )
     lead_link = (
-        f'<a class="summary-evidence-button" href="#decision-{summary.decision}">'
-        'See the evidence <span aria-hidden="true">↗</span></a>'
-        if summary.decision is not None
-        else ""
+        f'<a class="summary-evidence-button" href="{destination}">'
+        f"{'View this comparison' if comparison_available else 'View available trial records'}"
+        ' <span aria-hidden="true">→</span></a>'
     )
     notices = "".join(f"<li>{html.escape(note)}</li>" for note in summary.notices)
     scenario = (
@@ -355,7 +557,7 @@ def _short_story_summary(report: ReportData) -> str:
         f'<h2 class="summary-headline">{html.escape(summary.headline)}</h2>'
         '<ol class="story-steps" role="list">'
         '<li class="story-step"><span class="story-number" aria-hidden="true">1</span>'
-        '<div class="story-body"><div class="intent-heading"><h3>Edit goal</h3>'
+        '<div class="story-body"><div class="intent-heading"><h3>The intended change</h3>'
         f'<span class="intent-source">{intent_badge}</span>'
         f"{_info('intent-info', intent_label, f'<p>{html.escape(intent_note)}</p>')}"
         f'<nav class="intent-evidence" aria-label="Instruction aim evidence">{intent_links}</nav>'
@@ -363,7 +565,7 @@ def _short_story_summary(report: ReportData) -> str:
         f'<p class="story-intent">{html.escape(intent.text)}</p>'
         "</div></li>"
         '<li class="story-step"><span class="story-number" aria-hidden="true">2</span>'
-        '<div class="story-body"><h3>What happened in this scenario</h3>'
+        '<div class="story-body"><h3>What the evidence shows</h3>'
         f"{scenario}"
         f'<p class="summary-provenance">{html.escape(summary.evidence_label)}</p>'
         f'<p class="summary-status">Comparison: {html.escape(summary.status)}</p>'
@@ -372,7 +574,7 @@ def _short_story_summary(report: ReportData) -> str:
         '<span class="summary-arrow" aria-hidden="true">→</span>'
         f"{_summary_side(summary.after, 'After')}</div>"
         '<nav class="evidence-nav" aria-label="Summary evidence">'
-        f'{lead_link}<a href="#panel-trials">Inspect trial evidence</a></nav>'
+        f"{lead_link}</nav>"
         "</div></li>"
         '<li class="story-step"><span class="story-number" aria-hidden="true">3</span>'
         '<div class="story-body"><h3>What this means</h3>'
@@ -426,7 +628,7 @@ def _info(pop_id: str, label: str, body: str) -> str:
     """An info icon whose popover opens on hover, focus, or tap."""
     return (
         f'<div class="info"><button type="button" aria-label="{html.escape(label)}" '
-        f'aria-describedby="{pop_id}">{_INFO_ICON}</button>'
+        f'aria-describedby="{pop_id}" aria-controls="{pop_id}" aria-expanded="false">{_INFO_ICON}</button>'
         f'<div class="pop" id="{pop_id}" role="note">'
         f'<p class="pop-title">{html.escape(label)}</p>{body}</div></div>'
     )
@@ -469,37 +671,52 @@ def render_artifact(report: ReportData, css: str) -> str:
     after = report.variants.after
     flow = report.command_flow
 
-    before_note = f'<span class="col-note">{escaped(before.note)}</span>'
-    after_note = f'<span class="col-note">{escaped(after.note)}</span>'
-    runs = ""
-    for index, (before_trial, after_trial) in enumerate(
-        zip_longest(before.trials, after.trials), 1
-    ):
-        halves = ""
-        for trial, css_class in ((before_trial, "b"), (after_trial, "a")):
-            side = "before" if css_class == "b" else "after"
-            body = (
-                _trial_card(trial, self_reported, metadata.mode, side)
-                if trial
-                else '<p class="fnote">(no trial on this side)</p>'
+    trial_groups = (
+        "".join(
+            _trial_group(
+                index,
+                before_trial,
+                after_trial,
+                self_reported,
+                metadata.mode,
+                content.trial_summary_for_group(
+                    report.decisions, before_trial, after_trial
+                ),
             )
-            halves += (
-                f'<div class="half {css_class}">'
-                f'<p class="trial-side">{side.capitalize()}</p>{body}</div>'
+            for index, (before_trial, after_trial) in enumerate(
+                zip_longest(before.trials, after.trials), 1
             )
-        runs += f'<article class="run"><p class="run-label">Trial {index}</p>{halves}</article>'
+        )
+        or '<p class="note">No trial records are available.</p>'
+    )
+    trial_overview = "".join(
+        f'<section class="trial-cell {side}"><h3>{side.capitalize()}</h3>'
+        f'<p class="col-note">{escaped(variant.note)}</p>'
+        f'<p class="count">{escaped(variant.count_text + variant.count_suffix)}</p></section>'
+        for side, variant in (("before", before), ("after", after))
+    )
     trials_html = (
-        f'<p class="section-label">{escaped(content.TRIAL_EVIDENCE_HEADING)}</p>'
+        f'<h2 class="section-label">{escaped(content.TRIAL_EVIDENCE_HEADING)}</h2>'
         f'<p class="sub">{escaped(content.trial_evidence_note(self_reported))}</p>'
-        f'<div class="run run-head"><span></span>'
-        f'<div class="half-head b"><h2>Before</h2>{before_note}'
-        f'<span class="count">{escaped(before.count_text + before.count_suffix)}</span></div>'
-        f'<div class="half-head a"><h2>After</h2>{after_note}'
-        f'<span class="count">{escaped(after.count_text + after.count_suffix)}</span></div>'
-        f"</div>{runs}"
+        '<p class="note">Final answers are visible below. Each numbered comparison aligns '
+        "Before on the left and After on the right. Supporting-detail disclosures open both "
+        "sides together; matching numbers do not establish paired execution.</p>"
+        f'<div class="trial-pair trial-overview">{trial_overview}</div>'
+        f'<nav class="record-links" aria-label="Jump to trial">{_trial_group_links(report)}</nav>'
+        f"{trial_groups}"
     )
 
-    decisions_html = ""
+    decisions_html = (
+        '<div class="comparison-heading-with-info">'
+        f'<h2 id="behavior-diff-heading">{escaped(report_content.decision_heading)}</h2>'
+        f"{_info('pop-decision', 'Behavior comparison labels', _tag_legend(report_content.tag_legend))}</div>"
+        '<div class="empty-state"><h3>Behavior comparison unavailable</h3>'
+        f"<p>{escaped(content.NO_EXTRACTED_CHOICE)}</p>"
+        "<p>Missing extraction does not establish absent behavior. "
+        "The retained trial records remain available for inspection.</p></div>"
+        f'<p class="note">{escaped(report.result.summary)}</p>'
+        '<a href="#panel-trials">View available trial records</a>'
+    )
     if report.decisions.rows:
         decisions = report.decisions
         footer = content.decision_footer(decisions.rows)
@@ -528,19 +745,31 @@ def render_artifact(report: ReportData, css: str) -> str:
             if self_reported
             else ""
         )
+        if not content.complete_trial_evidence(report):
+            limitation += (
+                '<p class="note">Trial evidence is incomplete. The extracted comparisons below '
+                "are retained for inspection, not a complete Before/After conclusion.</p>"
+            )
         decisions_html = (
-            f'<div class="section-label">{escaped(report_content.decision_heading)}'
-            f"{_info('pop-decision', 'Decision labels', _tag_legend(report_content.tag_legend))}</div>"
+            '<div class="comparison-heading-with-info">'
+            f'<h2 id="behavior-diff-heading">{escaped(report_content.decision_heading)}</h2>'
+            f"{_info('pop-decision', 'Behavior comparison labels', _tag_legend(report_content.tag_legend))}</div>"
             f'<p class="tab-overview">{escaped(content.decision_overview(report))}</p>'
             f'<p class="sub">{escaped(report_content.decision_blurb)}</p>'
             f"{limitation}"
             f"{_decision_progression(report)}"
             f'<p class="note">{escaped(footer)}</p>{explanation}'
-            '<nav class="evidence-nav" aria-label="Decision evidence">'
-            '<a href="#panel-trials">Inspect trial evidence</a></nav>'
+            '<nav class="evidence-nav" aria-label="Behavior comparison evidence">'
+            '<a href="#panel-trials">View supporting trial records</a></nav>'
         )
 
-    flow_section = ""
+    flow_section = (
+        '<h2 class="section-label">Flow diff</h2>'
+        '<div class="empty-state"><h3>Recorded command flow unavailable</h3>'
+        f"<p>{escaped(content.SELF_REPORTED_LIMIT)}</p>"
+        "<p>No command sequence is inferred from answer text or self-reported actions.</p></div>"
+        '<a href="#panel-trials">View available trial records</a>'
+    )
     if not self_reported:
         patterns = content.flow_patterns(flow)
         pattern_rows = []
@@ -576,15 +805,16 @@ def render_artifact(report: ReportData, css: str) -> str:
             + "</ul>"
         )
         flow_links = (
-            '<a href="#panel-decision">Compare decisions</a>'
+            '<a href="#panel-decision">Compare behavior</a>'
             if report.decisions.rows
             else ""
         )
         flow_section = (
-            f'<div class="section-label">{escaped(report_content.flow_heading)}'
+            '<div class="comparison-heading-with-info">'
+            f"<h2>{escaped(report_content.flow_heading)}</h2>"
             f"{_info('pop-flow', content.flow_kinds_heading(flow.kinds).rstrip(':'), kinds_html)}</div>"
             '<section class="progression" id="flow-progression" tabindex="-1" aria-labelledby="flow-progression-heading">'
-            '<h2 class="comparison-heading" id="flow-progression-heading">Flow progression</h2>'
+            '<h2 class="comparison-heading" id="flow-progression-heading">Recorded command sequences</h2>'
             f'<p class="note">{escaped(content.FLOW_PROGRESSION_NOTE)}</p>'
             '<div class="flow-lanes">'
             f"{_flow_lane(before, 'before', 'Before')}"
@@ -622,9 +852,7 @@ def render_artifact(report: ReportData, css: str) -> str:
     result = report.result
     limits_html = "".join(f"<li>{escaped(limit)}</li>" for limit in result.limits)
     summary_html = f"""{_short_story_summary(report)}
-<details class="summary-details"><summary>Instruction edit</summary>
-{_instruction_edit(report)}
-</details>
+<p class="note summary-boundary">{escaped(report_content.boundary)}</p>
 <details class="summary-details"><summary>Full scenario and expected behavior</summary>
 <div class="scenario-context">{scenario_html}</div>
 {scenario_prompt}
@@ -636,26 +864,25 @@ def render_artifact(report: ReportData, css: str) -> str:
 <ul class="evidence-limits">{limits_html}</ul>
 </details>"""
 
-    tabs = [("summary", "Summary", "", summary_html)]
-    if decisions_html:
-        tabs.append(
-            (
-                "decision",
-                "Decision diff",
-                f"{len(report.decisions.rows)} decision{'s' if len(report.decisions.rows) != 1 else ''}",
-                decisions_html,
-            )
-        )
-    if flow_section:
-        tabs.append(("flow", "Flow diff", "", flow_section))
-    tabs.append(
+    tabs = [
+        ("summary", "Summary", "", summary_html),
+        ("instruction", "Instruction changes", "", _instruction_edit(report)),
+        (
+            "decision",
+            "Behavior diff",
+            f"{len(report.decisions.rows)} comparisons"
+            if report.decisions.rows
+            else "",
+            decisions_html,
+        ),
+        ("flow", "Flow diff", "", flow_section),
         (
             "trials",
             content.TRIAL_EVIDENCE_HEADING,
             f"{before.total} + {after.total} trials",
             trials_html,
-        )
-    )
+        ),
+    ]
 
     return f"""<title>{escaped(report_content.title)}</title>
 <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=IBM+Plex+Sans:wght@400;600;700&family=IBM+Plex+Mono:wght@400;500&display=swap">
@@ -677,7 +904,7 @@ def render_artifact(report: ReportData, css: str) -> str:
 def render_document(artifact: str) -> str:
     """Wrap an artifact body in a complete HTML document."""
     return (
-        '<!doctype html><html><head><meta charset="utf-8">'
+        '<!doctype html><html lang="en"><head><meta charset="utf-8">'
         '<meta name="viewport" content="width=device-width, initial-scale=1">'
         "</head><body>" + artifact + "</body></html>"
     )
diff --git a/plugin/skills/behavior-diff/scripts/reporting/render_markdown.py b/plugin/skills/behavior-diff/scripts/reporting/render_markdown.py
index 9a5940e..914b4ee 100644
--- a/plugin/skills/behavior-diff/scripts/reporting/render_markdown.py
+++ b/plugin/skills/behavior-diff/scripts/reporting/render_markdown.py
@@ -2,6 +2,7 @@
 
 import html
 import re
+from itertools import zip_longest
 
 from reporting import content
 from reporting.schema import ReportData
@@ -22,14 +23,15 @@ def _choices(choices, total: int) -> str:
 
 
 def _decision_links(indexes) -> str:
-    return " · ".join(f"[Decision {index}](#decision-{index})" for index in indexes)
+    return " · ".join(f"[Comparison {index}](#decision-{index})" for index in indexes)
 
 
-def _edit_links(row):
+def _edit_links(row, diff):
     if not row.edit_hunks:
         return "Related edit unavailable — no mapping recorded."
     links = " · ".join(
-        f"[Hunk {number}](#edit-hunk-{number})" for number in row.edit_hunks
+        f"[{_text(content.instruction_hunk_label(diff, number))}](#edit-hunk-{number})"
+        for number in row.edit_hunks
     )
     return "Related edit (model interpretation): " + links
 
@@ -39,7 +41,10 @@ def _instruction_edit(report):
     for line, number in content.instruction_diff_lines(report.rule_diff):
         text = html.escape(line)
         if number:
-            text = f'<span id="edit-hunk-{number}">{text}</span>'
+            label = html.escape(
+                content.instruction_hunk_label(report.rule_diff, number)
+            )
+            text = f'<span id="edit-hunk-{number}">{label}<br>{text}</span>'
         lines.append(text)
     return [
         f"### {_text(report.content.diff_heading)}\n",
@@ -57,15 +62,16 @@ def _other_findings_markdown(report):
         for index, text in findings:
             row = report.decisions.rows[index - 1]
             source = content.source_label(row.anchor, report.metadata.trace_source)
-            links = f"[Decision {index} · {_text(source)}](#decision-{index})"
+            links = f"[Comparison {index} · {_text(source)}](#decision-{index})"
             for number in row.edit_hunks:
-                links += f" · [See edit {number}](#edit-hunk-{number})"
+                label = _text(content.instruction_hunk_label(report.rule_diff, number))
+                links += f" · [{label}](#edit-hunk-{number})"
             markdown.append(f"- {_text(text)}<br>{links}\n")
         markdown.append(_text(content.additional_findings_note(report)) + "\n")
     else:
         markdown.append(_text(content.NO_ADDITIONAL_FINDINGS) + "\n")
     markdown.append(
-        "[View all decisions](#panel-decision)\n"
+        "[View all behavior comparisons](#panel-decision)\n"
         if report.decisions.rows
         else "[Inspect trial evidence](#panel-trials)\n"
     )
@@ -76,7 +82,12 @@ def _other_findings_markdown(report):
 def _decision_markdown(report):
     decisions = report.decisions
     if not decisions.rows:
-        return []
+        return [
+            '<a id="panel-decision"></a>\n',
+            "## Behavior diff\n",
+            _text(content.NO_EXTRACTED_CHOICE) + "\n",
+            "[View available trial records](#panel-trials)\n",
+        ]
     markdown = [
         '<a id="panel-decision"></a>\n',
         f"## {_text(report.content.decision_heading)}\n",
@@ -89,7 +100,7 @@ def _decision_markdown(report):
     if report.metadata.trace_source == "self-reported":
         markdown.append(_text(content.SELF_REPORTED_LIMIT) + "\n")
     markdown += [
-        "**Decision labels**\n",
+        "**Comparison labels · status, role, and source**\n",
         "\n".join(
             f"- **{_text(label)}** — {_text(meaning)}"
             for _, label, meaning in report.content.tag_legend
@@ -116,9 +127,24 @@ def _decision_markdown(report):
             f"| {_choices(row.before, decisions.before_count)}"
             f" | {_choices(row.after, decisions.after_count)} |\n"
         )
-        markdown.append(_edit_links(row) + "\n")
+        markdown.append(_edit_links(row, report.rule_diff) + "\n")
         if row.note:
             markdown.append(f"Note: {_text(row.note)}\n")
+        markdown.append(
+            "Available trial records (all trials; row attribution is not recorded): "
+            + " · ".join(
+                f"[Trial {number}](#{content.trial_group_anchor(number)})"
+                for number in range(
+                    1,
+                    max(
+                        len(report.variants.before.trials),
+                        len(report.variants.after.trials),
+                    )
+                    + 1,
+                )
+            )
+            + "\n"
+        )
     markdown.append(_text(content.decision_footer(decisions.rows)) + "\n")
     if decisions.dropped:
         markdown.append(_text(content.dropped_rows(decisions.dropped)) + "\n")
@@ -215,7 +241,7 @@ def _flow_markdown(report):
     markdown.append("\n</details>\n")
     links = []
     if report.decisions.rows:
-        links.append("[Compare decisions](#panel-decision)")
+        links.append("[Compare behaviors](#panel-decision)")
     links.append("[Inspect trial evidence](#panel-trials)")
     markdown.append(" · ".join(links) + "\n")
     return markdown
@@ -237,21 +263,14 @@ def _summary_markdown(report):
     markdown = [
         "## Summary\n",
         f"**{_text(summary.headline)}**\n",
-        "### 1. Edit goal\n",
+        "### 1. The intended change\n",
         f"**{_text(intent_label)}**\n",
         _text(intent.text) + "\n",
         _text(intent_note) + "\n",
     ]
-    intent_links = (
-        " · ".join(
-            f"[See edit {number}](#edit-hunk-{number})" for number in intent.edit_hunks
-        )
-        if intent.edit_hunks
-        else "[Inspect the instruction edit](#instruction-diff)"
-    )
     markdown += [
-        intent_links + "\n",
-        "### 2. What happened in this scenario\n",
+        "[View instruction changes](#instruction-diff)\n",
+        "### 2. What was observed\n",
     ]
     if summary.scenario:
         markdown.append(_text(summary.scenario) + "\n")
@@ -266,12 +285,18 @@ def _summary_markdown(report):
             if choice.detail:
                 markdown.append(_text(choice.detail) + "\n")
             markdown.append(_text(content.trial_count(choice.count, side.total)) + "\n")
-    links = []
-    if summary.decision is not None:
-        links.append(f"[See the evidence](#decision-{summary.decision})")
-    links.append("[Inspect trial evidence](#panel-trials)")
-    markdown.append(" · ".join(links) + "\n")
-    markdown.append("### 3. What this means\n")
+    target = (
+        f"decision-{summary.decision}"
+        if summary.decision is not None and summary.status != "unavailable"
+        else "panel-trials"
+    )
+    label = (
+        "View this comparison"
+        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")
     for label, claim in (
         ("Why it matters", summary.why),
         ("Watch out", summary.caution),
@@ -295,11 +320,6 @@ def render_markdown(report: ReportData) -> str:
         markdown.append(_text(content_data.note) + "\n")
     markdown.append('<a id="panel-summary"></a>\n')
     markdown += _summary_markdown(report)
-    markdown.append(
-        '<details id="instruction-diff"><summary>Instruction edit</summary>\n'
-    )
-    markdown += _instruction_edit(report)
-    markdown.append("</details>\n")
     markdown += [
         "<details><summary>Full scenario and expected behavior</summary>\n",
     ]
@@ -321,9 +341,19 @@ def render_markdown(report: ReportData) -> str:
     markdown += [f"- {_text(limit)}" for limit in result.limits]
     markdown.append("")
     markdown.append("</details>\n")
+    markdown.append('<a id="panel-instruction"></a>\n')
+    markdown.append('<a id="instruction-diff"></a>\n')
+    markdown.append("## Instruction changes\n")
+    markdown += _instruction_edit(report)
     markdown += _decision_markdown(report)
     if metadata.trace_source != "self-reported":
         markdown += _flow_markdown(report)
+    else:
+        markdown += [
+            '<a id="panel-flow"></a>\n',
+            "## Flow diff\n",
+            _text(content.SELF_REPORTED_LIMIT) + "\n",
+        ]
     self_reported = metadata.trace_source == "self-reported"
     action_label, empty_actions = content.trial_action_labels(self_reported)
     markdown += [
@@ -331,30 +361,101 @@ def render_markdown(report: ReportData) -> str:
         f"## {_text(content.TRIAL_EVIDENCE_HEADING)}\n",
         _text(content.trial_evidence_note(self_reported)) + "\n",
     ]
-    for side, variant, label in (
-        ("before", report.variants.before, f"Before — {metadata.before_label}"),
-        ("after", report.variants.after, f"After — {metadata.after_label}"),
+    markdown.append(
+        "Before and After are independent attempts, aligned by trial number for reading; "
+        "they are not consecutive steps or verified paired executions.\n"
+    )
+    markdown.append(
+        f"Before — {_text(metadata.before_label)}: {_count_line(report.variants.before)}\n"
+    )
+    markdown.append(
+        f"After — {_text(metadata.after_label)}: {_count_line(report.variants.after)}\n"
+    )
+    for number, pair in enumerate(
+        zip_longest(report.variants.before.trials, report.variants.after.trials), 1
     ):
-        markdown.append(f"### {_text(label)}\n")
-        markdown.append(_count_line(variant) + "\n")
-        for trial in variant.trials:
-            anchor = content.trial_anchor(side, trial.name)
-            markdown += [
-                f'<a id="{anchor}"></a>\n',
-                f"#### {_text(trial.name)} — {_text(trial.verdict)}\n",
-            ]
-            if trial.actions != "-":
-                markdown.append(_text(trial.actions) + "\n")
-            actions = "\n\n".join(trial.commands) or empty_actions
+        summary = content.trial_summary_for_group(report.decisions, *pair)
+        markdown += [
+            f'<a id="{content.trial_group_anchor(number)}"></a>\n',
+            f"### Trial {number}\n",
+            f"#### {_text(content.TRIAL_CHANGE_HEADING)}\n",
+            _text(summary.takeaway if summary else content.TRIAL_SUMMARY_UNAVAILABLE)
+            + "\n",
+            '<table><thead><tr><th scope="col">Before</th><th scope="col">After</th></tr></thead><tbody>',
+        ]
+        if summary is not None:
             markdown.append(
-                f"<details><summary>{html.escape(action_label)} ({len(trial.commands)})</summary>\n"
-                "<pre>" + html.escape(actions) + "</pre>\n"
-                "</details>\n"
+                "<tr><td>"
+                + "</td><td>".join(
+                    html.escape(sentence)
+                    if trial is not None
+                    else "No trial record on this side."
+                    for trial, sentence in zip(pair, (summary.before, summary.after))
+                )
+                + "</td></tr>"
             )
-            final = trial.final if trial.final.strip() else content.NO_FINAL_ANSWER
-            markdown.append(
-                f"<details><summary>{html.escape(content.FINAL_ANSWER_HEADING)}</summary>\n"
-                "<pre>" + html.escape(final) + "</pre>\n"
-                "</details>\n"
+            if summary.caveat:
+                markdown.append(
+                    '<tr><td colspan="2">' + html.escape(summary.caveat) + "</td></tr>"
+                )
+        markdown += [
+            '<tr><th colspan="2">Trial record and verdict</th></tr>',
+        ]
+        cells = []
+        answers = []
+        for side, trial in zip(("before", "after"), pair):
+            if trial is None:
+                cells.append(
+                    '<span class="trial-missing">No trial record on this side.</span>'
+                )
+                answers.append(
+                    '<span class="trial-missing">No trial record on this side.</span>'
+                )
+                continue
+            anchor = content.trial_anchor(side, trial.name)
+            cells.append(
+                f'<a id="{anchor}"></a><strong>{html.escape(trial.name)}</strong> — {html.escape(trial.verdict)}'
+            )
+            answers.append(
+                "<pre>"
+                + html.escape(
+                    trial.final if trial.final.strip() else content.NO_FINAL_ANSWER
+                )
+                + "</pre>"
+            )
+        markdown += [
+            "<tr><td>" + "</td><td>".join(cells) + "</td></tr>",
+            f'<tr><th colspan="2">{content.FINAL_ANSWER_HEADING}</th></tr>',
+            "<tr><td>" + "</td><td>".join(answers) + "</td></tr></tbody></table>\n",
+        ]
+        markdown.append("<details><summary>Supporting details · both sides</summary>\n")
+        markdown.append(
+            '<table><thead><tr><th scope="col">Before</th><th scope="col">After</th></tr></thead><tbody><tr><td>'
+            + "</td><td>".join(
+                "<pre>" + html.escape(trial.actions) + "</pre>"
+                if trial is not None and trial.actions != "-"
+                else (
+                    "No trial record available"
+                    if trial is None
+                    else "No action summary recorded"
+                )
+                for trial in pair
             )
+            + "</td></tr></tbody></table>\n</details>\n"
+        )
+        markdown.append(
+            f"<details><summary>{html.escape(action_label)} · both sides</summary>\n"
+        )
+        markdown.append(
+            '<table><thead><tr><th scope="col">Before</th><th scope="col">After</th></tr></thead><tbody><tr><td>'
+            + "</td><td>".join(
+                "<pre>"
+                + html.escape("\n\n".join(trial.commands) or empty_actions)
+                + "</pre>"
+                if trial is not None
+                else "No trial record available"
+                for trial in pair
+            )
+            + "</td></tr></tbody></table>\n</details>\n"
+        )
     return "\n".join(markdown)
diff --git a/plugin/skills/behavior-diff/scripts/reporting/report.css b/plugin/skills/behavior-diff/scripts/reporting/report.css
index 6af44f7..ce33f94 100644
--- a/plugin/skills/behavior-diff/scripts/reporting/report.css
+++ b/plugin/skills/behavior-diff/scripts/reporting/report.css
@@ -8,7 +8,12 @@
   --action:#1d4f91; --action-soft:#eaf2ff;
   --result:#6836a0; --result-soft:#f3eaff;
   --detail:#3f4c9b; --detail-soft:#eef0ff;
+  --before:#516484; --before-soft:#f1f5fb; --before-border:#c8d7dd;
+  --after:#90620a; --after-soft:#fffaf0; --after-border:#ead8b5;
+  --answer:#795b13; --answer-soft:#fff6d8;
+  --command:#195e68; --command-soft:#e5f4f7;
 }
+* { box-sizing:border-box; }
 body { background:var(--ground); color:var(--ink);
   font:15px/1.55 "IBM Plex Sans", -apple-system, "Segoe UI", sans-serif;
   max-width:1080px; margin:0 auto; padding:2.5rem 1.25rem 3rem; }
@@ -28,7 +33,7 @@ h2 { font-size:1.02rem; font-weight:600; margin:0; }
 a { color:var(--accent); text-underline-offset:.16em; }
 a:focus-visible { outline:2px solid var(--accent); outline-offset:3px; }
 [id] { scroll-margin-top:1rem; }
-.decision-row:target, .trial:target { outline:2px solid var(--accent); outline-offset:5px; }
+.decision-row:target { outline:2px solid var(--accent); outline-offset:5px; }
 .instruction-edit { padding:4px 0; }
 .edit-heading { display:flex; align-items:center; gap:.6rem; position:relative; }
 .edit-heading h2 { font-size:.95rem; margin:0; overflow-wrap:anywhere; min-width:0; }
@@ -38,6 +43,19 @@ a:focus-visible { outline:2px solid var(--accent); outline-offset:3px; }
 .edit-aim { font-size:1rem; line-height:1.5; margin:.75rem 0 .5rem;
   max-width:78ch; overflow-wrap:anywhere; }
 .edit-summary { color:var(--muted); font-size:.85rem; margin:.5rem 0 1rem; }
+.diff-toolbar { display:flex; flex-wrap:wrap; gap:.35rem; margin:.75rem 0; }
+.diff-toolbar button { min-height:32px; padding:.3rem .6rem; font:inherit;
+  font-size:.78rem; border:1px solid var(--border); border-radius:5px;
+  background:var(--panel); color:var(--accent); cursor:pointer; max-width:100%;
+  overflow-wrap:anywhere; text-align:left; }
+.diff-toolbar button[aria-pressed="true"] { background:var(--accent-soft);
+  border-color:var(--accent); font-weight:600; }
+.diff-toolbar button:focus-visible { outline:2px solid var(--accent); outline-offset:3px; }
+.instruction-edit .d-add { background:#edf8ef; }
+.instruction-edit .d-del { background:#fff0f0; }
+.instruction-edit .edit-selected { background:#d8eff0; color:#123c40;
+  border-left:3px solid var(--accent); font-weight:600;
+  box-decoration-break:clone; -webkit-box-decoration-break:clone; }
 .edit-links { display:block; margin:.4rem 0; font-size:.82rem; font-weight:400; }
 .edit-links a { display:inline-block; padding:.2rem 0; }
 [id^="edit-hunk-"] { display:block; scroll-margin-top:1rem; }
@@ -65,13 +83,13 @@ a:focus-visible { outline:2px solid var(--accent); outline-offset:3px; }
 .interpretation ul { margin:0; padding-left:1.15rem; }
 .interpretation li + li { margin-top:.5rem; }
 .evidence-links { display:block; font-size:.82rem; margin-top:.2rem; }
-.evidence-nav { display:flex; flex-wrap:wrap; gap:.35rem 1.25rem; margin:1rem 0; }
-.evidence-nav a { padding:.4rem 0; }
+.evidence-nav, .record-links { display:flex; flex-wrap:wrap; gap:.35rem 1.25rem; margin:1rem 0; }
+.evidence-nav a, .record-links a { padding:.4rem 0; }
 .evidence-limits { color:var(--muted); padding-left:1.2rem; max-width:85ch; }
 .evidence-limits li + li { margin-top:.35rem; }
 pre { background:var(--code-bg); border:1px solid var(--border);
   border-radius:6px; padding:.7rem .85rem; overflow-x:auto;
-  white-space:pre-wrap; margin:.5rem 0 0;
+  white-space:pre-wrap; overflow-wrap:anywhere; margin:.5rem 0 0; max-width:100%;
   font:12.5px/1.55 "IBM Plex Mono", ui-monospace, monospace; }
 .choice-count { display:block; color:var(--muted); font-size:.8rem;
   font-variant-numeric:tabular-nums; }
@@ -82,16 +100,18 @@ pre { background:var(--code-bg); border:1px solid var(--border);
   border-radius:6px; overflow-wrap:anywhere; }
 .decision-changed, .decision-tag.tag-changed {
   --decision-color:var(--changed); --decision-tint:var(--changed-soft); }
-.decision-unchanged, .decision-same-choice-proportions, .decision-tag.tag-same {
+.decision-unchanged, .decision-same-proportions, .decision-tag.tag-same {
   --decision-color:var(--same); --decision-tint:var(--same-soft); }
 .decision-question { margin:.35rem 0 0; color:var(--muted); font-size:.9rem; }
 .decision-meta { display:flex; flex-wrap:wrap; align-items:baseline;
   gap:.25rem .65rem; margin:.4rem 0 .75rem; color:var(--muted); font-size:.8rem; }
 .decision-status, .decision-tag { border-radius:3px; font-size:.78rem; padding:.1rem .4rem; }
 .decision-tag { --decision-color:var(--muted); --decision-tint:var(--code-bg); }
-.tag-action, .tag-cmd { --decision-color:var(--action); --decision-tint:var(--action-soft); }
+.tag-action { --decision-color:var(--action); --decision-tint:var(--action-soft); }
 .tag-result { --decision-color:var(--result); --decision-tint:var(--result-soft); }
-.tag-detail, .tag-ans { --decision-color:var(--detail); --decision-tint:var(--detail-soft); }
+.tag-detail { --decision-color:var(--detail); --decision-tint:var(--detail-soft); }
+.tag-answer, .tag-ans { --decision-color:var(--answer); --decision-tint:var(--answer-soft); }
+.tag-command, .tag-cmd { --decision-color:var(--command); --decision-tint:var(--command-soft); }
 .decision-row .decision-status, .decision-tag {
   background:var(--decision-tint); color:var(--decision-color); }
 .decision-evidence { padding:.75rem 1rem 1rem; border-top:1px solid var(--border); }
@@ -100,11 +120,13 @@ pre { background:var(--code-bg); border:1px solid var(--border);
 .decision-toolbar { display:flex; flex-wrap:wrap; align-items:center;
   justify-content:space-between; gap:.5rem 1rem; }
 .decision-toolbar .comparison-heading { margin:0; }
-.decision-toggle { border:1px solid var(--border); border-radius:5px;
-  background:var(--panel); color:var(--accent); font:inherit; font-size:.82rem;
-  padding:.45rem .75rem; cursor:pointer; }
-.decision-toggle:hover { background:var(--accent-soft); }
-.decision-toggle:focus-visible { outline:2px solid var(--accent); outline-offset:3px; }
+.decision-toggle, .evidence-controls button { border:1px solid var(--border); border-radius:5px;
+  background:var(--panel); color:var(--accent); font:inherit; font-size:.78rem;
+  min-height:32px; padding:.3rem .6rem; cursor:pointer; }
+.decision-toggle:hover, .evidence-controls button:hover { background:var(--accent-soft); }
+.decision-toggle:focus-visible, .evidence-controls button:focus-visible {
+  outline:2px solid var(--accent); outline-offset:3px; }
+.evidence-controls { display:flex; flex-wrap:wrap; gap:.35rem; align-items:center; }
 .progression { margin:1.25rem 0 1.75rem; }
 .progression > .comparison-heading { margin-top:0; }
 .decision-path, .command-path { list-style:none; padding:0; margin:1rem 0 0; }
@@ -209,20 +231,26 @@ 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-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"],
 .tabs:has(#panel-trials:target, #panel-trials :target) .tabbar a[href="#panel-trials"] {
   --tab-color:var(--accent); --tab-bg:var(--accent-soft);
   font-weight:600; border-bottom-color:var(--accent); }
+.tabs[data-enhanced] > .panel { display:none; }
+.tabs[data-enhanced] > .panel.is-active { display:block; }
+@media screen { .panel[hidden] { display:none !important; } }
 
 /* Info icon: the popover opens on hover, keyboard focus, or tap. */
 .info { position:relative; display:inline-flex; }
 .info > button { display:inline-flex; align-items:center;
-  justify-content:center; width:22px; height:22px; padding:0;
+  justify-content:center; width:32px; height:32px; padding:0;
   border:1px solid #b8c6cf; border-radius:50%; background:var(--panel);
   color:var(--muted); cursor:pointer; }
-.info > button:hover, .info > button:focus-visible {
-  border-color:var(--accent); color:var(--accent); outline:none; }
+.info > button:hover { border-color:var(--accent); color:var(--accent); }
+.info > button:focus-visible {
+  border-color:var(--accent); color:var(--accent);
+  outline:2px solid var(--accent); outline-offset:3px; }
 .info::after { content:""; position:absolute; left:0; right:0; top:100%;
   height:8px; }
 .pop { display:none; position:absolute; top:calc(100% + 8px); right:0;
@@ -231,7 +259,7 @@ details { margin-bottom:.25rem; }
   box-shadow:0 8px 24px rgba(28,39,51,.14); color:var(--ink);
   font-size:.85rem; line-height:1.5; font-weight:400;
   letter-spacing:0; text-transform:none; }
-.info:hover .pop, .info:focus-within .pop { display:block; }
+.info:hover .pop, .info:focus-within .pop, .info.info-open .pop { display:block; }
 .pop-title { margin:0 0 .5rem; font-weight:600; }
 .legend-group + .legend-group { border-top:1px solid var(--border); margin-top:.85rem; padding-top:.75rem; }
 .legend-group h3 { margin:0 0 .5rem; color:var(--ink); font-size:.8rem; font-weight:600; }
@@ -245,52 +273,99 @@ details { margin-bottom:.25rem; }
   columns:2; column-gap:1.5rem; }
 .kinds li { break-inside:avoid; }
 
-/* Trials: one card per row, before on the left, after on the right. */
-.run { display:grid; grid-template-columns:4.5rem 1fr 1fr; gap:0 1.1rem;
-  background:var(--panel); border:1px solid var(--border);
-  border-radius:8px; padding:.9rem 1.1rem 1rem; margin-top:.9rem; }
-.run-head { background:transparent; border:0; padding:0 1.1rem;
-  margin-top:1rem; }
-.run-label { margin:0; font-size:.75rem; font-weight:700;
-  letter-spacing:.08em; text-transform:uppercase; color:var(--muted); }
-.half { min-width:0; padding-left:.8rem; border-left:3px solid var(--border); }
-.half-head { display:flex; flex-wrap:wrap; align-items:baseline;
-  gap:.2rem .6rem; min-width:0; }
-.half-head h2 { font-size:.75rem; font-weight:700; letter-spacing:.08em;
-  text-transform:uppercase; color:var(--muted); }
-.col-note { color:var(--muted); font-size:.85rem; }
-.count { flex-basis:100%; color:var(--muted); font-size:.85rem;
-  font-variant-numeric:tabular-nums; }
-.trial-head { display:flex; align-items:center; justify-content:space-between;
-  gap:.55rem; margin:0 0 .3rem; }
-.trial-head strong { font-family:"IBM Plex Mono", ui-monospace, monospace;
-  font-size:.9rem; }
-.trial-side { display:none; margin:0 0 .4rem; font-size:.75rem; font-weight:700;
-  letter-spacing:.08em; text-transform:uppercase; color:var(--muted); }
-@media (max-width: 780px) {
+/* Each trial shares section rows and disclosures across Before and After. */
+.trial-group { background:var(--panel); border:1px solid var(--border);
+  border-radius:10px; padding:1rem; margin:1.25rem 0; overflow-wrap:anywhere; }
+.trial-group:target, .trial-cell:target {
+  outline:2px solid var(--accent); outline-offset:4px; }
+.trial-group > h3 { font-size:1rem; margin:0 0 .6rem; }
+.trial-group > .evidence-controls { margin:.5rem 0 .75rem; }
+.trial-pair { display:grid; grid-template-columns:repeat(2, minmax(0, 1fr));
+  gap:0 1rem; min-width:0; }
+.trial-pair-heading { margin:0; padding:.65rem .75rem; font-size:.8rem;
+  font-weight:700; letter-spacing:.07em; text-transform:uppercase;
+  color:var(--before); background:var(--before-soft); border-top:2px solid var(--before-border); }
+.trial-pair-heading.after, .trial-pair-heading:nth-child(2) {
+  color:var(--after); background:var(--after-soft); border-color:var(--after-border); }
+.trial-section-heading { grid-column:1 / -1; font-size:.85rem;
+  margin:1rem 0 .4rem; padding:.6rem 0 .3rem; border-top:1px solid var(--border); }
+.trial-change-heading { margin-top:0; padding-top:0; border-top:0; }
+.trial-change-takeaway, .trial-change-unavailable, .trial-change-caveat {
+  grid-column:1 / -1; margin:0 0 .75rem; max-width:80ch; }
+.trial-change-takeaway { font-size:1rem; font-weight:600; line-height:1.5; }
+.trial-change-description { margin:0; font-size:.94rem; line-height:1.6; }
+.trial-change-caveat { margin:.65rem 0 0; }
+.trial-cell { min-width:0; padding:.6rem .75rem; overflow-wrap:anywhere; }
+.trial-cell.before { background:var(--before-soft); }
+.trial-cell.after { background:var(--after-soft); }
+.trial-cell > :first-child { margin-top:0; }
+.trial-cell pre { max-height:none; }
+.trial-head { display:flex; flex-wrap:wrap; align-items:center;
+  justify-content:space-between; gap:.4rem; margin:0 0 .4rem; }
+.trial-head strong { font-family:"IBM Plex Mono", ui-monospace, monospace; font-size:.85rem; }
+.trial-side { font-size:.75rem; font-weight:700; color:var(--muted); margin:0 0 .4rem; }
+.trial-shared-details { grid-column:1 / -1; min-width:0;
+  border-top:1px solid var(--border); margin:.8rem 0 0; padding-top:.35rem; }
+.trial-shared-details > summary { padding:.6rem 0; font-weight:600; }
+.trial-shared-details .trial-shared-details {
+  margin:.75rem 0 0 .75rem; padding-left:.75rem; border-left:2px solid var(--border); }
+.comparison-heading-with-info { display:flex; align-items:center; gap:.5rem;
+  position:relative; min-width:0; }
+.comparison-heading-with-info .comparison-heading { margin:0; }
+.comparison-heading-with-info .info { position:static; flex:none; }
+.comparison-heading-with-info .info::after { display:none; }
+.comparison-heading-with-info .pop { left:0; right:auto; top:100%;
+  width:min(760px, calc(100vw - 3rem)); }
+.decision-lane.b, .decision-lane.before { background:var(--before-soft); border-top-color:var(--before-border); }
+.decision-lane.a, .decision-lane.after { background:var(--after-soft); border-top-color:var(--after-border); }
+.flow-lane.before > h3 { color:var(--before); }
+.flow-lane.after > h3 { color:var(--after); }
+.flow-lane.before .command-group { border-top:3px solid var(--before-border); }
+.flow-lane.after .command-group { border-top:3px solid var(--after-border); }
+@media (pointer:coarse) {
+  .info > button { width:44px; height:44px; }
+  .decision-toggle, .evidence-controls button { min-height:44px; }
+  .diff-toolbar button { min-height:44px; }
+}
+@media (max-width:780px) {
   .decision-evidence { padding:.65rem; }
   .flow-lanes { grid-template-columns:minmax(0, 1fr); }
   .decision-node { grid-template-columns:1.65rem minmax(0, 1fr); }
   .decision-disclosure { grid-column:2; }
   .decision-lanes { grid-column:1 / -1; gap:.5rem; }
   .decision-lane { padding:.5rem; }
-  .run { grid-template-columns:1fr; gap:.8rem 0; }
-  .run-head > span { display:none; }
-  .trial-side { display:block; }
-  .half { padding-top:.3rem; }
   .tabbar a { padding:.5rem .6rem; font-size:.88rem; }
   .comparison th, .comparison td { padding:.5rem; }
   .comparison { font-size:.85rem; }
 }
+@media (max-width:600px) {
+  body { padding:1.3rem .75rem 2rem; }
+  .trial-group { padding:.65rem; }
+  .trial-pair { gap:0 .5rem; }
+  .trial-cell, .trial-pair-heading { padding:.5rem; }
+  .trial-cell pre { padding:.5rem; font-size:11.5px; }
+  .legend > div { grid-template-columns:minmax(0, 1fr); gap:.2rem; }
+  .decision-toolbar { align-items:flex-start; }
+}
 @media print {
-  .tabbar, .decision-toggle, .decision-disclosure { display:none; }
-  .panel { display:block !important; }
-  .decision-row { break-inside:avoid; }
+  body { max-width:none; padding:0; background:#fff; }
+  .tabbar, .decision-toggle, .decision-disclosure, .evidence-controls,
+  .diff-toolbar, .info > button { display:none !important; }
+  .panel, .panel[hidden], .tabs[data-enhanced] > .panel {
+    display:block !important; break-before:page; }
+  #panel-summary { break-before:auto; }
   .decision-evidence { display:block; }
   .section-label { flex-wrap:wrap; }
-  .info { flex-basis:100%; }
-  .pop { display:block; position:static; box-shadow:none; width:auto;
-    margin-top:.5rem; } }
+  .comparison-heading-with-info, .edit-heading { display:block; }
+  .comparison-heading-with-info .info, .info { display:block; }
+  .pop, .comparison-heading-with-info .pop, .edit-heading .pop { display:block; position:static;
+    box-shadow:none; width:100%; max-width:none; margin-top:.5rem; }
+  details, pre { overflow:visible; max-height:none; }
+  pre { white-space:pre-wrap; }
+  .trial-pair, .flow-lanes { grid-template-columns:repeat(2, minmax(0, 1fr)); }
+  .trial-head, .trial-section-heading, .trial-pair-heading { break-after:avoid; }
+  .trial-change-heading, .trial-change-takeaway { break-after:avoid; }
+}
 
 .short-story-summary { --summary-paper:#fff; color:#142b35;
   font-family:ui-sans-serif, system-ui, sans-serif; padding:18px 20px 8px;
@@ -368,8 +443,9 @@ details { margin-bottom:.25rem; }
 .scenario-context h3 { font-size:.85rem; color:var(--muted); margin:0 0 7px; }
 .scenario-context p { font-size:.92rem; line-height:1.6; margin:0;
   white-space:pre-wrap; overflow-wrap:anywhere; }
-.scenario-prompt { margin:10px 0 0; }
-.scenario-prompt > summary { padding:8px 0; font-weight:600; }
+.scenario-prompt { margin:1rem 0 .5rem 1.25rem; padding-left:1rem;
+  border-left:2px solid var(--border); }
+.scenario-prompt > summary { padding:8px 0; font-weight:500; }
 .other-findings { list-style:none; padding:0; margin:0; }
 .other-findings li { padding:12px 0; overflow-wrap:anywhere; }
 .other-findings li + li { border-top:1px solid var(--border); }
diff --git a/plugin/skills/behavior-diff/scripts/reporting/schema.py b/plugin/skills/behavior-diff/scripts/reporting/schema.py
index bd857c2..8b4090a 100644
--- a/plugin/skills/behavior-diff/scripts/reporting/schema.py
+++ b/plugin/skills/behavior-diff/scripts/reporting/schema.py
@@ -15,8 +15,13 @@
     parse_intent,
     parse_narrative,
 )
+from reporting.trial_summary import (
+    TrialSummaryData,
+    parse_trial_summaries,
+    trial_group_names,
+)
 
-SCHEMA_VERSION = 7
+SCHEMA_VERSION = 8
 RESULT_KINDS = ("good", "bad", "neutral")
 
 
@@ -110,6 +115,7 @@ class DecisionData:
     implications: Tuple[EvidenceClaimData, ...]
     narrative: Optional[NarrativeData] = None
     intent: Optional[EditIntentData] = None
+    trial_summaries: Tuple[TrialSummaryData, ...] = ()
 
 
 @dataclass(frozen=True)
@@ -219,16 +225,20 @@ def from_dict(cls, data: Dict[str, object]) -> "ReportData":
             )
 
         rule_diff = _expect_str(_field(data, "rule_diff", "report-data"), "rule_diff")
+        variants = _variants(_field(data, "variants", "report-data"), "variants")
         decisions = _decisions(
             _field(data, "decisions", "report-data"),
             "decisions",
             len(parse_diff_hunks(rule_diff)),
+            trial_group_names(
+                (trial.name for trial in variants.before.trials),
+                (trial.name for trial in variants.after.trials),
+            ),
         )
         result = _result(
             _field(data, "result", "report-data"), "result", len(decisions.rows)
         )
         metadata = _metadata(_field(data, "metadata", "report-data"), "metadata")
-        variants = _variants(_field(data, "variants", "report-data"), "variants")
         report_content = _content(_field(data, "content", "report-data"), "content")
         intent = _intent(
             _field(data, "intent", "report-data"),
@@ -445,7 +455,7 @@ def _flow_path(value, path):
     )
 
 
-def _decisions(value, path, hunk_count):
+def _decisions(value, path, hunk_count, groups=None):
     value = _expect_dict(value, path)
     rows = _expect_list(_field(value, "rows", path), path + ".rows")
     parsed_rows = tuple(
@@ -471,6 +481,10 @@ def _decisions(value, path, hunk_count):
         intent is None or _json_value(asdict(intent)) != raw_intent
     ):
         _invalid(path + ".intent", "valid canonical instruction edit interpretation")
+    raw_trial_summaries = _field(value, "trial_summaries", path)
+    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")
     decisions = DecisionData(
         rows=parsed_rows,
         fork=_optional_reference(
@@ -489,6 +503,7 @@ def _decisions(value, path, hunk_count):
         ),
         narrative=narrative,
         intent=intent,
+        trial_summaries=trial_summaries,
     )
     from reporting.content import valid_decision_choices
 
diff --git a/plugin/skills/behavior-diff/scripts/reporting/summary.py b/plugin/skills/behavior-diff/scripts/reporting/summary.py
index 0f7ab93..2f11039 100644
--- a/plugin/skills/behavior-diff/scripts/reporting/summary.py
+++ b/plugin/skills/behavior-diff/scripts/reporting/summary.py
@@ -287,7 +287,7 @@ def build_summary(metadata, variants, decisions):
     )
     if primary_status == "mixed":
         notices.append(
-            "The primary result has mixed trial choices; see its full distribution in Decision diff."
+            "The primary result varies across trials; see its full distribution in Behavior diff."
         )
     elif primary_status == "unavailable":
         notices.append(
@@ -305,27 +305,27 @@ def build_summary(metadata, variants, decisions):
     )
     if different_process:
         notices.append(
-            "The primary result is the same; process choices differ in this scenario."
+            "The primary result is the same; actions differ in this scenario."
         )
     if not narrative:
         notices.append(
-            "Plain-language narrative unavailable; original extracted choices are shown without added explanation."
+            "Plain-language narrative unavailable; original extracted comparisons are shown without added explanation."
         )
     if status == "unavailable":
         headline = "Insufficient evidence for a Before/After conclusion."
     elif narrative:
         headline = narrative.headline
     elif different_process:
-        headline = "Same result; different process choices."
+        headline = "Same result; different actions."
     elif status == "mixed":
-        headline = "Trial choices vary in this scenario."
+        headline = "Answers or actions vary across trials in this scenario."
     elif status == "changed":
-        headline = "Different choices were observed in this scenario."
+        headline = "Different answers or actions were observed in this scenario."
     else:
         headline = "No difference was observed in the selected comparison."
     if status == "unchanged":
         notices.append(
-            "Matching choices in this scenario do not prove that the instruction edit has no effect."
+            "Matching observations in this scenario do not prove that the instruction edit has no effect."
         )
     sides = []
     for side in ("before", "after"):
@@ -354,20 +354,18 @@ def build_summary(metadata, variants, decisions):
         )
     if row is None:
         evidence_label = (
-            "No usable decision extraction; trial records remain available."
+            "No usable comparison extraction; trial records remain available."
         )
     elif row.anchor == "answer":
         evidence_label = (
             "Plans stated in final answers; not executed actions."
             if narrative and narrative.evidence_kind == "plans"
-            else "Choices extracted from final answers; not evidence of tool execution."
+            else "Based on final answers. An answer describing an action does not prove it happened."
         )
     elif metadata.trace_source == "self-reported":
-        evidence_label = (
-            "Choices extracted from self-reported actions; not captured tool evidence."
-        )
+        evidence_label = "Based on self-reported actions. These are not independently captured tool evidence."
     else:
-        evidence_label = "Choices extracted from recorded tool events; records do not prove successful completion."
+        evidence_label = "Based on recorded tool calls. Recorded calls do not establish successful completion."
 
     def claim(value):
         return EvidenceClaimData(value.text, value.decisions) if value else None
diff --git a/plugin/skills/behavior-diff/scripts/reporting/trial_summary.py b/plugin/skills/behavior-diff/scripts/reporting/trial_summary.py
new file mode 100644
index 0000000..0e07cda
--- /dev/null
+++ b/plugin/skills/behavior-diff/scripts/reporting/trial_summary.py
@@ -0,0 +1,87 @@
+"""Validate optional human summaries against exact trial evidence group identities."""
+
+import re
+from collections import Counter
+from dataclasses import dataclass
+from itertools import zip_longest
+from typing import Tuple
+
+
+@dataclass(frozen=True)
+class TrialSummaryData:
+    before_trial: str
+    after_trial: str
+    takeaway: str
+    before: str
+    after: str
+    caveat: str
+
+
+def trial_group_names(before, after):
+    """Use persisted variant order, not numeric suffixes or execution pairing."""
+    return tuple(zip_longest(before, after, fillvalue=""))
+
+
+def _text(value, required):
+    if type(value) is not str:
+        raise ValueError("invalid trial summary text")
+    text = value.strip()
+    if (
+        (required and not text)
+        or len(text) > 240
+        or len(text.split()) > 40
+        or any(ord(char) < 32 or ord(char) == 127 for char in value)
+        or any(char in value for char in "<>`")
+        or re.search(r"\*\*|__|!\[|\[[^\]]*\]\(|^#{1,6}\s", value)
+    ):
+        raise ValueError("trial summary must be short plain text")
+    return text
+
+
+def parse_trial_summaries(raw, groups=None) -> Tuple[TrialSummaryData, ...]:
+    """Discard invalid/ambiguous summaries without discarding underlying evidence.
+
+    When groups are supplied, both trial names must match one positional group
+    exactly. Duplicate identities invalidate all copies, even a malformed copy.
+    """
+    if type(raw) is not list:
+        return ()
+    identities = Counter(
+        (item["before_trial"], item["after_trial"])
+        for item in raw
+        if type(item) is dict
+        and type(item.get("before_trial")) is str
+        and type(item.get("after_trial")) is str
+    )
+    groups = tuple(groups) if groups is not None else None
+    allowed = set(groups) if groups is not None else None
+    parsed = {}
+    for item in raw:
+        if type(item) is not dict:
+            continue
+        before_trial, after_trial = item.get("before_trial"), item.get("after_trial")
+        if type(before_trial) is not str or type(after_trial) is not str:
+            continue
+        identity = (before_trial, after_trial)
+        if (
+            not any(identity)
+            or identities[identity] != 1
+            or (allowed is not None and identity not in allowed)
+            or (before_trial and not before_trial.startswith("before-"))
+            or (after_trial and not after_trial.startswith("after-"))
+        ):
+            continue
+        try:
+            takeaway = _text(item.get("takeaway"), True)
+            before = _text(item.get("before"), bool(before_trial))
+            after = _text(item.get("after"), bool(after_trial))
+            caveat = _text(item.get("caveat", ""), False)
+            if (not before_trial and before) or (not after_trial and after):
+                continue
+            parsed[identity] = TrialSummaryData(
+                before_trial, after_trial, takeaway, before, after, caveat
+            )
+        except ValueError:
+            continue
+    order = groups if groups is not None else parsed
+    return tuple(parsed[identity] for identity in order if identity in parsed)
diff --git a/tests/report-schema-test.py b/tests/report-schema-test.py
index 3152396..7876fe1 100755
--- a/tests/report-schema-test.py
+++ b/tests/report-schema-test.py
@@ -2,6 +2,7 @@
 import contextlib
 import copy
 import importlib.util
+import html
 import io
 import json
 import os
@@ -25,12 +26,17 @@
     ReportData,
     TrialData,
 )
+from reporting.trial_summary import (  # noqa: E402
+    TrialSummaryData,
+    parse_trial_summaries,
+    trial_group_names,
+)
 from report_fixtures import SCENARIOS, build_reports  # noqa: E402
 
 
 def synthetic_raw():
     raw = {
-        "schema_version": 7,
+        "schema_version": 8,
         "metadata": {
             "model": "synthetic/model",
             "mode": "review",
@@ -193,6 +199,24 @@ def synthetic_raw():
             ],
             "narrative": None,
             "intent": None,
+            "trial_summaries": [
+                {
+                    "before_trial": "before-1",
+                    "after_trial": "after-1",
+                    "takeaway": "The after record adds testing to the file review.",
+                    "before": "The before record shows a file read.",
+                    "after": "The after record shows a file read and a test command.",
+                    "caveat": "The recorded test command alone does not establish success.",
+                },
+                {
+                    "before_trial": "before-2",
+                    "after_trial": "after-2",
+                    "takeaway": "Both records show the same search activity.",
+                    "before": "The before record shows a file search.",
+                    "after": "The after record shows a file search.",
+                    "caveat": "",
+                },
+            ],
         },
     }
     from reporting.schema import _decisions, _metadata, _variants
@@ -492,6 +516,152 @@ def handle_starttag(self, tag, attrs):
                 assert f'id="{target}"' in markdown
 
 
+def assert_guided_report_structure(report):
+    """Navigation and paired records retain evidence without inventing pairing."""
+    from reporting.render_html import render_artifact
+    from reporting.render_markdown import render_markdown
+
+    diff = (
+        "--- a/WORKFLOW.md\n+++ b/WORKFLOW.md\n"
+        "@@ -20,2 +20,2 @@ Questions\n-old questions\n+new questions\n context\n"
+        "@@ -26 +26 @@ Transition\n-old gate\n+new gate\n"
+    )
+    labels = [content.instruction_hunk_label(diff, number) for number in (1, 2)]
+    assert labels[0] != labels[1], "Neighboring edit blocks need distinct locations."
+    assert "Questions" in labels[0] and "Transition" in labels[1]
+    assert "20" in labels[0] and "21" in labels[0] and "26" in labels[1]
+    raw_lines = tuple(content.instruction_diff_lines(diff))
+    assert tuple(line for line, _ in raw_lines) == tuple(diff.splitlines())
+    assert tuple(number for _, number in raw_lines if number) == (1, 2)
+
+    class Evidence(HTMLParser):
+        def __init__(self):
+            super().__init__()
+            self.in_trials = False
+            self.details = 0
+            self.pre = None
+            self.visible_answers = []
+            self.ids = []
+            self.primary_targets = []
+            self.missing_cells = 0
+
+        def handle_starttag(self, tag, attrs):
+            attrs = dict(attrs)
+            anchor = attrs.get("id", "")
+            if anchor:
+                self.ids.append(anchor)
+            if anchor == "panel-trials":
+                self.in_trials = True
+            if tag == "details":
+                self.details += 1
+            if tag == "pre" and self.in_trials and self.details == 0:
+                self.pre = []
+            if (
+                tag == "a"
+                and "summary-evidence-button" in attrs.get("class", "").split()
+            ):
+                self.primary_targets.append(attrs["href"])
+            if "trial-missing" in attrs.get("class", "").split():
+                self.missing_cells += 1
+
+        def handle_data(self, text):
+            if self.pre is not None:
+                self.pre.append(text)
+
+        def handle_endtag(self, tag):
+            if tag == "pre" and self.pre is not None:
+                self.visible_answers.append("".join(self.pre))
+                self.pre = None
+            if tag == "details":
+                self.details -= 1
+
+    first = replace(
+        report.variants.before.trials[0],
+        final="Before evidence | workflow feedback run 1",
+        commands=("printf 'before|one'\nprintf 'before-two'",),
+    )
+    second = replace(
+        report.variants.after.trials[0],
+        final="After evidence | workflow feedback run 1",
+        verdict="BLOCKED",
+        commands=(),
+    )
+    missing = replace(second, name="after-missing", final="")
+    specimen = replace(
+        report,
+        variants=replace(
+            report.variants,
+            before=replace(report.variants.before, trials=(first,), total=1, valid=1),
+            after=replace(
+                report.variants.after,
+                trials=(second, missing),
+                total=2,
+                valid=1,
+                blocked=1,
+            ),
+        ),
+    )
+    assert_evidence_links(specimen)
+    for rendered, is_html in (
+        (render_artifact(specimen, ""), True),
+        (render_markdown(specimen), False),
+    ):
+        evidence = Evidence()
+        evidence.feed(rendered)
+        for panel in ("summary", "instruction", "decision", "flow", "trials"):
+            assert f"panel-{panel}" in evidence.ids
+        assert [
+            anchor
+            for anchor in evidence.ids
+            if re.fullmatch(r"trial-group-\d+", anchor)
+        ] == [content.trial_group_anchor(1), content.trial_group_anchor(2)], (
+            "Unequal sides lost a shared trial group."
+        )
+        before_anchor = content.trial_anchor("before", first.name)
+        after_anchor = content.trial_anchor("after", second.name)
+        assert evidence.ids.index(before_anchor) < evidence.ids.index(after_anchor)
+        assert first.final in evidence.visible_answers
+        assert second.final in evidence.visible_answers
+        assert content.NO_FINAL_ANSWER in rendered
+        assert "BLOCKED" in rendered
+        assert evidence.missing_cells, (
+            "An unequal side needs an explicit missing-record cell."
+        )
+        assert "workflow feedback run 1" in rendered, (
+            "Domain run terminology was rewritten."
+        )
+        if is_html:
+            assert evidence.primary_targets == [
+                f"#decision-{report.summary.decision}"
+                if report.summary.decision is not None
+                and report.summary.status != "unavailable"
+                else "#panel-trials"
+            ], "The Summary must have one primary evidence destination."
+
+    # Independently retained records remain navigable without an extraction.
+    unavailable = replace(
+        report,
+        decisions=replace(report.decisions, rows=(), outcome=None, narrative=None),
+    )
+    from reporting.summary import build_summary
+
+    unavailable = replace(
+        unavailable,
+        summary=build_summary(
+            unavailable.metadata, unavailable.variants, unavailable.decisions
+        ),
+    )
+    assert_evidence_links(unavailable)
+    assert unavailable.summary.status == "unavailable"
+    assert unavailable.summary.before.choices == unavailable.summary.after.choices == ()
+    assert unavailable.summary.why is None and unavailable.summary.caution is None
+    for render in (lambda value: render_artifact(value, ""), render_markdown):
+        rendered = render(unavailable)
+        for variant in (report.variants.before, report.variants.after):
+            for trial in variant.trials:
+                assert html.escape(trial.final) in rendered
+
+
 def assert_no_invented_causality():
     from reporting.load import load_report
 
@@ -1181,6 +1351,25 @@ def assert_gallery_reports():
                 for index in report.result.behavior
             ), "An answer detail appeared as an action change."
 
+        mixed_summaries = reports["mixed"].decisions.trial_summaries
+        assert len(mixed_summaries) == 3
+        assert "changes" in mixed_summaries[0].takeaway
+        assert "changes" in mixed_summaries[1].takeaway
+        assert mixed_summaries[2].takeaway.startswith("Both reviews")
+        assert "changes" not in mixed_summaries[2].takeaway
+        assert reports["missing-extraction"].decisions.trial_summaries == ()
+        for name, report in reports.items():
+            if name != "missing-extraction":
+                assert len(report.decisions.trial_summaries) == 3, name
+            for number, summary in enumerate(report.decisions.trial_summaries):
+                assert (
+                    summary.before_trial == report.variants.before.trials[number].name
+                )
+                assert summary.after_trial == report.variants.after.trials[number].name
+        assert reports["planned-actions"].decisions.trial_summaries[0].caveat == (
+            "Neither proposed step is recorded as executed."
+        )
+
         assert content.flow_patterns(reports["same-result"].command_flow) == (
             (("Read files",), 3, 3),
         ), "Different files must not become different command categories."
@@ -1246,13 +1435,412 @@ def assert_gallery_reports():
         assert list(root.iterdir()) == [sentinel], "Refusal left partial gallery files."
 
 
+def assert_trial_summary_rendering(report):
+    """Every group leads with its own short summary while retaining complete evidence."""
+    from unittest.mock import patch
+
+    from reporting.render_html import render_artifact
+    from reporting.render_markdown import render_markdown
+
+    def rendered_groups(specimen):
+        with patch(
+            "subprocess.run", side_effect=AssertionError("Rendering called a process")
+        ):
+            outputs = (render_artifact(specimen, ""), render_markdown(specimen))
+        for rendered in outputs:
+            for number in range(
+                1,
+                max(
+                    len(specimen.variants.before.trials),
+                    len(specimen.variants.after.trials),
+                )
+                + 1,
+            ):
+                group = rendered.split(f'id="trial-group-{number}"', 1)[1]
+                group = group.split(f'id="trial-group-{number + 1}"', 1)[0]
+                yield number, group
+
+    for number, group in rendered_groups(report):
+        summary = report.decisions.trial_summaries[number - 1]
+        plain = html.unescape(group).replace("\\", "")
+        assert plain.index(content.TRIAL_CHANGE_HEADING) < plain.index(summary.takeaway)
+        assert plain.index(summary.takeaway) < plain.index(content.FINAL_ANSWER_HEADING)
+        assert summary.before in plain and summary.after in plain
+        assert summary.caveat in plain
+        for variant in (report.variants.before, report.variants.after):
+            trial = variant.trials[number - 1]
+            assert html.escape(trial.final) in group
+            for command in trial.commands:
+                assert html.escape(command) in group
+        if number == 2:
+            assert report.decisions.trial_summaries[0].takeaway not in plain
+
+    first, second = report.decisions.trial_summaries
+    for summaries in (
+        (),
+        (replace(first, after_trial=second.after_trial),),
+        (first, first),
+        (first, replace(first, before="Different duplicate description.")),
+    ):
+        specimen = replace(
+            report, decisions=replace(report.decisions, trial_summaries=summaries)
+        )
+        for _, group in rendered_groups(specimen):
+            plain = html.unescape(group).replace("\\", "")
+            assert content.TRIAL_SUMMARY_UNAVAILABLE in plain
+            assert first.takeaway not in plain
+            assert second.takeaway not in plain
+            for trial in report.variants.before.trials + report.variants.after.trials:
+                if html.escape(trial.name) in group:
+                    assert html.escape(trial.final) in group
+
+    one_side = replace(
+        second,
+        before_trial="",
+        before="",
+        takeaway="Only the after review is recorded in this group.",
+    )
+    unequal = replace(
+        report,
+        variants=replace(
+            report.variants,
+            before=replace(
+                report.variants.before, trials=report.variants.before.trials[:1]
+            ),
+        ),
+        decisions=replace(report.decisions, trial_summaries=(first, one_side)),
+    )
+    for number, group in rendered_groups(unequal):
+        if number == 2:
+            plain = html.unescape(group).replace("\\", "")
+            assert one_side.takeaway in plain and one_side.after in plain
+            assert "No trial record on this side." in plain
+            assert html.escape(report.variants.after.trials[1].final) in group
+
+    payload = '<script>alert("synthetic")</script> & [link](javascript:alert(1))'
+    unsafe = replace(
+        report,
+        decisions=replace(
+            report.decisions,
+            trial_summaries=(
+                replace(
+                    first,
+                    takeaway=payload,
+                    before=payload,
+                    after=payload,
+                    caveat=payload,
+                ),
+                second,
+            ),
+        ),
+    )
+    for baseline, rendered in (
+        (render_artifact(report, ""), render_artifact(unsafe, "")),
+        (render_markdown(report), render_markdown(unsafe)),
+    ):
+        assert_unchanged_scripts(baseline, rendered)
+        assert "&lt;script&gt;" in rendered
+
+
+def assert_trial_summary_validation(raw):
+    """Optional copy is bounded, canonical, and attached only to its own group."""
+    groups = (("before-1", "after-1"), ("before-2", "after-2"))
+    first, second = copy.deepcopy(raw["decisions"]["trial_summaries"])
+    expected = tuple(TrialSummaryData(**item) for item in (first, second))
+    assert parse_trial_summaries([second, first], groups) == expected
+    assert parse_trial_summaries([dict(first, caveat="")], groups)[0].caveat == ""
+    without_caveat = dict(first)
+    del without_caveat["caveat"]
+    assert parse_trial_summaries([without_caveat], groups)[0].caveat == ""
+    assert (
+        parse_trial_summaries([dict(first, takeaway="  Short finding.  ")], groups)[
+            0
+        ].takeaway
+        == "Short finding."
+    )
+    for field in ("takeaway", "before", "after", "caveat"):
+        for text in ("x" * 240, " ".join(["word"] * 40)):
+            accepted = parse_trial_summaries([dict(first, **{field: text})], groups)
+            assert accepted and getattr(accepted[0], field) == text
+        for text in (
+            "x" * 241,
+            " ".join(["word"] * 41),
+            "Two\nlines",
+            "Two\tcolumns",
+            "Control\x7f",
+            "<script>unsafe</script>",
+            "`command dump`",
+            "**Markdown emphasis**",
+            "[Markdown link](https://example.invalid)",
+            False,
+            None,
+            [],
+        ):
+            assert parse_trial_summaries([dict(first, **{field: text})], groups) == ()
+    for field in ("takeaway", "before", "after"):
+        assert parse_trial_summaries([dict(first, **{field: " "})], groups) == ()
+        missing = dict(first)
+        del missing[field]
+        assert parse_trial_summaries([missing], groups) == ()
+    for malformed in (None, False, {}, "summary", [None], [[]]):
+        assert parse_trial_summaries(malformed, groups) == ()
+    for invalid in (
+        dict(first, before_trial=True),
+        dict(first, after_trial=None),
+        dict(first, before_trial="after-1"),
+        dict(first, before_trial="", after_trial=""),
+        dict(first, before_trial="before-1 ", after_trial="after-1"),
+        dict(first, before_trial="before-1", after_trial="after-2"),
+        dict(first, before_trial="before-unknown"),
+    ):
+        assert parse_trial_summaries([invalid, second], groups) == (expected[1],)
+    assert parse_trial_summaries([first, first, second], groups) == (expected[1],)
+    assert parse_trial_summaries(
+        [first, dict(first, takeaway=False), second], groups
+    ) == (expected[1],), "A malformed duplicate must not leave an arbitrary winner."
+
+    one_sided = dict(first, before_trial="", before="")
+    absent_groups = (("", "after-1"),)
+    assert parse_trial_summaries([one_sided], absent_groups) == (
+        TrialSummaryData(**one_sided),
+    )
+    assert (
+        parse_trial_summaries([dict(one_sided, before="No work.")], absent_groups) == ()
+    )
+    other_side = dict(first, after_trial="", after="")
+    assert parse_trial_summaries([other_side], (("before-1", ""),)) == (
+        TrialSummaryData(**other_side),
+    )
+    assert trial_group_names(("before-10", "before-2"), ("after-alpha",)) == (
+        ("before-10", "after-alpha"),
+        ("before-2", ""),
+    )
+
+    canonical_error = (
+        "invalid report-data field decisions.trial_summaries: "
+        "expected valid canonical trial group summaries"
+    )
+    for invalid in (
+        None,
+        {},
+        [dict(first, takeaway=" padded ")],
+        [dict(first, after_trial="after-2")],
+        [first, first],
+        [second, first],
+        [dict(first, extra="not part of the contract")],
+        [dict(first, before=False)],
+    ):
+        specimen = copy.deepcopy(raw)
+        specimen["decisions"]["trial_summaries"] = invalid
+        assert_rejected(specimen, canonical_error)
+    empty = copy.deepcopy(raw)
+    empty["decisions"]["trial_summaries"] = []
+    assert assert_round_trip(empty).decisions.trial_summaries == ()
+    missing = copy.deepcopy(raw)
+    del missing["decisions"]["trial_summaries"]
+    assert_rejected(
+        missing,
+        "invalid report-data field decisions.trial_summaries: expected present field",
+    )
+    assert_rejected(
+        dict(raw, schema_version=7), "unsupported report-data schema version: 7"
+    )
+
+
+def assert_trial_summary_pipeline():
+    """Production prompt, ingestion, loading, and offline rendering share identities."""
+    import decisions
+    from reporting.load import load_report
+
+    with tempfile.TemporaryDirectory() as directory:
+        run = Path(directory)
+        (run / "task.md").write_text("Review the synthetic widget without changing it.")
+        (run / "config.json").write_text(
+            json.dumps(
+                {"mode": "review", "vocab": "generic", "target_file": "AGENTS.md"}
+            )
+        )
+        names = (
+            "before-review-extra",
+            "after-alpha",
+            "before-02",
+            "after-10",
+            "after-z-missing",
+        )
+        (run / "grades.tsv").write_text(
+            "".join(
+                f"{name}\t{'BLOCKED' if name == 'after-z-missing' else 'REVIEW'}\t-\n"
+                for name in names
+            )
+        )
+        for name in names[:-1]:
+            trial = run / name
+            trial.mkdir()
+            (trial / "trace.jsonl").write_text(
+                "\n".join(
+                    json.dumps(event)
+                    for event in (
+                        False,
+                        {"type": "assistant", "message": {"content": [False]}},
+                        {
+                            "type": "assistant",
+                            "message": {
+                                "content": [
+                                    {
+                                        "type": "tool_use",
+                                        "input": {
+                                            "command": "read synthetic-widget.txt"
+                                        },
+                                    }
+                                ]
+                            },
+                        },
+                        {
+                            "type": "result",
+                            "result": f"Complete synthetic answer for {name}.",
+                        },
+                    )
+                )
+            )
+        # Unlisted directories cannot shift the report's persisted groups.
+        (run / "before-00-ungraded").mkdir()
+        all_trials = decisions.trials_of(run, finished_only=False)
+        groups = decisions.summary_groups(all_trials)
+        assert groups == (
+            ("before-02", "after-10"),
+            ("before-review-extra", "after-alpha"),
+            ("", "after-z-missing"),
+        )
+        prompt, counts, instruction_diff = decisions.build_prompt(run)
+        assert counts == {"before": 2, "after": 2}
+        assert "NOT paired executions" in prompt
+        assert "aggregate decision counts" in prompt
+        assert "before-00-ungraded" not in prompt
+        assert "(not recorded)" in prompt and "after-z-missing" in prompt
+        encoded_groups = json.dumps(
+            [
+                {"before_trial": before, "after_trial": after}
+                for before, after in groups
+            ],
+            ensure_ascii=False,
+            indent=2,
+        )
+        assert encoded_groups in prompt
+        summaries = [
+            {
+                "before_trial": before,
+                "after_trial": after,
+                "takeaway": (
+                    "Both records show a file read."
+                    if before
+                    else "Only an incomplete after record is available."
+                ),
+                "before": "The before record shows a file read." if before else "",
+                "after": (
+                    "The after record shows a file read."
+                    if before
+                    else "The after record has no recorded final answer."
+                ),
+                "caveat": ""
+                if before
+                else "No before record is available in this group.",
+            }
+            for before, after in groups
+        ]
+        extraction = {
+            "chain": [
+                {
+                    "decision": "Which evidence was recorded?",
+                    "topic": "File review",
+                    "anchor": 1,
+                    "before": [{"choice": "read", "n": 2}],
+                    "after": [{"choice": "read", "n": 2}],
+                }
+            ],
+            "trial_summaries": summaries,
+        }
+        with contextlib.redirect_stdout(io.StringIO()):
+            assert decisions.write_decisions(
+                run,
+                json.dumps(extraction),
+                counts,
+                "synthetic/no-model",
+                instruction_diff,
+            )
+        saved = json.loads((run / "decisions.json").read_text())
+        assert saved["trial_summaries"] == summaries
+        report = load_report(run, run, "synthetic/no-model", run / "config.json")
+        assert [
+            (item.before_trial, item.after_trial)
+            for item in report.decisions.trial_summaries
+        ] == list(groups)
+        assert report.variants.after.trials[-1].final == ""
+        assert report.variants.after.trials[-1].verdict == "BLOCKED"
+        assert assert_round_trip(report.to_dict()) == report
+        baseline_trials = report.variants
+        baseline_rows = report.decisions.rows
+        for malformed in (
+            None,
+            "not a list",
+            [dict(summaries[0], after_trial="after-alpha")],
+            [dict(summaries[0], takeaway="x" * 241)],
+            [summaries[0], summaries[0]],
+        ):
+            normalized = decisions.normalize(
+                dict(extraction, trial_summaries=malformed), counts, groups=groups
+            )
+            assert normalized["trial_summaries"] == []
+            assert len(normalized["chain"]) == 1
+            saved["trial_summaries"] = malformed
+            (run / "decisions.json").write_text(json.dumps(saved))
+            loaded = load_report(run, run, "synthetic/no-model", run / "config.json")
+            assert loaded.decisions.trial_summaries == ()
+            assert loaded.decisions.rows == baseline_rows
+            assert loaded.variants == baseline_trials
+        del saved["trial_summaries"]
+        (run / "decisions.json").write_text(json.dumps(saved))
+        loaded = load_report(run, run, "synthetic/no-model", run / "config.json")
+        assert loaded.decisions.rows == baseline_rows
+        # A valid local summary is independent of invalid aggregate observations.
+        summary_only = dict(extraction, chain=[{"decision": "Bad row."}])
+        with contextlib.redirect_stdout(io.StringIO()):
+            assert decisions.write_decisions(
+                run,
+                json.dumps(summary_only),
+                counts,
+                "synthetic/no-model",
+                instruction_diff,
+            )
+        loaded = load_report(run, run, "synthetic/no-model", run / "config.json")
+        assert loaded.decisions.rows == ()
+        assert len(loaded.decisions.trial_summaries) == 3
+        assert loaded.variants == baseline_trials
+        from reporting.render_html import render_artifact
+        from reporting.render_markdown import render_markdown
+
+        for rendered in (render_artifact(loaded, ""), render_markdown(loaded)):
+            plain = html.unescape(rendered).replace("\\", "")
+            assert summaries[0]["takeaway"] in plain
+            assert summaries[-1]["takeaway"] in plain
+            assert content.TRIAL_SUMMARY_UNAVAILABLE not in plain
+            assert content.NO_FINAL_ANSWER in plain
+            for variant in (loaded.variants.before, loaded.variants.after):
+                for trial in variant.trials:
+                    if trial.final:
+                        assert html.escape(trial.final) in rendered
+
+
 def main():
     assert_render_import_safe()
     raw = synthetic_raw()
     report = assert_round_trip(raw)
+    assert_trial_summary_validation(raw)
+    assert_trial_summary_pipeline()
+    assert_trial_summary_rendering(report)
     assert_summary_evidence(report)
     assert_summary_boundaries(report)
     assert_evidence_links(report)
+    assert_guided_report_structure(report)
     assert_no_invented_causality()
     assert_tab_comparison_boundaries(report)
     assert_flow_pattern_boundaries()
@@ -1371,8 +1959,6 @@ def main():
         (render_markdown(report), render_markdown(escaping_report)),
     ):
         assert_unchanged_scripts(baseline, rendered)
-    assert 'class="badge review&quot;&gt;&lt;script&gt;&amp;"' in escaping_artifact
-    assert "REVIEW&quot;&gt;&lt;script&gt;&amp;</span>" in escaping_artifact
     unsafe_summary = copy.deepcopy(raw)
     payload = '<script>alert("x")</script>|[link](javascript:alert(1))'
     unsafe_summary["result"]["text"] = payload
diff --git a/tests/report_fixtures.py b/tests/report_fixtures.py
index ce417b9..08eda99 100644
--- a/tests/report_fixtures.py
+++ b/tests/report_fixtures.py
@@ -69,7 +69,7 @@ class Scenario:
     Scenario(
         "missing-extraction",
         "Comparison extraction is unavailable",
-        "Complete invoice-review traces remain available without a decision diff.",
+        "Complete invoice-review traces remain available without an extracted comparison.",
     ),
     Scenario(
         "self-reported",
@@ -109,6 +109,7 @@ class _Trial:
     actions: tuple[tuple[str, str], ...]
     final: str
     choices: dict[str, str]
+    summary: str
     verdict: str = "REVIEW"
     missing_files: tuple[str, ...] = ()
 
@@ -229,6 +230,25 @@ def _row(topic, question, anchor, trials):
     }
 
 
+def _trial_summaries(trials, comparisons):
+    """Attach authored prose to the exact synthetic trial group identities."""
+    if not len(trials["before"]) == len(trials["after"]) == len(comparisons):
+        raise ValueError("Synthetic trial summaries must cover both sides.")
+    return [
+        {
+            "before_trial": f"before-{number}",
+            "after_trial": f"after-{number}",
+            "takeaway": takeaway,
+            "before": before.summary,
+            "after": after.summary,
+            "caveat": caveat,
+        }
+        for number, (before, after, (takeaway, caveat)) in enumerate(
+            zip(trials["before"], trials["after"], comparisons), 1
+        )
+    ]
+
+
 def _write_extraction(
     run,
     rows,
@@ -238,6 +258,7 @@ def _write_extraction(
     claims=(),
     summary=None,
     intent=None,
+    trial_summaries=(),
 ):
     positions = {row["topic"]: index for index, row in enumerate(rows, 1)}
     _write_json(
@@ -253,6 +274,7 @@ def _write_extraction(
             ],
             "summary": summary,
             "intent": intent,
+            "trial_summaries": list(trial_summaries),
         },
     )
 
@@ -342,6 +364,13 @@ def _pr_description(run, scenario):
                         "Description scope": "Cache-expiry fix and regression coverage",
                         "Unrelated changes": "Excluded session-only and out-of-scope work",
                     },
+                    summary=(
+                        "Recorded reads include session notes, the branch patch, and scope; "
+                        "the answer describes only the cache-expiry fix."
+                        if side == "before"
+                        else "Recorded reads use the branch patch and scope without session notes; "
+                        "the answer still describes only the cache-expiry fix."
+                    ),
                 )
             )
     _write_sources(run, scenario, task, rules, files, trials)
@@ -371,6 +400,16 @@ def _pr_description(run, scenario):
                 ("Review sources", "Description scope"),
             ),
         ),
+        trial_summaries=_trial_summaries(
+            trials,
+            [
+                (
+                    "The PR description keeps the same scope while its recorded review sources change.",
+                    "The answer describes regression coverage but says the test was not run.",
+                )
+            ]
+            * 3,
+        ),
     )
 
 
@@ -540,11 +579,43 @@ def _invoice_review(run, scenario):
                     + final
                     + " These actions are self-reported; no independent tool capture is available."
                 )
+            if blocked:
+                sentence = (
+                    "The recorded invoice read fails; the answer reports a blocked review "
+                    "without inspecting the remaining records."
+                )
+            elif presentation == "Verdict with separate evidence bullets":
+                sentence = (
+                    "Recorded reads "
+                    + ("include" if inspect_history else "omit")
+                    + " payment history; the answer approves "
+                    "and lists the evidence in separate bullets."
+                )
+            else:
+                sentence = (
+                    "The self-report describes " if reported else "Recorded reads show "
+                )
+                if verdict == "HOLD":
+                    sentence += "a payment-history check; the answer holds the invoice for its prior payment."
+                elif inspect_history:
+                    sentence += "a payment-history check; the answer approves after finding no prior payment."
+                elif mixed_primary:
+                    sentence += (
+                        "receipt then vendor checks"
+                        if side == "before"
+                        else "vendor then receipt checks"
+                    ) + " without payment history; the answer approves the invoice."
+                else:
+                    sentence += (
+                        "invoice, receipt, and vendor checks without payment history; "
+                        "the answer approves the invoice."
+                    )
             trials[side].append(
                 _Trial(
                     actions=tuple(actions),
                     final=final,
                     choices=choices,
+                    summary=sentence,
                     verdict="BLOCKED" if blocked else "REVIEW",
                     missing_files=("invoice.csv",) if blocked else (),
                 )
@@ -552,6 +623,33 @@ def _invoice_review(run, scenario):
     _write_sources(run, scenario, task, rules, files, trials)
     if scenario.name == "missing-extraction":
         return
+    comparisons = []
+    for before, after in zip(trials["before"], trials["after"]):
+        before_choices, after_choices = before.choices, after.choices
+        if after.verdict == "BLOCKED":
+            takeaway = (
+                "After cannot complete the review because its invoice read fails."
+            )
+        elif before_choices["Review verdict"] != after_choices["Review verdict"]:
+            takeaway = (
+                "The answer changes from HOLD for a prior payment to APPROVE "
+                "without checking payment history."
+            )
+        elif (
+            before_choices["Answer presentation"]
+            != after_choices["Answer presentation"]
+        ):
+            takeaway = "The verdict stays APPROVE, but After lists the evidence in separate bullets."
+        elif before_choices["Record checks"] != after_choices["Record checks"]:
+            takeaway = (
+                "Both answers approve without checking payment history, "
+                "but the supporting records are read in a different order."
+            )
+        elif before_choices["Review verdict"] == "HOLD":
+            takeaway = "Both reviews check payment history and answer HOLD for the prior payment."
+        else:
+            takeaway = "Both reviews perform the same checks and answer APPROVE."
+        comparisons.append((takeaway, ""))
     rows = [
         _row("Invoice access", "Was the invoice available for review?", 2, trials),
         _row("Record checks", "Which supporting records were checked?", 3, trials),
@@ -680,6 +778,7 @@ def _invoice_review(run, scenario):
         fork_note=fork_note,
         claims=claims,
         summary=summary,
+        trial_summaries=_trial_summaries(trials, comparisons),
         intent={
             "text": (
                 "Prefer quick review and check the vendor before the receipt."
@@ -749,6 +848,13 @@ def _missing_primary(run, scenario):
                         ),
                         "Readiness caveat": "Pending status; no rollout decision",
                     },
+                    summary=(
+                        "Recorded reads cover the migration and pending deployment; "
+                        "the answer describes the schema addition without a rollout verdict."
+                        if side == "before"
+                        else "Recorded reads also cover rollback notes; the answer adds "
+                        "the backup prerequisite without a rollout verdict."
+                    ),
                 )
             )
     _write_sources(run, scenario, task, rules, files, trials)
@@ -782,6 +888,16 @@ def _missing_primary(run, scenario):
         ],
         fork="Rollback inspection",
         fork_note="The added rollback note can explain the additional backup observation.",
+        trial_summaries=_trial_summaries(
+            trials,
+            [
+                (
+                    "After adds a rollback prerequisite, but neither answer decides rollout readiness.",
+                    "The records show inspection, not execution of the migration.",
+                )
+            ]
+            * 3,
+        ),
     )
 
 
@@ -873,6 +989,13 @@ def _availability_review(run, scenario):
                         ),
                         "Review verdict": "APPROVE",
                     },
+                    summary=(
+                        "Recorded actions include source inspection and a passing test run; "
+                        "the answer approves the implementation."
+                        if run_tests
+                        else "Recorded actions show source inspection without a test run; "
+                        "the answer approves the implementation."
+                    ),
                 )
             )
     _write_sources(run, scenario, task, rules, files, trials)
@@ -897,6 +1020,18 @@ def _availability_review(run, scenario):
                 ("Test execution", "Review verdict"),
             ),
         ),
+        trial_summaries=_trial_summaries(
+            trials,
+            [
+                (
+                    "After adds a passing test run while the review answer stays APPROVE."
+                    if trial.choices["Test execution"] != "Did not run tests"
+                    else "Both reviews inspect the source without running tests and answer APPROVE.",
+                    "",
+                )
+                for trial in trials["after"]
+            ],
+        ),
     )
 
 
@@ -958,7 +1093,15 @@ def _intent_review(run, scenario):
                     "Do not ship. The token is predictable and the secret comparison "
                     "is not constant-time."
                 )
-            trials[side].append(_Trial(actions, final, choices))
+            sentence = (
+                f"The recorded query uses the {'old' if side == 'before' else 'new'} "
+                f"interface on {'archived' if source == 'archive.csv' else 'current'} records; "
+                f"the answer identifies {result} as the largest amount."
+                if flip
+                else "The recorded read inspects the authentication code; the answer "
+                "flags predictable tokens and unsafe secret comparison."
+            )
+            trials[side].append(_Trial(actions, final, choices, sentence))
     _write_sources(run, scenario, task, rules, files, trials)
     if flip:
         rows = [
@@ -982,7 +1125,28 @@ def _intent_review(run, scenario):
         for row in rows[1:]:
             row["edit_hunks"] = [1]
         primary = "Review verdict"
-    _write_extraction(run, rows, primary=primary)
+    _write_extraction(
+        run,
+        rows,
+        primary=primary,
+        trial_summaries=_trial_summaries(
+            trials,
+            [
+                (
+                    (
+                        "After queries archived rather than current records with a new interface; "
+                        "the answer changes from North to West."
+                        if number == 2
+                        else "The query interface changes, but both answers identify North."
+                    )
+                    if flip
+                    else "Both answers flag the same security problems and say not to ship.",
+                    "",
+                )
+                for number in range(3)
+            ],
+        ),
+    )
 
 
 def _planned_actions(run, scenario):
@@ -996,6 +1160,11 @@ def _planned_actions(run, scenario):
                 actions=(("cat AGENTS.md", rules[side]),),
                 final="I would " + choice + ". No changes have been made.",
                 choices={"Next step": choice},
+                summary=(
+                    "The answer proposes to "
+                    + choice
+                    + "; only an instruction read is recorded."
+                ),
             )
             for _ in range(3)
         ]
@@ -1044,6 +1213,16 @@ def _planned_actions(run, scenario):
         rows,
         primary="Next step",
         summary=summary,
+        trial_summaries=_trial_summaries(
+            trials,
+            [
+                (
+                    "The proposed next step changes from reviewing the failure to repairing it.",
+                    "Neither proposed step is recorded as executed.",
+                )
+            ]
+            * 3,
+        ),
         intent={
             "text": "Ask for a repair plan rather than another review step.",
             "edit_hunks": [1],