@m13v/s4l 1.7.1-rc.2 → 1.7.1-rc.21

package/mcp/menubar/s4l_card.py

@@ -82,6 +82,7 @@ from AppKit import (
     NSWindowStyleMaskClosable,
     NSWindowStyleMaskUtilityWindow,
     NSLineBreakByWordWrapping,
+    NSLineBreakByTruncatingTail,
     NSBezelStyleRounded,
     NSFontAttributeName,
     NSForegroundColorAttributeName,
@@ -103,12 +104,34 @@ from AppKit import (
     NSViewWidthSizable,
 )
 
+# Styling extras that may be missing on older AppKit; every consumer degrades
+# to the stock look when these are None (same posture as the SF Symbols
+# fallback in _eye_button).
+try:
+    from AppKit import NSFontWeightSemibold
+except Exception:
+    NSFontWeightSemibold = None
+try:
+    from AppKit import NSVisualEffectView
+except Exception:
+    NSVisualEffectView = None
+try:
+    # Registers the CGColor bridge type; without it every NSColor.CGColor()
+    # call in _round_rect logs an ObjCPointerWarning to menubar.err.log.
+    import Quartz  # noqa: F401
+except Exception:
+    pass
+
 # Strong reference to the live controller so pyobjc doesn't GC it mid-review
 # (the classic "button click crashes" footgun).
 _active = None
 
 W = 380
-H = 300
+# 2026-07-08: raised 300 -> 420 so two-draft cards can show both drafts at
+# full, comfortable editing height simultaneously (see _render()'s dual
+# branch); single-draft cards get the same extra room, which is a net
+# improvement there too, not a regression.
+H = 420
 M = 16
 NS_BEZEL_BORDER = 2  # NSBezelBorder
 
@@ -298,15 +321,52 @@ def _engagement_line(stats):
     return " · ".join(parts)
 
 
+def _reply_heading_suffix(d):
+    """Concise 'project/lane · viral N' readout appended straight onto the
+    'Reply (editable):' heading (2026-07-07), so the two facts a reviewer
+    checks first don't require opening the details eye. Pulled from the same
+    fields _details_lines used to render as 'Project:'/'Lane:'/'Virality
+    score:' rows; those three are omitted from the popover now to avoid
+    showing the same numbers twice. Empty string when neither is known."""
+    d = d or {}
+    project = (d.get("project") or "").strip()
+    lane = ((d.get("experiments") or {}).get("lane") or "").strip()
+    bits = []
+    # Project and lane are independent concepts most of the time (project
+    # "fazm" drafted under lane "personal_brand"), but the operator's own
+    # PersonalBrand project IS the personal_brand lane, so project=="PersonalBrand"
+    # + lane=="personal_brand" is the SAME fact twice, not two facts — compare
+    # with punctuation/case stripped so "PersonalBrand" vs "personal_brand"
+    # collapses to one token instead of "PersonalBrand/personal_brand".
+    same = project and lane and re.sub(r"[^a-z0-9]", "", project.lower()) == re.sub(
+        r"[^a-z0-9]", "", lane.lower()
+    )
+    if same:
+        bits.append(project)
+    elif project and lane:
+        bits.append(f"{project}/{lane}")
+    elif project:
+        bits.append(project)
+    elif lane:
+        bits.append(lane)
+    v = (d.get("stats") or {}).get("virality_score")
+    if v is not None:
+        try:
+            bits.append(f"viral {float(v):g}")
+        except (TypeError, ValueError):
+            pass
+    return " · ".join(bits)
+
+
 def _details_lines(d):
     """Drafting metadata for the reply row's eye popover: how this draft came
-    to be (project routing, engagement style, discovery query, link choice).
-    Everything comes from fields the plan candidate already carries; fields the
-    pipeline didn't stamp are omitted, and an empty list skips the icon."""
+    to be (engagement style, discovery query, link choice). Project, lane,
+    and virality score live inline on the heading itself (_reply_heading_suffix)
+    and are deliberately NOT repeated here. Everything else comes from fields
+    the plan candidate already carries; fields the pipeline didn't stamp are
+    omitted, and an empty list skips the icon."""
     d = d or {}
     lines = []
-    if d.get("project"):
-        lines.append(f"Project: {d['project']}")
     style = (d.get("engagement_style") or "").strip()
     if style:
         lines.append(f"Style: {style}")
@@ -332,10 +392,10 @@ def _details_lines(d):
             def _exp_describe(_name, _variant):
                 return None
     for name in sorted(exps):
-        label = (
-            "Lane" if name == "lane"
-            else f"Experiment {str(name).replace('_', ' ')}"
-        )
+        if name == "lane":
+            # Already surfaced inline on the heading via _reply_heading_suffix.
+            continue
+        label = f"Experiment {str(name).replace('_', ' ')}"
         line = f"{label}: {exps[name]}"
         exp_desc = _exp_describe(name, exps[name])
         if exp_desc:
@@ -366,12 +426,6 @@ def _details_lines(d):
         lines.append(f"Link: {kw}" if kw else f"Link: {d['link_url']}")
     elif (d.get("link_source") or "").strip():
         lines.append(f"Link: none ({d['link_source'].strip().replace('_', ' ')})")
-    v = (d.get("stats") or {}).get("virality_score")
-    if v is not None:
-        try:
-            lines.append(f"Virality score: {float(v):g}")
-        except (TypeError, ValueError):
-            pass
     return lines
 
 
@@ -398,18 +452,95 @@ def _age_str(iso):
     return f"{hours // 24}d"
 
 
-def _label(frame, text, *, size=12, bold=False, muted=False):
+# ---- contemporary styling helpers --------------------------------------------
+# Style-only layer (2026-07-07): frames, sizes, and control positions are
+# untouched; these helpers change nothing but the skin. The card reads as a
+# modern frosted macOS panel (vibrancy background, quiet semibold section
+# labels, a quote-style fill behind the thread text, a rounded-rect reply
+# editor, destructive-red reject) instead of the stock square-bezel utility
+# look. Every hook degrades to the stock look on AppKit versions that lack
+# the API, so none of these try/excepts may be "simplified" away.
+
+
+def _font(size, bold=False):
+    """Semibold (not heavy bold) for emphasis, matching modern macOS forms.
+    Used by BOTH _label and _add_link so link-width measurement in _render
+    stays in sync with the rendered title font."""
+    if bold and NSFontWeightSemibold is not None:
+        try:
+            return NSFont.systemFontOfSize_weight_(size, NSFontWeightSemibold)
+        except Exception:
+            pass
+    return NSFont.boldSystemFontOfSize_(size) if bold else NSFont.systemFontOfSize_(size)
+
+
+def _frosted(content):
+    """Wrap a content view in a behind-window vibrancy underlay (the frosted
+    look of Notification Center widgets). Same frame as the content, so
+    nothing moves. Bare view when NSVisualEffectView is unavailable."""
+    if NSVisualEffectView is None:
+        return content
+    try:
+        v = NSVisualEffectView.alloc().initWithFrame_(content.frame())
+        v.setMaterial_(6)  # NSVisualEffectMaterialPopover: adaptive light/dark
+        v.setBlendingMode_(0)  # behind-window
+        v.setState_(1)  # active even while this accessory app is inactive
+        v.addSubview_(content)
+        return v
+    except Exception:
+        return content
+
+
+def _fill_color():
+    """Subtle adaptive fill for the thread quote block."""
+    try:
+        return NSColor.quaternarySystemFillColor()
+    except Exception:
+        return NSColor.labelColor().colorWithAlphaComponent_(0.06)
+
+
+def _round_rect(view, *, border=True):
+    """Rounded-rect skin: 8px corners, optional hairline border. Returns True
+    on success so callers can restore their square-bezel fallback when the
+    layer API is unavailable. Border color is resolved to a CGColor at render
+    time; a mid-card system appearance flip keeps the stale shade until the
+    next card renders, which is acceptable for a short-lived panel."""
+    try:
+        view.setWantsLayer_(True)
+        layer = view.layer()
+        layer.setCornerRadius_(8.0)
+        layer.setMasksToBounds_(True)
+        if border:
+            layer.setBorderWidth_(1.0)
+            layer.setBorderColor_(NSColor.separatorColor().CGColor())
+        return True
+    except Exception:
+        return False
+
+
+def _label(frame, text, *, size=12, bold=False, muted=False, truncates=False):
     f = NSTextField.alloc().initWithFrame_(frame)
     f.setStringValue_(text or "")
     f.setBezeled_(False)
     f.setDrawsBackground_(False)
     f.setEditable_(False)
     f.setSelectable_(False)
-    f.setFont_(
-        NSFont.boldSystemFontOfSize_(size) if bold else NSFont.systemFontOfSize_(size)
-    )
+    f.setFont_(_font(size, bold))
     if muted:
         f.setTextColor_(NSColor.secondaryLabelColor())
+    # truncates=True: single line, "…" at the end when it overflows its frame,
+    # instead of word-wrapping into a second line the fixed-height frame then
+    # silently clips. For tight one-line strips (e.g. the reply heading's
+    # inline project/lane/virality tag) where an exact pixel width can't be
+    # guaranteed against every value.
+    if truncates:
+        f.setLineBreakMode_(NSLineBreakByTruncatingTail)
+        try:
+            f.cell().setWraps_(False)
+            f.cell().setScrollable_(False)
+        except Exception:
+            pass
+        return f
     f.setLineBreakMode_(NSLineBreakByWordWrapping)
     try:
         f.cell().setWraps_(True)
@@ -420,15 +551,25 @@ def _label(frame, text, *, size=12, bold=False, muted=False):
 
 
 def _editable_scroll(frame, text=""):
-    """Bezel-bordered scrollable text editor. The document view must be sized
-    to the scroll view's contentSize (NOT the outer frame) and track its width;
-    sized to the outer frame the text runs underneath the scroller. The
-    scroller itself auto-hides so it only appears when the text overflows.
+    """Rounded-rect scrollable text editor (hairline border, solid text
+    background over the frosted panel; falls back to the old square bezel when
+    layers are unavailable). The document view must be sized to the scroll
+    view's contentSize (NOT the outer frame) and track its width; sized to the
+    outer frame the text runs underneath the scroller. The scroller itself
+    auto-hides so it only appears when the text overflows.
     Returns (scroll, textview)."""
     scroll = NSScrollView.alloc().initWithFrame_(frame)
     scroll.setHasVerticalScroller_(True)
     scroll.setAutohidesScrollers_(True)
-    scroll.setBorderType_(NS_BEZEL_BORDER)
+    if _round_rect(scroll):
+        scroll.setBorderType_(0)  # NSNoBorder; the layer draws the outline
+        try:
+            scroll.setDrawsBackground_(True)
+            scroll.setBackgroundColor_(NSColor.textBackgroundColor())
+        except Exception:
+            pass
+    else:
+        scroll.setBorderType_(NS_BEZEL_BORDER)
     cs = scroll.contentSize()
     tv = NSTextView.alloc().initWithFrame_(NSMakeRect(0, 0, cs.width, cs.height))
     tv.setFont_(NSFont.systemFontOfSize_(12))
@@ -442,6 +583,11 @@ def _editable_scroll(frame, text=""):
     tv.setAutoresizingMask_(NSViewWidthSizable)
     tv.textContainer().setWidthTracksTextView_(True)
     tv.textContainer().setContainerSize_(NSMakeSize(cs.width, 1e7))
+    try:
+        # Breathing room inside the rounded rect; text no longer hugs the border.
+        tv.setTextContainerInset_(NSMakeSize(4, 6))
+    except Exception:
+        pass
     if text:
         tv.setString_(text)
     scroll.setDocumentView_(tv)
@@ -470,6 +616,21 @@ class _ReviewController(NSObject):
         self._interactions = []
         self._card_shown_at = None
         self._reason_field = None
+        # Two-draft cards (2026-07-08 redesign, no-recommendation pass same
+        # day): both drafts render at once as separate editable boxes;
+        # `_selected_draft` (0=a, 1=b) is "whichever box the reviewer is
+        # currently in", driven by focus (see textDidBeginEditing_ below),
+        # not a button. None = not yet chosen this card, _render() defaults
+        # it to slot 0 (Draft A) — the model never picks a favorite, so
+        # there's no recommendation to default to instead. Reset to None on
+        # every NEW card (see _render()'s "fresh card" branch below), so a
+        # switch made on one card never bleeds into the next.
+        # _draft_textviews/_draft_scrolls map slot -> its NSTextView/
+        # NSScrollView so the delegate callback and border-styling helper can
+        # find them; both empty on single-draft cards.
+        self._selected_draft = None
+        self._draft_textviews = {}
+        self._draft_scrolls = {}
         # Attention anchors for the unattended-review watchdog: the stack counts
         # as "touched" on present, on any tracked interaction, and on any
         # decision. No touch past the watchdog threshold = the user is not
@@ -673,6 +834,7 @@ class _ReviewController(NSObject):
             self._rendered_idx = self._idx
             self._interactions = []
             self._card_shown_at = time.time()
+            self._selected_draft = None
         self._reason_field = None
         content = NSView.alloc().initWithFrame_(NSMakeRect(0, 0, W, H))
 
@@ -680,8 +842,11 @@ class _ReviewController(NSObject):
         # row extending horizontally at the left (one click on an emoji =
         # approve at that strength), Reject at the right. Overall feedback
         # moved to the menu bar item.
+        # Section labels render quiet (semibold + secondary color): the modern
+        # macOS form look where chrome recedes and content (thread, draft)
+        # carries the full-strength label color.
         content.addSubview_(
-            _label(NSMakeRect(M, H - 38, 60, 20), "Approve", size=12, bold=True)
+            _label(NSMakeRect(M, H - 38, 60, 20), "Approve", size=12, bold=True, muted=True)
         )
         x = M + 62
         for i, (emoji, tip) in enumerate(APPROVE_EMOJIS):
@@ -707,6 +872,10 @@ class _ReviewController(NSObject):
         reject = NSButton.alloc().initWithFrame_(NSMakeRect(W - M - 66, H - 42, 66, 30))
         reject.setTitle_("Reject")
         reject.setBezelStyle_(NSBezelStyleRounded)
+        try:
+            reject.setHasDestructiveAction_(True)  # red title on macOS 12+
+        except Exception:
+            pass
         reject.setTarget_(self)
         reject.setAction_("reject:")
         content.addSubview_(reject)
@@ -722,7 +891,7 @@ class _ReviewController(NSObject):
         stats = d.get("stats") or {}
         thread_url = d.get("thread_url")
         content.addSubview_(
-            _label(NSMakeRect(M, H - 70, 78, 18), "Replying to", size=12, bold=True)
+            _label(NSMakeRect(M, H - 70, 78, 18), "Replying to", size=12, bold=True, muted=True)
         )
         right_x = W - M
         self._close_stats_popover()
@@ -757,7 +926,7 @@ class _ReviewController(NSObject):
             # after the handle instead of at a fixed column.
             text = f"@{handle}"
             measured = NSAttributedString.alloc().initWithString_attributes_(
-                text, {NSFontAttributeName: NSFont.boldSystemFontOfSize_(12)}
+                text, {NSFontAttributeName: _font(12, True)}
             ).size().width
             link_w = min(int(measured) + 8, handle_w)
             self._add_link(
@@ -781,7 +950,7 @@ class _ReviewController(NSObject):
                 )
         else:
             content.addSubview_(
-                _label(NSMakeRect(M + 78, H - 70, handle_w, 18), "thread", size=12, bold=True)
+                _label(NSMakeRect(M + 78, H - 70, handle_w, 18), "thread", size=12, bold=True, muted=True)
             )
         # Non-English drafts: the prep step stamps display-only English
         # translations (thread_text_en / reply_text_en) on the candidate. The
@@ -801,7 +970,18 @@ class _ReviewController(NSObject):
         )
         thread_tv.setEditable_(False)
         thread_tv.setSelectable_(True)  # links only respond when selectable
