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

package/mcp/menubar/s4l_card.py

@@ -331,7 +331,7 @@ def _truncate(s, n=320):
     return s if len(s) <= n else s[: n - 1] + "…"
 
 
-def _set_thread_text(thread_tv, text, link_url, *, font_size=12):
+def _set_thread_text(thread_tv, text, link_url, *, font_size=12, title=None):
     """Set the thread-quote text on `thread_tv`: the FULL text, never
     trimmed (2026-07-16 user direction -- the box scrolls instead when it
     doesn't fit; see its NSScrollView wrapper in _render()). A leading
@@ -340,8 +340,15 @@ def _set_thread_text(thread_tv, text, link_url, *, font_size=12):
     of how long the thread is or where the box happens to be scrolled to
     (the old trailing-link placement could end up scrolled out of view, or
     -- before scrolling existed at all -- get silently truncated off the
-    end; see the superseded _fit_thread_body this replaced)."""
+    end; see the superseded _fit_thread_body this replaced).
+
+    `title` (2026-07-17 user direction, Reddit): when given, it's drawn BOLD
+    on its own line ahead of `text`, so a Reddit card shows the post title in
+    bold with the selftext body beneath it in the same quote box. Twitter and
+    title-only Reddit threads pass title=None and render `text` alone,
+    exactly as before."""
     text = (text or "").strip()
+    title = (title or "").strip()
     body = NSMutableAttributedString.alloc().initWithString_attributes_("", {})
     if link_url:
         body.appendAttributedString_(
@@ -356,6 +363,19 @@ def _set_thread_text(thread_tv, text, link_url, *, font_size=12):
                 },
             )
         )
+    if title:
+        # Bold title on its own line; a trailing newline separates it from the
+        # body only when there IS a body (a title with no selftext shouldn't
+        # leave a dangling blank line).
+        body.appendAttributedString_(
+            NSAttributedString.alloc().initWithString_attributes_(
+                title + ("\n" if text else ""),
+                {
+                    NSFontAttributeName: NSFont.boldSystemFontOfSize_(font_size),
+                    NSForegroundColorAttributeName: NSColor.labelColor(),
+                },
+            )
+        )
     body.appendAttributedString_(
         NSAttributedString.alloc().initWithString_attributes_(
             text,
@@ -425,8 +445,26 @@ def _engagement_line(stats):
     return " · ".join(parts)
 
 
+def _compact_arm(variant):
+    """Shrink a draft_prompt A/B variant to a heading-sized token so the arm
+    fits inline next to project/lane/viral: 'treatment_v4' -> 't v4',
+    'control_v4' -> 'c v4'. Anything that isn't a treatment/control_vN shape
+    (future arm names, retired bare 'treatment'/'control') falls back to the
+    raw variant, so no arm goes unlabelled. The full one-sentence meaning
+    still lives in the details popover via active_experiments.describe()."""
+    v = (variant or "").strip()
+    if not v:
+        return ""
+    m = re.match(r"(treatment|control)(?:_v?(\w+))?$", v)
+    if not m:
+        return v
+    arm = "t" if m.group(1) == "treatment" else "c"
+    ver = m.group(2)
+    return f"{arm} v{ver}" if ver else arm
+
+
 def _reply_heading_suffix(d):
-    """Concise 'project/lane · viral N' readout appended straight onto the
+    """Concise 'project/lane · viral N · t v4' 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
@@ -465,6 +503,15 @@ def _reply_heading_suffix(d):
             bits.append(f"viral {float(v):g}")
         except (TypeError, ValueError):
             pass
+    # The drafting A/B arm (treatment vs control), compacted to 't v4'/'c v4'
+    # so the reviewer sees which prompt variant produced this draft without
+    # opening the details eye. Only draft_prompt rides the heading; other
+    # experiments stay solely in the popover. draft_prompt ALSO keeps its full
+    # one-sentence meaning in the popover (unlike 'lane', which is skipped
+    # there) because the compact token alone doesn't say what the arm does.
+    arm = _compact_arm((d.get("experiments") or {}).get("draft_prompt"))
+    if arm:
+        bits.append(arm)
     return " · ".join(bits)
 
 
@@ -801,6 +848,31 @@ def _label(frame, text, *, size=12, bold=False, muted=False, truncates=False):
     return f
 
 
+class _TileScroll(NSScrollView):
+    """Scroll box that yields the wheel to an enclosing canvas grid. Inside
+    the canvas (s4l_card_canvas.py) most of a tile's area is one of these
+    boxes, and AppKit routes the whole wheel gesture (momentum included) to
+    the innermost scroll view under the pointer -- so the canvas simply
+    would not scroll whenever the pointer sat over a thread quote or draft
+    editor (2026-07-16 user report). Forward the event to the outer scroll
+    view instead, UNLESS this box's own text view holds the caret (the
+    reviewer clicked into it, so inner scrolling is what they want). In the
+    corner card there is no enclosing scroll view and behavior is unchanged."""
+
+    def scrollWheel_(self, event):
+        try:
+            outer = self.enclosingScrollView()
+            if outer is not None:
+                win = self.window()
+                fr = win.firstResponder() if win is not None else None
+                if fr is None or fr is not self.documentView():
+                    outer.scrollWheel_(event)
+                    return
+        except Exception:
+            pass
+        objc.super(_TileScroll, self).scrollWheel_(event)
+
+
 def _editable_scroll(frame, text=""):
     """Rounded-rect scrollable text editor (hairline border, solid text
     background over the frosted panel; falls back to the old square bezel when
@@ -809,7 +881,7 @@ def _editable_scroll(frame, text=""):
     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 = _TileScroll.alloc().initWithFrame_(frame)
     scroll.setHasVerticalScroller_(True)
     scroll.setAutohidesScrollers_(True)
     if _round_rect(scroll):
@@ -902,6 +974,7 @@ class _ReviewController(NSObject):
         self._eye_btn = None
         self._details_btn = None
         self._stats_popover = None
+        self._pending_hover_kind = None
         self._age_expiry_label = None
         self._age_expiry_timer = None
         # Per-card telemetry, reset when a NEW card renders (not on the
@@ -1378,6 +1451,7 @@ class _ReviewController(NSObject):
             _label(NSMakeRect(M, H - 70, 78, 18), "Replying to", size=12, bold=True, muted=True)
         )
         right_x = W - M
