@m13v/s4l 1.7.2-rc.9 → 1.7.3

package/mcp/menubar/s4l_card.py

@@ -8,6 +8,17 @@ fires once the last card is decided or the window is closed. The whole AppKit
 surface is isolated behind that one function so the menu bar wiring doesn't
 depend on the windowing details.
 
+The panel is NONACTIVATING and auto-presented cards never take keyboard focus
+(2026-07-09 customer complaint: cards stole the caret mid-typing); the reply
+field becomes editable on first click, and only a user-initiated open
+(present_review(focus=True), the menu bar's "Review N pending drafts")
+activates the app and seats the caret immediately. A title-bar "Snooze 1h"
+button sits top-left where the traffic lights would be (they're hidden: the
+panel can't minimize or zoom, and the cross duplicated Snooze); it just
+closes the panel, and the menu bar interprets any close with undecided
+drafts (including Cmd-W) as a snooze (drafts stay pending, re-present after
+REVIEW_SNOOZE_SECONDS).
+
 Decision shape: {"n": int, "approved": bool, "loved": bool, "text": str,
 "edited": bool, "drop_link": bool, "reject_category": str|None,
 "reject_note": str|None, "interactions": [{"type": str, "ts": str}],
@@ -49,6 +60,7 @@ run loop, so that holds).
 
 import datetime
 import json
+import os
 import re
 import time
 
@@ -116,6 +128,42 @@ try:
     from AppKit import NSVisualEffectView
 except Exception:
     NSVisualEffectView = None
+# Nonactivating panel: an auto-presented card must never yank keyboard focus
+# from whatever the user is typing into (customer complaint 2026-07-09); the
+# panel becomes key only when the user clicks into one of its text fields.
+# Bit value 1 << 7 per AppKit; 0 degrades to the old always-activating panel.
+try:
+    from AppKit import NSWindowStyleMaskNonactivatingPanel
+except Exception:
+    NSWindowStyleMaskNonactivatingPanel = 0
+# Title-bar "Snooze 1h" button (top-left, where the traffic lights would be;
+# those are hidden because minimize/zoom are disabled no-ops on this panel and
+# the close cross just duplicated Snooze). Missing on very old AppKit; the
+# card then degrades to the stock cross (closing still snoozes, the labeled
+# button is just absent) because the traffic lights are only hidden when the
+# accessory actually mounted.
+try:
+    from AppKit import (
+        NSTitlebarAccessoryViewController,
+        NSLayoutAttributeLeft,
+        NSLayoutAttributeRight,
+    )
+except Exception:
+    NSTitlebarAccessoryViewController = None
+    NSLayoutAttributeLeft = None
+    NSLayoutAttributeRight = None
+try:
+    from AppKit import (
+        NSWindowCloseButton,
+        NSWindowMiniaturizeButton,
+        NSWindowZoomButton,
+    )
+except Exception:
+    NSWindowCloseButton = NSWindowMiniaturizeButton = NSWindowZoomButton = None
+try:
+    from AppKit import NSBezelStyleInline
+except Exception:
+    NSBezelStyleInline = None
 try:
     # Registers the CGColor bridge type; without it every NSColor.CGColor()
     # call in _round_rect logs an ObjCPointerWarning to menubar.err.log.
@@ -149,14 +197,28 @@ REJECT_REASONS = (
 # Client-side cap on tracked interactions per card (server clips at 50 too).
 MAX_INTERACTIONS = 50
 
-# Inline approve row: emoji + tooltip per approval level (button tag =
-# level). Level 1 = plain approve; 2+ = loved=True on the decision, with the
+
+def _snooze_secs():
+    """Snooze duration, for the title-bar button LABEL only. The menu bar owns
+    the actual timer (its REVIEW_SNOOZE_SECONDS reads the same env var)."""
+    try:
+        return max(60, int(float(os.environ.get("S4L_REVIEW_SNOOZE_S", "3600"))))
+    except Exception:
+        return 3600
+
+
+def _snooze_title():
+    s = _snooze_secs()
+    return f"Snooze {s // 3600}h" if s % 3600 == 0 else f"Snooze {s // 60}m"
+
+# Inline approve row: glyph + tooltip per approval level (button tag =
+# level). Level 1 = plain approve; 2 = loved=True on the decision, with the
 # exact level shipped as an approve_level_N interaction for the feedback
-# digest.
+# digest. Monochrome text-presentation glyphs (U+FE0E) so the buttons stay
+# black-and-white in both appearances instead of rendering as color emoji.
 APPROVE_EMOJIS = (
-    ("👍", "Approve"),
-    ("😄", "Approve, really good pick"),
-    ("❤️‍🔥", "Approve, best of the best"),
+    ("✓︎", "Approve"),
+    ("♥︎", "Approve, best of the best"),
 )
 
 # Review-surface state mirrored to the state dir for out-of-process observers
@@ -626,13 +688,21 @@ def _editable_scroll(frame, text=""):
 
 
 class _ReviewController(NSObject):
-    def initWithDrafts_onDecision_onComplete_(self, drafts, on_decision, on_complete):
+    def initWithDrafts_onDecision_onComplete_focus_(
+        self, drafts, on_decision, on_complete, focus
+    ):
         self = objc.super(_ReviewController, self).init()
         if self is None:
             return None
         self._drafts = list(drafts)
         self._on_decision = on_decision
         self._on_complete = on_complete
+        # focus=True only for a USER-initiated open (the menu bar's "Review N
+        # pending drafts"): activate the app and seat the caret in the reply
+        # field. Auto-presented cards (the timer tick) must appear without
+        # taking keyboard focus from whatever the user is doing.
+        self._focus = bool(focus)
+        self._close_reason = None  # "snooze" when the title-bar button closed us
         self._idx = 0
         self._decisions = []
         self._panel = None
@@ -776,26 +846,35 @@ class _ReviewController(NSObject):
             NSWindowStyleMaskTitled
             | NSWindowStyleMaskClosable
             | NSWindowStyleMaskUtilityWindow
+            | NSWindowStyleMaskNonactivatingPanel
         )
         panel = _ReviewPanel.alloc().initWithContentRect_styleMask_backing_defer_(
             frame, style, NSBackingStoreBuffered, False
         )
         panel.setLevel_(NSFloatingWindowLevel)
         panel.setFloatingPanel_(True)
-        panel.setBecomesKeyOnlyIfNeeded_(False)  # let the reply field be edited
+        # Key only when a text field is clicked: buttons (Approve/Reject) work
+        # without ever taking keyboard focus, and clicking into the reply field
+        # makes this nonactivating panel key without activating the app, so
+        # the user's frontmost app keeps its state. The old False + activate-
+        # on-present combination stole the keyboard mid-typing (2026-07-09
+        # customer complaint).
+        panel.setBecomesKeyOnlyIfNeeded_(True)
         panel.setHidesOnDeactivate_(False)
         panel.setReleasedWhenClosed_(False)
         panel.setDelegate_(self)
+        self._add_snooze_accessory(panel)
         self._panel = panel
         self._render()
-        panel.makeKeyAndOrderFront_(None)
         panel.orderFrontRegardless()
         self._log_surface("presented")
-        self.focusReply_(None)
-        # App activation/key-window promotion lands on the run loop; do one
-        # deferred pass so the first card is editable even when opened from the
-        # status-bar timer while another app is frontmost.
-        self.performSelector_withObject_afterDelay_("focusReply:", None, 0.05)
+        if self._focus:
+            # User asked for the cards (menu item): behave like a normal open,
+            # activate and put the caret in the reply field. Deferred second
+            # pass because activation/key promotion lands on the run loop.
+            panel.makeKeyAndOrderFront_(None)
+            self.focusReply_(None)
+            self.performSelector_withObject_afterDelay_("focusReply:", None, 0.05)
 
     def focusReply_(self, sender):
         panel = self._panel
@@ -826,6 +905,120 @@ class _ReviewController(NSObject):
         except Exception:
             pass
 
+    @objc.python_method
+    def _add_snooze_accessory(self, panel):
+        """Title-bar controls, replacing the traffic lights: "Snooze 1h" at
+        the top-left (minimize/zoom were disabled no-op dots on this panel,
+        and the close cross meant snooze anyway, so one labeled button says
+        what the only dismissal actually does) and "Discard all…" at the
+        top-right (moved here from the menu bar dropdown 2026-07-10; the
+        ellipsis is honest, the handler opens a confirmation alert first).
+        Snooze just closes the panel; the menu bar treats any close with
+        undecided drafts as a snooze. The traffic lights are hidden ONLY once
+        the snooze accessory mounts, so a failure on old AppKit leaves the
+        stock cross as the fallback dismissal. Cmd-W keeps working either way
+        (the Closable mask stays on)."""
+        if NSTitlebarAccessoryViewController is None or NSLayoutAttributeLeft is None:
+            return
+        try:
+            self._add_titlebar_button(
+                panel,
+                title=_snooze_title(),
+                action="snoozeClicked:",
+                tooltip=(
+                    "Put these drafts away for now. They stay pending and the "
+                    "card comes back later (or sooner from the S4L menu)."
+                ),
+                layout=NSLayoutAttributeLeft,
+            )
+            self._hide_traffic_lights(panel)
+        except Exception as e:
+            _log(f"snooze accessory unavailable: {e}")
+        if _discard_all_handler is not None and NSLayoutAttributeRight is not None:
+            try:
+                self._add_titlebar_button(
+                    panel,
+                    title="Discard all…",
+                    action="discardAllClicked:",
+                    tooltip=(
+                        "Throw away every pending draft (asks first). Nothing "
+                        "posts, and unlike a per-card reject this sends no "
+                        "feedback signal to the AI."
+                    ),
+                    layout=NSLayoutAttributeRight,
+                )
+            except Exception as e:
+                _log(f"discard-all accessory unavailable: {e}")
+
+    @objc.python_method
+    def _add_titlebar_button(self, panel, title, action, tooltip, layout):
+        btn = NSButton.alloc().initWithFrame_(NSMakeRect(0, 0, 80, 17))
+        btn.setTitle_(title)
+        if NSBezelStyleInline is not None:
+            btn.setBezelStyle_(NSBezelStyleInline)
+        else:
+            btn.setBezelStyle_(NSBezelStyleRounded)
+        btn.setFont_(NSFont.systemFontOfSize_(10.0))
+        btn.setToolTip_(tooltip)
+        btn.setTarget_(self)
+        btn.setAction_(action)
+        btn.sizeToFit()
+        bf = btn.frame()
+        holder = NSView.alloc().initWithFrame_(
+            NSMakeRect(0, 0, bf.size.width + 8, max(19, bf.size.height + 2))
+        )
+        btn.setFrameOrigin_(
+            (4, max(0, (holder.frame().size.height - bf.size.height) / 2.0))
+        )
+        holder.addSubview_(btn)
+        acc = NSTitlebarAccessoryViewController.alloc().init()
+        acc.setView_(holder)
+        acc.setLayoutAttribute_(layout)
+        panel.addTitlebarAccessoryViewController_(acc)
+
+    @objc.python_method
+    def _hide_traffic_lights(self, panel):
+        """Hide close/minimize/zoom once the Snooze accessory is up: minimize
+        and zoom are disabled dots (no Miniaturizable/Resizable in the mask)
+        and the cross duplicated Snooze. Hiding, not removing: performClose_
+        (Cmd-W and snoozeClicked_) still routes through the hidden close
+        button's machinery, and windowShouldClose_ still fires."""
+        if NSWindowCloseButton is None:
+            return
+        for which in (
+            NSWindowCloseButton,
+            NSWindowMiniaturizeButton,
+            NSWindowZoomButton,
+        ):
+            try:
+                b = panel.standardWindowButton_(which)
+                if b is not None:
+                    b.setHidden_(True)
+            except Exception:
+                pass
+
+    def snoozeClicked_(self, sender):
+        self._track("snooze")
+        self._close_reason = "snooze"
+        try:
+            self._panel.performClose_(None)
+        except Exception:
+            self._finish()
+
+    def discardAllClicked_(self, sender):
+        """Hand off to the menu bar's bulk-discard handler (registered via
+        set_discard_all_handler); it confirms with the user, flips the store,
+        and dismisses this panel via dismiss_active(), so nothing more happens
+        here. On cancel the card simply stays up."""
+        self._track("discard_all")
+        cb = _discard_all_handler
+        if cb is None:
+            return
+        try:
+            cb()
+        except Exception as e:
+            _log(f"discard-all handler failed: {e}")
+
     @objc.python_method
     def _eye_button(self, frame, kind):
         """Borderless SF-Symbol eye whose hover/click opens a popover. A plain
@@ -884,12 +1077,13 @@ class _ReviewController(NSObject):
             # Bezeled, not borderless: bare emoji read as decoration and
             # users doubted the click registered (2026-07-03/04 feedback,
             # twice now — the outline is what says "button").
-            btn = NSButton.alloc().initWithFrame_(NSMakeRect(x, H - 42, 44, 30))
+            btn = NSButton.alloc().initWithFrame_(NSMakeRect(x, H - 42, 38, 30))
             btn.setTitle_(emoji)
             btn.setBezelStyle_(NSBezelStyleRounded)
-            # 13pt = the size Reject's title renders at; anything bigger
-            # overflows the rounded bezel's ~22px content lane (16pt did).
-            btn.setFont_(NSFont.systemFontOfSize_(13))
+            # 16pt fits the rounded bezel's ~22px content lane for these
+            # text-presentation glyphs (the old color emoji clipped at 16pt,
+            # which is why this used to be 13pt).
+            btn.setFont_(NSFont.systemFontOfSize_(16))
             btn.setTag_(i + 1)  # tag = approval level
             btn.setTarget_(self)
             btn.setAction_("approve:")
@@ -898,7 +1092,7 @@ class _ReviewController(NSObject):
             except Exception:
                 pass
             content.addSubview_(btn)
-            x += 48
+            x += 42
 
         reject = NSButton.alloc().initWithFrame_(NSMakeRect(W - M - 66, H - 42, 66, 30))
         reject.setTitle_("Reject")
@@ -1239,9 +1433,15 @@ class _ReviewController(NSObject):
         )
         # setContentView_ rebuilds the view tree, so the caret would otherwise
         # default to the Approve button. Re-seat it in the reply field for every
-        # card (not just the first) so each one is immediately editable.
-        self._panel.makeFirstResponder_(tv)
-        self.performSelector_withObject_afterDelay_("focusReply:", None, 0.05)
+        # card the user is ACTIVELY reviewing (they opened the stack from the
+        # menu, or already decided/touched something), so each one is
+        # immediately editable. NOT on the initial auto-presented render:
+        # focusReply_ activates the app, and yanking the caret out of whatever
+        # the user was typing was the 2026-07-09 "too distracting" complaint.
+        # An untouched card's field becomes editable on first click instead.
+        if self._focus or self._decisions or self._last_interaction_at is not None:
+            self._panel.makeFirstResponder_(tv)
+            self.performSelector_withObject_afterDelay_("focusReply:", None, 0.05)
 
     @objc.python_method
     def _close_stats_popover(self):
@@ -1600,6 +1800,37 @@ class _ReviewController(NSObject):
         self._log_surface(f"extended +{len(added)}")
         return len(added)
 
+    @objc.python_method
+    def prune_drafts(self, ns):
+        """Drop not-yet-reached drafts (plan index `n` in `ns`) from the stack,
+        e.g. a card the backend already retired (expired freshness gate, etc.)
+        while it was still waiting to be shown. Only ever removes entries AFTER
+        the current index, so the card on screen right now and everything
+        already decided are untouched -- nothing visible disappears out from
+        under the user. Refreshes the title-bar counter live. Returns the
+        count actually removed."""
+        if self._panel is None or not ns:
+            return 0
+        ns = set(ns)
+        kept = []
+        removed = 0
+        for i, d in enumerate(self._drafts):
+            if i > self._idx and d.get("n") in ns:
+                removed += 1
+                continue
+            kept.append(d)
+        if not removed:
+            return 0
+        self._drafts = kept
+        try:
+            self._panel.setTitle_(
+                f"s4l · Review draft {self._idx + 1} of {len(self._drafts)}"
+            )
+        except Exception:
+            pass
+        self._log_surface(f"pruned {removed} expired")
+        return removed
+
     @objc.python_method
     def _fire_decision(self):
         # Fire the per-card callback the instant a decision is made, so an
@@ -1761,7 +1992,10 @@ class _ReviewController(NSObject):
 
     def windowShouldClose_(self, sender):
         # Closing the window stops review; remaining cards are left undecided
-        # (not posted). Finish with whatever was decided so far.
+        # (not posted). Finish with whatever was decided so far. The menu bar
+        # treats a close with undecided drafts as SNOOZE (they re-present after
+        # REVIEW_SNOOZE_SECONDS, or sooner via the menu), whether it came from
+        # the cross or the title-bar Snooze button.
         self._finish()
         return True
 
@@ -1783,11 +2017,12 @@ class _ReviewController(NSObject):
             except Exception:
                 pass
         _active = None
-        _log(f"closed: {len(self._decisions)} decided of {len(self._drafts)}")
-        _write_review_state(last_event="closed")
+        reason = self._close_reason or "closed"
+        _log(f"closed: {len(self._decisions)} decided of {len(self._drafts)} ({reason})")
+        _write_review_state(last_event="snoozed" if reason == "snooze" else "closed")
 
 
-def present_review(drafts, on_decision=None, on_complete=None):
+def present_review(drafts, on_decision=None, on_complete=None, focus=False):
     """Show the review cards (main thread only). drafts: list of
     {n, thread_author, thread_text, reply_text, link_url, thread_url?, stats?}
     where stats is the discovery-time candidate snapshot
@@ -1809,14 +2044,17 @@ def present_review(drafts, on_decision=None, on_complete=None):
     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."""
+    finishes the last card or closes the window. Both run on the main thread.
+    focus=True (user-initiated open, e.g. the menu bar's "Review N pending
+    drafts") activates the app and seats the caret in the reply field; the
+    default False shows the card without taking keyboard focus."""
     global _active
     if not drafts:
         if on_complete is not None:
             on_complete([])
         return
-    _active = _ReviewController.alloc().initWithDrafts_onDecision_onComplete_(
-        drafts, on_decision, on_complete
+    _active = _ReviewController.alloc().initWithDrafts_onDecision_onComplete_focus_(
+        drafts, on_decision, on_complete, focus
     )
 
 
@@ -1832,6 +2070,22 @@ def extend_active(drafts):
         return 0
 
 
+def prune_active(ns):
+    """Remove not-yet-reached drafts (by plan index `n`) from the open review
+    card, if one is up -- e.g. a card that expired on the backend mid-review
+    (see merge_review_queue.py's backend sync). Never touches the card
+    currently on screen or any already-decided one, so nothing visible is
+    yanked out from under the user. Returns the count actually removed (0 if
+    no card is open or none of `ns` are still ahead in the stack). Main thread
+    only (called from the menu bar's rumps timer)."""
+    if _active is None or not ns:
+        return 0
+    try:
+        return _active.prune_drafts(ns)
+    except Exception:
+        return 0
+
+
 def active_status():
     """Live review-surface snapshot for the menu bar's unattended-review
     watchdog, or None when no card is open. Main thread only."""
@@ -1913,6 +2167,20 @@ def heal_active():
         return False
 
 
+def focus_active():
+    """Bring the open card to the user deliberately (menu 'Review pending
+    drafts' while a card is already up): activate + caret in the reply field.
+    Main thread only. Returns True if a card was focused."""
+    c = _active
+    if c is None or c._panel is None:
+        return False
+    try:
+        c.focusReply_(None)
+        return True
+    except Exception:
+        return False
+
+
 # ---- overall-feedback composer ----------------------------------------------
 # One small floating panel with a free-text field, for guidance that is about
 # the PIPELINE rather than any single draft ("less shilling", "more dev
@@ -1940,6 +2208,21 @@ def set_feedback_handler(cb):
     _feedback_handler = cb
 
 
+# Bulk-discard hook for the title bar's "Discard all…" button, same
+# registration pattern as _feedback_handler above. The menu bar registers
+# _discard_all_pending here (it owns the confirmation alert, the store flip,
+# and dismissing the panel). Cards built while this is None simply don't get
+# the button.
+_discard_all_handler = None
+
+
+def set_discard_all_handler(cb):
+    """Register the title-bar "Discard all…" action. The menu bar calls this
+    before presenting cards with its bulk-discard handler."""
+    global _discard_all_handler
+    _discard_all_handler = cb
+
+
 def _feedback_frame():
     """Just below the open review card when there is one (so it never covers
     the card being reviewed), else the top-right corner of the pointer's

package/mcp/menubar/s4l_log_relay.py

@@ -165,6 +165,38 @@ def _loop():
             pass
 
 
+def emit(line, context="menubar"):
+    """Buffer ONE structured line for the relay under a caller-chosen context
+    (e.g. "browser-foreground"), and mirror it to the real stderr so the local
+    menubar.err.log keeps a copy. Bypasses the _Tee so the line is not ALSO
+    buffered under the default "menubar" context. Best-effort; never raises."""
+    try:
+        t = str(line).strip()
+        if not t or _BASE64_BLOB_RE.match(t):
+            return
+        real = sys.stderr._real if isinstance(sys.stderr, _Tee) else sys.stderr
+        try:
+            real.write(t + "\n")
+            real.flush()
+        except Exception:
+            pass
+        if not ENABLED:
+            return
+        with _lock:
+            _buf.append(
+                {
+                    "ts": _now_iso(),
+                    "stream": "stdout",
+                    "line": t[:MAX_LINE_LEN],
+                    "context": str(context or "menubar")[:200],
+                }
+            )
+            if len(_buf) > MAX_BUFFER:
+                del _buf[: len(_buf) - MAX_BUFFER]
+    except Exception:
+        pass
+
+
 def install():
     """Wrap sys.stderr with the relay tee and start the background flusher.
     Call once at menubar boot, after the S4L_REPO_DIR sys.path insertion."""