-        thread_tv.setDrawsBackground_(False)
+        # Quote-style block (subtle rounded fill, like a quoted tweet) so the
+        # thread reads as *their* content and the editor below as *ours*.
+        # Same frame as the old flat text; only the skin changed.
+        if _round_rect(thread_tv, border=False):
+            thread_tv.setDrawsBackground_(True)
+            thread_tv.setBackgroundColor_(_fill_color())
+            try:
+                thread_tv.setTextContainerInset_(NSMakeSize(6, 5))
+            except Exception:
+                pass
+        else:
+            thread_tv.setDrawsBackground_(False)
         # An NSTextView grows vertically by default; long threads inflated the
         # frame over the author row above (non-flipped superview: growth goes
         # UP) and pushed the trailing ↗ out of the box. Pin the frame and
@@ -831,23 +1011,59 @@ class _ReviewController(NSObject):
             thread_tv.setDelegate_(self)
         thread_tv.textStorage().setAttributedString_(body)
         content.addSubview_(thread_tv)
-        # Reply heading — black. Right-aligned on the same line: an eye icon
-        # whose hover/click popover carries the DRAFTING metadata (project
-        # routing, engagement style, discovery query, link choice), mirroring
-        # the author row's engagement-stats eye. Skipped when the plan carries
-        # none of it (older plans).
+        # Reply heading — bold. A concise "project/lane · viral N" tag rides
+        # right after it in a SEPARATE, regular-weight label (2026-07-08:
+        # was folded into the same bold string, which made the metadata read
+        # as loudly as the heading itself; split + measured-width placement
+        # mirrors the "@handle · followers" pattern in the author row above).
+        # Right-aligned on the same line: an eye icon whose hover/click
+        # popover carries the remaining DRAFTING metadata (style, discovery
+        # query, link choice), mirroring the author row's engagement-stats
+        # eye. Skipped when the plan carries none of it (older plans).
+        heading_text = (
+            f"Reply (posts in {_lang_name(card_lang)}, editable):"
+            if is_foreign
+            else "Reply (editable):"
+        )
+        # +8 (not +4): NSTextField's own cellSize() for this text measures
+        # ~4px wider than the raw NSAttributedString width used here, so a
+        # tight +4 pad was landing sub-pixel under the real render width and
+        # wrapping "(editable):" onto a clipped, invisible second line.
+        # Matches the +8 pad the @handle link width uses below for the same
+        # reason.
+        heading_w = min(
+            int(
+                NSAttributedString.alloc().initWithString_attributes_(
+                    heading_text, {NSFontAttributeName: _font(12, True)}
+                ).size().width
+            ) + 8,
+            W - 2 * M - 24,
+        )
         content.addSubview_(
             _label(
-                NSMakeRect(M, H - 172, W - 2 * M - 24, 16),
-                (
-                    f"Reply (posts in {_lang_name(card_lang)}, editable):"
-                    if is_foreign
-                    else "Reply (editable):"
-                ),
+                NSMakeRect(M, H - 172, heading_w, 16),
+                heading_text,
                 size=12,
                 bold=True,
+                muted=True,
             )
         )