+        self._cancel_pending_hover()
         self._close_stats_popover()
         self._stop_age_expiry_timer()
         self._eye_btn = None
@@ -1511,7 +1585,7 @@ class _ReviewController(NSObject):
         # direction); the box scrolls instead of shrinking the text to fit,
         # and the link sits at the START so it's always visible regardless
         # of scroll position or thread length.
-        thread_scroll = NSScrollView.alloc().initWithFrame_(
+        thread_scroll = _TileScroll.alloc().initWithFrame_(
             NSMakeRect(M, H - 150, W - 2 * M, 74)
         )
         thread_scroll.setHasVerticalScroller_(True)
@@ -1544,7 +1618,19 @@ class _ReviewController(NSObject):
             pass
         if thread_url:
             thread_tv.setDelegate_(self)
-        _set_thread_text(thread_tv, thread_en or d.get("thread_text"), thread_url)
+        # Reddit (2026-07-17 user direction): the thread has a TITLE and a
+        # BODY (selftext). Render the title bold with the body beneath it in
+        # this same quote box. thread_text carries the title (see
+        # merge_review_queue._reddit_plan_to_candidates); thread_selftext is
+        # the body, empty for link posts / title-only threads (then this falls
+        # through to the plain title-only render). Twitter has no selftext, so
+        # it always takes the else branch and renders exactly as before.
+        _thread_title = thread_en or d.get("thread_text")
+        _thread_body = (d.get("thread_selftext") or "").strip() if _plat == "reddit" else ""
+        if _thread_body:
+            _set_thread_text(thread_tv, _thread_body, thread_url, title=_thread_title)
+        else:
+            _set_thread_text(thread_tv, _thread_title, thread_url)
         thread_scroll.setDocumentView_(thread_tv)
         content.addSubview_(thread_scroll)
         # Reply heading — bold. A concise "project/lane · viral N" tag rides
@@ -1847,10 +1933,12 @@ class _ReviewController(NSObject):
         pop.setBehavior_(NSPopoverBehaviorApplicationDefined)
         pop.setContentViewController_(vc)
         pop.setContentSize_((pw, ph))
-        try:
-            NSApp.activateIgnoringOtherApps_(True)
-        except Exception:
-            pass
+        # No activateIgnoringOtherApps_ here (removed 2026-07-16): with
+        # ApplicationDefined behavior the popover shows fine from an inactive
+        # accessory app, and yanking app activation on a HOVER (these popovers
+        # open from mouseEntered_) stole focus from whatever the user was
+        # doing -- worst on the canvas, where scrolling sweeps anchors under
+        # the pointer.
         # Anchor to the eye's frame in the (non-flipped) content view, where
         # NSRectEdge 1 = NSMinYEdge is unambiguously the BOTTOM edge, so the
         # popover reliably opens below the icon. Anchoring to the button's own
@@ -1948,13 +2036,18 @@ class _ReviewController(NSObject):
         if kind == "draft":
             self._draft_hover_open[slot] = time.time()
             return
-        _log(f"{kind} eye hover enter" if kind != "expiry" else "expiry label hover enter")
-        if kind == "details":
-            self._show_details_popover()
-        elif kind == "expiry":
-            self._show_expiry_popover()
-        else:
-            self._show_stats_popover()
+        # Dwell-gated (2026-07-16 canvas scroll-perf fix): scrolling the
+        # canvas sweeps these tracking areas under a stationary pointer,
+        # and opening a popover synchronously per enter event (text
+        # measurement + NSPopover build) hitched the scroll. A short
+        # delayed perform only fires if the pointer actually STAYS on the
+        # anchor; enter/exit pairs from content moving underneath cancel
+        # out. Bonus: the delayed perform is queued in the default run-loop
+        # mode, which does not run during a wheel gesture (event-tracking
+        # mode), so a popover can never open mid-scroll at all.
+        self._cancel_pending_hover()
+        self._pending_hover_kind = kind
+        self.performSelector_withObject_afterDelay_("showHoverPopover:", kind, 0.2)
 
     def mouseExited_(self, event):
         kind, slot = self._hover_info(event)
@@ -1965,9 +2058,41 @@ class _ReviewController(NSObject):
                     (time.time() - started) * 1000
                 )
             return
