@@ -158,7 +158,7 @@ handling untrusted artifacts. Neither the gateway nor the linked implementation
 A walk serves itself on loopback, and the page is where you actually review. While a walk
 is listening, the beat being read leads the page on its own, under a bar that stays in
 view: the plan as a track with the current beat marked, the agent's own sentence about
-what it is doing, and Next beat. Everything already walked sits below, ordered by what is
+what it is doing, and Next item. Everything already walked sits below, ordered by what is
 owed rather than by what was walked: open flags expanded at the top, resolved beats folded
 to one line with your call on it, clean beats to one line each that still carries its
 proof. When the walk ends, that ledger is the page, and it is what the final render keeps.
@@ -168,17 +168,17 @@ that finished.
 The final render stays on your machine unless you agree to publish it, as **Finish** says.
 The keys do what the row under the beat says: Enter saves a note, or records a decision
 when the note is the decision; ⌘Enter or Ctrl+Enter fires the row's primary action; `n`
-is Next beat and `f` goes to the first open flag.
+is Next item and `f` goes to the first open flag.
 Resolving a beat asks twice, because none of it can be walked back: the store lets accept
 and drop out of an open flag only, and refuses to re-decide a beat that carries a delivery.
 So Implement, Include, Record decision and Drop all arm on the first click and send on the
 second, with the prompt naming which beat. Anything else answers no, including three
-seconds of nothing. Save note and Next beat go straight through.
+seconds of nothing. Save note and Next item go straight through.
 
 Decisions happen there too. Review mode uses Include in review and Drop. Report mode uses
 Include in report and Drop. Local branch and working-tree sessions retain Implement. A
 policy question whose answer completes the work carries Record decision.
-Each has a field for putting the call in your own words, and Next beat advances the walk
+Each has a field for putting the call in your own words, and Next item advances the walk
 from anywhere. Clicking is what unblocks the terminal side, which parks on the server
 between beats rather than spinning. The terminal still takes the same answers in words,
 so closing the tab never strands a session.
 
@@ -332,7 +332,7 @@ ordinary flag shows Implement for local `branch` targets or Include in review in
 mode, or Include in report in `report` mode, plus Drop. A legacy or malformed PR in branch
 mode shows that implementation is blocked instead. A decision-only flag with top-level
 `resolution_kind: "decision"` shows Record decision. Save note remains available on any
-beat, and Next beat works anywhere. The page writes its URL to `$R/serve.json`.
+beat, and Next item works anywhere. The page writes its URL to `$R/serve.json`.
 
 Those labels name the effect while the durable protocol remains stable. Implement,
 Include in review, and Include in report all post the canonical `accept` action.
 
@@ -193,6 +193,8 @@ h1 .num { color: var(--ink-3); font-variant-numeric: tabular-nums; }
 .assessment .recommendation { font-size: 19px; line-height: 1.5; }
 .assessment .decisions-owed { font-weight: 600; }
 .assessment .qualification { color: var(--ink-2); font-size: 14px; }
+.assessment h3 { margin: 20px 0 6px; font-size: 15px; line-height: 1.3; }
+.assessment .change { color: var(--ink-2); }
 .decision { max-width: 70ch; margin-bottom: 20px; }
 .decision p { margin: 0 0 6px; }
 
 
@@ -53,15 +53,15 @@
 
 # (heading, hint, states, expanded by default)
 SECTIONS = (
-    ("Needs your call", "out of beat order, on purpose", ("flag",), True),
+    ("Needs your call", "out of item order, on purpose", ("flag",), True),
     ("Accepted", "your call, and what came of it", ("accepted", "decided"), True),
-    ("Walked and clean", "nothing owed, proof on each", ("clean", "unverified"), False),
+    ("Read and clean", "nothing owed, proof on each", ("clean", "unverified"), False),
     ("Dropped", "raised, then set aside", ("dropped",), False),
 )
 
 LANDS_TAG = {"landed": "Landed", "ready": "Ready", "open": "Your call"}
