@@ -722,6 +722,9 @@ handoff with the same assessment and count of decisions owed as the page. Say wh
 reviewed or verified; clean counts and included findings alone do not establish merge
 readiness. The renderer qualifies incomplete coverage, unverified items, and static
 inspection instead of turning a delivery-complete page into a verified review.
+For every included finding, say in the recommendation whether it blocks the merge and who
+acts on it; a finished page that says "safe to merge" above a finding leaves the reviewer
+guessing which one wins.
 
 Render the page first, so the reviewer makes any remaining calls off the hoisted flags
 rather than off scrollback. Branch delivery and report acceptance are already complete,
 
@@ -192,15 +192,18 @@ h1 .num { color: var(--ink-3); font-variant-numeric: tabular-nums; }
 .assessment p { margin: 0 0 8px; }
 .assessment .recommendation { font-size: 19px; line-height: 1.5; }
 .assessment .decisions-owed { font-weight: 600; }
+.assessment .asks { margin: 0 0 8px; padding-left: 18px; }
+.assessment .asks li { margin: 0 0 4px; }
+.assessment .asks a { color: var(--flag); }
+.assessment .asks a:focus-visible { outline: 2px solid var(--flag); outline-offset: 1px; }
+.assessment .next-step { color: var(--ink-2); }
 .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; }
 
-/* ---- frame ----
-   The reviewer's two answers stay on the summary line, so the folded live frame still
-   says what the walk was agreed to be. */
+/* ---- frame ---- */
 .frame summary {
   cursor: pointer;
   width: fit-content;
@@ -219,6 +222,13 @@ h1 .num { color: var(--ink-3); font-variant-numeric: tabular-nums; }
   color: var(--ink-3);
 }
 .frame .frame-k { margin: 0 8px 0 4px; }
+.frame dt.frame-q {
+  font-family: var(--sans);
+  font-size: 14px;
+  letter-spacing: 0;
+  text-transform: none;
+  color: var(--ink-2);
+}
 .frame .sep { color: var(--rule); margin: 0 10px; }
 .frame q { font-style: normal; }
 .frame dl { margin: 12px 0 0; max-width: 68ch; }
 
@@ -61,7 +61,11 @@
 
 LANDS_TAG = {"landed": "Landed", "ready": "Ready", "open": "Your call"}
 FRAME_PROSE = (("claim_check", "Claim check"),)
-FRAME_CALLS = (("orient_call", "Your answer on the summary"), ("plan_call", "Your answer on the order"))
+# (session key, the question the reviewer answered before the walk)
+FRAME_CALLS = (
+    ("orient_call", "Is the summary of this change right?"),
+    ("plan_call", "In what order should the items be read?"),
+)
 
 # Only for --standalone. The viewport tag is load-bearing: report.css has a
 # 620px breakpoint that never fires without it.
@@ -387,7 +391,7 @@
   // ledger both say so; this says it where the click happened.
   function owedNote() {
     const staged = document.querySelector('#stage .beat.s-flag');
-    return staged ? `beat ${staged.dataset.n} stays owed` : '';
+    return staged ? `item ${staged.dataset.n} stays owed` : '';
   }
 
   function resumePending() {
@@ -598,6 +602,30 @@ def diff_html(lines):
     )
 
 
+def decision_text(beat, mode, replacement=False, untrusted_pr=False):
+    """A flag's (question, recommendation). A session older than the field gets the
+    choice its buttons offer, and no guessed recommendation."""
+    decision = beat.get("decision")
+    if isinstance(decision, dict):
+        return (
+            decision.get("question", "Decision not recorded."),
+            decision.get("recommendation", "Recommended option not recorded."),
+        )
+    if beat.get("resolution_kind") != "decision" and (
+        replacement or (mode == "branch" and untrusted_pr)
+    ):
+        question = "Replace this blocked session before choosing delivery, or drop this finding?"
+    elif beat.get("resolution_kind") == "decision":
+        question = "Choose the policy option in FIX or drop this question?"
+    else:
+        question = {
+            "branch": "Implement the proposed fix or drop this finding?",
+            "review": "Include in review or drop this finding?",
+            "report": "Include in report or drop this finding?",
+        }[mode]
+    return question, "Recommended option not recorded."
+
+
 def outcome_html(beat, mode):
     """One plain sentence on an accepted beat: what the reviewer chose and what it did.
     Accepting posts or records a finding; only branch mode changes the code."""