-        _log("eye hover exit")
+        self._cancel_pending_hover()
         self._close_stats_popover()
 
+    @objc.python_method
+    def _cancel_pending_hover(self):
+        pending = getattr(self, "_pending_hover_kind", None)
+        if pending is not None:
+            try:
+                NSObject.cancelPreviousPerformRequestsWithTarget_selector_object_(
+                    self, "showHoverPopover:", pending
+                )
+            except Exception:
+                pass
+            self._pending_hover_kind = None
+
+    def showHoverPopover_(self, kind):
+        """Delayed-perform target for a dwelled hover (see mouseEntered_)."""
+        self._pending_hover_kind = None
+        kind = str(kind)
+        try:
+            _log(
+                f"{kind} eye hover enter" if kind != "expiry" else "expiry label hover enter"
+            )
+            if kind == "details":
+                self._show_details_popover()
+            elif kind == "expiry":
+                self._show_expiry_popover()
+            else:
+                self._show_stats_popover()
+        except Exception:
+            # The card may have re-rendered (anchor replaced) between the
+            # hover and the dwell firing; a popover that can't anchor is
+            # simply skipped.
+            pass
+
     @objc.python_method
     def _flush_draft_hovers(self):
         """Bank any hover still in progress (pointer inside a draft box at
@@ -2481,6 +2606,7 @@ class _ReviewController(NSObject):
     @objc.python_method
     def _finish(self):
         global _active
+        self._cancel_pending_hover()
         self._close_stats_popover()
         self._stop_age_expiry_timer()
         if self._host_view is not None:

package/mcp/menubar/s4l_card_canvas.py

@@ -62,17 +62,24 @@ from Foundation import NSObject, NSMakeRect, NSMakeSize
 from AppKit import (
     NSApp,
     NSButton,
+    NSColor,
     NSFont,
     NSScrollView,
     NSView,
     NSWindowOcclusionStateVisible,
     NSBackingStoreBuffered,
     NSNormalWindowLevel,
+    NSFloatingWindowLevel,
     NSApplicationActivationPolicyAccessory,
     NSWindowStyleMaskTitled,
     NSWindowStyleMaskClosable,
     NSWindowStyleMaskUtilityWindow,
+    NSWindowStyleMaskResizable,
     NSBezelStyleRounded,
+    NSViewWidthSizable,
+    NSViewHeightSizable,
+    NSViewMinXMargin,
+    NSViewMinYMargin,
 )
 
 # Reuse the corner card's panel class (Cmd+V/C/X/A/Z routing for a status-bar
@@ -84,7 +91,6 @@ from s4l_card import (
     _ReviewPanel,
     _ReviewController,
     _label,
-    _frosted,
     _round_rect,
     _fill_color,
     _mouse_screen,
@@ -207,6 +213,7 @@ class _CanvasController(NSObject):
             NSWindowStyleMaskTitled
             | NSWindowStyleMaskClosable
             | NSWindowStyleMaskUtilityWindow
+            | NSWindowStyleMaskResizable
             | NSWindowStyleMaskNonactivatingPanel
         )
         panel = _ReviewPanel.alloc().initWithContentRect_styleMask_backing_defer_(
@@ -229,19 +236,69 @@ class _CanvasController(NSObject):
         panel.setBecomesKeyOnlyIfNeeded_(True)
         panel.setHidesOnDeactivate_(False)
         panel.setReleasedWhenClosed_(False)
+        # Don't let a resize (user drag or heal_active moving to a smaller
+        # screen) shrink below one column + the header.
+        try:
+            panel.setContentMinSize_(NSMakeSize(TILE_W + 2 * WIN_MARGIN + 40, 420))
+        except Exception:
+            pass
         panel.setDelegate_(self)
         self._panel = panel
         self._render()
         panel.orderFrontRegardless()
         self._log_surface("presented")
         if self._focus:
+            self.raise_to_front()
+
+    @objc.python_method
+    def raise_to_front(self):
+        """Reliably bring the canvas above the current front app ONCE. The panel
+        is a NON-activating panel at NSNormalWindowLevel (so it behaves like a
+        normal window the reviewer works IN, per 2026-07-16), which means a plain
+        makeKeyAndOrderFront on our accessory app can leave it BEHIND the
+        frontmost app: window-level ordering, not activation, decides what covers
+        what, and a normal-level window can't jump above another normal-level
+        window that belongs to the active app. That is exactly the 2026-07-17
+        Nhat report -- the canvas 'presented' occluded ("didn't surface"). Fix:
+        briefly promote to NSFloatingWindowLevel so orderFrontRegardless is
+        guaranteed to place it in front regardless of activation, then demote
+        back to normal a beat later so other apps can cover it again (keeping the
+        "work IN it like a normal window" posture; always-on-top is the corner
+        card's job, not this one)."""
+        panel = self._panel
+        if panel is None:
+            return
+        try:
+            NSApp.setActivationPolicy_(NSApplicationActivationPolicyAccessory)
+            NSApp.activateIgnoringOtherApps_(True)
+        except Exception:
+            pass
+        try:
+            panel.setLevel_(NSFloatingWindowLevel)
+        except Exception:
+            pass
+        try:
+            panel.makeKeyAndOrderFront_(None)
+            panel.orderFrontRegardless()
+        except Exception:
+            pass
+        # Drop back to a normal window level once it's on screen. performSelector
+        # keeps it above other windows just long enough to land in front; if
+        # scheduling ever fails, demote inline so it can never stay stuck on top.
+        try:
+            self.performSelector_withObject_afterDelay_("demoteWindowLevel:", None, 0.6)
+        except Exception:
             try:
-                NSApp.setActivationPolicy_(NSApplicationActivationPolicyAccessory)
-                NSApp.activateIgnoringOtherApps_(True)
+                panel.setLevel_(NSNormalWindowLevel)
             except Exception:
                 pass
-            panel.makeKeyAndOrderFront_(None)
-            panel.orderFrontRegardless()
+
+    def demoteWindowLevel_(self, _):
+        try:
+            if self._panel is not None:
+                self._panel.setLevel_(NSNormalWindowLevel)
+        except Exception:
+            pass
 
     @objc.python_method
     def _render(self):
@@ -259,6 +316,12 @@ class _CanvasController(NSObject):
         approve_x = w - WIN_MARGIN - btn_w
         discard_x = approve_x - btn_gap - btn_w
 
+        # Header widgets pin to the TOP edge (flexible bottom margin) so a
+        # window-frame change after build -- heal_active recentering on a
+        # different-sized screen, or a user resize -- can never clip the
+        # header under the title bar again (2026-07-16 user report: "the top
+        # bar gets stuck"; layout was built once and never followed the
+        # frame). Buttons additionally pin RIGHT (flexible left margin).
         discard_btn = NSButton.alloc().initWithFrame_(NSMakeRect(discard_x, btn_y, btn_w, btn_h))
         discard_btn.setTitle_("Discard All")
         discard_btn.setBezelStyle_(NSBezelStyleRounded)
@@ -269,6 +332,7 @@ class _CanvasController(NSObject):
         discard_btn.setFont_(NSFont.systemFontOfSize_(12))
         discard_btn.setTarget_(self)
         discard_btn.setAction_("discardAllClicked:")
+        discard_btn.setAutoresizingMask_(NSViewMinXMargin | NSViewMinYMargin)
         content.addSubview_(discard_btn)
 
         approve_btn = NSButton.alloc().initWithFrame_(NSMakeRect(approve_x, btn_y, btn_w, btn_h))
@@ -277,6 +341,7 @@ class _CanvasController(NSObject):
         approve_btn.setFont_(NSFont.systemFontOfSize_(12))
         approve_btn.setTarget_(self)
         approve_btn.setAction_("approveAllClicked:")
+        approve_btn.setAutoresizingMask_(NSViewMinXMargin | NSViewMinYMargin)
         content.addSubview_(approve_btn)
 
         self._count_label = _label(
@@ -285,6 +350,7 @@ class _CanvasController(NSObject):
             size=13,
             bold=True,
         )
+        self._count_label.setAutoresizingMask_(NSViewWidthSizable | NSViewMinYMargin)
         content.addSubview_(self._count_label)
 
         body_y = WIN_MARGIN
@@ -295,13 +361,29 @@ class _CanvasController(NSObject):
         )
         scroll.setHasVerticalScroller_(True)
         scroll.setAutohidesScrollers_(True)