-FRAME_PROSE = (("reconstruction", "Reconstruction"), ("claim_check", "Claim check"))
-FRAME_CALLS = (("orient_call", "Orient"), ("plan_call", "Plan"))
+FRAME_PROSE = (("claim_check", "Claim check"),)
+FRAME_CALLS = (("orient_call", "Your answer on the summary"), ("plan_call", "Your answer on the order"))
 
 # Only for --standalone. The viewport tag is load-bearing: report.css has a
 # 620px breakpoint that never fires without it.
@@ -113,7 +113,7 @@
     disarm();
     const label = button.textContent;
     const verb = label.split(' ')[0];
-    const which = n === 'walk' ? '' : ` beat ${n}`;
+    const which = n === 'walk' ? '' : ` item ${n}`;
     armed = {
       button,
       label,
@@ -131,7 +131,7 @@
   // stored, so it is not the reviewer's to repeat; a walk that failed or stopped still
   // needs telling, which is the one thing the page cannot do.
   const NOUNS = {
-    accept: 'decision', drop: 'decision', decide: 'decision', next: 'next beat',
+    accept: 'decision', drop: 'decision', decide: 'decision', next: 'next item',
   };
   function held(kind, headState) {
     const noun = NOUNS[kind] || kind || 'call';
@@ -811,7 +811,7 @@ def beat_html(
         body.append(diff_html(beat["diff"]))
     if beat.get("call"):
         body.append(
-            '<div class="call"><span class="lbl">Your call · beat '
+            '<div class="call"><span class="lbl">Your call · item '
             f'{n}</span><q>{md(beat["call"])}</q></div>'
         )
     delivery = delivery_html(beat, mode, replacement, untrusted_pr)
@@ -887,16 +887,16 @@ def beat_html(
         # and says what the keys do, once, where the reviewer is acting.
         advance = keys = ""
         if stage:
-            advance = '<button class="act" data-action="next">Next beat</button>'
+            advance = '<button class="act" data-action="next">Next item</button>'
             hints = [f"<kbd>Enter</kbd> {enter}"]
             if mod:
                 hints.append(f'<kbd><span data-mod>⌘</span>Enter</kbd> {mod}')
-            hints.append("<kbd>n</kbd> next beat")
+            hints.append("<kbd>n</kbd> next item")
             keys = f'<span class="keys">{" · ".join(hints)}</span>'
         # The note comes first so Tab lands on the primary right after typing.
         body.append(
             f'<div class="acts" data-acts="{attr(n)}">'
-            f'<input class="note" aria-label="your words, beat {attr(n)}" placeholder="{placeholder}">'
+            f'<input class="note" aria-label="your words, item {attr(n)}" placeholder="{placeholder}">'
             f'{controls}{advance}<span class="act-msg" role="status"></span>{keys}</div>'
         )
 
@@ -950,7 +950,7 @@ def coverage_html(session, beats):
         return ""
     left = [e for e in entries if e["state"] is None]
     walked = len(entries) - len(left)
-    head = f"{walked} of {len(entries)} beats walked"
+    head = f"{walked} of {len(entries)} items read"
     if not left:
         return f'<p class="coverage is-done">{md(head)}.</p>'
     rows = []
@@ -965,7 +965,7 @@ def coverage_html(session, beats):
             f'{md(textwrap.shorten(what, 88, placeholder="…"))}</span></li>'
         )
     return (
-        f'<div class="coverage"><p>{md(head)}. Not walked:</p>'
+        f'<div class="coverage"><p>{md(head)}. Not read yet:</p>'
         f'<ul class="cov-left">{"".join(rows)}</ul></div>'
     )
 
@@ -979,15 +979,15 @@ def bar_html(session, beats, current, phase):
     for entry in entries:
         state = entry["state"]
         if state is None:
-            cls, word = "is-todo", "not yet walked"
+            cls, word = "is-todo", "not read yet"
         else:
             suffix, token = STATE_STYLE.get(state, ("unver", "UNVERIFIED"))
             cls, word = f"s-{suffix}", token.lower()
         now = entry["n"] == current_n
         current_attr = ' aria-current="step"' if now else ""
         title = " · ".join(
             part for part in (
-                f"beat {entry['n']}", entry["tier"], entry["where"], word
+                f"item {entry['n']}", entry["tier"], entry["where"], word
             ) if part
         )
         marks.append(
@@ -996,17 +996,17 @@ def bar_html(session, beats, current, phase):
             f"{md(entry['n'])}</li>"
         )
     if current_n:
-        position = f"beat {current_n} of {total}" if total else f"beat {current_n}"
+        position = f"item {current_n} of {total}" if total else f"item {current_n}"
     elif phase == "done":
-        position = f"{len(beats)} of {total} walked" if total else f"{len(beats)} walked"
+        position = f"{len(beats)} of {total} read" if total else f"{len(beats)} read"
     else:
-        position = "waiting for beat 1"
+        position = "waiting for item 1"
     return (
         '<div class="bar">'
         f'<ol class="track" aria-label="{attr(position)}">{"".join(marks)}</ol>'
         '<span id="live" class="live starting" role="status">connecting</span>'
         '<div class="acts walk" data-acts="walk">'
-        '<button class="act" data-action="next">Next beat</button>'
+        '<button class="act" data-action="next">Next item</button>'
         '<span class="act-msg" role="status"></span></div>'
         "</div>"
     )
@@ -1022,17 +1022,17 @@ def stage_html(session, beats, current, card):
     if current:
         hint = " · ".join(
             part for part in (
-                f"beat {current_n} of {total}" if total else f"beat {current_n}",
+                f"item {current_n} of {total}" if total else f"item {current_n}",
                 current.get("tier", ""),
             ) if part
         )
     else:
-        hint = "nothing walked yet"
+        hint = "nothing read yet"
     ghost = ""
     if upcoming:
         line = " · ".join(
             part for part in (
-                f"beat {upcoming['n']} of {total}", upcoming["tier"], upcoming["where"]
+                f"item {upcoming['n']} of {total}", upcoming["tier"], upcoming["where"]
             ) if part
         )
         ghost = (
@@ -1068,21 +1068,26 @@ def assessment(session, beats, problems_by_n, validation_problems=()):
     label = "Provisional recommendation" if limits else "Recommendation"
     if execution_mode(session) == "no_exec":
         limits.append("Static inspection only; runtime behavior was not verified.")
-    if session_mode(session) in ("review", "report") and any(
-        beat.get("state") == "accepted" for beat in beats
-    ):
-        limits.append("Inclusion does not mean the underlying issue was fixed.")
+    mode = session_mode(session)
+    included = sum(beat.get("state") == "accepted" for beat in beats)
+    if mode in ("review", "report") and included:
+        limits.append(
+            f"{included} finding{'s' if included != 1 else ''} included in the {mode}. "
+            "Including a finding does not fix the issue it describes."
+        )
     owed = sum(beat.get("state") == "flag" for beat in beats)
     return label, text, limits, owed
 
 
 def assessment_html(session, beats, problems_by_n, validation_problems=()):
     label, text, limits, owed = assessment(session, beats, problems_by_n, validation_problems)
+    change = session.get("reconstruction")
     return (
         '<section class="assessment" aria-label="Review recommendation">'
         f'<h2>{label}</h2><p class="recommendation">{md(text)}</p>'
         f'<p class="decisions-owed">{owed} decision{"s" if owed != 1 else ""} owed</p>'
         + "".join(f'<p class="qualification">{md(limit)}</p>' for limit in limits)
+        + (f'<h3>What this change is</h3><p class="change">{md(change)}</p>' if change else "")
         + '</section>'
     )
 
@@ -1133,7 +1138,7 @@ def body_html(
         ("is-flag", counts.get("flag", 0), "needs your call"),
         ("is-acc", counts.get("accepted", 0) + counts.get("decided", 0), "accepted"),
         ("is-drop", counts.get("dropped", 0), "dropped"),
-        ("is-mute", len(beats), "beats walked"),
+        ("is-mute", len(beats), "items read"),
     ]
     parts.append(
         '<div class="counts">'
@@ -1205,7 +1210,7 @@ def frame_html(session, live):
         return ""
     summary = '<span class="sep">·</span>'.join(
         f'<span class="frame-k">{label}</span><q>{md(text)}</q>' for label, text in calls
-    ) or '<span class="frame-k">Orient</span>'
+    ) or '<span class="frame-k">How this review was framed</span>'
     body = "".join(f"<dt>{label}</dt><dd>{md(text)}</dd>" for label, text in prose)
     if body:
         body = f"<dl>{body}</dl>"