@@ -804,26 +832,7 @@ def beat_html(
 
     body = []
     if beat.get("state") == "flag":
-        decision = beat.get("decision")
-        if isinstance(decision, dict):
-            question = decision.get("question", "Decision not recorded.")
-            recommendation = decision.get("recommendation", "Recommended option not recorded.")
-        else:
-            if beat.get("resolution_kind") != "decision" and (
-                replacement or (mode == "branch" and untrusted_pr)
-            ):
-                question = "Replace this blocked session before choosing delivery, or drop this finding?"
-            else:
-                question = (
-                    "Choose the policy option in FIX or drop this question?"
-                    if beat.get("resolution_kind") == "decision"
-                    else {
-                        "branch": "Implement the proposed fix or drop this finding?",
-                        "review": "Include in review or drop this finding?",
-                        "report": "Include in report or drop this finding?",
-                    }[mode]
-                )
-            recommendation = "Recommended option not recorded."
+        question, recommendation = decision_text(beat, mode, replacement, untrusted_pr)
         body.append(
             '<div class="decision">'
             f'<p><strong>Decision:</strong> {md(question)}</p>'
@@ -950,7 +959,8 @@ def beat_html(
         )
 
     return (
-        f'<details class="beat s-{suffix}" data-n="{attr(n)}"{" open" if expanded else ""}>'
+        f'<details class="beat s-{suffix}" id="item-{attr(n)}" data-n="{attr(n)}"'
+        f'{" open" if expanded else ""}>'
         f"<summary>"
         f'<span class="b-num">{md(n)}</span>'
         f'<span class="b-tier">{md(beat.get("tier", ""))}</span>'
@@ -1097,7 +1107,7 @@ def stage_html(session, beats, current, card):
     )
 
 
-def assessment(session, beats, problems_by_n, validation_problems=()):
+def assessment(session, beats, problems_by_n, validation_problems=(), walking=False):
     text = session.get("recommendation")
     if not isinstance(text, str) or not text.strip():
         text = "Recommendation not recorded. Do not infer merge readiness from the counts."
@@ -1114,7 +1124,11 @@ def assessment(session, beats, problems_by_n, validation_problems=()):
         limits.append(f"{unverified} item{'s' if unverified != 1 else ''} unverified.")
     if problems_by_n or validation_problems:
         limits.append("The report has validation problems; resolve them before relying on it.")
-    label = "Provisional recommendation" if limits else "Recommendation"
+    owed = sum(beat.get("state") == "flag" for beat in beats)
+    if limits:
+        label = "Provisional recommendation"
+    else:
+        label = "Recommendation" if owed or walking else "Final recommendation"
     if execution_mode(session) == "no_exec":
         limits.append("Static inspection only; runtime behavior was not verified.")
     mode = session_mode(session)
@@ -1124,17 +1138,46 @@ def assessment(session, beats, problems_by_n, validation_problems=()):
             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)
+NEXT_STEP = {
+    "review": "Nothing reaches GitHub until you post the whole review at the end.",
+    "report": "Including a finding records it in this report and posts nothing.",
+    "branch": "Implement applies the stated fix and commits it.",
+}
+
+
+def assessment_html(
+    session, beats, problems_by_n, validation_problems=(),
+    replacement=False, untrusted_pr=False, walking=False,
+):
+    label, text, limits, owed = assessment(
+        session, beats, problems_by_n, validation_problems, walking,
+    )
     change = session.get("reconstruction")
+    mode = session_mode(session)
+    asks = "".join(
+        f'<li><a href="#item-{attr(beat.get("n", "?"))}">Item {md(beat.get("n", "?"))}</a>: '
+        f'{md(decision_text(beat, mode, replacement, untrusted_pr)[0])}</li>'
+        for beat in beats if beat.get("state") == "flag"
+    )
+    if asks:
+        blocked = replacement or (mode == "branch" and untrusted_pr)
+        step = (
+            "Implementing is blocked for this session; a finding can only be dropped or noted."
+            if blocked else NEXT_STEP[mode]
+        )
+        waiting = f'<ul class="asks">{asks}</ul><p class="next-step">{step}</p>'
+    elif label == "Final recommendation":
+        waiting = '<p class="next-step">The review is complete. Nothing is waiting on you.</p>'
+    else:
+        waiting = ""
     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>'
+        + waiting
         + "".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>'
@@ -1162,7 +1205,10 @@ def body_html(
             key=lambda b: b["n"],
             default=None,
         )
-    parts = [assessment_html(session, beats, problems_by_n, validation_problems)]
+    parts = [assessment_html(
+        session, beats, problems_by_n, validation_problems, replacement, untrusted_pr,
+        walking=live and phase != "done",
+    )]
     if live:
         parts.append(bar_html(session, beats, current, phase))
         if phase != "done":
@@ -1257,10 +1303,11 @@ def frame_html(session, live):
     calls = [(label, session.get(key)) for key, label in FRAME_CALLS if session.get(key)]
     if not prose and not calls:
         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">How this review was framed</span>'
-    body = "".join(f"<dt>{label}</dt><dd>{md(text)}</dd>" for label, text in prose)
+    summary = '<span class="frame-k">How this review was framed</span>'
+    body = "".join(
+        f'<dt class="frame-q">{label}</dt><dd>You answered <q>{md(text)}</q></dd>'
+        for label, text in calls
+    ) + "".join(f"<dt>{label}</dt><dd>{md(text)}</dd>" for label, text in prose)
     if body:
         body = f"<dl>{body}</dl>"
     return (
@@ -1516,7 +1563,9 @@ def main():
     )
     out.write_text(SHELL + page if args.standalone else page, encoding="utf-8")
 
-    label, recommendation, limits, owed = assessment(session, beats, problems_by_n, all_problems)
+    label, recommendation, limits, owed = assessment(
+        session, beats, problems_by_n, all_problems, walking=args.live,
+    )
     print(f"{label}: {recommendation}", file=sys.stderr)
     print(f"{owed} decision{'s' if owed != 1 else ''} owed", file=sys.stderr)
     for limit in limits:
 
@@ -559,11 +559,11 @@ def test_the_status_line_lives_in_the_bar_once(self):
 
     def test_a_resolved_beat_folds_to_its_line_with_the_call_while_walking(self):
         html = self.live(self.beats())
-        self.assertRegex(html, r'<details class="beat s-acc" data-n="2">')
+        self.assertRegex(html, r'<details class="beat s-acc" id="item-2" data-n="2">')
         self.assertIn('<span class="b-call">“leave it”</span>', html)
         # and stays open once the walk is done, as the final report has it
         self.assertRegex(self.live(self.beats(), phase="done"),
-                         r'<details class="beat s-acc" data-n="2" open>')
+                         r'<details class="beat s-acc" id="item-2" data-n="2" open>')
 
 
 class WalkCoverage(unittest.TestCase):