+        # Long headings (foreign-language variant) can leave very little room
+        # for the suffix; truncates=True ellipsizes it instead of the old
+        # word-wrap silently clipping mid-word ("fazm/" with no "…") into the
+        # fixed-height frame's invisible second line.
+        heading_suffix = _reply_heading_suffix(d)
+        suffix_w = W - 2 * M - 24 - heading_w
+        if heading_suffix and suffix_w > 20:
+            content.addSubview_(
+                _label(
+                    NSMakeRect(M + heading_w, H - 172, suffix_w, 16),
+                    f" · {heading_suffix}",
+                    size=11,
+                    muted=True,
+                    truncates=True,
+                )
+            )
         if _details_lines(d):
             # No y nudge needed here (unlike the author row): this label is
             # 16px, so an 18px button at the same y already centers its image
@@ -856,36 +1072,95 @@ class _ReviewController(NSObject):
             content.addSubview_(deye)
             self._details_btn = deye
 
-        # Editable reply, with the attached link folded in as it'll post (no
-        # separate link field). The trailing link is stripped on send so the
-        # pipeline still mints the tracked /r/<code> short link (no double link).
-        reply = d.get("reply_text") or ""
-        link = d.get("link_url")
-        composed = f"{reply} {link}" if link else reply
-        # Non-English draft with a stamped translation: a muted read-only
-        # "EN:" block sits between the heading and the editable field so the
-        # reviewer reads the draft in English while still editing (and
-        # posting) the original-language text below. Full translation lives
-        # in the details popover; inline is truncated to what ~3 lines fit.
+        # Two-draft cards (2026-07-08 redesign; no-recommendation pass same
+        # day): show BOTH drafts at once, stacked, each independently
+        # editable, rather than a toggle that swaps one field's content. No
+        # buttons: selection is "whichever box the reviewer is currently in",
+        # shown via that box's own border (an accent outline vs a plain
+        # hairline, mirroring a standard focus ring) and updated live by
+        # textDidBeginEditing_ below. The model never picks a favorite
+        # (removed 2026-07-08 per user: no ask-the-model-to-recommend), so
+        # Draft A (slot 0) is simply the fixed default until the reviewer
+        # clicks into Draft B. Absent/short (reused stale draft, legacy plan)
+        # falls back to one full-height editable box, same as before.
+        drafts = d.get("drafts")
+        dual = isinstance(drafts, list) and len(drafts) == 2
+        sel_idx = self._selected_draft if (dual and self._selected_draft in (0, 1)) else 0
+        if dual:
+            self._selected_draft = sel_idx
+
         edit_top = H - 172 - 6