-        scroll.setDrawsBackground_(False)
+        # OPAQUE background, deliberately (2026-07-16 scroll-perf fix): a
+        # transparent scroll view can't blit already-drawn pixels on scroll
+        # (copy-on-scroll and responsive-scrolling overdraw are both off for
+        # it), so every wheel tick re-rendered the entire visible grid --
+        # dozens of tiles, each with 2-3 nested text views -- and scrolling
+        # visibly lagged. Same reason the canvas window skips the corner
+        # card's _frosted vibrancy underlay below: compositing the whole
+        # grid over a live behind-window blur was most of the per-frame
+        # cost, for an effect barely visible behind a full grid of tiles.
+        scroll.setDrawsBackground_(True)
+        try:
+            scroll.setBackgroundColor_(NSColor.windowBackgroundColor())
+        except Exception:
+            pass
+        scroll.setAutoresizingMask_(NSViewWidthSizable | NSViewHeightSizable)
         content.addSubview_(scroll)
         self._scroll = scroll
 
         self._build_grid(scroll)
 
-        self._panel.setContentView_(_frosted(content))
+        # Plain content view, no _frosted wrapper (see the opaque-background
+        # comment above). NSPanel's own windowBackgroundColor fills the rest.
+        self._panel.setContentView_(content)
         self._refresh_header()
 
     # ---- grid layout ---------------------------------------------------------