@@ -1093,6 +1093,47 @@ def test_live_fragment_counts_only_unresolved_flags(self):
         resolved = rr.body_html(self.session(), states, {}, live=True, phase="done")
         self.assertIn("0 decisions owed", resolved)
 
+    def test_the_summary_lists_each_open_question_and_the_next_step(self):
+        second = self.flag(n=2)
+        second["decision"] = dict(second["decision"], question="Keep or revert the cache change?")
+        page = rr.render(self.session(audience={"mode": "review"}),
+                         [self.flag(), second, beat(n=3)], "", {})
+        summary = page.split('class="assessment"')[1].split("</section>")[0]
+        self.assertIn('<a href="#item-1">Item 1</a>: Include the authorization finding', summary)
+        self.assertIn('<a href="#item-2">Item 2</a>: Keep or revert the cache change?', summary)
+        self.assertIn("Nothing reaches GitHub until you post the whole review at the end.", summary)
+        self.assertLess(summary.index('class="asks"'), summary.index("What this change is")
+                        if "What this change is" in summary else len(summary))
+        self.assertIn('id="item-2"', page)
+        legacy = self.flag()
+        legacy.pop("decision")
+        old = rr.render(self.session(audience={"mode": "review"}), [legacy], "", {})
+        self.assertIn('<a href="#item-1">Item 1</a>: Include in review or drop this finding?', old)
+
+    def test_a_finished_review_is_labelled_final_and_says_nothing_is_waiting(self):
+        done = rr.render(self.session(), [beat(n=1), beat(n=2)], "", {})
+        self.assertIn("<h2>Final recommendation</h2>", done)
+        self.assertIn("The review is complete. Nothing is waiting on you.", done)
+        owed = rr.render(self.session(), [self.flag(), beat(n=2)], "", {})
+        self.assertIn("<h2>Recommendation</h2>", owed)
+        self.assertNotIn("Nothing is waiting on you", owed)
+        partial = rr.render(self.session(), [beat(n=1)], "", {})
+        self.assertIn("<h2>Provisional recommendation</h2>", partial)
+        self.assertNotIn("Nothing is waiting on you", partial)
+        # every item read but the walk has not said done: not final yet
+        walking = rr.render(self.session(), [beat(n=1), beat(n=2)], "", {}, live=True, phase="parked")
+        self.assertIn("<h2>Recommendation</h2>", walking)
+        self.assertNotIn("Nothing is waiting on you", walking)
+        ended = rr.render(self.session(), [beat(n=1), beat(n=2)], "", {}, live=True, phase="done")
+        self.assertIn("<h2>Final recommendation</h2>", ended)
+
+    def test_a_blocked_session_does_not_promise_the_blocked_action(self):
+        page = rr.render(self.session(target={"kind": "github_pr", "repo": "a/b", "number": 1}),
+                         [self.flag()], "", {})
+        summary = page.split('class="assessment"')[1].split("</section>")[0]
+        self.assertIn("Implementing is blocked for this session", summary)
+        self.assertNotIn("Implement applies the stated fix", summary)
+
     def test_every_flag_names_the_decision_and_recommendation(self):
         policy = self.flag(n=2, resolution_kind="decision")
         policy["decision"] = {
@@ -1210,11 +1251,16 @@ def test_a_final_page_keeps_context_after_the_review_assessment(self):
         self.assertIn('<h3>What this change is</h3><p class="change">closes the hole <code>S0</code> left</p>', html)
         self.assertIn("<dd>the body holds up</dd>", html)
 
-    def test_a_live_walk_folds_it_to_the_reviewers_answers(self):
+    def test_a_live_walk_folds_it_and_each_answer_sits_beside_its_question(self):
         html = rr.render(self.SESSION, [], "", {}, live=True, phase="parked")
-        summary = html.split('<details class="frame"><summary>')[1].split("</summary>")[0]
-        self.assertIn("<q>confirm</q>", summary)
-        self.assertIn("<q>Walk it in this order</q>", summary)
+        frame = html.split('<details class="frame">')[1].split("</details>")[0]
+        self.assertIn('<summary><span class="frame-k">How this review was framed</span></summary>', frame)
+        self.assertIn(
+            '<dt class="frame-q">Is the summary of this change right?</dt>'
+            "<dd>You answered <q>confirm</q></dd>", frame)
+        self.assertIn(
+            '<dt class="frame-q">In what order should the items be read?</dt>'
+            "<dd>You answered <q>Walk it in this order</q></dd>", frame)
 
     def test_prose_with_no_recorded_answer_is_still_labelled(self):
         html = rr.render({"repo": "r", "claim_check": "the body holds up"}, [], "", {})
@@ -1225,7 +1271,7 @@ def test_the_reconstruction_leads_as_what_the_change_is_and_leaves_the_frame(sel
         self.assertLess(html.index("What this change is"), html.index('class="frame"'))
         frame = html.split('<details class="frame"')[1]
         self.assertNotIn("closes the hole", frame)
-        self.assertIn("Your answer on the summary", frame)
+        self.assertIn("Is the summary of this change right?", frame)
         self.assertNotIn("What this change is", rr.render({"repo": "r"}, [], "", {}))
 
     def test_the_reviewers_words_cannot_carry_markup(self):
 
@@ -77,6 +77,7 @@ def test_assessment_and_decisions_are_explicit_in_both_surfaces(self):
             "agent's recommendation, not the reviewer's GitHub verdict",
             "A static review cannot claim verified runtime behavior",
             "Before the walk is complete, call it provisional",
+            "say in the recommendation whether it blocks the merge",
         ):
             self.assertIn(phrase, text)