-        if reply_en:
-            tr_h = 42
-            content.addSubview_(
-                _label(
-                    NSMakeRect(M, edit_top - tr_h, W - 2 * M, tr_h),
-                    f"EN: {_truncate(reply_en, 150)}",
-                    size=11,
-                    muted=True,
+        link = d.get("link_url")
+
+        # Tail link baked at draft time is normally already in each draft's
+        # text (scripts/twitter_gen_links.py + the drafts-link-sync step in
+        # run-twitter-cycle.sh); only append link_url when a text is
+        # genuinely link-free (older/fallback plans), else it'd show twice.
+        def _compose(text):
+            text = text or ""
+            return text if (not link or link in text) else f"{text} {link}"
+
+        self._draft_textviews = {}
+        self._draft_scrolls = {}
+        if dual:
+            avail_h = edit_top - M
+            gap = 5
+            label_h = 15
+            unit = (avail_h - gap) / 2.0
+            box_h = unit - label_h
+            for slot in (0, 1):
+                # slot 0 (Draft A) always renders on top, slot 1 (Draft B)
+                # always on the bottom: a fixed, predictable order so cards
+                # don't reshuffle as the reviewer switches between them.
+                box_y = M if slot == 1 else M + unit + gap
+                label_y = box_y + box_h
+                draft = drafts[slot]
+                draft_text_en = (draft.get("text_en") or "").strip()
+                if is_foreign and draft_text_en:
+                    content.addSubview_(
+                        _label(
+                            NSMakeRect(M, label_y, W - 2 * M, label_h),
+                            f"EN: {_truncate(draft_text_en, 90)}",
+                            size=10,
+                            muted=True,
+                            truncates=True,
+                        )
+                    )
+                scroll, tv = _editable_scroll(
+                    NSMakeRect(M, box_y, W - 2 * M, box_h), _compose(draft.get("text"))
                 )
+                tv.setDelegate_(self)
+                content.addSubview_(scroll)
+                self._draft_scrolls[slot] = scroll
+                self._draft_textviews[slot] = tv
+            self._update_draft_borders()
+            tv = self._draft_textviews[sel_idx]
+        else:
+            reply = d.get("reply_text") or ""
+            # Non-English draft with a stamped translation: a muted read-only
+            # "EN:" block sits between the heading and the editable field so
+            # the reviewer reads the draft in English while still editing
+            # (and posting) the original-language text below. Full
+            # translation lives in the details popover; inline is truncated
+            # to what ~3 lines fit.
+            if reply_en:
+                tr_h = 42
+                content.addSubview_(
+                    _label(
+                        NSMakeRect(M, edit_top - tr_h, W - 2 * M, tr_h),
+                        f"EN: {_truncate(reply_en, 150)}",
+                        size=11,
+                        muted=True,
+                    )
+                )
+                edit_top -= tr_h + 4
+            scroll, tv = _editable_scroll(
+                NSMakeRect(M, M, W - 2 * M, edit_top - M), _compose(reply)
             )
-            edit_top -= tr_h + 4
-        scroll, tv = _editable_scroll(
-            NSMakeRect(M, M, W - 2 * M, edit_top - M), composed
-        )
-        content.addSubview_(scroll)
+            content.addSubview_(scroll)
         self._textview = tv
 
-        self._panel.setContentView_(content)
+        self._panel.setContentView_(_frosted(content))
         # Counter lives in the native title bar, not inside the content, with
         # the product name so a stray card is identifiable at a glance.
         self._panel.setTitle_(
@@ -1028,7 +1303,7 @@ class _ReviewController(NSObject):
         _link_targets so one openLink: selector serves every link on the card."""
         btn = NSButton.alloc().initWithFrame_(frame)
         btn.setBordered_(False)
-        font = NSFont.boldSystemFontOfSize_(size) if bold else NSFont.systemFontOfSize_(size)
+        font = _font(size, bold)
         attrs = {
             NSFontAttributeName: font,
             NSForegroundColorAttributeName: NSColor.linkColor(),
@@ -1067,38 +1342,94 @@ class _ReviewController(NSObject):
             pass
         return True
 
+    # NSTextView/NSText delegate: fires when a text view becomes the one
+    # being edited, i.e. right when it gains focus (click or tab), before any
+    # keystroke. Two-draft cards use this as the ONLY selection mechanism:
+    # whichever draft box the reviewer is in IS the selected one. Only the
+    # two draft boxes set self as delegate for this notification (the
+    # read-only thread quote never fires it), so no candidate_id lookup is
+    # needed, just a slot match against self._draft_textviews.
+    def textDidBeginEditing_(self, notification):
+        try:
+            tv = notification.object()
+        except Exception:
+            return
+        for slot, cand_tv in (self._draft_textviews or {}).items():
+            if cand_tv is tv and slot != self._selected_draft:
+                self._selected_draft = slot
+                self._textview = cand_tv
+                self._update_draft_borders()
+                break
+
+    @objc.python_method
+    def _update_draft_borders(self):
+        """Redraw the two draft boxes' borders in place (no re-render, so an
+        in-progress edit/caret in either box is never disturbed): the
+        selected box gets a thicker system-accent outline (the platform's own
+        selection color, respects the user's macOS accent choice and
+        light/dark mode), the other a plain hairline, matching the existing
+        thread-quote/editable-field border look."""
+        for slot, scroll in (self._draft_scrolls or {}).items():
+            try:
+                layer = scroll.layer()
+                if layer is None:
+                    continue
+                if slot == self._selected_draft:
+                    layer.setBorderWidth_(2.0)
+                    layer.setBorderColor_(NSColor.controlAccentColor().CGColor())
+                else:
+                    layer.setBorderWidth_(1.0)
+                    layer.setBorderColor_(NSColor.separatorColor().CGColor())
+            except Exception:
+                pass
+
     @objc.python_method
     def _current_text(self):
         try:
             return str(self._textview.string())
         except Exception:
-            return self._drafts[self._idx].get("reply_text") or ""
+            d = self._drafts[self._idx]
+            drafts = d.get("drafts")
+            if isinstance(drafts, list) and len(drafts) == 2 and self._selected_draft in (0, 1):
+                return drafts[self._selected_draft].get("text") or ""
+            return d.get("reply_text") or ""
 
     @objc.python_method
     def _record(self, approved, reject_category=None, reject_note=None, loved=False):
         d = self._drafts[self._idx]
-        orig = (d.get("reply_text") or "").strip()
+        # Two-draft cards: `orig` (what counts as "unedited") is whichever
+        # draft is CURRENTLY SELECTED, not always the plan's default
+        # reply_text. Otherwise picking the non-recommended draft without
+        # further hand-editing would show up as `edited=True` with the
+        # recommended draft as `original_text`, which would look exactly
+        # like a human rewrite to the edit-learning digest and pollute it.
+        drafts = d.get("drafts")
+        dual = isinstance(drafts, list) and len(drafts) == 2
+        sel_idx = self._selected_draft if (dual and self._selected_draft in (0, 1)) else None
+        if sel_idx is not None:
+            chosen_draft = drafts[sel_idx]
+            orig = (chosen_draft.get("text") or "").strip()
+            draft_variant = chosen_draft.get("variant") or ("a" if sel_idx == 0 else "b")
+        else:
+            orig = (d.get("reply_text") or "").strip()
+            draft_variant = None
         link = d.get("link_url") or ""
         drop_link = False
         if approved:
             text = self._current_text()
-            # The card folds link_url into the editable field (see _render). On
-            # send we must reconcile what the user did with that link:
-            #   - link still present anywhere -> remove ALL occurrences so the
-            #     poster mints the single tracked /r/<code> short link (no double
-            #     link, no bare URL). Generalizes the old endswith() strip, which
-            #     missed the link whenever the user typed anything after it.
-            #   - link gone (user deleted it while editing) -> drop_link=True so
-            #     the poster does NOT re-append it. Without this signal the post
-            #     pipeline's forced TWITTER_TAIL_LINK_RATE=1.0 silently revived a
-            #     link the user intentionally removed.
-            if link:
-                if link in text:
-                    text = text.replace(link, "")
-                else:
-                    drop_link = True
-            # Collapse only horizontal whitespace left by the removal; preserve
-            # any newlines the user intended.
+            # reply_text already carries the link embedded at draft time (see
+            # _render) — post it as-is, don't strip it back out. tail_link_variant
+            # is stamped before the card is ever shown, so the post pipeline now
+            # trusts reply_text verbatim and never re-adds a missing link; the old
+            # strip-then-hope-the-poster-revives-it logic predates that move and
+            # was mislabeling every approval as "edited" (body != orig once the
+            # link was stripped) and occasionally shipping a tweet with no link
+            # at all. Only signal drop_link when the user actually deleted the
+            # link while editing, so the poster clears link_url instead of
+            # reviving it.
+            if link and link not in text:
+                drop_link = True
+            # Collapse only horizontal whitespace runs; preserve intended newlines.
             body = re.sub(r"[ \t]{2,}", " ", text).strip()
         else:
             body = orig
@@ -1129,6 +1460,14 @@ class _ReviewController(NSObject):
                 # edit/reject patterns per language. draft_text/original_text
                 # stay in the ORIGINAL language (that is what posts).
                 "language": d.get("language"),
+                # Two-draft cards: which draft ("a"|"b") was showing when this
+                # decision was made, its 0/1 index, and whether it was the
+                # fixed default (Draft A / slot 0) rather than a reviewer
+                # switch to Draft B. None/False on single-draft candidates.
+                # Kept separate from `edited` above by design.
+                "draft_variant": draft_variant,
+                "draft_index": sel_idx,
+                "draft_auto_selected": bool(dual and sel_idx == 0),
             }
         )
         self._last_decision_at = time.time()
@@ -1226,6 +1565,10 @@ class _ReviewController(NSObject):
         skip = NSButton.alloc().initWithFrame_(NSMakeRect(W - M - 150, H - 42, 150, 30))
         skip.setTitle_("Reject, no reason")
         skip.setBezelStyle_(NSBezelStyleRounded)
+        try:
+            skip.setHasDestructiveAction_(True)  # red title on macOS 12+
+        except Exception:
+            pass
         skip.setTarget_(self)
         skip.setAction_("rejectSkip:")
         content.addSubview_(skip)
@@ -1243,20 +1586,50 @@ class _ReviewController(NSObject):
             btn.setAction_("rejectReason:")
             content.addSubview_(btn)
             y -= 32
-        note = NSTextField.alloc().initWithFrame_(NSMakeRect(M, 14, W - 2 * M, y + 28 - 14 - 8))
+        # Optional-note field, skinned like the reply editor: a rounded-rect
+        # wrapper carries the fill + hairline border while the borderless
+        # field sits inset inside it so the text doesn't hug the border (an
+        # unbezeled NSTextField has zero internal padding). Same outer frame
+        # as the old bezeled field, which remains the fallback.
+        note_frame = NSMakeRect(M, 14, W - 2 * M, y + 28 - 14 - 8)
+        wrap = NSView.alloc().initWithFrame_(note_frame)
+        if _round_rect(wrap):
+            try:
+                wrap.layer().setBackgroundColor_(
+                    NSColor.textBackgroundColor().CGColor()
+                )
+            except Exception:
+                pass
+            note = NSTextField.alloc().initWithFrame_(
+                NSMakeRect(
+                    6, 4, note_frame.size.width - 12, note_frame.size.height - 8
+                )
+            )
+            note.setBezeled_(False)
+            note.setDrawsBackground_(False)
+            try:
+                # The square focus ring fights the rounded skin (renders as a
+                # heavy outline); the border already marks the field.
+                note.setFocusRingType_(1)  # NSFocusRingTypeNone
+            except Exception:
+                pass
+            wrap.addSubview_(note)
+            content.addSubview_(wrap)
+        else:
+            note = NSTextField.alloc().initWithFrame_(note_frame)
+            note.setBezeled_(True)
+            content.addSubview_(note)
         note.setEditable_(True)
-        note.setBezeled_(True)
         note.setFont_(NSFont.systemFontOfSize_(12))
         try:
             note.setPlaceholderString_("Optional note (sent with whichever reason you pick)")
             note.cell().setWraps_(True)
         except Exception:
             pass
-        content.addSubview_(note)
         self._reason_field = note
 
         self._textview = None
-        self._panel.setContentView_(content)
+        self._panel.setContentView_(_frosted(content))
         self._panel.makeFirstResponder_(note)
 
     @objc.python_method
@@ -1332,11 +1705,14 @@ def present_review(drafts, on_decision=None, on_complete=None):
     draft time): the card then shows the English thread text, a muted read-only
     "EN:" translation of the reply, and a "posts in <language>" heading, while
     the editable field keeps the original-language reply_text (what posts).
-    Optional drafting metadata (project, engagement_style, style_description,
-    search_topic, language, link_source, link_keyword, experiments) feeds a
-    second eye on the "Reply (editable):" row whose popover explains how the
-    draft was made; experiments is a generic {name: variant} dict rendered
-    as-is, one line per active experiment/scenario arm.
+    project, the experiments["lane"] arm, and stats.virality_score render
+    inline on the "Reply (editable):" heading itself as a concise
+    "project/lane · viral N" tag (2026-07-07). The rest of the optional
+    drafting metadata (engagement_style, style_description, search_topic,
+    language, link_source, link_keyword, remaining experiments) feeds a
+    second eye on that same row whose popover explains how the draft was
+    made; experiments other than "lane" render generically, one line per
+    active experiment/scenario arm.
     on_decision(decision) fires the instant each card is approved/rejected (so an
     approved draft posts right away); on_complete(decisions) fires when the user
     finishes the last card or closes the window. Both run on the main thread."""
@@ -1521,7 +1897,7 @@ class _FeedbackController(NSObject):
         send.setAction_("feedbackSend:")
         content.addSubview_(send)
 
-        panel.setContentView_(content)
+        panel.setContentView_(_frosted(content))
         self._panel = panel
         panel.makeKeyAndOrderFront_(None)
         panel.orderFrontRegardless()