diff --git a/CHANGELOG.md b/CHANGELOG.md
index c4083fd8..7fef7408 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -130,6 +130,10 @@ below corresponds to one such version.
   queries the same) as the pill, and the fix (your query, the semantic model, the examples, the question,
   agami again, nothing) as the action. A query written differently is a noted fact, no longer a blocker
   on a matching answer. (ACE-127)
+- The reconcile card after a second read: the question is the title, columns are compared by the data
+  they carry (the compare-results score names `column_pairs` and `unmatched_generated_columns`), a bare
+  column reads as its table's column in the claims reader, the change text and the decision boxes derive
+  from the one fix, an `example` decision joins the block, the checks panel folds. (ACE-128)
 - From the first test of the grid: a plain column in a list query is no longer graded as a missing
   metric (the receipt's output items say whether they aggregate); a date window written against the
   clock (`date_trunc('year', current_date) + interval`) resolves and compares against another such
diff --git a/packages/agami-core/src/semantic_model/comparator.py b/packages/agami-core/src/semantic_model/comparator.py
index 3d4e6dbb..149d4e4c 100644
--- a/packages/agami-core/src/semantic_model/comparator.py
+++ b/packages/agami-core/src/semantic_model/comparator.py
@@ -410,6 +410,11 @@ class ItemScore:
     accuracy: Optional[float]
     reason: str
     unmatched_golden_columns: tuple[str, ...] = ()
+    # Which golden column paired with which generated column, by VALUES, and which generated columns
+    # paired with none. A renamed column is the same column here; a reader that compared names would
+    # call it missing. Additive; empty where no column-level comparison ran.
+    column_pairs: tuple[tuple[str, str], ...] = ()
+    unmatched_generated_columns: tuple[str, ...] = ()
     golden_row_count: Optional[int] = None
     generated_row_count: Optional[int] = None
     order_sensitive: Optional[bool] = None
@@ -629,6 +634,32 @@ def _judge(
     return _Verdict("error", None, f"{match!r} is not a match level this comparison knows")
 
 
+def _column_pairs(
+    golden: ExecResult, generated: ExecResult, match: MatchLevel, ordered: bool
+) -> tuple[tuple[tuple[str, str], ...], tuple[str, ...]]:
+    """(golden column, generated column) pairs matched by values, and the generated columns left
+    over, for the two levels that pair columns at all. Never raises; a shape the pairing cannot read
+    reports nothing rather than failing a score that already ran."""
+    if match not in ("exact", "values") or not golden.rows or not generated.rows:
+        return (), ()
+    if len(golden.rows) != len(generated.rows):
+        # Pairing is by value vectors, and two vectors of different length are never equal, so
+        # every column would read unpaired: not a fact about the columns, only about the counts,
+        # which the score already reports. Nothing is claimed here.
+        return (), ()
+    try:
+        pairing, _unmatched = match_columns(
+            golden.columns, golden.rows, generated.columns, generated.rows,
+            ordered=ordered, quantize=match == "values",
+        )
+    except Exception:
+        # The score itself has already reported a ragged or malformed result as an error with a
+        # value-free reason; the pairing is a courtesy on top and must never turn that into a raise.
+        return (), ()
+    pairs = tuple((golden.columns[g], generated.columns[i]) for g, i in sorted(pairing.items()))
+    extra = tuple(name for i, name in enumerate(generated.columns) if i not in set(pairing.values()))
+    return pairs, extra
+
 def compare_result_sets(
     golden: ExecResult,
     generated: ExecResult,
@@ -657,11 +688,14 @@ def compare_result_sets(
         verdict = _Verdict(
             "error", None, f"the comparison failed with an unexpected {type(exc).__name__}"
         )
+    pairs, extra = _column_pairs(golden, generated, match, ordered)
     return ItemScore(
         status=verdict.status,
         accuracy=verdict.accuracy,
         reason=verdict.reason,
         unmatched_golden_columns=verdict.unmatched,
+        column_pairs=pairs,
+        unmatched_generated_columns=extra,
         golden_row_count=len(golden.rows),
         generated_row_count=len(generated.rows),
         order_sensitive=ordered,
diff --git a/packages/agami-core/src/semantic_model/golden_claims.py b/packages/agami-core/src/semantic_model/golden_claims.py
index 2dd8cd83..e71200ea 100644
--- a/packages/agami-core/src/semantic_model/golden_claims.py
+++ b/packages/agami-core/src/semantic_model/golden_claims.py
@@ -235,6 +235,12 @@ def _rendered(node: "exp.Expression", aliases: dict[str, str], depth: int) -> st
     if isinstance(node, exp.Column):
         qualifier = node.table
         if not qualifier:
+            # An unqualified column in a SELECT that reads exactly one table belongs to that table,
+            # so `opened` and `r.opened` are one key; with two tables in scope it stays bare, since
+            # guessing an owner would make two different columns one key.
+            tables = {rt._tkey(rt._bare(t)) for t in aliases.values()}
+            if len(tables) == 1:
+                return f"{next(iter(tables))}.{node.name.lower()}"
             return node.name.lower()
         # The schema and catalog parts are dropped with the alias: `sales.orders.region` and
         # `orders.region` name one column, and `_bare` has already stripped the schema off the
@@ -464,7 +470,10 @@ def _unit_name(node: "exp.Expression | None") -> Optional[str]:
     return _RELATIVE_UNITS.get(str(text).strip().strip("'\"").lower())
 
 
-def _relative_bound(node: "exp.Expression | None") -> Optional[str]:
+_MAX_RELATIVE_DEPTH = 8
+
+
+def _relative_bound(node: "exp.Expression | None", depth: int = _MAX_RELATIVE_DEPTH) -> Optional[str]:
     """The bound a node spells RELATIVE to the run date, as words: `today`, `start of this year`,
     `start of this year + 7 month`, `today - 30 day`. None for any other shape.
 
@@ -474,36 +483,38 @@ def _relative_bound(node: "exp.Expression | None") -> Optional[str]:
     date it computed would be a bound neither statement wrote. It is compared only against another
     relative bound (`_window_status`), never against a literal date.
     """
-    if node is None:
+    if node is None or depth <= 0:
+        # A relative bound deeper than a handful of steps is not a window anyone wrote; past the
+        # budget it reads None, so `read_claims` keeps its promise never to raise on a pathological tree.
         return None
     if isinstance(node, exp.Paren):
-        return _relative_bound(node.this)
+        return _relative_bound(node.this, depth - 1)
     if isinstance(node, exp.Cast):
-        return _relative_bound(node.this)
+        return _relative_bound(node.this, depth - 1)
     if isinstance(node, exp.CurrentDate):
         return "today"
     if isinstance(node, exp.CurrentTimestamp) or (isinstance(node, exp.Anonymous) and str(node.this).lower() in ("now", "getdate", "sysdate", "current_timestamp")):
         return "now"
     if isinstance(node, (exp.DateTrunc, exp.TimestampTrunc)):
-        inner = _relative_bound(node.this if isinstance(node, exp.TimestampTrunc) else node.args.get("this"))
+        inner = _relative_bound(node.this if isinstance(node, exp.TimestampTrunc) else node.args.get("this"), depth - 1)
         unit = _unit_name(node.args.get("unit"))
         if isinstance(node, exp.DateTrunc):
             # sqlglot's DateTrunc holds the unit in `unit` and the value in `this`; some dialects
             # parse the argument order the other way round, so both are tried.
-            inner = _relative_bound(node.this) or _relative_bound(node.args.get("unit"))
+            inner = _relative_bound(node.this, depth - 1) or _relative_bound(node.args.get("unit"), depth - 1)
             unit = _unit_name(node.args.get("unit")) or _unit_name(node.this)
         if inner in ("today", "now") and unit:
             return f"start of this {unit}"
         return None
     if isinstance(node, (exp.Add, exp.Sub)):
-        base = _relative_bound(node.this)
+        base = _relative_bound(node.this, depth - 1)
         step = _interval_words(node.expression)
         if base and step:
             return _step(base, isinstance(node, exp.Add), *step)
         return None
     date_add_types = tuple(t for t in (exp.DateAdd, getattr(exp, "TsOrDsAdd", None)) if t is not None)
     if isinstance(node, date_add_types + (exp.DateSub,)):
-        base = _relative_bound(node.this)
+        base = _relative_bound(node.this, depth - 1)
         n = node.expression
         unit = _unit_name(node.args.get("unit"))
         count: Optional[int] = None
diff --git a/plugins/agami/scripts/parse_reconcile_intake.py b/plugins/agami/scripts/parse_reconcile_intake.py
index 788f3981..38168971 100644
--- a/plugins/agami/scripts/parse_reconcile_intake.py
+++ b/plugins/agami/scripts/parse_reconcile_intake.py
@@ -30,7 +30,7 @@
 _KEYS = {"profile", "reconcile-run", "intake"}
 
 
-def _key_of(line: str):
+def _key_of(line: str) -> str | None:
     low = line.strip().lower()
     for k in _KEYS:
         if low.startswith(k + ":") or low == k + ":":
@@ -144,8 +144,15 @@ def main(argv=None) -> int:
         print(json.dumps({"ok": False, "data": None, "anomalies": [{"kind": "bad_argument", "detail": str(exc)}],
                           "needs_judgment": {"kind": "bad_argument", "ask": "pass the rows file `reconcile.py intake` wrote and the pasted block"}}, indent=2))
         return 2
+    if not isinstance(intake, dict) or not isinstance(intake.get("rows"), list):
+        print(json.dumps({"ok": False, "data": None, "anomalies": [{"kind": "bad_argument", "detail": "the rows file is not the output of `reconcile.py intake`"}],
+                          "needs_judgment": {"kind": "bad_argument", "ask": "pass the rows file `reconcile.py intake` wrote (an object with a `rows` list)"}}, indent=2))
+        return 2
     known = {r.get("row", n) for n, r in enumerate(intake.get("rows", []), 1)}
-    data, anomalies, needs = parse(text, known, run=args.run)
+    # The block must name the run it is applied to. When --run is not given, the run is the folder
+    # --out lands in, so a block from another run can never be applied by leaving the flag off.
+    run = args.run or (Path(args.out).expanduser().resolve().parent.name if args.out else None)
+    data, anomalies, needs = parse(text, known, run=run)
     counts = None
     if needs is None:
         applied, counts = apply(intake, data["decisions"])
diff --git a/plugins/agami/scripts/parse_reconcile_report.py b/plugins/agami/scripts/parse_reconcile_report.py
index 80423bef..7d563f93 100644
--- a/plugins/agami/scripts/parse_reconcile_report.py
+++ b/plugins/agami/scripts/parse_reconcile_report.py
@@ -38,12 +38,32 @@
 from pathlib import Path
 
 _KEYS = {"profile", "reconcile-run", "decisions"}
-_DECISIONS = frozenset({"keep", "change", "fix", "reword", "nothing"})
-_WITH_WORDS = frozenset({"change", "fix", "reword"})
+_DECISIONS = frozenset({"keep", "change", "fix", "reword", "example", "nothing"})
+_WITH_WORDS = frozenset({"change", "fix", "reword", "example"})
 _FIELDS = ("row", "decision", "words")
 _DROPPED_KINDS = frozenset({"unknown_decision", "decision_missing_row", "row_decided_twice",
                             "decision_not_an_object", "keep_not_offered", "words_ignored_on_keep",
-                            "words_ignored_on_nothing", "words_not_text"})
+                            "words_ignored_on_nothing", "words_not_text", "example_not_offered"})
+
+
+def example_blocked_rows(run_dir: Path) -> set[int]:
+    """Rows whose ledger holds a part the data proved wrong: a statement with a mistake in it is never
+    offered as a prompt example, whatever the page suggested. Read from each row's ledger.json."""
+    blocked: set[int] = set()
+    rows_dir = run_dir / "rows"
+    if not rows_dir.is_dir():
+        return blocked
+    for row_dir in rows_dir.iterdir():
+        ledger = row_dir / "ledger.json"
+        if not row_dir.name.isdigit() or not ledger.exists():
+            continue
+        try:
+            parts = json.loads(ledger.read_text(encoding="utf-8")).get("rows", [])
+        except (OSError, ValueError):
+            continue
+        if any(isinstance(p, dict) and p.get("verdict") == "query_defect" for p in parts):
+            blocked.add(int(row_dir.name))
+    return blocked
 
 
 def keepable_rows(run_dir: Path) -> set[int]:
@@ -81,7 +101,7 @@ def keepable_rows(run_dir: Path) -> set[int]:
     return keep
 
 
-def _key_of(line: str):
+def _key_of(line: str) -> str | None:
     low = line.strip().lower()
     for k in _KEYS:
         if low.startswith(k + ":") or low == k + ":":
@@ -112,7 +132,8 @@ def _sections(text: str) -> tuple[dict, list[str]]:
     return out, repeated
 
 
-def parse(text: str, keepable: set[int] | None = None, run: str | None = None) -> tuple[dict, list, dict | None]:
+def parse(text: str, keepable: set[int] | None = None, run: str | None = None,
+          example_blocked: set[int] | None = None) -> tuple[dict, list, dict | None]:
     sec, repeated = _sections(text)
     anomalies: list = [{"kind": "key_repeated", "detail": key} for key in repeated]
     needs: dict | None = None
@@ -156,6 +177,9 @@ def parse(text: str, keepable: set[int] | None = None, run: str | None = None) -
         if row in seen:
             anomalies.append({"kind": "row_decided_twice", "row": row})
             continue
+        if decision == "example" and row in (example_blocked or set()):
+            anomalies.append({"kind": "example_not_offered", "row": row})
+            continue  # dropped like a keep the run did not offer; _DROPPED_KINDS carries the kind
         if decision == "keep" and row not in (keepable or set()):
             # The offer's predicate belongs to the ledger: a keep the run's own files do not
             # allow is not the person's to grant from a page.
@@ -200,7 +224,7 @@ def main(argv=None) -> int:
         print(json.dumps({"ok": False, "data": None, "anomalies": [{"kind": "bad_argument", "detail": str(exc)}],
                           "needs_judgment": {"kind": "bad_argument", "ask": "the block file could not be read"}}, indent=2))
         return 2
-    data, anomalies, needs = parse(text, keepable_rows(run_dir), run=run_dir.name)
+    data, anomalies, needs = parse(text, keepable_rows(run_dir), run=run_dir.name, example_blocked=example_blocked_rows(run_dir))
     print(json.dumps({"ok": needs is None, "data": data, "anomalies": anomalies, "needs_judgment": needs}, indent=2))
     return 0
 
diff --git a/plugins/agami/scripts/reconcile.py b/plugins/agami/scripts/reconcile.py
index 27f76cf6..aa6f62e0 100644
--- a/plugins/agami/scripts/reconcile.py
+++ b/plugins/agami/scripts/reconcile.py
@@ -438,11 +438,16 @@ def _rows_from_json(items: Any, *, file: str, source: str | None) -> tuple[list[
     return rows, skipped
 
 
+_MAX_INTAKE_BYTES = 20 * 1024 * 1024
+
+
 def _rows_from_file(path: Path, source: str | None) -> tuple[list[dict], list[dict]]:
     """One file's rows and the lines it could not use. The extension decides how lines are cut:
     `.json` is a list, `.sql` is statements split on `;`, `.txt` and `.md` are one question per
     line, and everything else is CSV."""
     file = path.name
+    if path.stat().st_size > _MAX_INTAKE_BYTES:
+        raise ValueError(f"{file} is {path.stat().st_size // (1024 * 1024)} MB; the intake reads files up to {_MAX_INTAKE_BYTES // (1024 * 1024)} MB. Export fewer rows, or split the file.")
     text = path.read_text(encoding="utf-8")
     suffix = path.suffix.lower()
     if suffix == ".json":
@@ -1394,7 +1399,7 @@ def row_status(match: bool | None, ledger_verdict: str | None) -> str:
 
 
 # --------------------------------------------------------------------------------------------
-# next-chunk: the run works five rows at a time, and rows.jsonl is its checkpoint
+# next-chunk: the run works five rows at a time, and rows.jsonl is its checkpoint.
 # --------------------------------------------------------------------------------------------
 
 CHUNK_SIZE = 5
@@ -1473,12 +1478,12 @@ def next_chunk(run_dir: Path, size: int = CHUNK_SIZE) -> dict:
 
 
 # --------------------------------------------------------------------------------------------
-# report-items: the report page's items, templated from what the run wrote, never written by hand
+# report-items: the report page's items, templated from what the run wrote, never written by hand.
 # --------------------------------------------------------------------------------------------
 
 _STATE = {CONFIRMED: "held", QUERY_DEFECT: "defect", MODEL_GAP: "gap", UNRESOLVED: "open", NOTED: "noted"}
 _STATE_WORDS = {"held": "passed", "defect": "a mistake in your query", "gap": "a gap in the semantic model",
-                "open": "could not check", "noted": "noticed"}
+                "open": "could not check", "noted": "noticed", "differs": "the two queries differ"}
 _CLAIM_KEYS = {"tables": "tables read", "filter_predicates": "filters", "date_window": "date window",
                "group_keys": "grouped by", "join_keys": "join keys", "ordering": "ordered by", "limit": "limit"}
 # The words a ledger part's grade takes on the page, by part family and grade. Every cell on the
@@ -1711,22 +1716,41 @@ def add(key, state, yours=None, agami=None, note=None, yours_hi=None, agami_hi=N
         add("rows", "held" if same_rows else "defect", yours_text, agami_text)
         yc = list(((rec.get("statement_recorded") or {}).get("columns")) or [])
         ac = list(((rec.get("recorded") or {}).get("columns")) or [])
+        pairs = [tuple(p) for p in (result_set.get("column_pairs") or []) if isinstance(p, (list, tuple)) and len(p) == 2]
         if yc or ac:
-            only_yours, only_agami = _only(yc, ac), _only(ac, yc)
+            values_compared = same_rows and (bool(pairs) or bool(result_set.get("unmatched_golden_columns")))
+            if values_compared:
+                # Columns are compared by the values they carry, never by name: the comparator says
+                # which of yours paired with which of agami's, and a renamed column is the same column.
+                only_yours = [c for c in (result_set.get("unmatched_golden_columns") or []) if c in yc]
+                only_agami = list(result_set.get("unmatched_generated_columns") or [])
+                renamed = [f"{a} → {b}" for a, b in pairs if a != b]
+            else:
+                # No values comparison ran (the row counts differ, or an older score file): names are
+                # all there is. Identical names are one column set; the rows check carries the counts.
+                only_yours, only_agami, renamed = _only(yc, ac), _only(ac, yc), []
             if not only_yours and not only_agami:
                 col_state = "held"
             elif only_yours:
                 col_state = "defect"
             else:
                 col_state = "noted"  # agami returned more than asked; nothing of yours is missing
-            add("columns", col_state, yc, ac, yours_hi=only_yours, agami_hi=only_agami,
-                note=(f"the comparison scores on columns; {len(result_set.get('unmatched_golden_columns') or [])} unmatched scored 0"
-                      if result_set.get("unmatched_golden_columns") else (f"agami returned columns your query did not: {', '.join(only_agami)}" if col_state == "noted" else None)))
+            # No sentence: the tokens carry the difference the way a diff does. A column only yours
+            # has reads as removed, one only agami's as added, and a pair with two names is marked in
+            # place so the reader sees they hold the same values.
+            add("columns", col_state, yc, ac, yours_hi=only_yours, agami_hi=only_agami)
+            if renamed:
+                rows[-1]["renamed"] = [[a, b] for a, b in pairs if a != b]
         acc = result_set.get("accuracy")
         if acc is not None:
             same = float(acc) >= 1.0
-            add("values", "held" if same else "defect", "identical, row for row" if same else f"{float(acc):.0%} of the values match",
-                None, note=None if same else result_set.get("reason"))
+            if same:
+                add("values", "held", "identical, row for row", None)
+            elif pairs and result_set.get("unmatched_golden_columns"):
+                add("values", "held", f"identical on the {len(pairs)} paired column{'s' if len(pairs) != 1 else ''}", None,
+                    note="the score is 0 only because a column of yours has no partner; the paired columns match")
+            else:
+                add("values", "defect", f"{float(acc):.0%} of the values match", None, note=result_set.get("reason"))
     else:
         match = rec.get("match") if rec.get("match") is not None else (scalar or {}).get("match")
         if rec.get("status") == "error":
@@ -1757,15 +1781,20 @@ def add(key, state, yours=None, agami=None, note=None, yours_hi=None, agami_hi=N
         status = claim.get("status")
         if yours is None and agami is None and status in ("agrees", "same"):
             continue
-        state = "held" if status in ("agrees", "same") else "defect" if status == "differs" else "open"
+        state = "held" if status in ("agrees", "same") else "differs" if status == "differs" else "open"
         note = None
-        if name == "date_window" and state == "open":
-            part = parts.get("date_window") or {}
-            note = part.get("note") or "the window could not be read from one of the two queries"
+        graded = parts.get({"date_window": "date_window", "filter_predicates": "predicates"}.get(name, ""))
+        if state == "open" and graded and graded.get("verdict") == CONFIRMED:
+            # The ledger read this claim with more context (no date filter anywhere, say) and confirmed it.
+            state, note = "held", None
+            if name == "date_window":
+                yours, agami = yours or "no date filter", agami or "no date filter"
+        elif name == "date_window" and state == "open":
+            note = (graded or {}).get("note") or "the window could not be read from one of the two queries"
             yours = yours or "could not read"
             agami = agami or "could not read"
         add(_CLAIM_KEYS.get(name, name), state, yours, agami, note=note,
-            yours_hi=_only(yours, agami) if state == "defect" else None, agami_hi=_only(agami, yours) if state == "defect" else None)
+            yours_hi=_only(yours, agami) if state == "differs" else None, agami_hi=_only(agami, yours) if state == "differs" else None)
 
     # 3 · every part of the person's statement the ledger graded, with agami's side where a receipt says.
     filters, metrics = _receipt_filters(agami_receipt), _receipt_metrics(agami_receipt)
@@ -1830,8 +1859,8 @@ def _result(rec: dict, diff: list[dict]) -> dict:
         cols = rows.get("columns"); values = rows.get("values")
         same_rows = rows["rows"]["state"] == "held"
         values_ok = values is None or values["state"] == "held"
-        if same_rows and values_ok and (cols is None or cols["state"] == "held"):
-            data = "matches"
+        if same_rows and values_ok and (cols is None or cols["state"] in ("held", "noted")):
+            data = "matches"  # a column only agami returned is noticed, not a difference in the answer
         elif same_rows and cols is not None and cols["state"] != "held" and _values_agree_on_shared_columns(rec):
             data = "partly"
         else:
@@ -1842,36 +1871,55 @@ def _result(rec: dict, diff: list[dict]) -> dict:
     claims = ((rec.get("claims") or {}).get("claims") or []) if isinstance(rec.get("claims"), dict) else []
     statuses = [c.get("status") for c in claims]
     columns_differ = "columns" in rows and rows["columns"]["state"] != "held"
+    by_name = {c.get("name"): c.get("status") for c in claims}
+    parts = ((rec.get("ledger") or {}).get("rows") or []) if isinstance(rec.get("ledger"), dict) else []
+    part_verdicts = {p.get("part"): p.get("verdict") for p in parts}
+    # A claim the ledger graded confirmed (no date filter anywhere, say) is not unknown for this purpose.
+    for name, part in (("date_window", "date_window"), ("filter_predicates", "predicates")):
+        if by_name.get(name) == "unknown" and part_verdicts.get(part) == CONFIRMED:
+            by_name[name] = "agrees"
+    statuses = list(by_name.values())
+    definitional_unknown = any(by_name.get(n) == "unknown" for n in ("tables", "filter_predicates", "date_window", "join_keys", "group_keys"))
     if (not claims or all(st == "unknown" for st in statuses)) and not columns_differ:
         query = "not_comparable"
     elif any(st == "differs" for st in statuses) or columns_differ:
         # The seven claims do not cover the projection; two queries that return different columns
         # are different queries even when every claim agrees.
         query = "different"
+    elif definitional_unknown:
+        # Nothing differs, but a claim that decides sameness could not be read: sameness is not established.
+        query = "not_comparable"
     else:
         query = "same"
-    parts = ((rec.get("ledger") or {}).get("rows") or []) if isinstance(rec.get("ledger"), dict) else []
-    unchecked = sum(1 for p in parts if p.get("verdict") == UNRESOLVED) + sum(1 for st in statuses if st == "unknown")
+    # A check counts once: a claim the ledger carries as a part is counted as that part.
+    graded_claims = {"date_window", "filter_predicates"} if part_verdicts else set()
+    unchecked = sum(1 for p in parts if p.get("verdict") == UNRESOLVED) + sum(1 for n, st in by_name.items() if st == "unknown" and n not in graded_claims)
     label = "could not run" if data == "could_not_compare" else _RESULT_LABEL[(data, query)]
     differing = sorted(r["key"] for r in diff
-                       if (r["state"] == "defect" or (r["key"] == "columns" and r["state"] == "noted"))
+                       if (r["state"] in ("defect", "differs") or (r["key"] == "columns" and r["state"] == "noted"))
                        and r["key"] in _DEFINITIONAL | {"ordered by", "limit", "columns"})
     return {"data": data, "query": query, "label": label, "unchecked": unchecked, "differs_in": differing}
 
 
 def _values_agree_on_shared_columns(rec: dict) -> bool:
-    """A table compare whose only difference is the column set: every golden column the generated side
-    carries matched by value, so the score is exactly the matched share."""
+    """A table compare whose only difference is the column set. The comparator pairs columns by their
+    values, so every pair it reports agrees by construction; the answer is partly the same when at
+    least one pair exists beside a column of yours with no partner or a column of agami's with none.
+    The score itself is 0.0 whenever any column of yours is unpaired, so it cannot be the test."""
     score = (rec.get("comparison") or {}).get("result_set") if isinstance(rec.get("comparison"), dict) else None
     if not score:
         return False
+    acc = score.get("accuracy")
+    if acc is not None and float(acc) >= 1.0:
+        return True  # agami returned everything you did, and more
+    pairs = score.get("column_pairs") or []
+    if pairs:
+        return bool(score.get("unmatched_golden_columns") or score.get("unmatched_generated_columns"))
+    # an older score file without pairs: fall back to the matched share of the columns
     cols = list(((rec.get("statement_recorded") or {}).get("columns")) or [])
     unmatched = list(score.get("unmatched_golden_columns") or [])
-    acc = score.get("accuracy")
     if acc is None or not cols:
         return False
-    if float(acc) >= 1.0:
-        return True  # agami returned everything you did, and more
     matched = len(cols) - len(unmatched)
     return matched > 0 and abs(float(acc) - matched / len(cols)) < 1e-6
 
@@ -1913,13 +1961,57 @@ def _fix(rec: dict, diff: list[dict], result: dict) -> str:
 }
 
 
+def _change_for_fix(fix: str, rec: dict, diff: list[dict]) -> tuple[list[str], list[str], dict]:
+    """The card's change text, its to-do and the words each decision box starts with, all from the one
+    fix. The three used to come from three places and could disagree on one card."""
+    parts = ((rec.get("ledger") or {}).get("rows") or []) if isinstance(rec.get("ledger"), dict) else []
+    fit = next((p for p in parts if p.get("part") == "question_fit"), None)
+    gaps = [r["key"] for r in diff if r["state"] == "gap"]
+    cols = next((r for r in diff if r["key"] == "columns"), None)
+    extra = list((cols or {}).get("yours_hi") or [])
+    mistakes = _measured_mistakes(rec)
+    prefill = {"change": "", "fix": "", "reword": rec.get("question") or "", "example": ""}
+    if fix == "query":
+        if mistakes:
+            change = [f"Fix your query: {', '.join(mistakes)}. Then run this row again."]
+            prefill["fix"] = "; ".join(mistakes)
+        elif extra:
+            change = [f"Your query returns columns the question did not ask for: {', '.join(extra)}. Remove them, or name them in the question."]
+            prefill["fix"] = "remove " + ", ".join(extra)
+            prefill["reword"] = (rec.get("question") or "").rstrip(".?") + f", with {', '.join(extra)}?"
+        else:
+            change = ["Fix your query where the marks are red, then run this row again."]
+        todo = ["Your query: fix the red rows, then re-run."]
+    elif fix == "semantic_model":
+        change = [f"The semantic model is missing: {', '.join(gaps)}. Add them through /agami-save-correction." if gaps
+                  else "Decide which definition your team means. A change to the semantic model goes through /agami-save-correction."]
+        todo = [f"The semantic model: {', '.join(gaps)}." if gaps else "The semantic model: decide the definition."]
+        prefill["change"] = ("add " + ", ".join(gaps)) if gaps else ""
+    elif fix == "examples":
+        change, todo = list(_FIX_CHANGE["examples"][0]), list(_FIX_CHANGE["examples"][1])
+    elif fix == "question":
+        reason = (fit or {}).get("note") or ""
+        change = [("Reword the question, or change your query, so they ask the same thing. " + reason).strip()]
+        todo = ["The question: reword it and re-run."]
+    elif fix == "ask_again":
+        if rec.get("status") == "error":
+            change, todo = list(_OWNER_CHANGE["agami"][0]), list(_OWNER_CHANGE["agami"][1])
+        else:
+            change, todo = list(_FIX_CHANGE["ask_again"][0]), list(_FIX_CHANGE["ask_again"][1])
+    else:
+        change, todo = list(_OWNER_CHANGE["keep"][0]), list(_OWNER_CHANGE["keep"][1])
+    if fit and fit.get("verdict") != CONFIRMED and fit.get("note") and fix != "question":
+        change.append(f"Also: {fit['note']}")
+    return change, todo, prefill
+
+
 def _owner(rec: dict, diff: list[dict]) -> str:
     """Who acts, from the evidence, in this order: a mistake in the query is the person's; a gap the
     ledger measured is the semantic model's; a question read differently is the question's."""
     status = rec.get("status")
     parts = ((rec.get("ledger") or {}).get("rows") or []) if isinstance(rec.get("ledger"), dict) else []
     fit = next((p for p in parts if p.get("part") == "question_fit"), None)
-    differing = {r["key"] for r in diff if r["state"] == "defect"}
+    differing = {r["key"] for r in diff if r["state"] in ("defect", "differs")}
     if status == "match":
         # The keep-offer (Phase 3e, and the page's keep gate) is made only for a one-cell answer whose
         # statement, if any, answers its question; a matched table or a doubtful fit is not offered.
@@ -1994,7 +2086,7 @@ def _measured_mistakes(rec: dict) -> list[str]:
 
 def _sentence(rec: dict, diff: list[dict]) -> str:
     status = rec.get("status")
-    red = [r["key"] for r in diff if r["state"] == "defect" and r["key"] not in ("answer", "rows", "values")]
+    red = [r["key"] for r in diff if r["state"] in ("defect", "differs") and r["key"] not in ("answer", "rows", "values")]
     mistakes = _measured_mistakes(rec)
     open_ = [r["key"] for r in diff if r["state"] == "open"]
     gaps = [r["key"] for r in diff if r["state"] == "gap"]
@@ -2018,8 +2110,12 @@ def resume(reconcile_dir: Path) -> dict | None:
     for run_dir in candidates:
         try:
             state = next_chunk(run_dir)
-        except (json.JSONDecodeError, ValueError):
-            continue
+        except json.JSONDecodeError:
+            continue  # an intake.json that is not JSON is not a run to resume
+        except ValueError as exc:
+            # A corrupt checkpoint is refused, never skipped: skipping would resume an older run and
+            # leave this one's row to be run twice later.
+            raise ValueError(f"{run_dir}: {exc}") from exc
         if not state["complete"]:
             return {"run_dir": str(run_dir), "finished": state["finished"], "remaining": state["remaining"],
                     "chunk_rows": state["chunk_rows"], "progress": state["progress"]}
@@ -2034,6 +2130,9 @@ def report_items(run_dir: Path) -> list[dict]:
     items = []
     for rec in records:
         rec = dict(rec, status=rec.get("status") or "error")
+        if isinstance(rec.get("error"), str):
+            # The page shows the classifier's one line, never a driver's message with a host or a table in it.
+            rec["error"] = rec["error"].strip().splitlines()[0][:200] if rec["error"].strip() else None
         n = rec.get("row")
         row_dir = run_dir / "rows" / str(n)
         agami_receipt = None
@@ -2049,18 +2148,18 @@ def report_items(run_dir: Path) -> list[dict]:
         legacy_owner = _owner(rec, diff)
         # keep is the fix "nothing" on a row the keep gate accepts; the page's keep offer is that
         keep_ok = legacy_owner == "keep"
-        owner = "keep" if (fix == "none" and keep_ok) else _FIX_OWNER[fix]
-        change, todo = _change(owner if owner != "agami" else legacy_owner, rec, diff)
-        if fix in _FIX_CHANGE:
-            change, todo = list(_FIX_CHANGE[fix][0]), list(_FIX_CHANGE[fix][1])
-            if fix == "ask_again" and rec.get("status") == "error":
-                change, todo = list(_OWNER_CHANGE["agami"][0]), list(_OWNER_CHANGE["agami"][1])
-        if fix == "none" and not keep_ok and rec.get("status") == "match":
+        owner = "keep" if (keep_ok and fix in ("none", "examples")) else _FIX_OWNER[fix]
+        change, todo, prefill = _change_for_fix(fix, rec, diff)
+        if fix == "none" and not keep_ok:
+            # nothing to fix, and not kept either: say why in the words the status gives
             change, todo = _change("nothing", rec, diff)
         if result["data"] == "matches" and result["query"] == "different":
             clause = ("The two queries differ in: " + ", ".join(result["differs_in"]) + ("; the match may not hold on other data." if set(result["differs_in"]) & _DEFINITIONAL else "; a cosmetic difference."))
         else:
             clause = None
+        cols_row = next((r for r in diff if r["key"] == "columns"), None)
+        if cols_row and cols_row.get("agami_hi") and not cols_row.get("yours_hi"):
+            clause = ((clause + " ") if clause else "") + f"agami also returned: {', '.join(cols_row['agami_hi'])}."
         prov = rec.get("provenance") or {}
         shape_words = {"a": "a question", "b": "a question with your SQL", "c": "a number from your dashboard", "d": "a number with the SQL behind it"}
         source = ", ".join(p for p in (prov.get("source"), f"{prov['file']}:{prov['line']}" if prov.get("file") and prov.get("line") else prov.get("file"),
@@ -2078,8 +2177,8 @@ def report_items(run_dir: Path) -> list[dict]:
             "source": source or None, "status": rec.get("status") or "error",
             "expected": expected, "answer": answer,
             "delta_pct": (round(delta * 100, 1) if isinstance(delta, (int, float)) and not isinstance(delta, bool) else None),
-            "single_cell": bool(single), "owner": owner, "keep_allowed": owner == "keep", "diff": diff,
-            "result": result, "fix": fix, "fix_words": _FIX_WORDS[fix],
+            "single_cell": bool(single), "owner": owner, "keep_allowed": keep_ok, "diff": diff,
+            "result": result, "fix": fix, "fix_words": _FIX_WORDS[fix], "prefill": prefill,
             "sentence": _sentence(rec, diff) + (" " + clause if clause else ""),
             "words": words, "disagreement": None, "change": list(change), "todo": list(todo),
             "sql_yours": rec.get("statement") or None, "sql_agami": rec.get("sql") or None,
@@ -2153,7 +2252,11 @@ def main(argv: list[str] | None = None) -> int:
         if not root.is_dir():
             print(f"reconcile resume: directory not found: {root}", file=sys.stderr)
             return 2
-        found = resume(root)
+        try:
+            found = resume(root)
+        except ValueError as exc:
+            print(f"reconcile resume: {exc}", file=sys.stderr)
+            return 2
         print(json.dumps(found, indent=2))
         # Exit 4, "nothing to do": every run under the directory is complete, or there is none.
         return 0 if found else 4
@@ -2245,10 +2348,11 @@ def main(argv: list[str] | None = None) -> int:
         if missing:
             print(f"reconcile intake: file not found: {', '.join(missing)}", file=sys.stderr)
             return 2
+        csv.field_size_limit(sys.maxsize)  # a long SQL cell is a row, not an error
         try:
             result = intake(paths, source=args.source)
-        except (json.JSONDecodeError, UnicodeDecodeError) as exc:
-            print(f"reconcile intake: could not read the input: {exc}", file=sys.stderr)
+        except (json.JSONDecodeError, UnicodeDecodeError, ValueError, csv.Error, RecursionError) as exc:
+            print(f"reconcile intake: could not read the input: {str(exc).splitlines()[0][:300]}", file=sys.stderr)
             return 2
         if not result["rows"]:
             # Exit 4, "nothing to do", kept apart from 2 so the skill can say which happened:
diff --git a/plugins/agami/scripts/render_reconcile_intake.py b/plugins/agami/scripts/render_reconcile_intake.py
index b42a7e47..5bb1ec51 100644
--- a/plugins/agami/scripts/render_reconcile_intake.py
+++ b/plugins/agami/scripts/render_reconcile_intake.py
@@ -84,8 +84,6 @@ def _validate_item(item: dict, idx: int) -> None:
             raise ValueError(f"item {idx}: '{key}' must be text")
     if item.get("line") is not None and (not isinstance(item["line"], int) or isinstance(item["line"], bool)):
         raise ValueError(f"item {idx}: 'line' must be a whole number")
-    if item.get("line") is not None and (not isinstance(item["line"], int) or isinstance(item["line"], bool)):
-        raise ValueError(f"item {idx}: 'line' must be a whole number")
     if item.get("statement_preview") and len(item["statement_preview"]) > 80:
         raise ValueError(f"item {idx}: 'statement_preview' is at most 80 characters")
 
diff --git a/plugins/agami/scripts/render_reconcile_report.py b/plugins/agami/scripts/render_reconcile_report.py
index 2910e4df..2fe04490 100644
--- a/plugins/agami/scripts/render_reconcile_report.py
+++ b/plugins/agami/scripts/render_reconcile_report.py
@@ -41,14 +41,14 @@
 # What one card may carry, beat by beat. Every text field is DISPLAY text the skill already wrote in
 # plain language; the lists are one sentence per line. A `rows` or `recorded` key is refused.
 _FIELDS = ("row", "label", "question", "source", "status", "expected", "answer", "delta_pct", "single_cell",
-           "owner", "read", "how", "words", "disagreement", "change", "checks", "todo", "report_path", "diff", "sentence", "sql_yours", "sql_agami", "keep_allowed", "result", "fix", "fix_words")
+           "owner", "read", "how", "words", "disagreement", "change", "checks", "todo", "report_path", "diff", "sentence", "sql_yours", "sql_agami", "keep_allowed", "result", "fix", "fix_words", "prefill")
 _LISTS = ("read", "how", "words", "change", "todo")
-_DIFF_KEYS = ("key", "state", "yours", "agami", "note", "yours_hi", "agami_hi")
+_DIFF_KEYS = ("key", "state", "yours", "agami", "note", "yours_hi", "agami_hi", "renamed")
 _STATUSES = {"match", "match_unverified", "mismatch", "expected_doubtful", "error"}
 # Who acts in beat 4, which colors the fourth column: the person's query, the semantic model, the
 # question, agami's answer (a worked example), keep, or nothing.
 _OWNERS = {"you", "model", "question", "agami", "keep", "nothing"}
-_CHECK_STATES = {"held", "defect", "open", "gap", "noted"}
+_CHECK_STATES = {"held", "defect", "open", "gap", "noted", "differs"}
 _LAYOUTS = ("auto", "cards", "audit")
 _DATA_RESULTS = {"matches", "partly", "differs", "could_not_compare"}
 _QUERY_RESULTS = {"same", "different", "not_comparable"}
@@ -97,6 +97,9 @@ def _validate_item(item: dict, idx: int) -> None:
                 raise ValueError(f"item {idx}: diff '{hi}' must be a list of the tokens to highlight")
         if row.get("note") is not None and not isinstance(row["note"], str):
             raise ValueError(f"item {idx}: diff 'note' must be text")
+        renamed = row.get("renamed")
+        if renamed is not None and not (isinstance(renamed, list) and all(isinstance(p, list) and len(p) == 2 and all(isinstance(x, str) for x in p) for p in renamed)):
+            raise ValueError(f"item {idx}: diff 'renamed' must be a list of [yours, agami] name pairs")
         if "rows" in row or "recorded" in row:
             raise ValueError(f"item {idx}: result rows are never rendered, not even inside a diff row")
     if item.get("keep_allowed") is not None and not isinstance(item["keep_allowed"], bool):
@@ -110,6 +113,9 @@ def _validate_item(item: dict, idx: int) -> None:
         raise ValueError(f"item {idx}: 'fix' must be one of {sorted(_FIXES)}")
     if item.get("fix_words") is not None and not isinstance(item["fix_words"], str):
         raise ValueError(f"item {idx}: 'fix_words' must be text")
+    prefill = item.get("prefill")
+    if prefill is not None and (not isinstance(prefill, dict) or not all(isinstance(k, str) and isinstance(v, str) for k, v in prefill.items())):
+        raise ValueError(f"item {idx}: 'prefill' must map a decision to the words its box starts with")
     if item.get("sentence") is not None and not isinstance(item["sentence"], str):
         raise ValueError(f"item {idx}: 'sentence' must be text")
     for key in ("sql_yours", "sql_agami"):
diff --git a/plugins/agami/shared/reconcile-grades-template.html b/plugins/agami/shared/reconcile-grades-template.html
index a755028a..b8c581bc 100644
--- a/plugins/agami/shared/reconcile-grades-template.html
+++ b/plugins/agami/shared/reconcile-grades-template.html
@@ -28,7 +28,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>{{REPORT_TITLE}} — agami</title>
+  <title>{{REPORT_TITLE}} · agami</title>
   <style>
 {{THEME_CSS}}
 {{PAGE_CSS}}
diff --git a/plugins/agami/shared/reconcile-intake-template.html b/plugins/agami/shared/reconcile-intake-template.html
index 9d5df448..6c5dce4f 100644
--- a/plugins/agami/shared/reconcile-intake-template.html
+++ b/plugins/agami/shared/reconcile-intake-template.html
@@ -14,7 +14,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>{{REPORT_TITLE}} — agami</title>
+  <title>{{REPORT_TITLE}} · agami</title>
   <style>
 {{THEME_CSS}}
 {{PAGE_CSS}}
diff --git a/plugins/agami/shared/reconcile-pages.css b/plugins/agami/shared/reconcile-pages.css
index 7ad06fb9..37968433 100644
--- a/plugins/agami/shared/reconcile-pages.css
+++ b/plugins/agami/shared/reconcile-pages.css
@@ -2,13 +2,18 @@
    checklist and its rail, the decision controls, the footer and the paste-back modal. Read by
    render_reconcile_report.py, render_reconcile_grades.py and render_reconcile_intake.py into the
    PAGE_CSS placeholder, after the plugin's theme.css, so every page a run renders looks like one
-   product. Colors mean one thing everywhere: held (green), a mistake in the person's query (red),
-   a gap in the semantic model (violet), could not check (amber), noticed (gray). */
+   product. One palette, one meaning per color, on every pill, mark, chip and diff token:
+     green  (--held)   passed, match, keep
+     red    (--defect) your query: a mistake, a column only yours has
+     violet (--gap)    the semantic model: a gap, a fix to a definition
+     amber  (--open)   the question, or a check that could not run, or a partial match
+     blue   (--agami)  agami's side: a column only agami returned, add an example, ask again, the suggested decision
+     gray   (--noted)  noted, nothing to fix, could not compare */
     :root { --held: #1f7a4d; --held-bg: #e3f3ea; --open: #b7791f; --open-bg: #fbf1dc; --defect: #b3261e; --defect-bg: #f9e3e1;
-            --gap: #6b4fbb; --gap-bg: #ece7fa; --noted: #6b7684; --noted-bg: #eceff3; }
+            --gap: #6b4fbb; --gap-bg: #ece7fa; --noted: #6b7684; --noted-bg: #eceff3; --agami: #1d5fb4; --agami-bg: #e4edfb; }
     @media (prefers-color-scheme: dark) { :root { --held: #5cc48f; --held-bg: #173325; --open: #e0a94a; --open-bg: #3a2e14; --defect: #f08a82; --defect-bg: #3d1c19;
-            --gap: #b39cf2; --gap-bg: #2b2342; --noted: #a2adb9; --noted-bg: #252c35; } }
-    body { margin: 0; font-family: system-ui, -apple-system, 'Segoe UI', sans-serif; background: var(--bg, #f7f7f8); color: var(--fg, #17212b); }
+            --gap: #b39cf2; --gap-bg: #2b2342; --noted: #a2adb9; --noted-bg: #252c35; --agami: #7fb0f0; --agami-bg: #16273d; } }
+    body { margin: 0; font-family: "Segoe UI", system-ui, -apple-system, Roboto, "Helvetica Neue", Arial, sans-serif; background: var(--bg, #f7f7f8); color: var(--fg, #17212b); }
     .wrap { max-width: 1040px; margin: 0 auto; padding: 28px 20px 96px; }
     header { display: flex; align-items: center; justify-content: space-between; gap: 16px; padding-bottom: 18px; border-bottom: 1px solid var(--border, #d9dde3); }
     .logo svg { display: block; height: 26px; width: auto; }
@@ -25,15 +30,17 @@
     .pill.noted { color: var(--noted); background: var(--noted-bg); }
     .chips { display: flex; gap: 10px; flex-wrap: wrap; margin: 14px 0 6px; }
     .chip { display: flex; align-items: baseline; gap: 8px; padding: 8px 12px; border-radius: 8px; background: var(--bg-elev, #fff); border: 1px solid var(--border, #d9dde3); }
-    .chip b { font-size: 20px; font-family: ui-monospace, monospace; font-variant-numeric: tabular-nums; }
+    .chip b { font-size: 20px; font-family: ui-monospace, "Cascadia Mono", "Cascadia Code", Consolas, "SF Mono", Menlo, "Roboto Mono", "Liberation Mono", monospace; font-variant-numeric: tabular-nums; }
     .chip span { color: var(--muted, #5b6875); font-size: 13px; }
     .chip.held b { color: var(--held); } .chip.open b { color: var(--open); } .chip.defect b { color: var(--defect); } .chip.gap b { color: var(--gap); } .chip.noted b { color: var(--noted); }
     /* cards */
     .card { background: var(--bg-elev, #fff); border: 1px solid var(--border, #d9dde3); border-radius: 8px; padding: 14px 16px; margin: 12px 0; }
     .card .head { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; }
     .card .head .title { font-weight: 700; font-size: 16px; }
-    .card .head .n { font-family: ui-monospace, monospace; font-size: 12px; color: var(--muted, #5b6875); }
-    .card .head .nums { margin-left: auto; font-family: ui-monospace, monospace; font-size: 13px; color: var(--muted, #5b6875); font-variant-numeric: tabular-nums; }
+    .card .head .title.q { font-size: 17px; line-height: 1.3; flex: 1 1 320px; }
+    .card .head .state { margin-left: auto; display: inline-flex; align-items: center; gap: 6px; white-space: nowrap; }
+    .card .head .n { font-family: ui-monospace, "Cascadia Mono", "Cascadia Code", Consolas, "SF Mono", Menlo, "Roboto Mono", "Liberation Mono", monospace; font-size: 12px; color: var(--muted, #5b6875); }
+    .card .head .nums { margin-left: auto; font-family: ui-monospace, "Cascadia Mono", "Cascadia Code", Consolas, "SF Mono", Menlo, "Roboto Mono", "Liberation Mono", monospace; font-size: 13px; color: var(--muted, #5b6875); font-variant-numeric: tabular-nums; }
     .card .src { font-size: 13px; color: var(--muted, #5b6875); margin-top: 2px; }
     .beats { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 12px; margin-top: 12px; }
     .beat { border-left: 3px solid var(--border, #d9dde3); padding: 2px 0 2px 10px; font-size: 14px; }
@@ -48,7 +55,7 @@
     .more { margin-top: 10px; display: grid; gap: 8px; }
     .more[hidden] { display: none; }
     .more label { font-size: 13px; color: var(--muted, #5b6875); display: block; }
-    .more textarea { width: 100%; min-height: 64px; font-family: ui-monospace, monospace; font-size: 13px; border: 1px solid var(--border, #d9dde3); border-radius: 6px; padding: 8px; background: var(--bg, #fff); color: inherit; }
+    .more textarea { width: 100%; min-height: 64px; font-family: ui-monospace, "Cascadia Mono", "Cascadia Code", Consolas, "SF Mono", Menlo, "Roboto Mono", "Liberation Mono", monospace; font-size: 13px; border: 1px solid var(--border, #d9dde3); border-radius: 6px; padding: 8px; background: var(--bg, #fff); color: inherit; }
     /* audit */
     .audit { display: grid; grid-template-columns: 1fr 320px; gap: 16px; margin-top: 14px; }
     .audit .q { font-size: 16px; font-weight: 700; margin: 0 0 4px; }
@@ -69,12 +76,12 @@
     .modal { position: fixed; inset: 0; background: rgba(0,0,0,0.45); display: flex; align-items: center; justify-content: center; }
     .modal[hidden] { display: none; }
     .modal-card { background: var(--bg-elev, #fff); border-radius: 10px; padding: 20px; width: min(720px, 92vw); }
-    .modal-card textarea { width: 100%; min-height: 200px; font-family: ui-monospace, monospace; font-size: 13px; }
+    .modal-card textarea { width: 100%; min-height: 200px; font-family: ui-monospace, "Cascadia Mono", "Cascadia Code", Consolas, "SF Mono", Menlo, "Roboto Mono", "Liberation Mono", monospace; font-size: 13px; }
     .modal-actions { display: flex; gap: 10px; align-items: center; margin-top: 10px; }
     .modal-status { font-size: 13px; color: var(--muted, #5b6875); }
     @media (max-width: 820px) { .beats, .audit { grid-template-columns: 1fr; } }
     .intake .row { display: grid; grid-template-columns: 34px 1fr 1fr; gap: 12px; align-items: start; }
-    .intake .k { font-family: ui-monospace, monospace; font-size: 12px; color: var(--muted, #5b6875); }
+    .intake .k { font-family: ui-monospace, "Cascadia Mono", "Cascadia Code", Consolas, "SF Mono", Menlo, "Roboto Mono", "Liberation Mono", monospace; font-size: 12px; color: var(--muted, #5b6875); }
     .intake textarea { width: 100%; min-height: 44px; font: inherit; font-size: 14px; border: 1px solid var(--border, #d9dde3); border-radius: 6px; padding: 6px 8px; background: var(--bg, #fff); color: inherit; }
     .intake .drop { color: var(--muted, #5b6875); font-size: 13px; }
     .intake .row.dropped { opacity: 0.5; }
@@ -95,12 +102,12 @@
     .dg { display: grid; grid-template-columns: 22px minmax(120px, 170px) minmax(0, 1fr) minmax(0, 1fr); margin-top: 10px; font-size: 13.5px; }
     .dg > div { padding: 6px 8px; border-top: 1px solid var(--border, #d9dde3); min-width: 0; }
     .dg .h { border-top: 0; padding-bottom: 2px; font-size: 11px; text-transform: uppercase; letter-spacing: 0.06em; color: var(--muted, #5b6875); font-weight: 600; }
-    .dg .m { font-family: ui-monospace, monospace; font-weight: 700; text-align: center; padding-left: 0; padding-right: 0; }
+    .dg .m { font-family: ui-monospace, "Cascadia Mono", "Cascadia Code", Consolas, "SF Mono", Menlo, "Roboto Mono", "Liberation Mono", monospace; font-weight: 700; text-align: center; padding-left: 0; padding-right: 0; }
     .dg .k { color: var(--muted, #5b6875); overflow-wrap: anywhere; }
-    .dg .v { font-family: ui-monospace, monospace; font-size: 12.5px; overflow-wrap: anywhere; }
+    .dg .v { font-family: ui-monospace, "Cascadia Mono", "Cascadia Code", Consolas, "SF Mono", Menlo, "Roboto Mono", "Liberation Mono", monospace; font-size: 12.5px; overflow-wrap: anywhere; }
     .dg .v .tok + .tok::before { content: ", "; color: var(--muted, #5b6875); }
     .dg .v .hi { text-decoration: underline; text-decoration-thickness: 2px; text-underline-offset: 2px; font-weight: 600; }
-    .dg .held.m { color: var(--held); } .dg .defect.m { color: var(--defect); } .dg .open.m { color: var(--open); } .dg .gap.m { color: var(--gap); } .dg .noted.m { color: var(--noted); }
+    .dg .held.m { color: var(--held); } .dg .defect.m { color: var(--defect); } .dg .differs.m { color: var(--open); } .dg .open.m { color: var(--open); } .dg .gap.m { color: var(--gap); } .dg .noted.m { color: var(--noted); }
     .dg .defect.v .hi, .dg .defect.v.whole { color: var(--defect); text-decoration-color: var(--defect); }
     .dg .open.v { color: var(--open); } .dg .gap.k, .dg .gap.v { color: var(--gap); } .dg .noted.v { color: var(--muted, #5b6875); }
     .dg .n { grid-column: 2 / -1; border-top: 0; padding-top: 0; font-size: 12.5px; color: var(--muted, #5b6875); }
@@ -114,7 +121,7 @@
     .act b { font-size: 11px; text-transform: uppercase; letter-spacing: 0.06em; color: var(--muted, #5b6875); }
     .pill.you { background: var(--defect-bg); color: var(--defect); } .pill.model { background: var(--gap-bg); color: var(--gap); }
     .pill.question { background: var(--open-bg); color: var(--open); } .pill.keep { background: var(--held-bg); color: var(--held); }
-    .pill.agami, .pill.nothing { background: var(--noted-bg); color: var(--noted); }
+    .pill.agami { background: var(--agami-bg); color: var(--agami); } .pill.nothing { background: var(--noted-bg); color: var(--noted); }
     @media (max-width: 640px) { .dg { grid-template-columns: 22px 1fr; } .dg .k { grid-column: 2; } .dg .v { grid-column: 2; border-top: 0; padding-top: 0; } .dg .v.yours::before { content: "yours · "; color: var(--muted, #5b6875); font-family: inherit; } .dg .v.agami::before { content: "agami · "; color: var(--muted, #5b6875); font-family: inherit; } .dg .h { display: none; } }
     /* the decisions: each option says what it is and what happens next; the run's suggestion is tagged */
     .grade.opts { display: grid; gap: 4px; margin-top: 10px; }
@@ -122,7 +129,7 @@
     .grade.opts .opt.on { background: var(--code-bg, #f3f5f7); }
     .grade.opts .opt b { font-weight: 600; white-space: nowrap; }
     .grade.opts .opt .what { color: var(--muted, #5b6875); font-size: 13px; }
-    .tag.suggested { font-size: 11px; font-weight: 600; letter-spacing: 0.02em; background: var(--hi-bg, #e6efff); color: var(--accent, #1d5fb4); border-radius: 999px; padding: 1px 7px; margin-left: 6px; vertical-align: middle; }
+    .tag.suggested { font-size: 11px; font-weight: 600; letter-spacing: 0.02em; background: var(--agami-bg); color: var(--agami); border-radius: 999px; padding: 1px 7px; margin-left: 6px; vertical-align: middle; }
     .more label .p { display: block; font-size: 13px; color: var(--muted, #5b6875); margin-bottom: 4px; }
     @media (max-width: 640px) { .grade.opts .opt { grid-template-columns: 18px 1fr; } .grade.opts .opt .what { grid-column: 2; } }
     /* the two statements, collapsed under the grid */
@@ -138,3 +145,26 @@
     .filters .k { min-width: 44px; }
     .chips[hidden] { display: none; }
     .chips.result:empty { display: none; }
+    /* the checks panel folds; it opens itself when something did not pass */
+    details.checks { margin-top: 8px; }
+    details.checks > summary { cursor: pointer; font-size: 12px; text-transform: uppercase; letter-spacing: 0.06em; color: var(--muted, #5b6875); font-weight: 600; list-style: none; }
+    details.checks > summary::before { content: "▸ "; }
+    details.checks[open] > summary::before { content: "▾ "; }
+    details.checks > summary::-webkit-details-marker { display: none; }
+    /* list cells read like a diff */
+    .dg .v .tok.del { background: var(--defect-bg); color: var(--defect); text-decoration: none; font-weight: 600; padding: 0 4px; border-radius: 4px; }
+    .dg .v .tok.add { background: var(--agami-bg); color: var(--agami); font-weight: 600; padding: 0 4px; border-radius: 4px; }
+    .dg .v .tok.renamed { text-decoration: underline dotted; text-underline-offset: 2px; cursor: help; }
+    /* marks and arrows draw from a font that carries them on Windows too */
+    .dg .m, .mark, .tok.del, .tok.add { font-family: "Segoe UI Symbol", "Segoe UI", ui-monospace, "Cascadia Mono", Consolas, Menlo, monospace; }
+    .dg .v { font-size: 13px; }
+    /* the palette, said once under the filters */
+    .legend { display: flex; flex-wrap: wrap; gap: 4px 14px; margin: 2px 0 10px; font-size: 12px; color: var(--muted, #5b6875); }
+    .legend span::before { content: ""; display: inline-block; width: 9px; height: 9px; border-radius: 50%; margin-right: 5px; vertical-align: middle; background: var(--noted); }
+    .legend .held::before { background: var(--held); } .legend .defect::before { background: var(--defect); } .legend .gap::before { background: var(--gap); }
+    .legend .open::before { background: var(--open); } .legend .agami::before { background: var(--agami); } .legend .noted::before { background: var(--noted); }
+    /* a claim that differs between the two queries: amber, its own mark, the differing tokens marked without blame */
+    .dg .differs.v .tok.diff { background: var(--open-bg); color: var(--open); font-weight: 600; padding: 0 4px; border-radius: 4px; }
+    .dg .differs.k { color: var(--open); }
+    /* a chip whose count fell to zero under the other filters stays, dimmed, so it can still be toggled */
+    .chip.zero, .pill.zero { opacity: 0.45; }
diff --git a/plugins/agami/shared/reconcile-report-template.html b/plugins/agami/shared/reconcile-report-template.html
index 738d3a00..db878068 100644
--- a/plugins/agami/shared/reconcile-report-template.html
+++ b/plugins/agami/shared/reconcile-report-template.html
@@ -23,7 +23,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>{{REPORT_TITLE}} — agami</title>
+  <title>{{REPORT_TITLE}} · agami</title>
   <style>
 {{THEME_CSS}}
 {{PAGE_CSS}}
@@ -47,6 +47,7 @@ <h1>{{REPORT_TITLE}}</h1>
     <div class="filters" id="result-row" hidden>
       <span class="k">Result</span><span class="chips result" id="result-chips"></span>
     </div>
+    <div class="legend" aria-label="what the colors mean"><span class="held">passed</span><span class="defect">your query</span><span class="gap">the semantic model</span><span class="open">the question, or could not check</span><span class="agami">agami</span><span class="noted">noted</span></div>
     <div class="filters" id="filters">
       <span class="k">Fix</span><span id="owner-chips"></span>
       <span class="k">Find</span><input type="search" id="q" placeholder="a word in the question, a check or a value" aria-label="narrow the rows by a word">
@@ -64,7 +65,7 @@ <h1>{{REPORT_TITLE}}</h1>
   <div class="modal" id="modal" hidden>
     <div class="modal-card">
       <h2>Send to Claude</h2>
-      <p class="meta">Copy this block and paste it back into Claude. "keep" is your yes to the offer for that row. "change" sends a definition to save-correction, with your words. "fix" and "reword" come back to you. "nothing" changes nothing.</p>
+      <p class="meta">Copy this block and paste it back into Claude. "keep" is your yes to the offer for that row. "change" sends a definition to save-correction, with your words. "fix" and "reword" come back to you. "example" sends your query to save-correction as a prompt example. "nothing" changes nothing.</p>
       <textarea id="modal-text" readonly></textarea>
       <div class="modal-actions">
         <button type="button" id="modal-copy" class="primary">Copy to clipboard</button>
@@ -98,7 +99,9 @@ <h2>Send to Claude</h2>
       return '<span class="pill ' + cls + '">' + esc(item.result.label) + '</span>'
         + (n ? '<span class="tag unchecked">' + n + (n === 1 ? ' check' : ' checks') + ' not run</span>' : '');
     }
-    const FIX_WORDS = { query: 'fix your query', semantic_model: 'fix the semantic model', examples: 'add an example', question: 'reword the question', ask_again: 'ask agami again', none: 'nothing to fix' };
+    // The fix words come from the items themselves (report-items writes fix_words); one home for six strings.
+    const FIX_WORDS = {};
+    DATA.items.forEach(i => { if (i.fix && i.fix_words) FIX_WORDS[i.fix] = i.fix_words; });
     const FIX_CLASS = { query: 'you', semantic_model: 'model', examples: 'agami', question: 'question', ask_again: 'agami', none: 'keep' };
     function fixOf(item) { return item.fix || ({ you: 'query', model: 'semantic_model', question: 'question', agami: 'ask_again', keep: 'none', nothing: 'none' }[item.owner || 'nothing']); }
     function nums(item) {
@@ -118,19 +121,23 @@ <h2>Send to Claude</h2>
              prompt: 'What you will fix, in a few words (optional)', ph: 'e.g. the status value is lower-case delivered' },
       reword: { word: 'reword the question', what: 'The question was read differently from what you meant. Ask it in other words.',
                 prompt: 'The question, in the words you mean', ph: 'e.g. How many orders were placed in Q3 2025, cancelled ones included?' },
+      example: { word: 'add an example', what: 'Your query goes to /agami-save-correction as a prompt example for this question, so agami writes it your way next time.',
+                 prompt: 'Anything to add for the example (optional)', ph: 'e.g. use this whenever the question says "open"' },
       nothing: { word: 'nothing', what: 'Leave this row as it is.' },
     };
+    // What each box starts with, from the run's own words for this row; the person edits or clears it.
+    function prefillFor(item, decision) { return ((item.prefill || {})[decision]) || ''; }
     const SUGGEST = { keep: 'keep', model: 'change', you: 'fix', question: 'reword', agami: 'nothing', nothing: 'nothing' };
     function controls(item, d) {
-      const choices = (item.keep_allowed ? ['keep'] : []).concat(['change', 'fix', 'reword', 'nothing']);
-      const byFix = { query: 'fix', semantic_model: 'change', examples: item.keep_allowed ? 'keep' : 'change', question: 'reword', ask_again: 'nothing', none: item.keep_allowed ? 'keep' : 'nothing' };
+      const choices = (item.keep_allowed ? ['keep'] : []).concat(['change', 'fix', 'reword', 'example', 'nothing']);
+      const byFix = { query: 'fix', semantic_model: 'change', examples: item.keep_allowed ? 'keep' : 'example', question: 'reword', ask_again: 'nothing', none: item.keep_allowed ? 'keep' : 'nothing' };
       const suggested = item.fix ? byFix[item.fix] : ((SUGGEST[item.owner] === 'keep' && !item.keep_allowed) ? 'nothing' : (SUGGEST[item.owner] || null));
       const spec = DECISIONS[d.decision] || {};
       return '<div class="grade opts">' + choices.map(v =>
           '<label class="opt' + (d.decision === v ? ' on' : '') + '"><input type="radio" name="d' + item.row + '" value="' + v + '"' + (d.decision === v ? ' checked' : '') + '>'
           + '<b>' + esc(DECISIONS[v].word) + (v === suggested ? ' <span class="tag suggested">suggested</span>' : '') + '</b>'
           + '<span class="what">' + esc(DECISIONS[v].what) + '</span></label>').join('') + '</div>'
-        + '<div class="more"' + (['change', 'fix', 'reword'].includes(d.decision) ? '' : ' hidden') + '>'
+        + '<div class="more"' + (['change', 'fix', 'reword', 'example'].includes(d.decision) ? '' : ' hidden') + '>'
         + '<label><span class="p">' + esc(spec.prompt || 'Say it in words') + '</span><textarea data-field="words" placeholder="' + esc(spec.ph || '') + '">' + esc(d.words || '') + '</textarea></label></div>';
     }
     // What is shown. A filter narrows the cards, never the block: decided() reads every row.
@@ -143,27 +150,31 @@ <h2>Send to Claude</h2>
         .concat((item.diff || []).flatMap(r => [r.key, r.note].concat(r.yours || [], r.agami || [])));
       return parts.filter(Boolean).join(' ').toLowerCase();
     }
-    function visible() {
+    // Whether a row passes the filters. `ignore` names one filter to leave out: each chip row counts
+    // the rows the OTHER filters leave, so the Fix counts follow the Result filter and the search, and
+    // the Result counts follow the Fix filter, the way facets do.
+    function passes(item, ignore) {
       const q = view.q.trim().toLowerCase();
-      return DATA.items.filter(item => (!view.status.size || view.status.has(statusClass(item)))
-        && (!view.result.size || view.result.has((item.result || {}).label || ''))
-        && (!view.owner.size || view.owner.has(item.fix ? fixOf(item) : (item.owner || 'nothing')))
-        && (!q || haystack(item).includes(q)));
+      return (ignore === 'status' || !view.status.size || view.status.has(statusClass(item)))
+        && (ignore === 'result' || !view.result.size || view.result.has((item.result || {}).label || ''))
+        && (ignore === 'owner' || !view.owner.size || view.owner.has(item.fix ? fixOf(item) : (item.owner || 'nothing')))
+        && (!q || haystack(item).includes(q));
     }
+    function visible() { return DATA.items.filter(item => passes(item)); }
     function chips() {
       const counts = {};
-      DATA.items.forEach(i => { const cls = statusClass(i); counts[cls] = (counts[cls] || 0) + 1; });
+      DATA.items.forEach(i => { const cls = statusClass(i); counts[cls] = (counts[cls] || 0) + (passes(i, 'status') ? 1 : 0); });
       const words = { held: 'match', defect: 'a mistake on your side', gap: 'differs', open: 'could not check', noted: 'did not run' };
       // The result chips filter like every other chip; when the items carry result labels they are
       // the one filter row, and the older status chips step aside.
       const labels = {};
       const RESULT_CLASS = { 'match': 'held', 'same answer, different query': 'open', 'same rows, different columns': 'open',
                              'different answer': 'defect', 'same query, different answer': 'defect', 'could not run': 'noted' };
-      DATA.items.forEach(i => { if (i.result && i.result.label) labels[i.result.label] = (labels[i.result.label] || 0) + 1; });
+      DATA.items.forEach(i => { if (i.result && i.result.label) labels[i.result.label] = (labels[i.result.label] || 0) + (passes(i, 'result') ? 1 : 0); });
       const results = document.getElementById('result-chips');
       results.classList.toggle('filtering', view.result.size > 0);
       results.innerHTML = Object.entries(labels).map(([label, n]) =>
-        '<button type="button" class="chip ' + (RESULT_CLASS[label] || 'noted') + (view.result.has(label) ? ' on' : '') + '" data-result="' + esc(label) + '" aria-pressed="' + view.result.has(label) + '"><b>' + n + '</b><span>' + esc(label) + '</span></button>').join('');
+        '<button type="button" class="chip ' + (RESULT_CLASS[label] || 'noted') + (view.result.has(label) ? ' on' : '') + (n ? '' : ' zero') + '" data-result="' + esc(label) + '" aria-pressed="' + view.result.has(label) + '"><b>' + n + '</b><span>' + esc(label) + '</span></button>').join('');
       results.querySelectorAll('[data-result]').forEach(el => el.addEventListener('click', () => { toggle(view.result, el.dataset.result); renderItems(); }));
       // `root` (the status chips) is declared further down in this function; reach it by id here.
       document.getElementById('chips').hidden = Object.keys(labels).length > 0;
@@ -171,15 +182,15 @@ <h2>Send to Claude</h2>
       const root = document.getElementById('chips');
       root.classList.toggle('filtering', view.status.size > 0);
       root.innerHTML = Object.entries(counts).map(([cls, n]) =>
-        '<button type="button" class="chip ' + cls + (view.status.has(cls) ? ' on' : '') + '" data-filter="' + cls + '" aria-pressed="' + view.status.has(cls) + '"><b>' + n + '</b><span>' + esc(words[cls] || cls) + '</span></button>').join('');
+        '<button type="button" class="chip ' + cls + (view.status.has(cls) ? ' on' : '') + (n ? '' : ' zero') + '" data-filter="' + cls + '" aria-pressed="' + view.status.has(cls) + '"><b>' + n + '</b><span>' + esc(words[cls] || cls) + '</span></button>').join('');
       root.querySelectorAll('[data-filter]').forEach(el => el.addEventListener('click', () => { toggle(view.status, el.dataset.filter); renderItems(); }));
       const owners = {};
-      DATA.items.forEach(i => { const o = i.fix ? fixOf(i) : (i.owner || 'nothing'); owners[o] = (owners[o] || 0) + 1; });
+      DATA.items.forEach(i => { const o = i.fix ? fixOf(i) : (i.owner || 'nothing'); owners[o] = (owners[o] || 0) + (passes(i, 'owner') ? 1 : 0); });
       const bar = document.getElementById('filters');
       bar.hidden = DATA.layout === 'audit' || DATA.items.length < 2;
       bar.classList.toggle('filtering', view.owner.size > 0);
       document.getElementById('owner-chips').innerHTML = Object.entries(owners).map(([o, n]) =>
-        '<button type="button" class="pill ' + esc(FIX_CLASS[o] || o) + (view.owner.has(o) ? ' on' : '') + '" data-owner="' + esc(o) + '" aria-pressed="' + view.owner.has(o) + '">' + n + ' · ' + esc(FIX_WORDS[o] || OWNER_SHORT[o] || o) + '</button>').join(' ');
+        '<button type="button" class="pill ' + esc(FIX_CLASS[o] || o) + (view.owner.has(o) ? ' on' : '') + (n ? '' : ' zero') + '" data-owner="' + esc(o) + '" aria-pressed="' + view.owner.has(o) + '">' + n + ' · ' + esc(FIX_WORDS[o] || OWNER_SHORT[o] || o) + '</button>').join(' ');
       document.getElementById('owner-chips').querySelectorAll('[data-owner]').forEach(el => el.addEventListener('click', () => { toggle(view.owner, el.dataset.owner); renderItems(); }));
     }
     function toggle(set, key) { if (set.has(key)) set.delete(key); else set.add(key); }
@@ -189,23 +200,37 @@ <h2>Send to Claude</h2>
     }
     // The diff grid: one grid row per check, mark | what was checked | yours | agami, so a tall cell on
     // one side never pushes the other out of line. Differing tokens are highlighted in place.
-    const MARK = { held: '✓', defect: '✗', open: '○', gap: '▲', noted: '·' };
-    const MARK_WORDS = { held: 'passed', defect: 'does not match', open: 'could not check', gap: 'gap in the semantic model', noted: 'noted' };
-    function cell(v, hi, side, state) {
+    const MARK = { held: '✓', defect: '✗', open: '○', gap: '▲', noted: '·', differs: '≠' };
+    const MARK_WORDS = { held: 'passed', defect: 'does not match', open: 'could not check', gap: 'gap in the semantic model', noted: 'noted', differs: 'the two queries differ' };
+    // A list cell reads like a diff: a token only on this side is removed (yours, red, a minus) or
+    // added (agami, green, a plus); a token whose partner on the other side has another name is
+    // marked in place, with the partner's name on hover. No sentence repeats what the marks show.
+    function cell(v, hi, side, state, renamed) {
       const cls = 'v ' + side + ' ' + state + (Array.isArray(v) || !(hi || []).length ? '' : ' whole');
       if (v == null) return '<div class="' + cls + '"></div>';
-      if (Array.isArray(v)) return '<div class="' + cls + '">' + v.map(tok => '<span class="tok' + ((hi || []).includes(tok) ? ' hi' : '') + '">' + esc(tok) + '</span>').join('') + '</div>';
+      if (Array.isArray(v)) {
+        const partner = {};
+        (renamed || []).forEach(([a, b]) => { if (side === 'yours') partner[a] = b; else partner[b] = a; });
+        return '<div class="' + cls + '">' + v.map(tok => {
+          if ((hi || []).includes(tok)) return '<span class="tok ' + (state === 'differs' ? 'diff' : (side === 'yours' ? 'del' : 'add')) + '">' + (state === 'differs' ? '' : (side === 'yours' ? '−' : '+')) + esc(tok) + '</span>';
+          if (partner[tok]) return '<span class="tok renamed" title="same values as ' + esc(partner[tok]) + '">' + esc(tok) + '</span>';
+          return '<span class="tok">' + esc(tok) + '</span>';
+        }).join('') + '</div>';
+      }
       return '<div class="' + cls + '">' + ((hi || []).includes(v) ? '<span class="hi">' + esc(v) + '</span>' : esc(v)) + '</div>';
     }
     function diffGrid(item) {
       const rows = item.diff || [];
-      return '<div class="dg" role="table" aria-label="what was checked, yours beside agami">'
+      const passed = rows.filter(r => r.state === 'held').length;
+      const open = rows.length - passed;
+      return '<details class="checks"><summary>Checks: ' + passed + ' passed' + (open ? ', ' + open + ' did not' : '') + '</summary>'
+        + '<div class="dg" role="table" aria-label="what was checked, yours beside agami">'
         + '<div class="h"></div><div class="h">checked</div><div class="h">yours</div><div class="h">agami</div>'
         + rows.map(r => '<div class="m ' + esc(r.state) + '" title="' + esc(MARK_WORDS[r.state] || r.state) + '">' + (MARK[r.state] || '·') + '</div>'
             + '<div class="k ' + esc(r.state) + '">' + esc(r.key) + '</div>'
-            + cell(r.yours, r.yours_hi, 'yours', r.state) + cell(r.agami, r.agami_hi, 'agami', r.state)
-            + (r.note && r.state !== 'held' ? '<div class="n ' + esc(r.state) + '">' + esc(r.note) + '</div>' : '')).join('')
-        + '</div>';
+            + cell(r.yours, r.yours_hi, 'yours', r.state, r.renamed) + cell(r.agami, r.agami_hi, 'agami', r.state, r.renamed)
+            + (r.note && (r.state !== 'held' || r.key === 'columns') ? '<div class="n ' + esc(r.state) + '">' + esc(r.note) + '</div>' : '')).join('')
+        + '</div></details>';
     }
     // The two statements, collapsed: the person's own SQL shown to its author, and agami's, which
     // the receipt already shows. Never a result row.
@@ -228,9 +253,8 @@ <h2>Send to Claude</h2>
     function diffCard(item) {
       const d = decisions[item.row] || {};
       return '<div class="card" data-row="' + item.row + '">'
-        + '<div class="head"><span class="n">#' + item.row + '</span><span class="title">' + esc(item.label || item.question) + '</span>' + resultPill(item)
-        + (item.source ? '<span class="src">' + esc(item.source) + '</span>' : '') + '</div>'
-        + (item.label ? '<div class="src">' + esc(item.question) + '</div>' : '')
+        + '<div class="head"><span class="n">#' + item.row + '</span><span class="title q">' + esc(item.question) + '</span><span class="state">' + resultPill(item) + '</span></div>'
+        + ((item.label || item.source) ? '<div class="src">' + esc([item.label, item.source].filter(Boolean).join(' · ')) + '</div>' : '')
         + diffGrid(item)
         + (item.sentence ? '<div class="sentence">' + esc(item.sentence) + '</div>' : '')
         + sqlBlock(item) + words(item) + action(item, d)
@@ -240,9 +264,8 @@ <h2>Send to Claude</h2>
     function diffAudit(item) {
       const d = decisions[item.row] || {};
       return '<div class="card" data-row="' + item.row + '">'
-        + '<div class="head"><span class="n">#' + item.row + '</span><span class="title">' + esc(item.label || item.question) + '</span>' + resultPill(item)
-        + (item.source ? '<span class="src">' + esc(item.source) + '</span>' : '') + '</div>'
-        + (item.label ? '<div class="src">' + esc(item.question) + '</div>' : '')
+        + '<div class="head"><span class="n">#' + item.row + '</span><span class="title q">' + esc(item.question) + '</span><span class="state">' + resultPill(item) + '</span></div>'
+        + ((item.label || item.source) ? '<div class="src">' + esc([item.label, item.source].filter(Boolean).join(' · ')) + '</div>' : '')
         + '<div class="audit"><div>' + diffGrid(item) + (item.sentence ? '<div class="sentence">' + esc(item.sentence) + '</div>' : '') + sqlBlock(item) + words(item) + '</div>'
         + '<div class="rail"><b>What to do</b>' + lines(item.todo && item.todo.length ? item.todo : item.change) + action(item, d) + '</div></div>'
         + (item.report_path ? '<div class="receipt meta">receipt: ' + esc(item.report_path) + '</div>' : '')
@@ -298,11 +321,16 @@ <h2>Send to Claude</h2>
     }
     function onDecide(e) {
       const card = e.target.closest('.card'); const row = Number(card.dataset.row);
-      decisions[row] = Object.assign(decisions[row] || {}, { decision: e.target.value });
+      const item = DATA.items.find(i => i.row === row) || {};
+      const prior = decisions[row] || {};
+      // A box the person has not typed in starts with the run's words for the new decision.
+      const untouched = !prior.words || prior.words === prefillFor(item, prior.decision);
+      decisions[row] = Object.assign(prior, { decision: e.target.value, words: untouched ? prefillFor(item, e.target.value) : prior.words });
       const more = card.querySelector('.more'); const spec = DECISIONS[e.target.value] || {};
-      more.hidden = !['change', 'fix', 'reword'].includes(e.target.value);
+      more.hidden = !['change', 'fix', 'reword', 'example'].includes(e.target.value);
       more.querySelector('.p').textContent = spec.prompt || 'Say it in words';
       more.querySelector('textarea').placeholder = spec.ph || '';
+      if (untouched) more.querySelector('textarea').value = decisions[row].words || '';
       card.querySelectorAll('.opt').forEach(el => el.classList.toggle('on', el.querySelector('input').value === e.target.value));
       renderSummary();
     }
diff --git a/plugins/agami/skills/agami-reconcile/SKILL.md b/plugins/agami/skills/agami-reconcile/SKILL.md
index bc5de150..a0f5ce82 100644
--- a/plugins/agami/skills/agami-reconcile/SKILL.md
+++ b/plugins/agami/skills/agami-reconcile/SKILL.md
@@ -368,7 +368,7 @@ Beat 4 names the side: "your query" for a defect, "the semantic model" for a gap
    ```bash
    python3 "$AGAMI_PLUGIN_ROOT/scripts/parse_reconcile_report.py" --block-file /tmp/agami-reconcile-decisions-<ts>.txt --run-dir "<artifacts_dir>/local/reconcile/<ts>"
    ```
-   A `needs_judgment` means the block did not parse, came from another run, or carries a decision that could not be applied as written (a keep the run does not allow, words beside a keep, a misspelt decision): ask for it again, apply nothing. Then, per decision: **`keep`** is the person's yes to Phase 3e's offer for that row, applied through 3e's own doors and its own rules (the split, the band, one call per row); **`change`** takes the finding and the person's words to `/agami-save-correction`, one definition at a time; **`fix`** and **`reword`** come back to the person as the next thing to do, with the row's beat 4 repeated; **`nothing`** changes nothing. No decision writes anything this skill does not already write.
+   A `needs_judgment` means the block did not parse, came from another run, or carries a decision that could not be applied as written (a keep the run does not allow, words beside a keep, a misspelt decision): ask for it again, apply nothing. Then, per decision: **`keep`** is the person's yes to Phase 3e's offer for that row, applied through 3e's own doors and its own rules (the split, the band, one call per row); **`change`** takes the finding and the person's words to `/agami-save-correction`, one definition at a time; **`example`** takes the person's statement and its question to `/agami-save-correction` as a prompt example, with the words as its note, so agami writes the query their way next time (the same door 3e's keep uses for an example, without 3e's split); **`fix`** and **`reword`** come back to the person as the next thing to do, with the row's beat 4 repeated; **`nothing`** changes nothing. No decision writes anything this skill does not already write.
 
 ### 3b — Mismatches table (lead with what didn't match)
 
diff --git a/tests/test_comparator_column_pairs.py b/tests/test_comparator_column_pairs.py
new file mode 100644
index 00000000..eef6932f
--- /dev/null
+++ b/tests/test_comparator_column_pairs.py
@@ -0,0 +1,37 @@
+"""The comparator names which golden column paired with which generated column, by values, and which
+generated columns paired with none; a renamed column is the same column, not a missing one."""
+
+from __future__ import annotations
+
+import dataclasses
+from decimal import Decimal
+
+from semantic_model.comparator import ExecResult, compare_result_sets
+
+
+def test_renamed_and_extra_columns_are_reported_as_pairs_and_extras():
+    golden = ExecResult(columns=["number", "status", "channel"], rows=[("A1", "paid", "web"), ("A2", "open", "shop")])
+    generated = ExecResult(columns=["o.number", "o.status", "region"], rows=[("A1", "paid", "EU"), ("A2", "open", "US")])
+    score = compare_result_sets(golden, generated, match="values")
+    assert score.accuracy == 0.0 and score.unmatched_golden_columns == ("channel",)
+    assert score.column_pairs == (("number", "o.number"), ("status", "o.status")) and score.unmatched_generated_columns == ("region",)
+    generated2 = ExecResult(columns=["o.number", "o.status", "o.channel", "region"], rows=[("A1", "paid", "web", "EU"), ("A2", "open", "shop", "US")])
+    score2 = compare_result_sets(golden, generated2, match="values")
+    assert score2.accuracy == 1.0 and score2.column_pairs == (("number", "o.number"), ("status", "o.status"), ("channel", "o.channel"))
+    assert score2.unmatched_generated_columns == ("region",) and score2.unmatched_golden_columns == ()
+
+
+def test_a_scalar_pair_serialises_and_other_levels_report_nothing():
+    score = compare_result_sets(ExecResult(columns=["revenue"], rows=[(Decimal("10"),)]), ExecResult(columns=["total"], rows=[(Decimal("10"),)]), match="values")
+    d = dataclasses.asdict(score)
+    assert list(map(list, d["column_pairs"])) == [["revenue", "total"]] and d["unmatched_generated_columns"] == ()
+    shape = compare_result_sets(ExecResult(columns=["a"], rows=[(1,)]), ExecResult(columns=["b"], rows=[(2,)]), match="shape")
+    assert shape.column_pairs == () and shape.unmatched_generated_columns == ()
+
+
+def test_different_row_counts_report_no_pairs_and_no_extras():
+    golden = ExecResult(columns=["department", "pending_items"], rows=[("a", 1), ("b", 2)])
+    generated = ExecResult(columns=["department", "pending_items"], rows=[("a", 1), ("b", 2), ("c", 3)])
+    score = compare_result_sets(golden, generated, match="values")
+    assert score.accuracy == 0.0 and score.column_pairs == () and score.unmatched_generated_columns == () and score.unmatched_golden_columns == ()
+
diff --git a/tests/test_golden_claims.py b/tests/test_golden_claims.py
index ed5b36d5..6b23cc05 100644
--- a/tests/test_golden_claims.py
+++ b/tests/test_golden_claims.py
@@ -162,7 +162,7 @@ def test_an_order_by_keeps_the_order_it_was_written_in(self, engine):
         other = gc.read_claims("SELECT region FROM orders ORDER BY status, region", dialect=dialect)
 
         assert one.ordering != other.ordering
-        assert one.ordering == (("region", "asc"), ("status", "asc"))
+        assert one.ordering == (("orders.region", "asc"), ("orders.status", "asc"))
 
     def test_an_unparseable_statement_is_read_as_unreadable_rather_than_as_empty(self, engine):
         """The reason `unreadable` exists: an empty claim set must never be asked to mean both
diff --git a/tests/test_golden_claims_bare_columns.py b/tests/test_golden_claims_bare_columns.py
new file mode 100644
index 00000000..849d8bef
--- /dev/null
+++ b/tests/test_golden_claims_bare_columns.py
@@ -0,0 +1,23 @@
+"""An unqualified column in a single-table statement reads as that table's column, so `ORDER BY opened`
+and `ORDER BY r.opened` are one claim; with two tables in scope it stays bare."""
+
+from __future__ import annotations
+
+from semantic_model import golden_claims as gc
+
+
+def _by_name(a: str, b: str, dialect: str = "postgres") -> dict:
+    return {c.name: c.status for c in gc.compare_statements(a, b, dialect=dialect).claims}
+
+
+def test_bare_and_qualified_spellings_agree_on_one_table():
+    a = "SELECT number FROM requests r WHERE r.state = 'open' ORDER BY r.opened"
+    b = "SELECT number FROM requests WHERE state = 'open' ORDER BY opened"
+    by = _by_name(a, b)
+    assert by["filter_predicates"] == gc.AGREES and by["ordering"] == gc.AGREES
+    assert gc.read_claims(b, dialect="postgres").filter_predicates == frozenset({"eq(requests.state, 'open')"})
+
+
+def test_with_two_tables_a_bare_column_stays_bare():
+    sql = "SELECT r.number FROM requests r JOIN items i ON i.request_id = r.id WHERE state = 'open'"
+    assert "eq(state, 'open')" in gc.read_claims(sql, dialect="postgres").filter_predicates  # bare: two tables could own it
diff --git a/tests/test_golden_claims_relative_windows.py b/tests/test_golden_claims_relative_windows.py
index f51c89b2..4f7ba048 100644
--- a/tests/test_golden_claims_relative_windows.py
+++ b/tests/test_golden_claims_relative_windows.py
@@ -80,3 +80,13 @@ def test_between_reads_relative_bounds_and_a_two_digit_year_stays_a_date():
     w = gc.read_claims("SELECT COUNT(*) FROM orders WHERE EXTRACT(YEAR FROM order_date) = 25", dialect="postgres").date_window
     assert w is not None and w.start == "0025-01-01" and not gc._symbolic(w.start)
 
+
+def test_a_pathological_relative_bound_reads_none_and_never_raises():
+    deep = "SELECT x FROM t WHERE d >= CURRENT_DATE" + " + INTERVAL '1' DAY" * 3000
+    assert gc.read_claims(deep, dialect="postgres").date_window is None
+    nested = "SELECT x FROM t WHERE d >= " + "CAST(" * 3000 + "CURRENT_DATE" + " AS DATE)" * 3000
+    claims = gc.read_claims(nested, dialect="postgres")
+    assert claims.date_window is None
+    # a window a handful of steps deep still folds
+    assert _window("o.order_date >= (CURRENT_DATE - INTERVAL '1' DAY) - INTERVAL '2' DAY").start == "today - 1 day - 2 day"
+
diff --git a/tests/test_parse_reconcile_report.py b/tests/test_parse_reconcile_report.py
index b97ad262..02466c96 100644
--- a/tests/test_parse_reconcile_report.py
+++ b/tests/test_parse_reconcile_report.py
@@ -125,3 +125,20 @@ def test_words_that_are_not_text_drop_the_decision():
     data, anomalies, needs = pr.parse(text, set(), "r")
     assert data["decisions"] == [] and {a["kind"] for a in anomalies} == {"words_not_text"} and needs is not None
 
+
+def test_the_example_decision_is_accepted_with_or_without_words():
+    text = "profile: demo\nreconcile-run: r\ndecisions:\n" + json.dumps([{"row": 1, "decision": "example"}, {"row": 2, "decision": "example", "words": "for the refund question"}]) + "\ndone\n"
+    data, anomalies, needs = pr.parse(text, set(), "r")
+    assert needs is None and anomalies == []
+    assert data["decisions"] == [{"row": 1, "decision": "example"}, {"row": 2, "decision": "example", "words": "for the refund question"}]
+
+
+def test_an_example_is_never_offered_on_a_row_whose_ledger_holds_a_mistake(tmp_path):
+    run = tmp_path / "20260913-101500"; (run / "rows" / "1").mkdir(parents=True); (run / "rows" / "2").mkdir(parents=True)
+    (run / "rows" / "1" / "ledger.json").write_text(json.dumps({"rows": [{"part": "literal:orders.status='Delivered'", "verdict": "query_defect"}]}))
+    (run / "rows" / "2" / "ledger.json").write_text(json.dumps({"rows": [{"part": "runs", "verdict": "confirmed"}]}))
+    assert pr.example_blocked_rows(run) == {1}
+    text = "profile: demo\nreconcile-run: 20260913-101500\ndecisions:\n" + json.dumps([{"row": 1, "decision": "example"}, {"row": 2, "decision": "example"}]) + "\ndone\n"
+    data, anomalies, needs = pr.parse(text, set(), "20260913-101500", example_blocked=pr.example_blocked_rows(run))
+    assert data["decisions"] == [{"row": 2, "decision": "example"}] and {a["kind"] for a in anomalies} == {"example_not_offered"} and needs is not None
+
diff --git a/tests/test_reconcile_learning_loop_skill.py b/tests/test_reconcile_learning_loop_skill.py
index 21d0e972..e2ee680f 100644
--- a/tests/test_reconcile_learning_loop_skill.py
+++ b/tests/test_reconcile_learning_loop_skill.py
@@ -348,3 +348,8 @@ def test_the_items_file_carries_the_result_and_the_fix():
     table = _between(SKILL, "### 2d", "### 2e")
     assert 'A query written differently from agami\'s is not this' in table and '"same answer, different query"' in table
 
+
+def test_the_example_decision_has_a_route():
+    story = _between(SKILL, "### 3a.5", "### 3b")
+    assert "**`example`** takes the person's statement and its question to `/agami-save-correction` as a prompt example" in story
+
diff --git a/tests/test_reconcile_page_filters.py b/tests/test_reconcile_page_filters.py
index f09029b9..c88271c9 100644
--- a/tests/test_reconcile_page_filters.py
+++ b/tests/test_reconcile_page_filters.py
@@ -67,3 +67,10 @@ def test_each_filter_row_on_the_report_page_is_labelled():
     for token in ('<span class="k">Result</span>', '<span class="k">Fix</span>', '<span class="k">Find</span>', '>Clear filters</button>', 'id="result-row"'):
         assert token in html, token
 
+
+def test_each_chip_row_counts_the_rows_the_other_filters_leave():
+    html = rr.render(title="t", profile="p", run="r", items=CARDS)
+    assert "function passes(item, ignore)" in html and "function visible() { return DATA.items.filter(item => passes(item)); }" in html
+    assert "(passes(i, 'owner') ? 1 : 0)" in html and "(passes(i, 'result') ? 1 : 0)" in html and "(passes(i, 'status') ? 1 : 0)" in html
+    assert "(n ? '' : ' zero')" in html
+
diff --git a/tests/test_reconcile_pages_load_in_node.py b/tests/test_reconcile_pages_load_in_node.py
index 045e8fc0..c93bd0a7 100644
--- a/tests/test_reconcile_pages_load_in_node.py
+++ b/tests/test_reconcile_pages_load_in_node.py
@@ -4,6 +4,7 @@
 
 from __future__ import annotations
 
+import os
 import re
 import shutil
 import subprocess
@@ -20,6 +21,8 @@
 import render_reconcile_report as rr  # noqa: E402
 
 NODE = shutil.which("node")
+if NODE is None and os.environ.get("CI"):
+    raise RuntimeError("node is required on CI for the page load tests; add a setup-node step")
 
 # A document that answers every call the pages make at load time with an inert element. Structure is
 # not modelled: the point is that the script's own code runs, not that the DOM is right.
diff --git a/tests/test_reconcile_report_items.py b/tests/test_reconcile_report_items.py
index e9c01268..c9f43cdd 100644
--- a/tests/test_reconcile_report_items.py
+++ b/tests/test_reconcile_report_items.py
@@ -86,7 +86,7 @@ def test_a_table_that_differs_in_columns_names_the_extra_columns_and_blames_the_
     # The same rows come back; only the columns the person's query returns differ: the query is what to change.
     assert item["owner"] == "you" and item["single_cell"] is False and item["expected"] == "21 rows"
     assert item["change"] == ["Your query returns columns the question did not ask for: planned_ship_date, delivered_at, channel. Remove them, or name them in the question."]
-    assert rows["values"]["yours"] == "100% of the values match" or rows["values"]["state"] == "held"
+    assert rows["values"]["state"] == "held" and rows["values"]["yours"] == "identical, row for row"
     assert item["sentence"].startswith("The two answers do not match. What differs: columns")
 
 
@@ -283,7 +283,7 @@ def test_the_first_reviews_findings(tmp_path):
     run = _run(tmp_path, [agami_extra, doubtful, unreadable, no_status, twice_a, twice_b])
     items = {i["row"]: i for i in reconcile.report_items(run)}
     cols = next(r for r in items[1]["diff"] if r["key"] == "columns")
-    assert cols["state"] == "noted" and cols["agami_hi"] == ["extra"] and cols["note"] == "agami returned columns your query did not: extra"
+    assert cols["state"] == "noted" and cols["agami_hi"] == ["extra"] and cols["note"] is None  # the tokens carry it, diff-style
     assert items[1]["owner"] != "you" and "every check passed" in items[1]["sentence"]
     assert items[2]["change"][0] == "Fix your query: value orders.status='Delivered'. Then run this row again."
     assert "tables read" not in items[2]["sentence"] and "value orders.status='Delivered'" in items[2]["sentence"]
diff --git a/tests/test_reconcile_result_and_fix.py b/tests/test_reconcile_result_and_fix.py
index 32523c83..32f4d703 100644
--- a/tests/test_reconcile_result_and_fix.py
+++ b/tests/test_reconcile_result_and_fix.py
@@ -59,13 +59,13 @@ def test_every_result_label_and_its_fix(tmp_path):
     }
     assert items[2]["sentence"].endswith("The two queries differ in: filters; the match may not hold on other data.")
     assert items[3]["sentence"].endswith("The two queries differ in: ordered by; a cosmetic difference.")
-    assert items[2]["owner"] == "agami" and items[2]["fix_words"] == "add an example"
+    assert items[2]["owner"] == "keep" and items[2]["keep_allowed"] is True and items[2]["fix_words"] == "add an example"  # the gate's word, whatever the fix
     assert items[2]["change"][0].startswith("Add your query as a prompt example")
     assert items[1]["owner"] == "keep" and items[1]["keep_allowed"] is True and items[1]["fix_words"] == "nothing to fix"
     assert items[3]["keep_allowed"] is True  # a cosmetic difference does not block the keep offer
     assert items[5]["change"][0].startswith("Ask the question again; the same query gave a different answer")
     assert items[8]["change"][0].startswith("Ask the question again in other words; agami's query failed")
-    assert items[4]["result"]["unchecked"] == 2  # the open date window part, and the unknown claim
+    assert items[4]["result"]["unchecked"] == 1  # the date window: one check, counted once
     assert items[4]["result"]["differs_in"] == ["columns"]
 
 
@@ -91,3 +91,52 @@ def test_a_doubtful_fit_is_the_questions_fix_even_when_the_answer_matches(tmp_pa
     assert item["result"]["label"] == "same answer, different query" and item["fix"] == "question" and item["keep_allowed"] is False
     assert item["change"][0].startswith("Reword the question, or change your query, so they ask the same thing.")
 
+
+def test_columns_are_compared_by_data_and_a_renamed_column_is_the_same_column(tmp_path):
+    """The comparator pairs columns by values. Yours with three extra columns, all others paired under
+    other names, is "same rows, different columns", and the pairs are named; a table whose every
+    column paired is a match even when every name differs."""
+    partly = dict(TABLE_DIFF, row=1, recorded={"columns": ["o.number", "o.status", "o.region", "o.region_code", "o.placed_at"], "rows": []},
+                  comparison={"result_set": {"accuracy": 0.0, "reason": "no generated column carries the values of: planned_ship_date, delivered_at, channel",
+                                             "unmatched_golden_columns": ["planned_ship_date", "delivered_at", "channel"],
+                                             "column_pairs": [["number", "o.number"], ["status", "o.status"], ["placed_at", "o.placed_at"], ["region", "o.region"], ["region_code", "o.region_code"]],
+                                             "unmatched_generated_columns": [], "golden_row_count": 21, "generated_row_count": 21}})
+    renamed = dict(TABLE_DIFF, row=2, status="match", statement_recorded={"columns": ["number", "status"], "row_count": 21}, recorded={"columns": ["o.number", "o.status"], "rows": []},
+                   comparison={"result_set": {"accuracy": 1.0, "reason": "", "unmatched_golden_columns": [], "column_pairs": [["number", "o.number"], ["status", "o.status"]],
+                                              "unmatched_generated_columns": [], "golden_row_count": 21, "generated_row_count": 21}},
+                   ledger={"rows": [_part("runs", "confirmed"), _part("question_fit", "confirmed", {"fit": "plausible"})], "verdict": "confirmed", "counts": {}}, claims=None)
+    items = _items(tmp_path, [partly, renamed])
+    rows1 = {r["key"]: r for r in items[1]["diff"]}
+    assert items[1]["result"]["label"] == "same rows, different columns" and items[1]["fix"] == "query"
+    assert rows1["columns"]["state"] == "defect" and rows1["columns"]["yours_hi"] == ["planned_ship_date", "delivered_at", "channel"] and rows1["columns"].get("agami_hi") in (None, [])
+    assert rows1["columns"]["note"] is None and ["number", "o.number"] in rows1["columns"]["renamed"]
+    assert rows1["values"]["state"] == "held" and rows1["values"]["yours"] == "identical on the 5 paired columns"
+    assert items[1]["prefill"]["fix"] == "remove planned_ship_date, delivered_at, channel"
+    rows2 = {r["key"]: r for r in items[2]["diff"]}
+    assert items[2]["result"]["label"] == "match" and rows2["columns"]["state"] == "held" and rows2["columns"]["renamed"] == [["number", "o.number"], ["status", "o.status"]]
+
+
+def test_the_change_text_the_prefill_and_the_fix_come_from_one_source(tmp_path):
+    items = _items(tmp_path, [dict(GAPS_AND_GRAIN, row=1), dict(DEFECT, row=2)])
+    gaps = items[1]
+    assert gaps["fix"] == "semantic_model" and gaps["change"][0].startswith("The semantic model is missing: values declared on")
+    assert gaps["prefill"]["change"].startswith("add values declared on") and gaps["prefill"]["reword"] == GAPS_AND_GRAIN["question"]
+    assert gaps["change"][1].startswith("Also:")  # the doubtful fit rides along as a second line
+    defect = items[2]
+    assert defect["fix"] == "query" and defect["prefill"]["fix"] == "value orders.status='Delivered'"
+
+
+def test_identical_column_names_with_different_row_counts_are_one_column_set(tmp_path):
+    """Values cannot pair when the row counts differ, so the columns fall back to names: identical
+    names read as the same columns, and only the rows check carries the difference."""
+    rec = dict(TABLE_DIFF, row=1, statement_recorded={"columns": ["department", "pending_items"], "row_count": 13},
+               recorded={"columns": ["department", "pending_items"], "rows": []},
+               comparison={"result_set": {"accuracy": 0.0, "reason": "the answer key has 13 rows and the generated result has 759",
+                                          "unmatched_golden_columns": [], "column_pairs": [], "unmatched_generated_columns": [],
+                                          "golden_row_count": 13, "generated_row_count": 759}})
+    item = reconcile.report_items(_run(tmp_path, [rec]))[0]
+    rows = {r["key"]: r for r in item["diff"]}
+    assert rows["rows"]["state"] == "defect" and rows["rows"]["yours"] == "13 rows" and rows["rows"]["agami"] == "759 rows"
+    assert rows["columns"]["state"] == "held" and not rows["columns"].get("yours_hi") and not rows["columns"].get("agami_hi")
+    assert item["result"]["data"] == "differs" and "columns" not in item["result"]["differs_in"]
+
diff --git a/tests/test_render_reconcile_diff_grid.py b/tests/test_render_reconcile_diff_grid.py
index 36db975f..59782a02 100644
--- a/tests/test_render_reconcile_diff_grid.py
+++ b/tests/test_render_reconcile_diff_grid.py
@@ -32,11 +32,11 @@ def test_the_grid_has_one_row_per_check_with_the_category_first_and_the_extra_to
     # One grid, four tracks: the alignment is structural, not two stacks side by side.
     css = html[html.index("<style>"):html.index("</style>")]
     assert re.search(r"\.dg \{[^}]*grid-template-columns: 22px minmax\(120px, 170px\) minmax\(0, 1fr\) minmax\(0, 1fr\)", css)
-    assert "'<span class=\"tok' + ((hi || []).includes(tok) ? ' hi' : '')" in html
-    assert "MARK = { held: '✓', defect: '✗', open: '○', gap: '▲', noted: '·' }" in html
+    assert "(side === 'yours' ? 'del' : 'add')" in html and "class=\"tok renamed\"" in html
+    assert "MARK = { held: '✓', defect: '✗', open: '○', gap: '▲', noted: '·', differs: '≠' }" in html
     assert "diffCard(item)" in html and "diffAudit(item)" in html and 'layout: "cards"' in html
     # The sentence and the semantic model's words ride along; the note shows only off a held row.
-    assert "r.note && r.state !== 'held'" in html and '<details class="words"><summary>The semantic model says</summary>' in html
+    assert "r.note && (r.state !== 'held' || r.key === 'columns')" in html and '<details class="words"><summary>The semantic model says</summary>' in html
 
 
 def test_one_item_with_a_diff_takes_the_audit_layout_and_keeps_the_rail():
@@ -68,7 +68,7 @@ def test_each_decision_says_what_it_is_and_what_happens_and_the_box_asks_for_the
                   "SUGGEST = { keep: 'keep', model: 'change', you: 'fix', question: 'reword'", 'class="tag suggested"', 'class="opt'):
         assert token in html, token
     # The block's contract is untouched: the same five radio values, the same words field.
-    for token in ("value=\"' + v + '\"", 'data-field="words"', "['change', 'fix', 'reword'].includes(d.decision)"):
+    for token in ("value=\"' + v + '\"", 'data-field="words"', "['change', 'fix', 'reword', 'example'].includes(d.decision)"):
         assert token in html, token
 
 
@@ -112,8 +112,8 @@ def test_the_result_pill_and_the_fix_pill_come_from_the_verbs_two_fields():
     item = dict(ITEM, result={"data": "matches", "query": "different", "label": "same answer, different query", "unchecked": 2, "differs_in": ["filters"]},
                 fix="examples", fix_words="add an example", keep_allowed=True)
     html = rr.render(title="t", profile="p", run="r", items=[item, dict(item, row=3)])
-    for token in ("function resultPill(item)", "'same answer, different query'".replace("'", '"')[1:-1], "check' : ' checks') + ' not run", "FIX_WORDS = { query: 'fix your query'",
-                  "examples: item.keep_allowed ? 'keep' : 'change'", 'id="result-chips"', "<b>fix</b>", '"fix": "examples"', '"label": "same answer, different query"'):
+    for token in ("function resultPill(item)", "'same answer, different query'".replace("'", '"')[1:-1], "check' : ' checks') + ' not run", "const FIX_WORDS = {};",
+                  "examples: item.keep_allowed ? 'keep' : 'example'", 'id="result-chips"', "<b>fix</b>", '"fix": "examples"', '"label": "same answer, different query"'):
         assert token in html, token
     with pytest.raises(ValueError, match="'result' needs data in"):
         rr.render(title="t", profile="p", run="r", items=[dict(item, result={"data": "maybe", "query": "same", "label": "x"})])
@@ -131,3 +131,35 @@ def test_the_result_chips_filter_and_replace_the_status_chips_when_labels_exist(
                   "document.getElementById('result-row').hidden = Object.keys(labels).length === 0;", "view.result.clear();"):
         assert token in html, token
 
+
+def test_the_card_after_the_second_read_question_first_folding_checks_example_and_prefill():
+    item = dict(ITEM, prefill={"change": "add values declared on x", "fix": "remove channel", "reword": "List all orders placed from June this year.", "example": ""},
+                result={"data": "partly", "query": "different", "label": "same rows, different columns", "unchecked": 0, "differs_in": ["columns"]}, fix="query", fix_words="fix your query")
+    html = rr.render(title="t", profile="p", run="r", items=[item, dict(item, row=3)])
+    for token in ('<span class="title q">\' + esc(item.question) + \'</span>'.replace("\\", ""), "<span class=\"state\">' + resultPill(item)".replace("\\", ""),
+                  "[item.label, item.source].filter(Boolean).join(' · ')", "<details class=\"checks\"".replace("\\", ""), "'</summary>'", "Checks: ' + passed + ' passed",
+                  "example: { word: 'add an example'", "function prefillFor(item, decision)", "['change', 'fix', 'reword', 'example'].includes(d.decision)",
+                  "examples: item.keep_allowed ? 'keep' : 'example'", '"prefill": {"change": "add values declared on x"'):
+        assert token in html, token
+    # the pinned contract stays
+    for token in ("['change', 'fix', 'reword', 'example'].includes(e.target.value)", 'data-field="words"'):
+        assert token in html, token
+
+
+def test_list_cells_read_like_a_diff():
+    item = dict(ITEM, diff=[{"key": "columns", "state": "defect", "yours": ["number", "channel"], "agami": ["o.number", "region"], "yours_hi": ["channel"], "agami_hi": ["region"], "renamed": [["number", "o.number"]]}])
+    html = rr.render(title="t", profile="p", run="r", items=[item, dict(item, row=3)])
+    for token in ("(state === 'differs' ? 'diff' : (side === 'yours' ? 'del' : 'add'))", "class=\"tok renamed\" title=\"same values as '", '"renamed": [["number", "o.number"]]'):
+        assert token.replace("\\", "") in html, token
+    with pytest.raises(ValueError, match="name pairs"):
+        rr.render(title="t", profile="p", run="r", items=[dict(item, diff=[{"key": "columns", "state": "held", "renamed": ["number"]}])])
+
+
+def test_the_checks_start_closed_and_the_palette_has_one_meaning_per_color():
+    html = rr.render(title="t", profile="p", run="r", items=[ITEM, dict(ITEM, row=3)])
+    assert "'<details class=\"checks\"><summary>Checks: '" in html and "(open ? ' open' : '')" not in html
+    css = html[html.index("<style>"):html.index("</style>")]
+    assert "--agami:" in css and ".pill.agami { background: var(--agami-bg); color: var(--agami); }" in css
+    assert ".dg .v .tok.add { background: var(--agami-bg); color: var(--agami);" in css and "background: var(--agami-bg); color: var(--agami); border-radius: 999px" in css
+    assert '<div class="legend"' in html and 'class="agami">agami</span>' in html
+