From 1b1f6ec7e211931be33f2fc97d31434ccdedc305 Mon Sep 17 00:00:00 2001
From: Eva <arncalso@gmail.com>
Date: Tue, 23 Jun 2026 14:11:57 +0700
Subject: [PATCH 1/2] =?UTF-8?q?feat(viewer):=204=20sat=E2=86=927=20web-vie?=
 =?UTF-8?q?wer=20UX/correctness=20fixes=20(battle-log=20sanitize,=20dice-h?=
 =?UTF-8?q?eader=20strip,=20roll=20context,=20drop-confirm)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

From the binding-sweep per-persona friction analysis:

1. BATTLE-LOG SANITIZER COVERAGE (adversarial friction): the combat Battle Log
   rendered l.title/l.text RAW, so DM engine meta-text (wrapper-progress lines,
   roll-summary headers, scaffolding) leaked there — the Chronicle's guard never
   reached this panel. BattleLogLine now routes both fields through the SAME
   window-exported sanitizeNarration (screen-combat.jsx).

2. DICE-RESULT-HEADER STRIP (narrative's only major — 'cracked the 9/10'): extend
   the sanitizer to drop (a) the roll-result-summary header form ('… lands at 18;
   the quiet interpose at 16.') and (b) a leading/standalone Markdown horizontal
   rule ('---'/'***'/'___'/'— —'). Verb+bare-integer anchored and whole-line for the
   chained header so genuine prose ('the bell strikes at 12', 'the arrow lands at his
   feet', em-dash asides) is never eaten (screen-table.jsx).

3. DIE-ROLL BUTTON CONTEXT (adversarial minor): the d20/d12/d8/d6 buttons fired a
   contextless 'requests a dN roll', bypassing the Declare guard. They now bind the
   roll to the player's typed intent, else attach the latest narrative line — parity
   with the Declare text-guard (composeRollMove, screen-table.jsx).

4. DROP-CONFIRM ON EQUIPPED GEAR (adversarial minor): a one-click Drop on equipped
   body armor was irreversible. Both Drop affordances (context-menu + detail pane)
   now confirm via window.confirm ONLY for currently-equipped items; loose stash
   items are never nagged (isItemEquipped, screen-inventory.jsx).

Tests: extend test_sanitize_narration.py (dice-header + leading-rule strip + a
hardened negative-prose suite), add test_battle_log_sanitize.py (BattleLogLine
meta-text strip + real-combat-text survival) and test_viewer_ux_guards.py
(composeRollMove context + isItemEquipped/drop-confirm). Local viewer suite green
(only pre-existing test_portrait_gen pydantic-env failure is unrelated).
---
 viewer/openworlds/screen-combat.jsx      |  16 ++-
 viewer/openworlds/screen-inventory.jsx   |  45 ++++++-
 viewer/openworlds/screen-table.jsx       |  91 ++++++++++++-
 viewer/tests/test_battle_log_sanitize.py | 134 ++++++++++++++++++
 viewer/tests/test_sanitize_narration.py  |  73 ++++++++++
 viewer/tests/test_viewer_ux_guards.py    | 165 +++++++++++++++++++++++
 6 files changed, 513 insertions(+), 11 deletions(-)
 create mode 100644 viewer/tests/test_battle_log_sanitize.py
 create mode 100644 viewer/tests/test_viewer_ux_guards.py

diff --git a/viewer/openworlds/screen-combat.jsx b/viewer/openworlds/screen-combat.jsx
index 27473083..83d3cc42 100644
--- a/viewer/openworlds/screen-combat.jsx
+++ b/viewer/openworlds/screen-combat.jsx
@@ -754,13 +754,25 @@ function ApBadge({ used, label }) {
 
 function BattleLogLine({ l }) {
   const meta = Array.isArray(l.meta) ? l.meta : [];
+  // SAT→7 (adversarial friction): the player-facing Battle Log must get the SAME read/projection
+  // hygiene as the main Chronicle. The /move + combat-event tail can carry DM engine META-TEXT — a
+  // wrapper-progress line ("Momentum carries through the scene…", "Your choice takes hold…"), a
+  // roll-summary header, or other scaffolding — which leaked here RAW because this panel never
+  // routed through the Chronicle's guard. Reuse the SAME window-exported sanitizeNarration (the engine
+  // stays sole writer; this is a projection filter only). Defensive: fall back to the raw string if the
+  // sibling <script> that defines it hasn't published yet (mirrors screen-table's own window-guard).
+  const sanitize = (t) => (typeof window !== "undefined" && typeof window.sanitizeNarration === "function")
+    ? window.sanitizeNarration(t || "")
+    : (t || "");
+  const title = sanitize(l.title) || l.event || "Combat";
+  const text = sanitize(l.text);
   return (
     <div style={{ padding: "5px 0", borderBottom: "1px solid rgba(140,100,60,0.16)" }}>
       <div style={{ display: "flex", gap: 6, alignItems: "baseline" }}>
         <span style={{ fontFamily: "var(--f-display)", fontSize: 10, letterSpacing: "0.16em", textTransform: "uppercase", color: "var(--ink-900)" }}>
-          {l.title || l.event || "Combat"}
+          {title}
         </span>
-        <span className="body-sm" style={{ color: "var(--ink-700)" }}>{l.text}</span>
+        <span className="body-sm" style={{ color: "var(--ink-700)" }}>{text}</span>
       </div>
       {meta.length > 0 && (
         <div style={{ display: "flex", gap: 5, flexWrap: "wrap", marginTop: 4 }}>
diff --git a/viewer/openworlds/screen-inventory.jsx b/viewer/openworlds/screen-inventory.jsx
index c0f06134..ea12d197 100644
--- a/viewer/openworlds/screen-inventory.jsx
+++ b/viewer/openworlds/screen-inventory.jsx
@@ -103,6 +103,19 @@ function ScreenInventory({ onNavigate, state, setState }) {
   }, [loadSurface]);
 
   const hero = party.find((p) => p.id === activeHero) || party[0] || null;
+  // SAT→7 (drop-confirm on equipped gear): a one-click Drop on WORN gear (body armor especially) is
+  // irreversible with no safety net. This wrapper performs the drop /move unchanged for a LOOSE stash
+  // item (no nag), but gates an EQUIPPED item behind window.confirm (the same pattern as quickload /
+  // seed-reset). Cancel = no-op; confirm = the exact original drop move. Shared by both Drop affordances
+  // (context-menu + detail pane) so they nag identically. Loose inventory is never nagged.
+  const confirmDrop = React.useCallback((item, doDrop) => {
+    if (typeof doDrop !== "function" || !item) return;
+    if (isItemEquipped(item, hero && hero.equipped)) {
+      const ok = window.confirm(dropEquippedConfirmMessage(item.name));
+      if (!ok) return;
+    }
+    doDrop();
+  }, [hero]);
   // RRI-5e98e6f: derive the displayed coin purse from the ONE shared selector + normalizer the
   // Market also uses, so the same character's coins read identically on both screens (no
   // 35-vs-232 divergence). partyPurse resolves the active hero (else party[0]) and zeroes/ints it.
@@ -361,7 +374,7 @@ function ScreenInventory({ onNavigate, state, setState }) {
               : { label: "Hand to a companion (preview)", icon: "→", disabled: true, title: "Display-only — start a live session to act", onClick: () => toast({ kind: "item", title: ctxMenu.item.name + " handed over" }) },
             { divider: true },
             canAct
-              ? { label: "Drop", icon: "▾", tone: "crimson", title: "Relays to the DM via /move — the engine resolves it", onClick: () => postInvMove("do", { text: "I drop the " + ctxMenu.item.name + "." }, { kind: "danger", title: "Dropping " + ctxMenu.item.name, body: "Relayed to the DM — you will not get it back unless you fetch it yourself." }) }
+              ? { label: "Drop", icon: "▾", tone: "crimson", title: "Relays to the DM via /move — the engine resolves it", onClick: () => confirmDrop(ctxMenu.item, () => postInvMove("do", { text: "I drop the " + ctxMenu.item.name + "." }, { kind: "danger", title: "Dropping " + ctxMenu.item.name, body: "Relayed to the DM — you will not get it back unless you fetch it yourself." })) }
               : { label: "Drop (preview)", icon: "▾", tone: "crimson", disabled: true, title: "Display-only — start a live session to act", onClick: () => toast({ kind: "danger", title: "Dropped: " + ctxMenu.item.name, body: "You will not get it back unless you fetch it yourself." }) },
           ]}
         />
@@ -416,6 +429,27 @@ function inferEquipSlotId(name) {
   return ""; // unrecognized — placed into the first free generic cell by assignEquipSlots
 }
 
+// SAT→7 (adversarial minor): is `item` one of the hero's CURRENTLY-EQUIPPED pieces? Equipped gear is
+// hero.equipped (the worn read-model). We match on the name SLUG so a display-name vs. catalog-name
+// nuance ("Studded Leather" vs "studded leather armor"…) doesn't miss — but stay STRICT (exact slug)
+// so a loose stash item is never wrongly flagged. Pure: reads only its args, writes nothing.
+function isItemEquipped(item, equipped) {
+  if (!item || !item.name || !Array.isArray(equipped)) return false;
+  const target = slug(item.name);
+  if (!target) return false;
+  return equipped.some((e) => e && e.name && slug(e.name) === target);
+}
+// The confirm copy for dropping/unequipping a WORN piece — irreversible, body armor especially. One
+// shared string so the context-menu Drop and the detail-pane Drop nag identically. Returns the message;
+// callers gate the actual drop behind `window.confirm(this)` (matching screen-settings/screen-seed).
+function dropEquippedConfirmMessage(name) {
+  return (
+    "Drop " + (name || "this item") + "?\n\n" +
+    "It is CURRENTLY EQUIPPED. Dropping it unequips and discards it — you will not get it back unless " +
+    "you fetch it yourself. This cannot be undone."
+  );
+}
+
 // Build a { slotId: equippedItem } map from hero.equipped. Rings and weapons spill from
 // their primary cell to the secondary (ring1→ring2, mainhand→offhand) so a hero wearing two
 // rings or dual-wielding shows both. Anything unrecognized lands in the first open cell so
@@ -853,7 +887,12 @@ function ItemDetail({ item, hero, toast, canAct, postInvMove, examineSignal }) {
         )}
         <BrassButton tone="ghost" size="sm" aria-haspopup="dialog" onClick={() => setExamineOpen(true)}>Examine</BrassButton>
         {canAct ? (
-          <BrassButton tone="ghost" size="sm" title="Relays to the DM via /move — the engine resolves it" onClick={() => postInvMove("do", { text: "I drop the " + item.name + "." }, { kind: "danger", title: "Dropping " + item.name, body: "Relayed to the DM." })}>
+          <BrassButton tone="ghost" size="sm" title="Relays to the DM via /move — the engine resolves it" onClick={() => {
+            // SAT→7: confirm before dropping CURRENTLY-EQUIPPED gear (worn body armor especially) — loose
+            // stash items drop with no nag. Mirrors the context-menu Drop via the same shared helpers.
+            if (isItemEquipped(item, hero && hero.equipped) && !window.confirm(dropEquippedConfirmMessage(item.name))) return;
+            postInvMove("do", { text: "I drop the " + item.name + "." }, { kind: "danger", title: "Dropping " + item.name, body: "Relayed to the DM." });
+          }}>
             Drop
           </BrassButton>
         ) : (
@@ -890,4 +929,4 @@ function itemCategory(item) {
 
 function toRoman(n) { return ["", "I", "II", "III", "IV", "V"][n] || n; }
 
-Object.assign(window, { ScreenInventory, CoinSlot, ItemSlot, ItemDetail, packContents, EQUIP_SLOTS, PaperDoll, EquipSlotCell, inferEquipSlotId, assignEquipSlots, ITEM_TYPES, ITEM_KINDS, itemCategory, toRoman, slug, itemScope, itemStatRows, itemCompareRows });
+Object.assign(window, { ScreenInventory, CoinSlot, ItemSlot, ItemDetail, packContents, EQUIP_SLOTS, PaperDoll, EquipSlotCell, inferEquipSlotId, assignEquipSlots, isItemEquipped, dropEquippedConfirmMessage, ITEM_TYPES, ITEM_KINDS, itemCategory, toRoman, slug, itemScope, itemStatRows, itemCompareRows });
diff --git a/viewer/openworlds/screen-table.jsx b/viewer/openworlds/screen-table.jsx
index c912b684..aa00421e 100644
--- a/viewer/openworlds/screen-table.jsx
+++ b/viewer/openworlds/screen-table.jsx
@@ -65,13 +65,21 @@ const _BARE_TOOL_LINE = new RegExp(
   "^\\s*[`'\"(_*]*\\s*(?:" + _TOOLS_ALT + ")\\s*(?:\\([^)]*\\))?\\s*[`'\")_*]*\\s*[.;:]?\\s*$",
   "i",
 );
+// SAT→7 (narrative friction): the DM agent occasionally emits a Markdown HORIZONTAL RULE as a
+// section separator ("---", "***", "___", or "— —") on its OWN line — a bare structural divider
+// that reads as a stray glyph in the player's story scroll. A line that is NOTHING BUT a rule
+// (3+ of the same rule char, optionally spaced) is formatting, never fiction, so drop it whole.
+// HIGH-CONFIDENCE: requires the whole line to be the rule (an em-dash "—pause—" mid-prose, or a
+// real "wait — what?" with surrounding words, is NOT a bare rule line and is untouched).
+const _HRULE_LINE = /^\s*(?:-\s*){3,}\s*$|^\s*(?:\*\s*){3,}\s*$|^\s*(?:_\s*){3,}\s*$|^\s*(?:—\s*){2,}\s*$/;
 function _isInternalLine(line) {
   const t = (line || "").trim();
   if (!t) return false; // keep blank lines for caller's join (they're harmless)
   return _GM_ADVISORY_HEADER.test(t)
     || _ADVISORY_SUBTITLE.test(t)
     || _ADVISORY_DIRECTIVE.test(t)
-    || _BARE_TOOL_LINE.test(t);
+    || _BARE_TOOL_LINE.test(t)
+    || _HRULE_LINE.test(t);
 }
 
 // #347: the SECOND class of DM-internal leak — the DM agent's STORY-CRAFT scaffolding
@@ -125,6 +133,35 @@ const _STAGE_DIRECTION = new RegExp(
     "\\bof the\\b[^.]{0,30}\\b(?:cold open|beat|act|scene)\\b[^.]{0,30}\\bcomplete\\b" +
   ")", "i",
 );
+// (3b) SAT→7 (narrative's only major — this "cracked the 9/10"): the ROLL-RESULT-SUMMARY HEADER.
+// Before narrating an outcome the DM agent sometimes states the raw check totals as a header line —
+// "The intimidation lands at 18; the quiet interpose at 16." — bookkeeping that belongs in the dice
+// tray, not the story prose. The fingerprint is a check NOUN/result "lands at <N>" optionally chained
+// with one or more "; <thing> at <M>" clauses, all on bare INTEGER roll totals. Drop the whole sentence.
+//
+// HIGH-CONFIDENCE (story quality is the north star — never eat real prose): the trigger REQUIRES a bare
+// integer immediately after "at" (a roll total, e.g. "at 18") AND a roll-summary VERB ("lands at"). The
+// canonical verb is what disambiguates a check total from ordinary fiction: "the arrow lands at his feet"
+// (noun, not a number) and "we arrive at the gate" (no roll verb) both pass through untouched, and a bare
+// "the bell strikes at 12." / "we meet at 3." (no roll verb) is NEVER matched. This is the PRIMARY arm —
+// "<thing> lands/comes-in/settles/resolves/clears at <N>".
+const _ROLL_RESULT_SUMMARY = new RegExp(
+  "\\b(?:lands?|comes?(?:\\s+in)?|falls?|settles?|resolves?|clears?)\\s+(?:in\\s+)?at\\s+\\d+\\b",
+  "i",
+);
+// The FULL roll-summary HEADER LINE — the verb-anchored primary PLUS any "; <thing> at <N>" continuations
+// chained onto it ("The intimidation lands at 18; the quiet interpose at 16."). This is matched at the LINE
+// level (before the per-sentence splitter fragments it on the ";"), so the whole header — including its
+// trailing clauses and an optional trailing rule — is dropped as a unit. It REQUIRES the leading roll verb,
+// so it can only extend a genuine roll-summary; a standalone "; we meet at 3" never has the primary verb and
+// is never reached. Anchored to the whole line ('^…$') so it only fires on a header, not a mid-prose clause.
+const _ROLL_SUMMARY_HEADER_LINE = new RegExp(
+  "^\\s*[^.!?]*?" +
+    "\\b(?:lands?|comes?(?:\\s+in)?|falls?|settles?|resolves?|clears?)\\s+(?:in\\s+)?at\\s+\\d+\\b" +
+    "(?:[^.!?]*?\\bat\\s+\\d+\\b)*" +
+    "\\s*[.!?]?\\s*(?:-{3,}|\\*{3,}|_{3,}|—{2,})?\\s*$",
+  "i",
+);
 // (4) #752: INTER-BEAT TRANSITION meta-text — the engine/DM "seam" stage-directions that leaked
 // into the chronicle BETWEEN player beats (adversarial confirm sweep: "Engine META-TEXT transition
 // phrases leak into the chronicle between player beats"). These announce the move from one beat/
@@ -216,22 +253,28 @@ function _isScaffoldingSentence(sentence) {
   const s = (sentence || "").trim();
   if (!s) return false;
   return _CRAFT_JARGON.test(s) || _STAGE_DIRECTION.test(s) || _BEAT_TRANSITION.test(s)
-    || _AUTHORING_PREAMBLE.test(s);
+    || _AUTHORING_PREAMBLE.test(s) || _ROLL_RESULT_SUMMARY.test(s);
 }
 function _hasScaffolding(text) {
   return _TALLY_TEST.test(text) || _CRAFT_JARGON.test(text)
     || _STAGE_DIRECTION.test(text) || _BEAT_TRANSITION.test(text)
-    || _AUTHORING_PREAMBLE.test(text);
+    || _AUTHORING_PREAMBLE.test(text) || _ROLL_RESULT_SUMMARY.test(text);
 }
-// Clean scaffolding from one line, preserving the real prose. Two grains:
+// Clean scaffolding from one line, preserving the real prose. Three grains:
+//   0. drop a WHOLE roll-summary HEADER line (verb-anchored "lands at N" + its "; … at M" chain) — done
+//      before the splitter so the chained clauses don't get peeled apart and survive piecemeal;
 //   1. excise dice/check TALLY phrases in place (keeps the rest of their sentence);
 //   2. split into sentences (on . ! ? ;, terminator kept) and DROP any sentence that is
-//      wholly plot-craft jargon / a stage-direction.
+//      wholly plot-craft jargon / a stage-direction / a (single-clause) roll-summary.
 // Returns the cleaned line (possibly "").
 function _stripScaffoldingSentences(line) {
   if (typeof line !== "string" || !line) return line;
   // Fast path: nothing scaffolding-shaped here, don't touch the line at all.
   if (!_hasScaffolding(line)) return line;
+  // (0) A line that is WHOLLY a roll-summary header (the verb-anchored primary plus any chained "; … at N"
+  // continuations, modulo a trailing rule) is bookkeeping through-and-through — drop it entirely so a
+  // chained second clause ("…; the quiet interpose at 16.") can't ride through after the ";"-splitter.
+  if (_ROLL_SUMMARY_HEADER_LINE.test(line)) return "";
   // (1) In-place tally excision (global; reset lastIndex defensively).
   _TALLY.lastIndex = 0;
   let cleaned = line.replace(_TALLY, "");
@@ -240,10 +283,15 @@ function _stripScaffoldingSentences(line) {
   if (parts) cleaned = parts.filter((p) => !_isScaffoldingSentence(p)).join("");
   // Tidy punctuation/space the excisions may have left (" ." / "  " / leading "; " /
   // a clause separator now dangling at the end, e.g. "Zevlor held silence;" → "…silence.").
+  // SAT→7: also peel a TRAILING horizontal-rule glyph the DM tacked after a roll-summary header
+  // ("…at 16. ---") so the divider doesn't linger once its summary line is gone. Only a trailing
+  // run of pure rule chars is removed; an em-dash bound to words ("groans open —") is left intact
+  // because the rule run must be ≥3 dashes / ≥2 em-dashes (a bare divider, never inline prose).
   return cleaned
     .replace(/\s+([.!?;,])/g, "$1")
     .replace(/\s{2,}/g, " ")
     .replace(/^[\s;,.]+/, "")
+    .replace(/\s*(?:-{3,}|\*{3,}|_{3,}|—{2,})\s*$/, "")
     .replace(/\s*[;,]\s*$/, ".")
     .trim();
 }
@@ -276,6 +324,27 @@ if (typeof window !== "undefined") {
   window.WRAPPER_PROGRESS_LINES = Array.from(_WRAPPER_PROGRESS_LINES);
   window.isWrapperProgressLine = _isWrapperProgressLine;
 }
+// SAT→7 (die-roll button context): pure builder for the dice-button move + its chronicle echo, so the
+// "never fire a contextless roll" guard is unit-testable without mounting ScreenTable. Mirrors the
+// Declare text-guard: a TYPED intent is the move's reason; absent one, the latest narrative line is
+// attached so the DM resolves the check against the moment in play. Returns { move, echo } where `move`
+// is the POST payload (kind/name/text) and `echo` is the verb PHRASE recordPlayerEcho prepends the
+// hero name to. `intent`/`context` are trimmed defensively; no name is baked into the echo.
+function composeRollMove(sides, intent, context) {
+  const n = Number(sides) || 20;
+  const want = (typeof intent === "string" ? intent : "").trim();
+  const ctx = (typeof context === "string" ? context : "").trim();
+  const text = want
+    ? `I roll a d${n} to ${want}`
+    : ctx
+      ? `I roll a d${n} (in response to: ${ctx})`
+      : `I roll a d${n}`;
+  const echo = want ? `rolls a d${n} to ${want}` : `rolls a d${n}`;
+  return { move: { kind: "check", name: `d${n}`, text }, echo };
+}
+if (typeof window !== "undefined") {
+  window.composeRollMove = composeRollMove;
+}
 function sanitizeNarration(text) {
   if (typeof text !== "string" || !text) return "";
   const kept = text
@@ -1205,13 +1274,23 @@ function ScreenTable({ onNavigate, state, setState, liveSession }) {
             ? "Type a move before declaring"
             : "Declare move";
 
+  // SAT→7 (adversarial minor): the dice buttons used to fire a CONTEXTLESS "requests a d20 roll" —
+  // they bypassed the Declare guard entirely, so the DM got a bare die with no idea WHAT the hero is
+  // attempting. Parity with the Declare text-guard: prefer the intent the player TYPED into the composer
+  // (so "d20 to pick the lock" reaches the engine); otherwise ATTACH the latest narrative context (the
+  // newest sanitized scene line) so the roll resolves against the moment in play instead of nothing.
+  // Either way the move carries a reason, and the echo the player sees names it — never a bare "d20 roll".
   const requestRoll = (sides = 20) => {
     const action = actionById("check");
     if (!action?.available) {
       toast({ kind: "danger", title: `d${sides} unavailable`, body: action?.disabled_reason || readOnlyReason });
       return;
     }
-    postMove({ kind: "check", name: `d${sides}`, text: `roll d${sides}` }, `requests a d${sides} roll`, "check");
+    // Build the contextful move + echo via the pure helper (typed intent first, else the latest scene
+    // line). recordPlayerEcho prepends hero.name to the verb-phrase echo, so it never reads as a bare die.
+    const { move, echo } = composeRollMove(sides, draftText, latestStreamedLine);
+    postMove(move, echo, "check");
+    if (draftText) setInput("");
   };
 
   const invokeAction = (action) => {
diff --git a/viewer/tests/test_battle_log_sanitize.py b/viewer/tests/test_battle_log_sanitize.py
new file mode 100644
index 00000000..c5b4a770
--- /dev/null
+++ b/viewer/tests/test_battle_log_sanitize.py
@@ -0,0 +1,134 @@
+"""SAT→7 (adversarial friction): the player-facing Battle Log must get the SAME read/projection
+hygiene as the main Chronicle.
+
+`BattleLogLine` (viewer/openworlds/screen-combat.jsx) renders one combat-log row. Before this fix it
+emitted `l.title` and `l.text` RAW — so DM engine META-TEXT (a wrapper-progress line like "Momentum
+carries through the scene…" / "Your choice takes hold…", a roll-result-summary header, or other
+scaffolding) leaked into the combat log because the panel never routed through `sanitizeNarration`
+(`grep "Battle" screen-table.jsx` returns 0 hits — the guard lived only in the Chronicle's screen).
+
+The fix routes both rendered fields through the SAME window-exported `sanitizeNarration` the Chronicle
+uses. These tests exercise the REAL shipped functions: they transpile the ACTUAL `screen-table.jsx`
+(which publishes `window.sanitizeNarration`) AND `screen-combat.jsx` (which renders `BattleLogLine`)
+with the bundled Babel into ONE shared sandbox — mirroring how the browser loads them as sibling
+<script type='text/babel'> tags — then render each row and assert on its flattened visible TEXT.
+"""
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+HERE = Path(__file__).resolve().parent
+OPENWORLDS = HERE.parent / "openworlds"
+SCREEN_TABLE = OPENWORLDS / "screen-table.jsx"
+SCREEN_COMBAT = OPENWORLDS / "screen-combat.jsx"
+BABEL = OPENWORLDS / "vendor" / "babel-standalone-7.29.0.min.js"
+
+
+def _node() -> str:
+    node = shutil.which("node")
+    if not node:
+        pytest.skip("node not on PATH; skipping JS-behavior test")
+    return node
+
+
+def _render_battle_rows(rows: list[dict]) -> list[str]:
+    """Transpile screen-table.jsx + screen-combat.jsx into one sandbox (so sanitizeNarration is
+    published before BattleLogLine references it, exactly as the sibling browser <script> tags do),
+    render each row, and return its flattened visible TEXT."""
+    program = (
+        "const fs = require('fs'); const vm = require('vm');\n"
+        + "const Babel = require(%s);\n" % json.dumps(str(BABEL))
+        + "function h(type, props, ...children){ return { type: (typeof type==='function'?(type.name||'C'):type),"
+        + " props: props||{}, children: children.flat(Infinity).filter(c=>c!=null) }; }\n"
+        + "const React = { useState:()=>[null,()=>{}], useRef:()=>({}), useCallback:f=>f, useEffect:()=>{},"
+        + " createElement:h, Fragment:'F' };\n"
+        # Cross-file refs screen-combat.jsx reaches for as globals (sibling-script model): stub them
+        # inertly so they resolve and contribute no visible text.
+        + "const Img = (props) => h('Img', props);\n"
+        + "const sb = { React, Img, Array, Number, String, Boolean, Math, Object, JSON };\n"
+        + "sb.window = sb; sb.OpenWorldsIcon = undefined;\n"
+        + "vm.createContext(sb);\n"
+        + "function load(p){ const src = fs.readFileSync(p, 'utf8');"
+        + " const code = Babel.transform(src, { presets: ['react'], filename: p }).code;"
+        + " vm.runInContext(code, sb); }\n"
+        + "load(%s);\n" % json.dumps(str(SCREEN_TABLE))
+        + "load(%s);\n" % json.dumps(str(SCREEN_COMBAT))
+        + "if (typeof sb.window.sanitizeNarration !== 'function') throw new Error('sanitizeNarration not published');\n"
+        + "const BattleLogLine = sb.window.BattleLogLine;\n"
+        + "if (typeof BattleLogLine !== 'function') throw new Error('BattleLogLine not exported on window');\n"
+        + "function textOf(n){ if(n==null) return ''; if(typeof n==='string'||typeof n==='number') return String(n);"
+        + " if(Array.isArray(n)) return n.map(textOf).join(''); if(n.children) return n.children.map(textOf).join('');"
+        + " return ''; }\n"
+        + "const rows = " + json.dumps(rows) + ";\n"
+        + "const out = rows.map((l) => textOf(BattleLogLine({ l })));\n"
+        + "process.stdout.write(JSON.stringify(out));\n"
+    )
+    proc = subprocess.run(
+        [_node(), "--input-type=commonjs"], input=program, text=True, capture_output=True
+    )
+    if proc.returncode != 0:
+        raise AssertionError(f"node failed: {proc.stderr}")
+    return json.loads(proc.stdout)
+
+
+def test_battle_log_strips_wrapper_progress_meta_text():
+    # The verbatim adversarial leak: a wrapper-progress placeholder rode into the combat log as a row's
+    # text. The Battle Log must strip it exactly as the Chronicle does — leaving only the real label.
+    (momentum, choice) = _render_battle_rows([
+        {"title": "Combat", "text": "Momentum carries through the scene; consequences are beginning to surface."},
+        {"event": "turn", "text": "Your choice takes hold; nearby voices, risks, and consequences begin to answer."},
+    ])
+    assert "Momentum carries through" not in momentum
+    assert "consequences are beginning to surface" not in momentum
+    assert "Combat" in momentum  # the title label survives
+    assert "Your choice takes hold" not in choice
+    assert "turn" in choice  # the event label survives
+
+
+def test_battle_log_strips_roll_result_summary_and_rule():
+    # A roll-summary header + trailing horizontal rule must not leak into the combat log either.
+    (row,) = _render_battle_rows([
+        {"title": "Skirmish", "text": "The intimidation lands at 18; the quiet interpose at 16. ---"},
+    ])
+    assert "lands at 18" not in row.lower()
+    assert "interpose at 16" not in row.lower()
+    assert "---" not in row
+    assert "Skirmish" in row
+
+
+def test_battle_log_strips_scaffolding_in_title():
+    # A scaffolding stage-direction that landed in the TITLE is stripped; the title falls back to the
+    # event label / "Combat", and the real text survives.
+    (row,) = _render_battle_rows([
+        {"title": "Beat complete", "event": "attack", "text": "The orc falls, axe clattering to the stone."},
+    ])
+    assert "beat complete" not in row.lower()
+    assert "The orc falls" in row
+
+
+def test_battle_log_preserves_real_combat_text_and_meta():
+    # The value of the surgical strip: genuine combat narration + the engine title + the dice-meta badge
+    # all survive untouched. Story/mechanics quality is the north star — never eat real combat prose.
+    (row,) = _render_battle_rows([
+        {
+            "title": "Tav -> Goblin Sapper",
+            "text": "Tav strikes the sapper, steel biting deep.",
+            "meta": [{"label": "d20", "value": 13}, {"label": "dmg", "value": 6}],
+        },
+    ])
+    assert "Tav -> Goblin Sapper" in row
+    assert "Tav strikes the sapper" in row
+    assert "d20" in row and "13" in row
+    assert "dmg" in row and "6" in row
+
+
+def test_battle_log_empty_state_row_is_clean():
+    # A row with only an event label and clean text renders the label + the prose, no leakage.
+    (row,) = _render_battle_rows([{"event": "move", "text": "Renn advances to the broken cart."}])
+    assert "move" in row
+    assert "Renn advances to the broken cart" in row
diff --git a/viewer/tests/test_sanitize_narration.py b/viewer/tests/test_sanitize_narration.py
index 70e86144..98feeecd 100644
--- a/viewer/tests/test_sanitize_narration.py
+++ b/viewer/tests/test_sanitize_narration.py
@@ -294,6 +294,79 @@ def test_authoring_preamble_stripped_inline_and_in_multiline_beat(self):
         self.assertIn("The lantern gutters", out["multiline_beat"])
         self.assertIn("He draws his blade", out["multiline_beat"])
 
+    # SAT→7 (narrative's ONLY major — this "cracked the 9/10"): the ROLL-RESULT-SUMMARY header form
+    # ("The intimidation lands at 18; the quiet interpose at 16.") and a leading/standalone Markdown
+    # HORIZONTAL RULE ("---") are DM bookkeeping that leaked into the player's story scroll. Both must be
+    # stripped — while genuine prose that merely uses "lands at"/"arrive at"/a dash MUST survive.
+    def test_strips_dice_result_summary_header(self):
+        cases = {
+            "verbatim": "The intimidation lands at 18; the quiet interpose at 16.",
+            "with_trailing_rule": "The intimidation lands at 18; the quiet interpose at 16. ---",
+            "single_roll": "The lockpick check lands at 14.",
+            "comes_in_at": "Her stealth comes in at 12.",
+            "settles_at": "His persuasion settles at 9.",
+            "triple_chain": "The strike lands at 19; the parry at 14; the riposte at 11.",
+        }
+        out = self._sanitize_many(cases)
+        for key, original in cases.items():
+            with self.subTest(case=key):
+                self.assertEqual(out[key], "", f"roll-summary not stripped for {key!r}: {out[key]!r}")
+
+    def test_strips_dice_header_keeps_surrounding_prose(self):
+        beat = (
+            "The intimidation lands at 18; the quiet interpose at 16.\n"
+            "The guard narrows his eyes and steps back from the door."
+        )
+        out = self._sanitize_many({"beat": beat})["beat"]
+        self.assertNotIn("lands at 18", out.lower())
+        self.assertNotIn("interpose at 16", out.lower())
+        self.assertNotIn("---", out)
+        self.assertIn("The guard narrows his eyes", out)
+
+    def test_strips_leading_and_standalone_horizontal_rule(self):
+        cases = {
+            "leading_rule": "---\nThe guard narrows his eyes.",
+            "rule_dashes": "---",
+            "rule_stars": "***",
+            "rule_underscores": "___",
+            "rule_emdash": "— —",
+            "spaced_dashes": "- - - -",
+        }
+        out = self._sanitize_many(cases)
+        self.assertEqual(out["leading_rule"], "The guard narrows his eyes.")
+        for key in ("rule_dashes", "rule_stars", "rule_underscores", "rule_emdash", "spaced_dashes"):
+            with self.subTest(case=key):
+                self.assertEqual(out[key], "", f"horizontal rule not dropped for {key!r}: {out[key]!r}")
+
+    def test_dice_header_and_rule_guard_preserves_legitimate_fiction(self):
+        # NEGATIVE test (the critical false-positive guard the file's comments stress): real narration
+        # using "lands at"/"arrive at"/"glances at"/a number-after-at-that-is-not-terminal, or an em-dash
+        # bound to words, MUST pass through verbatim. Genuine prose is never eaten.
+        legit = {
+            "arrow_feet": "The arrow lands at his feet, quivering in the mud.",
+            "arrive_gate": "They arrive at the gate just past dawn, hooves steaming.",
+            "settles_table": "She settles at the table and glances at him across the candle.",
+            "lands_stair": "He lands at the bottom of the stair, breathless but whole.",
+            "arrive_oclock": "We arrive at 5 in the morning, road-weary and cold.",
+            "dash_pause": "Wait — what did you just say to me?",
+            "emdash_aside": "The door — old, iron-banded — groans open on its hinges.",
+            "single_inline_dash": "A long-forgotten path - half-overgrown - wound up the ridge.",
+            "rain_prose": "Rain hammers the cobbles outside the Elfsong as the bard tunes his lute.",
+            # NUMBER-after-"at" with NO roll verb — the canonical false-positive class. A bell that
+            # "strikes at 12", a rendezvous "at 3", a candle that "gutters out at 9" are all real prose;
+            # only a roll-summary VERB ("lands/settles/comes in at <N>") triggers the strip.
+            "bell_strikes_12": "The bell tower strikes at 12.",
+            "meet_at_3": "We meet at 3 by the broken fountain.",
+            "candle_at_9": "The candle gutters out at 9, and the room goes dark.",
+            "camp_at_6": "The caravan reached the river and made camp at 6.",
+            # a roll-summary VERB but a NOUN target (not a number) is fiction, not a roll total.
+            "cat_lands_side": "The cat lands at her side without a sound.",
+        }
+        out = self._sanitize_many(legit)
+        for key, original in legit.items():
+            with self.subTest(case=key):
+                self.assertEqual(out[key], original)
+
     def test_authoring_preamble_guard_preserves_legitimate_fiction(self):
         # The false-positive guard, mirroring _NARRATION_LEAK's FP-hardening notes: a literal-
         # machinery "through the engine" (the bare form that wrongly matched Gond/artificer/Steel-
diff --git a/viewer/tests/test_viewer_ux_guards.py b/viewer/tests/test_viewer_ux_guards.py
new file mode 100644
index 00000000..1da70771
--- /dev/null
+++ b/viewer/tests/test_viewer_ux_guards.py
@@ -0,0 +1,165 @@
+"""SAT→7 viewer UX guards — the die-roll-context builder + the drop-confirm-on-equipped predicate.
+
+Two adversarial-minor fixes, each backed by a PURE window-exported helper so the guard is unit-testable
+without mounting the React screen (mirroring the sibling JS-behavior tests, which transpile the ACTUAL
+`.jsx` with the bundled Babel and run the exported function under Node):
+
+  • composeRollMove (viewer/openworlds/screen-table.jsx): the d20/d12/d8/d6 buttons used to fire a
+    CONTEXTLESS "requests a d20 roll" — bypassing the "Type a move before declaring" guard. This builder
+    gives the roll a reason: the player's TYPED intent if present, else the latest narrative line attached
+    as context, so the DM never resolves a bare die. Parity with the Declare text-guard.
+
+  • isItemEquipped / dropEquippedConfirmMessage (viewer/openworlds/screen-inventory.jsx): a one-click
+    Drop on EQUIPPED body armor was irrevocable with no confirmation. The predicate flags ONLY currently-
+    equipped gear (loose stash items are never nagged); the message is the shared confirm copy.
+"""
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+HERE = Path(__file__).resolve().parent
+OPENWORLDS = HERE.parent / "openworlds"
+SCREEN_TABLE = OPENWORLDS / "screen-table.jsx"
+SCREEN_INVENTORY = OPENWORLDS / "screen-inventory.jsx"
+BABEL = OPENWORLDS / "vendor" / "babel-standalone-7.29.0.min.js"
+
+
+def _node() -> str:
+    node = shutil.which("node")
+    if not node:
+        pytest.skip("node not on PATH; skipping JS-behavior test")
+    return node
+
+
+def _eval(files: list[Path], expr_setup: str) -> object:
+    """Transpile the given .jsx files into one sandbox and run `expr_setup` (which must
+    process.stdout.write a JSON result)."""
+    loads = "".join(
+        "load(%s);\n" % json.dumps(str(f)) for f in files
+    )
+    program = (
+        "const fs = require('fs'); const vm = require('vm');\n"
+        + "const Babel = require(%s);\n" % json.dumps(str(BABEL))
+        + "const React = { useState:()=>[null,()=>{}], useRef:()=>({}), useCallback:f=>f, useEffect:()=>{},"
+        + " createElement:()=>null, Fragment:'F' };\n"
+        + "const sb = { React, Array, Number, String, Boolean, Math, Object, JSON };\n"
+        + "sb.window = sb; vm.createContext(sb);\n"
+        + "function load(p){ const src = fs.readFileSync(p, 'utf8');"
+        + " const code = Babel.transform(src, { presets: ['react'], filename: p }).code;"
+        + " vm.runInContext(code, sb); }\n"
+        + loads
+        + expr_setup
+    )
+    proc = subprocess.run(
+        [_node(), "--input-type=commonjs"], input=program, text=True, capture_output=True
+    )
+    if proc.returncode != 0:
+        raise AssertionError(f"node failed: {proc.stderr}")
+    return json.loads(proc.stdout)
+
+
+# --------------------------------------------------------------------------------------------- #
+# Fix #3 — composeRollMove: a die-roll is never contextless (parity with the Declare text-guard).
+# --------------------------------------------------------------------------------------------- #
+def _compose_roll(sides, intent, context) -> dict:
+    setup = (
+        "const fn = sb.window.composeRollMove;\n"
+        + "if (typeof fn !== 'function') throw new Error('composeRollMove not exported');\n"
+        + "const r = fn(%s, %s, %s);\n" % (json.dumps(sides), json.dumps(intent), json.dumps(context))
+        + "process.stdout.write(JSON.stringify(r));\n"
+    )
+    return _eval([SCREEN_TABLE], setup)
+
+
+def test_roll_uses_typed_intent_as_the_reason():
+    r = _compose_roll(20, "pick the lock", "The door is iron-barred.")
+    assert r["move"]["kind"] == "check"
+    assert r["move"]["name"] == "d20"
+    # The TYPED intent wins and becomes the move's reason (never a bare "d20 roll").
+    assert r["move"]["text"] == "I roll a d20 to pick the lock"
+    assert r["echo"] == "rolls a d20 to pick the lock"
+
+
+def test_roll_attaches_latest_narrative_context_when_no_intent():
+    r = _compose_roll(20, "", "The guard eyes you warily, hand on his hilt.")
+    # No typed intent -> bind the roll to the latest scene line so it is NOT contextless.
+    assert "(in response to: The guard eyes you warily, hand on his hilt.)" in r["move"]["text"]
+    assert r["move"]["text"].startswith("I roll a d20")
+    assert r["echo"] == "rolls a d20"
+
+
+def test_roll_whitespace_intent_falls_through_to_context():
+    r = _compose_roll(8, "   ", "Smoke fills the hall.")
+    assert "(in response to: Smoke fills the hall.)" in r["move"]["text"]
+    assert "I roll a d8" in r["move"]["text"]
+
+
+def test_roll_with_no_intent_and_no_context_is_explicit_not_blank():
+    # Graceful floor: even with nothing to bind to, the move names the die explicitly — it is never the
+    # old bare "requests a dN roll" string with no actor verb.
+    r = _compose_roll(12, "", "")
+    assert r["move"]["text"] == "I roll a d12"
+    assert r["echo"] == "rolls a d12"
+    assert "(in response to:" not in r["move"]["text"]
+
+
+def test_roll_defaults_to_d20_for_bad_sides():
+    r = _compose_roll(None, "leap the chasm", "")
+    assert r["move"]["name"] == "d20"
+    assert r["move"]["text"] == "I roll a d20 to leap the chasm"
+
+
+# --------------------------------------------------------------------------------------------- #
+# Fix #4 — isItemEquipped + dropEquippedConfirmMessage: confirm only on EQUIPPED gear.
+# --------------------------------------------------------------------------------------------- #
+def _is_equipped(item, equipped) -> bool:
+    setup = (
+        "const fn = sb.window.isItemEquipped;\n"
+        + "if (typeof fn !== 'function') throw new Error('isItemEquipped not exported');\n"
+        + "process.stdout.write(JSON.stringify(fn(%s, %s)));\n" % (json.dumps(item), json.dumps(equipped))
+    )
+    return _eval([SCREEN_INVENTORY], setup)
+
+
+def test_equipped_armor_is_flagged():
+    equipped = [{"name": "Studded Leather"}, {"name": "Longsword"}]
+    assert _is_equipped({"name": "Studded Leather"}, equipped) is True
+    assert _is_equipped({"name": "Longsword"}, equipped) is True
+
+
+def test_equipped_match_is_slug_tolerant_but_strict():
+    # Slug-normalized match folds trivial case/space differences…
+    assert _is_equipped({"name": "studded leather"}, [{"name": "Studded Leather"}]) is True
+    # …but a genuinely different item (a loose peer) is NOT wrongly flagged.
+    assert _is_equipped({"name": "Studded Leather +1"}, [{"name": "Studded Leather"}]) is False
+
+
+def test_loose_inventory_item_is_not_flagged():
+    equipped = [{"name": "Studded Leather"}, {"name": "Longsword"}]
+    # A potion / a stash blade the hero is NOT wearing must never trigger the confirm nag.
+    assert _is_equipped({"name": "Healing Potion"}, equipped) is False
+    assert _is_equipped({"name": "Rusty Shortsword"}, equipped) is False
+
+
+def test_equipped_predicate_is_defensive():
+    assert _is_equipped(None, [{"name": "Longsword"}]) is False
+    assert _is_equipped({"name": "Longsword"}, None) is False
+    assert _is_equipped({}, [{"name": "Longsword"}]) is False
+    assert _is_equipped({"name": "Longsword"}, []) is False
+
+
+def test_drop_confirm_message_names_the_item_and_warns_irreversible():
+    setup = (
+        "const fn = sb.window.dropEquippedConfirmMessage;\n"
+        + "if (typeof fn !== 'function') throw new Error('dropEquippedConfirmMessage not exported');\n"
+        + "process.stdout.write(JSON.stringify(fn('Studded Leather')));\n"
+    )
+    msg = _eval([SCREEN_INVENTORY], setup)
+    assert "Studded Leather" in msg
+    assert "EQUIPPED" in msg
+    assert "cannot be undone" in msg

From 2e0733d155a08fbb5ffbfcd39a3fb3f27a456521 Mon Sep 17 00:00:00 2001
From: Eva <arncalso@gmail.com>
Date: Tue, 23 Jun 2026 14:22:41 +0700
Subject: [PATCH 2/2] fix(viewer): roll-summary strip must be clause-terminal
 (spare in-world quantities)

The dice-result-header stripper (_ROLL_RESULT_SUMMARY / _ROLL_SUMMARY_HEADER_LINE)
was verb- AND number-anchored but matched any '<roll verb> at <N>', eating the whole
narration line even when <N> was a real in-world quantity, not a check total
('the line falls at 12 men', 'settles at 5 gold', 'comes in at 40 pounds').

A roll TOTAL always ends its clause ('lands at 18.' / 'lands at 18;'), never
'lands at 18 men'. Require the integer to be CLAUSE-TERMINAL via a shared
_ROLL_VERB_AT_N core: '...at \d+(?=[.;,!?]|\s*$)' on the primary AND every
chained '; ... at N' continuation. Genuine fiction (number-then-noun) now survives
verbatim; the real header (single / chained / triple-chain / trailing-rule) is
still stripped, as is the leading/trailing rule.

Adds test_roll_verb_with_in_world_quantity_survives_verbatim (6 fixtures) and keeps
the existing positive strip + FP-guard tests green (18 tests / 62 subtests pass).
---
 viewer/openworlds/screen-table.jsx      | 22 ++++++++++++++++------
 viewer/tests/test_sanitize_narration.py | 21 +++++++++++++++++++++
 2 files changed, 37 insertions(+), 6 deletions(-)

diff --git a/viewer/openworlds/screen-table.jsx b/viewer/openworlds/screen-table.jsx
index aa00421e..1ae0b2dd 100644
--- a/viewer/openworlds/screen-table.jsx
+++ b/viewer/openworlds/screen-table.jsx
@@ -145,20 +145,30 @@ const _STAGE_DIRECTION = new RegExp(
 // (noun, not a number) and "we arrive at the gate" (no roll verb) both pass through untouched, and a bare
 // "the bell strikes at 12." / "we meet at 3." (no roll verb) is NEVER matched. This is the PRIMARY arm —
 // "<thing> lands/comes-in/settles/resolves/clears at <N>".
-const _ROLL_RESULT_SUMMARY = new RegExp(
-  "\\b(?:lands?|comes?(?:\\s+in)?|falls?|settles?|resolves?|clears?)\\s+(?:in\\s+)?at\\s+\\d+\\b",
-  "i",
-);
+//
+// CRITICAL refinement (the false-positive the verb anchor alone did NOT catch): the integer must be a
+// roll TOTAL, which always ends the clause — a check result is "lands at 18." / "lands at 18;", NEVER
+// "lands at 18 men". So the bare "at <N>" is only a roll summary when <N> is CLAUSE-TERMINAL: immediately
+// followed by clause-ending punctuation ([.;,!?]) or end-of-string (the "; <thing> at <M>" chained-
+// continuation case is just a ';'-terminal primary). When <N> is followed by a WORD/noun it is an in-world
+// quantity — "the line falls at 12 men", "settles at 5 gold", "comes in at 40 pounds", "clears at 6 bells"
+// — genuine fiction that MUST survive verbatim. `_ROLL_VERB_AT_N` is the shared, clause-terminal core.
+const _ROLL_VERB_AT_N =
+  "\\b(?:lands?|comes?(?:\\s+in)?|falls?|settles?|resolves?|clears?)\\s+(?:in\\s+)?at\\s+\\d+(?=[.;,!?]|\\s*$)";
+const _ROLL_RESULT_SUMMARY = new RegExp(_ROLL_VERB_AT_N, "i");
 // The FULL roll-summary HEADER LINE — the verb-anchored primary PLUS any "; <thing> at <N>" continuations
 // chained onto it ("The intimidation lands at 18; the quiet interpose at 16."). This is matched at the LINE
 // level (before the per-sentence splitter fragments it on the ";"), so the whole header — including its
 // trailing clauses and an optional trailing rule — is dropped as a unit. It REQUIRES the leading roll verb,
 // so it can only extend a genuine roll-summary; a standalone "; we meet at 3" never has the primary verb and
 // is never reached. Anchored to the whole line ('^…$') so it only fires on a header, not a mid-prose clause.
+// Each "at <N>" (primary AND every chained continuation) is clause-terminal — the same total-ends-the-clause
+// rule as `_ROLL_VERB_AT_N` — so a header whose number is followed by a noun ("falls at 12 men …") never
+// matches and the genuine-fiction line survives whole.
 const _ROLL_SUMMARY_HEADER_LINE = new RegExp(
   "^\\s*[^.!?]*?" +
-    "\\b(?:lands?|comes?(?:\\s+in)?|falls?|settles?|resolves?|clears?)\\s+(?:in\\s+)?at\\s+\\d+\\b" +
-    "(?:[^.!?]*?\\bat\\s+\\d+\\b)*" +
+    _ROLL_VERB_AT_N +
+    "(?:[^.!?]*?\\bat\\s+\\d+(?=[.;,!?]|\\s*$))*" +
     "\\s*[.!?]?\\s*(?:-{3,}|\\*{3,}|_{3,}|—{2,})?\\s*$",
   "i",
 );
diff --git a/viewer/tests/test_sanitize_narration.py b/viewer/tests/test_sanitize_narration.py
index 98feeecd..ce292801 100644
--- a/viewer/tests/test_sanitize_narration.py
+++ b/viewer/tests/test_sanitize_narration.py
@@ -367,6 +367,27 @@ def test_dice_header_and_rule_guard_preserves_legitimate_fiction(self):
             with self.subTest(case=key):
                 self.assertEqual(out[key], original)
 
+    def test_roll_verb_with_in_world_quantity_survives_verbatim(self):
+        # REGRESSION (adversarial-verify catch): the roll-summary strip is verb-anchored AND
+        # number-anchored, but "<roll verb> at <N>" is ONLY a check total when <N> ENDS the clause
+        # ("lands at 18." / "lands at 18;"). A roll total never reads "lands at 18 men" — when the
+        # integer is followed by a WORD it is an in-world QUANTITY (men, gold, wagons, pounds, votes,
+        # bells), genuine fiction that must survive verbatim. The verb-only guard wrongly ate the WHOLE
+        # line on these; the clause-terminal requirement (followed by [.;,!?] or end-of-string) spares
+        # them while STILL stripping the real header (verified in test_strips_dice_result_summary_header).
+        legit = {
+            "falls_12_men": "The line falls at 12 men, and still the orcs come.",
+            "settles_5_gold": "After haggling, the merchant settles at 5 gold and a promise.",
+            "lands_7_wagons": "The caravan lands at 7 wagons strong before the gates.",
+            "comes_in_40_pounds": "The hauled net comes in at 40 pounds of silver carp.",
+            "resolves_9_votes": "The council resolves at 9 votes to 4.",
+            "clears_6_bells": "The fog clears at 6 bells, grey and cold.",
+        }
+        out = self._sanitize_many(legit)
+        for key, original in legit.items():
+            with self.subTest(case=key):
+                self.assertEqual(out[key], original)
+
     def test_authoring_preamble_guard_preserves_legitimate_fiction(self):
         # The false-positive guard, mirroring _NARRATION_LEAK's FP-hardening notes: a literal-
         # machinery "through the engine" (the bare form that wrongly matched Gond/artificer/Steel-