@@ -325,6 +407,15 @@ class _CanvasController(NSObject):
         # visible in the window, we need a scroll bar").
         self._cols = max(1, min(GRID_COLS, int((self._doc_w + GRID_GAP) // (TILE_W + GRID_GAP))))
         doc = _FlippedView.alloc().initWithFrame_(NSMakeRect(0, 0, self._doc_w, cs.height))
+        # Layer-backed explicitly: scrolling then moves composited layers
+        # instead of re-drawing views through the window backing store,
+        # which with this many tiles is the difference between smooth and
+        # laggy (2026-07-16 scroll-perf fix; pairs with the opaque scroll
+        # background in _render).
+        try:
+            doc.setWantsLayer_(True)
+        except Exception:
+            pass
         self._doc = doc
         self._slots = []
         scroll.setDocumentView_(doc)
@@ -411,6 +502,15 @@ class _CanvasController(NSObject):
         self._reflow_from(idx)
         self._resize_doc()
         self._refresh_header()
+        # Last card decided -> nothing left to review, so close the canvas
+        # instead of leaving an empty "0 pending drafts" window on screen.
+        # _finish() fires on_complete with every decision made this session,
+        # exactly like the corner card auto-finishing past its final draft
+        # (s4l_card._advance). Reached from a tile completing (approve/reject)
+        # and from prune_drafts draining the last candidate; either way an
+        # empty canvas has no reason to stay up.
+        if not self._order and self._panel is not None:
+            self._finish()
 
     # Approve All / Discard All buttons live in the header row (see
     # _render()), not a dedicated card -- these two actions just target the
@@ -571,6 +671,30 @@ class _CanvasController(NSObject):
         )
         _write_review_state(controller=self, last_event=event)
 
+    @objc.python_method
+    def _relayout_grid(self):
+        """Recompute geometry after the window's frame changed (user resize,
+        or heal_active recentering on a different-sized screen): column
+        count and slot POSITIONS only -- tiles are subviews of their slot
+        views and move with them, so in-progress edits survive a resize
+        untouched (unlike _reflow_from, which rebuilds content)."""
+        if self._scroll is None or self._doc is None:
+            return
+        cs = self._scroll.contentSize()
+        self._doc_w = cs.width
+        self._cols = max(
+            1, min(GRID_COLS, int((self._doc_w + GRID_GAP) // (TILE_W + GRID_GAP)))
+        )
+        for i, slot in enumerate(self._slots):
+            slot["view"].setFrame_(self._slot_frame(i))
+        self._resize_doc()
+
+    def windowDidResize_(self, notification):
+        try:
+            self._relayout_grid()
+        except Exception as e:
+            _log(f"canvas relayout failed: {e}")
+
     def windowDidMove_(self, notification):
         now = time.time()
         if now - self._last_move_log < 1.0:
@@ -676,13 +800,10 @@ def focus_active():
     if c is None or c._panel is None:
         return False
     try:
-        NSApp.setActivationPolicy_(NSApplicationActivationPolicyAccessory)
-        NSApp.activateIgnoringOtherApps_(True)
-    except Exception:
-        pass
-    try:
-        c._panel.makeKeyAndOrderFront_(None)
-        c._panel.orderFrontRegardless()
+        # Same reliable front-raise as the initial focused present: a brief
+        # window-level promotion so an already-open canvas comes above the front
+        # app even though it is a non-activating normal-level panel.
+        c.raise_to_front()
         c._panel.makeMainWindow()
         return True
     except Exception: