space: compare tab — seed vs output diff with the reason for every edit

BUILD.json

@@ -1,7 +1,7 @@
 {
-  "built_at": "2026-10-29T17:51:55",
-  "commit": "e8bb2e0",
-  "files": 52,
+  "built_at": "2026-10-29T18:33:03",
+  "commit": "39f5347",
+  "files": 53,
   "with_store": false,
   "with_card": true
 }

data/dataset/dataset_card.json

@@ -1,12 +1,12 @@
 {
-  "traces": 4563,
+  "traces": 4694,
   "languages": {
-    "en": 4370,
+    "en": 4501,
     "de": 193
   },
   "language_pct": {
-    "en": 95.8,
-    "de": 4.2
+    "en": 95.9,
+    "de": 4.1
   },
   "topic_language_matrix": {
     "languages": [
@@ -15,54 +15,54 @@
     ],
     "rows": {
       "review": {
-        "en": 1399,
+        "en": 1418,
         "de": 80,
-        "total": 1479
+        "total": 1498
       },
       "implement": {
-        "en": 876,
+        "en": 931,
         "de": 43,
-        "total": 919
+        "total": 974
       },
       "debug": {
-        "en": 720,
+        "en": 750,
         "de": 26,
-        "total": 746
+        "total": 776
       },
       "research": {
-        "en": 552,
+        "en": 559,
         "de": 7,
-        "total": 559
+        "total": 566
       },
       "other": {
-        "en": 291,
+        "en": 295,
         "de": 6,
-        "total": 297
+        "total": 301
       },
       "test": {
-        "en": 174,
+        "en": 180,
         "de": 15,
-        "total": 189
+        "total": 195
       },
       "ops": {
-        "en": 108,
+        "en": 110,
         "de": 4,
-        "total": 112
+        "total": 114
       },
       "refactor": {
-        "en": 99,
+        "en": 101,
         "de": 3,
-        "total": 102
+        "total": 104
       },
       "data-analysis": {
-        "en": 90,
+        "en": 95,
         "de": 6,
-        "total": 96
+        "total": 101
       },
       "creative": {
-        "en": 51,
+        "en": 52,
         "de": 0,
-        "total": 51
+        "total": 52
       },
       "office-docs": {
         "en": 10,
@@ -71,41 +71,41 @@
       }
     },
     "totals": {
-      "en": 4370,
+      "en": 4501,
       "de": 193,
-      "total": 4563
+      "total": 4694
     }
   },
   "tools_and_prompt": {
     "tools": {
-      "rows": 4563,
-      "with_tools": 4557,
+      "rows": 4694,
+      "with_tools": 4688,
       "pct": 99.9,
       "by_source": {
-        "derived-from-observed-calls": 4098,
-        "claude-request-shape": 459,
+        "derived-from-observed-calls": 4199,
+        "claude-request-shape": 489,
         "none": 6
       }
     },
     "system_prompt": {
-      "rows": 4563,
-      "with_system": 1826,
-      "pct": 40.0,
+      "rows": 4694,
+      "with_system": 1917,
+      "pct": 40.8,
       "by_source": {
-        "none": 2737,
+        "none": 2777,
         "raw-system-row": 663,
-        "claude-request-shape": 459,
-        "codex-base-instructions": 408,
+        "claude-request-shape": 489,
+        "codex-base-instructions": 466,
         "in-trace": 292,
-        "hermes-system-prompts": 4
+        "hermes-system-prompts": 7
       }
     }
   },
   "provenance": {
     "basis": "session-id prefix (the improver overwrites meta.source)",
     "counts": {
-      "real-session": 2187,
-      "subagent": 913,
+      "real-session": 2288,
+      "subagent": 943,
       "nemotron-agentic-ka": 581,
       "split-segment": 508,
       "nemotron-agentic-tc": 370,
@@ -115,11 +115,11 @@
       "nemotron-swe-e8ff278b": 1
     },
     "pct": {
-      "real-session": 47.9,
-      "subagent": 20.0,
-      "nemotron-agentic-ka": 12.7,
-      "split-segment": 11.1,
-      "nemotron-agentic-tc": 8.1,
+      "real-session": 48.7,
+      "subagent": 20.1,
+      "nemotron-agentic-ka": 12.4,
+      "split-segment": 10.8,
+      "nemotron-agentic-tc": 7.9,
       "nemotron-swe-3c63eaaa": 0.0,
       "nemotron-swe-6ca796dd": 0.0,
       "nemotron-swe-bc9ee6b7": 0.0,
@@ -127,105 +127,105 @@
     }
   },
   "agent_roles": {
-    "orchestrator": 3650,
-    "subagent": 913
+    "orchestrator": 3751,
+    "subagent": 943
   },
   "tasks": {
-    "review": 1479,
-    "implement": 919,
-    "debug": 746,
-    "research": 559,
-    "other": 297,
-    "test": 189,
-    "ops": 112,
-    "refactor": 102,
-    "data-analysis": 96,
-    "creative": 51,
+    "review": 1498,
+    "implement": 974,
+    "debug": 776,
+    "research": 566,
+    "other": 301,
+    "test": 195,
+    "ops": 114,
+    "refactor": 104,
+    "data-analysis": 101,
+    "creative": 52,
     "office-docs": 13
   },
   "messages": {
-    "total": 152211,
+    "total": 155544,
     "by_role": {
-      "user": 5045,
-      "assistant": 73803,
-      "tool": 71537,
-      "system": 1826
+      "user": 5181,
+      "assistant": 75430,
+      "tool": 73016,
+      "system": 1917
     },
     "per_trace": {
-      "mean": 33.4,
-      "median": 23,
+      "mean": 33.1,
+      "median": 23.0,
       "p90": 68,
       "max": 274
     }
   },
   "tool_calls": {
-    "total": 71537,
+    "total": 73016,
     "per_trace": {
-      "mean": 15.7,
-      "median": 10,
+      "mean": 15.6,
+      "median": 10.0,
       "p90": 33,
       "max": 143
     },
     "traces_with_none": 6,
-    "distinct_tools": 556,
+    "distinct_tools": 560,
     "top_tools": {
-      "Bash": 26609,
-      "exec": 13574,
-      "terminal": 4730,
-      "read_file": 3641,
-      "Read": 3012,
-      "Edit": 2493,
+      "Bash": 26864,
+      "exec": 14121,
+      "terminal": 4837,
+      "read_file": 3645,
+      "Read": 3192,
+      "Edit": 2632,
       "search_files": 2247,
-      "execute_code": 1970,
+      "execute_code": 1971,
       "tool_call": 1679,
-      "Grep": 1007,
+      "Grep": 1055,
       "skill_view": 966,
-      "patch": 875,
+      "patch": 880,
       "wait": 489,
-      "unlock_discoverable_agent_tool": 457,
-      "call_discoverable_agent_tool": 457
+      "Write": 476,
+      "unlock_discoverable_agent_tool": 457
     }
   },
   "user_turns": {
     "per_trace": {
       "mean": 1.1,
-      "median": 1,
+      "median": 1.0,
       "p90": 1,
       "max": 18
     },
-    "single_turn_traces": 4211,
-    "multi_turn_traces": 352
+    "single_turn_traces": 4337,
+    "multi_turn_traces": 357
   },
   "tokens": {
     "method": "chars/4 (prose proxy); scale by ~1.15 for a central estimate",
     "budget": 131072,
-    "chars_total": 374416612,
-    "est_total": 93604153,
+    "chars_total": 384072729,
+    "est_total": 96018182,
     "per_trace": {
-      "mean": 20513.4,
-      "median": 16365,
-      "p90": 46390,
+      "mean": 20455.1,
+      "median": 16305.0,
+      "p90": 46185,
       "max": 121769
     },
     "fits_budget": {
       "4096": {
-        "traces": 1139,
-        "pct": 25.0
+        "traces": 1150,
+        "pct": 24.5
       },
       "8192": {
-        "traces": 1463,
-        "pct": 32.1
+        "traces": 1504,
+        "pct": 32.0
       },
       "16384": {
-        "traces": 2282,
-        "pct": 50.0
+        "traces": 2356,
+        "pct": 50.2
       },
       "65536": {
-        "traces": 4514,
-        "pct": 98.9
+        "traces": 4645,
+        "pct": 99.0
       },
       "131072": {
-        "traces": 4563,
+        "traces": 4694,
         "pct": 100.0
       }
     }
@@ -234,68 +234,68 @@
   "supervision": {
     "contract": "loss on assistant spans only; tool/user/system spans are masked context",
     "chars_by_role": {
-      "user": 7445197,
-      "assistant": 13944527,
-      "tool": 339128629,
-      "system": 13898259
+      "user": 7566460,
+      "assistant": 14219298,
+      "tool": 347006849,
+      "system": 15280122
     },
     "assistant_share_pct": 3.7,
-    "tool_share_pct": 90.6
+    "tool_share_pct": 90.3
   },
   "difficulty": {
     "basis": "tool calls in the ideal path (proxy, not a score)",
     "bands": {
       "D1": {
         "label": "one-shot / single edit",
-        "traces": 136,
+        "traces": 141,
         "pct": 3.0
       },
       "D2": {
         "label": "short loop",
-        "traces": 786,
-        "pct": 17.2
+        "traces": 815,
+        "pct": 17.4
       },
       "D3": {
         "label": "multi-step",
-        "traces": 1384,
-        "pct": 30.3
+        "traces": 1437,
+        "pct": 30.6
       },
       "D4": {
         "label": "long session",
-        "traces": 1057,
+        "traces": 1088,
         "pct": 23.2
       },
       "D5": {
         "label": "very long session",
-        "traces": 1200,
-        "pct": 26.3
+        "traces": 1213,
+        "pct": 25.8
       }
     },
     "tool_calls": {
-      "mean": 15.7,
-      "median": 10,
+      "mean": 15.6,
+      "median": 10.0,
       "p90": 33,
       "max": 143
     },
     "messages": {
-      "mean": 33.4,
-      "median": 23,
+      "mean": 33.1,
+      "median": 23.0,
       "p90": 68,
       "max": 274
     },
     "est_tokens": {
-      "mean": 20513.4,
-      "median": 16365,
-      "p90": 46390,
+      "mean": 20455.1,
+      "median": 16305.0,
+      "p90": 46185,
       "max": 121769
     }
   },
   "safety_filter": {
     "applied": true,
-    "traces_in": 4831,
-    "traces_kept": 4563,
-    "traces_excluded": 268,
-    "excluded_secret": 239,
+    "traces_in": 4966,
+    "traces_kept": 4694,
+    "traces_excluded": 272,
+    "excluded_secret": 243,
     "excluded_personal": 29,
     "rule": "drop any trace carrying credential material (passwords, tokens, private keys, connection strings with real credentials) or third-party personal data (private legal correspondence, home addresses, phone numbers, IBANs). Code, internal hostnames, business contact addresses and the owner's own identity stay.",
     "report": "safety_report.json"
@@ -304,7 +304,7 @@
     "classes": {
       "time_sensitive": 13,
       "time_anchored": 12,
-      "not_time_sensitive": 4538
+      "not_time_sensitive": 4669
     },
     "labels": {
       "time_sensitive": "answer decays: temporal fact, no retrieval tool",

traceforge/space/app.py

@@ -17,6 +17,8 @@ import json
 import os
 from typing import Any, Optional
 
+from traceforge.space.diffview import build as build_diff
+from traceforge.space.diffview import load_labels, render_html, triage_path
 from traceforge.space.hashing import short_hash
 from traceforge.space.ingest import parse_records, read_upload
 from traceforge.space.jobs import get_worker
@@ -45,6 +47,25 @@ CSS = """
 .tf-head { font-size:13px; color:#8b949e; margin:2px 0 8px; }
 .tf-pill { padding:2px 8px; border-radius:999px; font-size:11px;
            border:1px solid #2a3140; }
+.tf-diff-sum { font-size:12px; color:#9aa4b2; margin:4px 0 12px; }
+.tf-diff-row { border:1px solid #2a3140; border-radius:8px; margin:0 0 8px;
+               background:#0d1117; overflow:hidden; }
+.tf-diff-row.tf-k-dropped { border-left:3px solid #f85149; }
+.tf-diff-row.tf-k-edited { border-left:3px solid #d29922; }
+.tf-diff-row.tf-k-added { border-left:3px solid #3fb950; }
+.tf-diff-row.tf-k-kept { border-left:3px solid #2a3140; opacity:.72; }
+.tf-diff-h { display:flex; gap:8px; align-items:center; flex-wrap:wrap;
+             padding:6px 10px; background:#161b22; font-size:11px;
+             color:#8b949e; }
+.tf-idx { color:#6e7681; } .tf-role { color:#2f81f7; }
+.tf-why { color:#9aa4b2; font-style:italic; }
+.tf-diff-b { padding:8px 10px; font-size:12px; color:#c9d1d9;
+             white-space:pre-wrap; word-break:break-word; }
+.tf-diff-b pre { margin:0; white-space:pre-wrap; font-size:12px; }
+.tf-diff-b summary { cursor:pointer; color:#8b949e; }
+.tf-diff-b del { background:#3d1418; color:#ffa198; text-decoration:none; }
+.tf-diff-b ins { background:#12351f; color:#7ee787; text-decoration:none; }
+.tf-more { color:#6e7681; font-style:italic; }
 """
 
 
@@ -326,6 +347,23 @@ def build_app(store: Optional[TraceStore] = None,
             return None, None
         return out.to_dict(), store.output_path(h)
 
+    # ------------------------------------------------------------ compare
+
+    def on_compare(h, only):
+        if not h:
+            return '<div class="tf-head">pick a processed seed above</div>'
+        seed = store.load_seed(h)
+        if seed is None:
+            return '<div class="tf-head">no seed stored for that hash</div>'
+        out = store.load_output(h)
+        if out is None:
+            rec = store.get(h) or {}
+            why = rec.get("error") or "no output stored"
+            return (f'<div class="tf-head">no output for this hash — '
+                    f'{_esc(why)}</div>')
+        labels = load_labels(triage_path(cfg, f"space-{h[:16]}"))
+        return render_html(build_diff(seed, out, labels), only=only)
+
     # ---------------------------------------------------------------- UI
 
     with gr.Blocks(title="traceforge — ideal-world agent traces") as app:
@@ -448,6 +486,25 @@ def build_app(store: Optional[TraceStore] = None,
             pick.change(on_browse, inputs=[pick], outputs=[preview, dl])
             app.load(browse_choices, outputs=[pick])
 
+        with gr.Tab("Compare seed → output"):
+            gr.Markdown(
+                "One row per seed message. **removed** rows are dead ends the "
+                "ideal path routes around, **rewritten** rows are the same work "
+                "in a better shape, and the italic note is the triage verdict "
+                "that drove the edit. Unchanged rows are collapsed.")
+            with gr.Row():
+                pick2 = gr.Dropdown(label="processed seed (by hash)", choices=[],
+                                    scale=4)
+                btn_reload2 = gr.Button("Reload list", scale=1)
+            only_in = gr.Radio(choices=["all", "changed", "removed"],
+                               value="all", label="show")
+            diff_out = gr.HTML()
+            btn_reload2.click(browse_choices, outputs=[pick2])
+            pick2.change(on_compare, inputs=[pick2, only_in], outputs=[diff_out])
+            only_in.change(on_compare, inputs=[pick2, only_in],
+                           outputs=[diff_out])
+            app.load(browse_choices, outputs=[pick2])
+
     return app
 
 

traceforge/space/diffview.py

@@ -0,0 +1,314 @@
+"""Seed-vs-output diff, with the reason each message changed.
+
+The splice engine rewrites a trace by dropping dead ends, rephrasing
+sloppy turns and compressing dumps.  The output alone does not say *why*
+a message is gone, which makes a rewrite hard to audit and impossible to
+learn from.  Triage already labels every source message
+(keep/drop/rephrase/fact_check/summarize) with a short reason; this
+module lines the seed up against the output and attaches that reason to
+every row, so the Space can show the edit as a reviewable diff.
+
+Alignment is a sequence match on (role, content, tool calls).  The splice
+engine emits output messages in source order, so kept turns match
+exactly, a rewrite shows up as a replace block, and a drop as a delete
+block.  No provenance has to be threaded through the pipeline.
+"""
+
+from __future__ import annotations
+
+import difflib
+import html
+import json
+import os
+import re
+from typing import Any, Optional
+
+# Per-side render cap.  A tool result can be megabytes; the diff is for
+# reading, and the full text is one click away in Browse outputs.
+MAX_CHARS = 6000
+
+_TOKEN = re.compile(r"\s+|\w+|[^\w\s]")
+
+KINDS = ("kept", "edited", "dropped", "added")
+
+
+# ------------------------------------------------------------------ helpers
+
+def _field(msg: Any, name: str, default: Any = None) -> Any:
+    """Read a field from a Message dataclass or a plain dict."""
+    if isinstance(msg, dict):
+        return msg.get(name, default)
+    return getattr(msg, name, default)
+
+
+def messages_of(obj: Any) -> list:
+    """Accept a Trace, a dict with `messages`, or a bare message list."""
+    if obj is None:
+        return []
+    if isinstance(obj, (list, tuple)):
+        return list(obj)
+    if isinstance(obj, dict):
+        return list(obj.get("messages") or [])
+    return list(getattr(obj, "messages", None) or [])
+
+
+def _calls(msg: Any) -> str:
+    out = []
+    for tc in (_field(msg, "tool_calls") or []):
+        name = _field(tc, "name", "") or ""
+        args = _field(tc, "arguments", "") or ""
+        out.append(f"{name}({args})")
+    return "|".join(out)
+
+
+def _key(msg: Any) -> tuple:
+    """What has to be identical for two messages to count as the same turn."""
+    return (_field(msg, "role", "") or "",
+            (_field(msg, "content") or "").strip(),
+            _calls(msg))
+
+
+def text_of(msg: Any) -> str:
+    """The readable body of a message: content, tool calls, tool name."""
+    parts = []
+    content = _field(msg, "content")
+    if content:
+        parts.append(str(content))
+    calls = _calls(msg)
+    if calls:
+        parts.append("→ " + calls.replace("|", "\n→ "))
+    name = _field(msg, "tool_name")
+    if name:
+        parts.append(f"[{name}]")
+    return "\n".join(parts)
+
+
+def _clip(s: str, n: int = MAX_CHARS) -> tuple[str, int]:
+    if len(s) <= n:
+        return s, 0
+    return s[:n], len(s) - n
+
+
+# ---------------------------------------------------------------- alignment
+
+def _row(kind: str, src: Optional[int], dst: Optional[int],
+         seed: list, out: list) -> dict:
+    before = text_of(seed[src]) if src is not None else ""
+    after = text_of(out[dst]) if dst is not None else ""
+    msg = seed[src] if src is not None else (out[dst] if dst is not None else {})
+    return {
+        "kind": kind,
+        "src": src,
+        "dst": dst,
+        "role": _field(msg, "role", "") or "",
+        "before": before,
+        "after": after,
+        "action": "",
+        "reason": "",
+    }
+
+
+def align(seed: Any, out: Any) -> list[dict]:
+    """Line the seed up against the output; one row per visible change."""
+    a, b = messages_of(seed), messages_of(out)
+    ka = [_key(m) for m in a]
+    kb = [_key(m) for m in b]
+    sm = difflib.SequenceMatcher(None, ka, kb, autojunk=False)
+    rows: list[dict] = []
+    for tag, i1, i2, j1, j2 in sm.get_opcodes():
+        if tag == "equal":
+            for k in range(i2 - i1):
+                rows.append(_row("kept", i1 + k, j1 + k, a, b))
+        elif tag == "delete":
+            for i in range(i1, i2):
+                rows.append(_row("dropped", i, None, a, b))
+        elif tag == "insert":
+            for j in range(j1, j2):
+                rows.append(_row("added", None, j, a, b))
+        else:  # replace: pair positionally, then the leftovers
+            n = min(i2 - i1, j2 - j1)
+            for k in range(n):
+                rows.append(_row("edited", i1 + k, j1 + k, a, b))
+            for i in range(i1 + n, i2):
+                rows.append(_row("dropped", i, None, a, b))
+            for j in range(j1 + n, j2):
+                rows.append(_row("added", None, j, a, b))
+    return rows
+
+
+# ------------------------------------------------------------------ reasons
+
+def labels_from_record(rec: Any) -> dict[int, dict]:
+    """Normalise a triage record (or its label list) to {index: label}."""
+    if not rec:
+        return {}
+    items = rec.get("labels") if isinstance(rec, dict) else rec
+    out: dict[int, dict] = {}
+    for item in (items or []):
+        if not isinstance(item, dict):
+            continue
+        raw = item.get("i")
+        if raw is None:
+            continue
+        try:
+            i = int(raw)
+        except (TypeError, ValueError):
+            continue
+        out[i] = {"action": str(item.get("action") or ""),
+                  "reason": str(item.get("reason") or "")}
+    return out
+
+
+def load_labels(path: str) -> dict[int, dict]:
+    """Read a triage record from disk; {} when absent or unreadable."""
+    try:
+        with open(path, encoding="utf-8") as f:
+            return labels_from_record(json.load(f))
+    except (OSError, json.JSONDecodeError, TypeError):
+        return {}
+
+
+def attach_reasons(rows: list[dict], labels: dict[int, dict]) -> list[dict]:
+    """Put the triage verdict on every row that came from a seed message."""
+    for row in rows:
+        src = row.get("src")
+        lab = labels.get(src) if src is not None else None
+        if lab:
+            row["action"] = lab.get("action") or ""
+            row["reason"] = lab.get("reason") or ""
+        elif row["kind"] == "added":
+            row["action"] = "added"
+            row["reason"] = "written by the rewrite; no seed message"
+        else:
+            row["action"] = row["action"] or "keep"
+    return rows
+
+
+def build(seed: Any, out: Any, labels: Optional[dict[int, dict]] = None) -> dict:
+    """Rows + summary for one seed/output pair."""
+    rows = attach_reasons(align(seed, out), labels or {})
+    counts = {k: 0 for k in KINDS}
+    for row in rows:
+        counts[row["kind"]] = counts.get(row["kind"], 0) + 1
+    return {
+        "rows": rows,
+        "summary": {
+            "in": len(messages_of(seed)),
+            "out": len(messages_of(out)),
+            **counts,
+        },
+    }
+
+
+# --------------------------------------------------------------------- diff
+
+def word_diff(a: str, b: str) -> list[tuple[str, str]]:
+    """Token-level (op, text) segments: equal / delete / insert."""
+    ta, tb = _TOKEN.findall(a), _TOKEN.findall(b)
+    sm = difflib.SequenceMatcher(None, ta, tb, autojunk=False)
+    segs: list[tuple[str, str]] = []
+    for tag, i1, i2, j1, j2 in sm.get_opcodes():
+        if tag == "equal":
+            segs.append(("equal", "".join(ta[i1:i2])))
+        elif tag == "delete":
+            segs.append(("delete", "".join(ta[i1:i2])))
+        elif tag == "insert":
+            segs.append(("insert", "".join(tb[j1:j2])))
+        else:
+            segs.append(("delete", "".join(ta[i1:i2])))
+            segs.append(("insert", "".join(tb[j1:j2])))
+    return segs
+
+
+def _esc(s: Any) -> str:
+    return html.escape(str(s if s is not None else ""))
+
+
+def _inline_diff(before: str, after: str) -> str:
+    before, cut_a = _clip(before)
+    after, cut_b = _clip(after)
+    parts = []
+    for op, text in word_diff(before, after):
+        if op == "equal":
+            parts.append(_esc(text))
+        elif op == "delete":
+            parts.append(f"<del>{_esc(text)}</del>")
+        else:
+            parts.append(f"<ins>{_esc(text)}</ins>")
+    body = "".join(parts)
+    if cut_a or cut_b:
+        body += (f'<span class="tf-more">…[+{cut_a + cut_b} chars not shown]'
+                 "</span>")
+    return body
+
+
+_BADGE = {
+    "kept": ("tf-ok", "unchanged"),
+    "edited": ("tf-warn", "rewritten"),
+    "dropped": ("tf-bad", "removed"),
+    "added": ("tf-ok", "added"),
+}
+
+
+def _why(row: dict) -> str:
+    action = row.get("action") or ""
+    reason = row.get("reason") or ""
+    if row["kind"] == "kept":
+        return "kept as-is"
+    bits = []
+    if action and action not in ("keep", row["kind"]):
+        bits.append(f"plan: {action}")
+    if reason:
+        bits.append(reason)
+    return " — ".join(bits) or "no reason recorded"
+
+
+def _row_html(row: dict) -> str:
+    cls, label = _BADGE.get(row["kind"], ("", row["kind"]))
+    idx = f'#{row["src"]}' if row.get("src") is not None else "new"
+    head = (f'<div class="tf-diff-h">'
+            f'<span class="tf-pill {cls}">{label}</span>'
+            f'<span class="tf-idx">{_esc(idx)}</span>'
+            f'<span class="tf-role">{_esc(row.get("role") or "")}</span>'
+            f'<span class="tf-why">{_esc(_why(row))}</span></div>')
+    if row["kind"] == "kept":
+        preview = (row["before"] or "").strip().splitlines()
+        first = preview[0][:110] if preview else ""
+        more = f" (+{len(preview) - 1} lines)" if len(preview) > 1 else ""
+        body = (f'<details class="tf-diff-b"><summary>{_esc(first)}'
+                f'{_esc(more)}</summary><pre>{_esc(_clip(row["before"])[0])}'
+                "</pre></details>")
+    elif row["kind"] == "dropped":
+        body = f'<div class="tf-diff-b"><del>{_esc(_clip(row["before"])[0])}</del></div>'
+    elif row["kind"] == "added":
+        body = f'<div class="tf-diff-b"><ins>{_esc(_clip(row["after"])[0])}</ins></div>'
+    else:
+        body = f'<div class="tf-diff-b">{_inline_diff(row["before"], row["after"])}</div>'
+    return f'<div class="tf-diff-row tf-k-{row["kind"]}">{head}{body}</div>'
+
+
+def render_html(diff: dict, *, only: str = "all") -> str:
+    """The whole viewer body. `only` is all / changed / removed."""
+    rows = diff.get("rows") or []
+    if only == "changed":
+        rows = [r for r in rows if r["kind"] != "kept"]
+    elif only == "removed":
+        rows = [r for r in rows if r["kind"] == "dropped"]
+    s = diff.get("summary") or {}
+    if not s.get("in") and not s.get("out"):
+        return '<div class="tf-head">nothing to compare</div>'
+    head = (f'<div class="tf-diff-sum">{s.get("in", 0)} → {s.get("out", 0)} '
+            f'messages · <span class="tf-bad">{s.get("dropped", 0)} removed</span>'
+            f' · <span class="tf-warn">{s.get("edited", 0)} rewritten</span>'
+            f' · <span class="tf-ok">{s.get("added", 0)} added</span>'
+            f' · {s.get("kept", 0)} unchanged</div>')
+    if not rows:
+        return ('<div class="tf-wrap">' + head +
+                '<div class="tf-head">no rows match this filter</div></div>')
+    return ('<div class="tf-wrap">' + head +
+            "".join(_row_html(r) for r in rows) + "</div>")
+
+
+def triage_path(cfg: Any, session_id: str) -> str:
+    """Where triage cached the labels for one session."""
+    return os.path.join(getattr(cfg, "triage_dir", ""), f"{session_id}.json")