relay-companion 0.1.39 → 0.1.40

package/overlay/inbox.html

@@ -100,7 +100,7 @@
   }
   .count {
     font-family:var(--mono); font-size:13px; font-weight:500; font-variant-numeric:tabular-nums;
-    color:var(--accent); line-height:1; transition:color .3s var(--settle);
+    color:var(--accent); line-height:1; white-space:nowrap; transition:color .3s var(--settle);
   }
   .count.zero { color:var(--muted-3); }
   /* ✕ — fully hide the overlay; the Relay mark in the OS status area brings it back.
@@ -651,7 +651,7 @@
 
   const REDUCED = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
   const EXPANDED = { w: 344, h: 524 };
-  const PILL = { w: 178, h: 44 }; // wide enough for mark + word + count + ✕
+  const PILL = { w: 244, h: 44 }; // wide enough for mark + word + "N unopened" + ✕
   const PEEK = { w: 344, h: 118 };
 
   // ---------- zero-latency sound (Web Audio, pre-decoded) ----------
@@ -720,16 +720,19 @@
   // ---------- collapse / expand / peek ----------
   let collapsed = false;
   let peeking = false, peekTimer = null;
+  let notificationDurationMs = 7000;
+  let activeNotificationIds = [];
   let ghost = false, ghostTimer = null; // notification-only mode while the pill is dismissed
   function clearPeek() {
     if (peekTimer) { clearTimeout(peekTimer); peekTimer = null; }
     peeking = false;
-    cardEl.classList.remove("peek");
+    cardEl.classList.remove("peek", "notifying");
   }
   function setCollapsed(v) {
     clearPeek();
     if (v === collapsed) return;
     collapsed = v;
+    refreshCountLabel();
     cardEl.classList.toggle("collapsed", collapsed);
     springTo(collapsed ? PILL.w : EXPANDED.w, collapsed ? PILL.h : EXPANDED.h);
     playTink();
@@ -747,6 +750,7 @@
     if (ghostTimer) { clearTimeout(ghostTimer); ghostTimer = null; }
     clearPeek();
     collapsed = false;
+    refreshCountLabel();
     cardEl.classList.add("offstage");
     cardEl.classList.remove("collapsed", "ghost", "bye");
     snapSize(EXPANDED.w, EXPANDED.h);
@@ -767,6 +771,10 @@
     if (ghostTimer) { clearTimeout(ghostTimer); ghostTimer = null; }
     if (peekTimer) { clearTimeout(peekTimer); peekTimer = null; }
     const wasGhost = ghost;
+    if (!wasGhost && activeNotificationIds.length && window.relay.attentionDone) {
+      window.relay.attentionDone(activeNotificationIds);
+      activeNotificationIds = [];
+    }
     cardEl.classList.add("bye");
     setInteractive(false);
     byeTimer = setTimeout(() => {
@@ -784,6 +792,7 @@
     cancelBye(); // a banner arriving mid-exit must not be torn down by the old exit
     clearPeek();
     collapsed = false;
+    refreshCountLabel();
     cardEl.classList.remove("collapsed", "offstage", "bye");
     ghost = true; peeking = true;
     cardEl.classList.add("peek", "ghost");
@@ -801,11 +810,13 @@
       ghostTimer = null;
       if (interactive || quickReplyIsActive()) { ghostTimer = setTimeout(tick, 4000); return; }
       dismissOverlay(); // rides the ghostOut exit, then main re-hides the window
-    }, 7000);
+    }, notificationDurationMs);
   }
   // Status-area Relay mark clicked: the card comes back FULLY OPEN (never the pill).
   function trayOpen() {
     const wasOffstage = cardEl.classList.contains("offstage") || cardEl.classList.contains("bye");
+    const completedNotificationIds = activeNotificationIds;
+    activeNotificationIds = [];
     cancelBye(); // a reopen mid-exit must survive: the pending dismiss would hide us again
     if (ghostTimer) { clearTimeout(ghostTimer); ghostTimer = null; }
     ghost = false;
@@ -825,30 +836,38 @@
       springTo(EXPANDED.w, EXPANDED.h);
     }
     renderAll();
+    if (completedNotificationIds.length && window.relay.attentionDone) window.relay.attentionDone(completedNotificationIds);
     playTink();
   }
   // The banner must show its WHOLE first row — a clipped preview reads as broken.
   // Measure after render; QR question rows are tall, so allow room before capping.
   function peekHeight() {
-    const first = scrollEl.querySelector(".row, .task");
-    const rowH = first ? first.offsetHeight : 74;
-    return Math.min(44 + rowH + 6, 340);
-  }
-  // A new relay arrived. If folded, peek open like an iOS banner (~7s) then fold back.
-  // The peek routes to Relays. Task/share rows are hidden until that product surface is ready.
-  function notifyArrival(row) {
-    if (!collapsed && !peeking) return;
+    const stack = [...relaysListEl.querySelectorAll(".row")];
+    const rowsHeight = stack.reduce((sum, row) => sum + row.offsetHeight, 0);
+    return Math.min(44 + rowsHeight + 6, EXPANDED.h);
+  }
+  // New relays always enter the notification stack, including from a fully expanded
+  // card. The main process has already pushed the new payload, so render/sizing uses
+  // the latest unopened rows rather than the previous inbox.
+  function notifyArrival(rows) {
     if (peekTimer) clearTimeout(peekTimer);
+    cancelBye();
+    if (ghostTimer) { clearTimeout(ghostTimer); ghostTimer = null; }
+    ghost = false;
     peeking = true;
     collapsed = false;
-    cardEl.classList.remove("collapsed");
-    cardEl.classList.add("peek");
+    refreshCountLabel();
+    activeNotificationIds = (Array.isArray(rows) ? rows : [rows]).filter(Boolean).map((row) => row.id).filter(Boolean);
+    cardEl.classList.remove("collapsed", "peek", "offstage", "ghost", "bye");
+    // Keep the exact production expanded UI (tabs, typography, separators). This
+    // class is state-only for tests; it intentionally has no visual CSS of its own.
+    cardEl.classList.add("notifying");
     activeView = "relays";
     syncTabs();
     applyView();
     renderAll();
     scrollEl.scrollTop = 0;
-    springTo(PEEK.w, peekHeight());
+    springTo(EXPANDED.w, EXPANDED.h);
     playTink();
     peekTimer = setTimeout(function tick() {
       peekTimer = null;
@@ -858,10 +877,14 @@
       // hold while hovered too). Mirrors the ghost-notification guard.
       if (interactive || quickReplyIsActive()) { peekTimer = setTimeout(tick, 4000); return; }
       peeking = false;
-      cardEl.classList.remove("peek");
+      cardEl.classList.remove("peek", "notifying");
       collapsed = true; cardEl.classList.add("collapsed");
+      refreshCountLabel();
       springTo(PILL.w, PILL.h);
-    }, 7000);
+      renderAll(); // restore the normal full list behind the now-folded pill
+      if (activeNotificationIds.length && window.relay.attentionDone) window.relay.attentionDone(activeNotificationIds);
+      activeNotificationIds = [];
+    }, notificationDurationMs);
   }
   function openFull() {
     if (ghost) {
@@ -872,10 +895,15 @@
       if (ghostTimer) { clearTimeout(ghostTimer); ghostTimer = null; }
       window.relay.undismiss();
     }
+    const completedNotificationIds = activeNotificationIds;
+    activeNotificationIds = [];
     clearPeek();
     collapsed = false;
+    refreshCountLabel();
     cardEl.classList.remove("collapsed");
     springTo(EXPANDED.w, EXPANDED.h);
+    renderAll();
+    if (completedNotificationIds.length && window.relay.attentionDone) window.relay.attentionDone(completedNotificationIds);
     playTink();
   }
 
@@ -1159,13 +1187,19 @@
     else window.relay.open(id);
   }
 
+  let unreadCount = 0;
+  function refreshCountLabel() {
+    const label = collapsed ? `${unreadCount} unopened` : String(unreadCount);
+    if (countEl.textContent !== label) {
+      countEl.textContent = label;
+      if (!REDUCED) { countEl.style.animation = "none"; void countEl.offsetWidth; countEl.style.animation = "countRoll .2s var(--settle)"; }
+    }
+  }
   function setCount(n) {
+    unreadCount = n;
     cardEl.classList.toggle("has-unread", n > 0);
     countEl.classList.toggle("zero", n === 0);
-    if (countEl.textContent !== String(n)) {
-      countEl.textContent = String(n);
-      if (!REDUCED) { countEl.style.animation = "none"; void countEl.offsetWidth; countEl.style.animation = "countRoll .2s var(--settle)"; }
-    }
+    refreshCountLabel();
   }
 
   function setBadge(el, n) {
@@ -1199,7 +1233,8 @@
     // focused textarea and lose what the user is typing. Defer and re-render on blur/submit.
     if (quickReplyIsActive()) { pendingRelaysRender = true; return; }
     pendingRelaysRender = false;
-    const rows = (payload.relays || []).filter(isRelayListKind);
+    const allRows = (payload.relays || []).filter(isRelayListKind);
+    const rows = peeking ? allRows.filter((row) => row.unread) : allRows;
     relaysEmptyEl.classList.toggle("gone", rows.length > 0);
     const seen = prevRelayIds;
     relaysListEl.innerHTML = rows.map((r) => {
@@ -2115,6 +2150,10 @@
       tasks: Array.isArray(next.tasks) ? next.tasks : [],
       contacts: Array.isArray(next.contacts) ? next.contacts : (payload.contacts || []),
     };
+    const configuredDuration = Number(next.ui && next.ui.notificationDurationMs);
+    notificationDurationMs = Number.isFinite(configuredDuration) && configuredDuration >= 250
+      ? configuredDuration
+      : 7000;
     renderAll();
   }
 

package/overlay/main.cjs

@@ -20,7 +20,7 @@
 //   - Mutations (accept/reject/approve/decline/answer) call RelayClient with device-token
 //     auth. ack/mark-read writes state.json directly (atomic temp+rename).
 
-const { app, BrowserWindow, Menu, Tray, ipcMain, nativeImage, shell, screen, systemPreferences } = require("electron");
+const { app, BrowserWindow, Menu, Tray, ipcMain, nativeImage, powerMonitor, shell, screen, systemPreferences } = require("electron");
 const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
@@ -30,7 +30,7 @@ const { execFile, execFileSync, spawn, pathToFileURL } = (() => {
   return { execFile: cp.execFile, execFileSync: cp.execFileSync, spawn: cp.spawn, pathToFileURL: url.pathToFileURL };
 })();
 const { hostFromBundle, chooseClickHost, runningHostsFromProcessList } = require("./host-select.cjs");
-const { overlayWanted, createHostRunningTracker, shouldIgnoreDismiss } = require("./visibility.cjs");
+const { overlayWanted, createHostRunningTracker, shouldIgnoreDismiss, boundedPresentedRelayIds } = require("./visibility.cjs");
 const { withJsonLock } = require("../src/state-lock.cjs");
 const {
   reinforceSpacePresence,
@@ -61,25 +61,51 @@ let lastHostSeenAt = 0;
 let lastSig = "";
 
 // Dismissed mode: the user clicked the ✕ on the card, so the overlay stays hidden
-// until they click the Relay status-area icon. Persisted across relaunches. While
-// dismissed, a fresh relay still shows the designed notification (a "ghost" peek):
-// the window appears just for the banner, then hides again when it finishes.
+// until they click the Relay status-area icon OR a genuinely new relay arrives. A new
+// relay latches the pill visible until the user dismisses it again, so an arrival can
+// never spend seven seconds behind a lock screen and then disappear for good.
 const OVERLAY_PREFS_PATH = path.join(RELAY_HOME, "overlay-prefs.json");
-let dismissed = false;
-let ghostActive = false; // a ghost notification is on screen while dismissed
-let trayForcedVisible = false; // tray click while no host is running still shows the card
+let overlayPrefs = {};
 try {
-  dismissed = JSON.parse(fs.readFileSync(OVERLAY_PREFS_PATH, "utf8")).dismissed === true;
+  overlayPrefs = JSON.parse(fs.readFileSync(OVERLAY_PREFS_PATH, "utf8")) || {};
 } catch {}
-function setDismissed(value) {
-  dismissed = Boolean(value);
+let dismissed = overlayPrefs.dismissed === true;
+let attentionLatched = overlayPrefs.attentionLatched === true;
+const presentedRelayIds = new Set(
+  Array.isArray(overlayPrefs.presentedRelayIds) ? overlayPrefs.presentedRelayIds.filter(Boolean).map(String) : [],
+);
+let ghostActive = false; // a ghost notification is on screen while dismissed
+let trayForcedVisible = false; // tray click while no host is running still shows the card
+const PRESENTED_RELAY_CAP = 500;
+function writeOverlayPrefs() {
   try {
     fs.mkdirSync(RELAY_HOME, { recursive: true });
-    fs.writeFileSync(OVERLAY_PREFS_PATH, `${JSON.stringify({ dismissed }, null, 2)}\n`);
+    fs.writeFileSync(
+      OVERLAY_PREFS_PATH,
+      `${JSON.stringify({ dismissed, attentionLatched, presentedRelayIds: [...presentedRelayIds] }, null, 2)}\n`,
+    );
   } catch (error) {
     console.error("[overlay] prefs write failed:", error && error.message);
   }
 }
+function setDismissed(value) {
+  dismissed = Boolean(value);
+  writeOverlayPrefs();
+}
+function markRelaysPresented(ids, retainedUnreadIds = []) {
+  const current = [...presentedRelayIds];
+  const bounded = boundedPresentedRelayIds(
+    current,
+    ids,
+    retainedUnreadIds,
+    PRESENTED_RELAY_CAP,
+  );
+  const changed = bounded.length !== current.length || bounded.some((id, index) => id !== current[index]);
+  if (!changed) return;
+  presentedRelayIds.clear();
+  for (const id of bounded) presentedRelayIds.add(id);
+  writeOverlayPrefs();
+}
 
 function reopenSurfaceName() {
   if (process.platform === "darwin") return "the Relay icon in the menu bar";
@@ -403,6 +429,7 @@ function buildPayload() {
     ui: {
       canDismiss: trayAvailable,
       reopenSurface: reopenSurfaceName(),
+      notificationDurationMs: Number(process.env.RELAY_OVERLAY_NOTIFICATION_MS) || 7000,
     },
     relays: readRelays(),
     sent: sentCache,
@@ -411,10 +438,74 @@ function buildPayload() {
   };
 }
 
-let knownIds = null; // null until first load, so we never "notify" for rows already present
 // Pushes are serialized: overlapping timers (fs.watch + safety poll + sent refresh)
 // must not interleave sends, or the renderer can paint an older payload last.
 let pushChain = Promise.resolve();
+const USER_IDLE_THRESHOLD_SECONDS = 15;
+let systemSuspended = false;
+let screenLocked = false;
+let loginSessionActive = true;
+let deferredAttention = false;
+let activeAttentionIds = new Set();
+let testAwayOverride = null;
+
+function userIsAway() {
+  if (testAwayOverride !== null) return testAwayOverride;
+  if (process.env.RELAY_OVERLAY_TEST_FORCE_ACTIVE === "1") return false;
+  if (systemSuspended || screenLocked || !loginSessionActive) return true;
+  try {
+    const state = powerMonitor.getSystemIdleState(USER_IDLE_THRESHOLD_SECONDS);
+    return state === "idle" || state === "locked";
+  } catch {
+    return false;
+  }
+}
+
+// If the machine locks or sleeps while a notification is still on screen, it was
+// probably never seen. Put the whole active stack back into the unpresented pool so
+// unlock/resume can show it again instead of merely revealing the collapsed pill.
+function requeueActiveAttention() {
+  if (!activeAttentionIds.size) return;
+  for (const id of activeAttentionIds) presentedRelayIds.delete(id);
+  activeAttentionIds = new Set();
+  deferredAttention = true;
+  writeOverlayPrefs();
+}
+
+function reconcileAttentionAfterReturn() {
+  if (userIsAway()) return;
+  deferredAttention = false;
+  refreshOverlayForActiveSpace({ force: true });
+  pushInbox(true).catch((error) => console.error("[overlay] return reconciliation failed:", error && error.message));
+}
+
+function scheduleReturnReconciliation() {
+  // The daemon and pill are independent launchd jobs. Reconcile now for already-
+  // staged rows, then again across the daemon's next poll for post-wake arrivals.
+  for (const delay of [0, 1200, 4500]) setTimeout(reconcileAttentionAfterReturn, delay);
+}
+
+function presentUnopenedStack(payload, unpresented) {
+  if (!unpresented.length || userIsAway() || !win || win.isDestroyed()) return false;
+  const stack = visibleRelayRows(payload.relays).filter((row) => row.unread);
+  if (!stack.length) return false;
+
+  // A new relay revokes an old dismissal. The resulting pill stays latched on screen
+  // after the notification collapses, even with no Claude/Codex host running, until
+  // the user explicitly dismisses it again.
+  dismissed = false;
+  attentionLatched = true;
+  ghostActive = false;
+  trayForcedVisible = false;
+  deferredAttention = false;
+  maybeShow({ force: true });
+  win.webContents.send("newRelay", stack, { ghost: false, stacked: true });
+  activeAttentionIds = new Set(stack.map((row) => row.id));
+  markRelaysPresented(unpresented.map((row) => row.id), stack.map((row) => row.id));
+  syncTray();
+  return true;
+}
+
 function pushInbox(force) {
   pushChain = pushChain.then(() => pushInboxNow(force)).catch((error) => {
     console.error("[overlay] pushInbox failed:", error && error.message);
@@ -426,26 +517,10 @@ async function pushInboxNow(force) {
   const payload = buildPayload();
   const rows = payload.relays;
   const notifiableRows = visibleRelayRows(rows);
-  if (knownIds === null) {
-    knownIds = new Set(notifiableRows.map((r) => r.id));
-  } else {
-    const fresh = notifiableRows.filter((r) => r.unread && !knownIds.has(r.id));
-    knownIds = new Set(notifiableRows.map((r) => r.id));
-    if (fresh.length && win && !win.isDestroyed()) {
-      // newest arrival drives the peek. While dismissed, the same designed banner still
-      // shows — as a "ghost": the window appears for the notification only, and the
-      // renderer fades it out (never folding back into a pill) when it's done.
-      if (trayAvailable && dismissed) {
-        if (hostRunning) {
-          ghostActive = true;
-          showOverlayWindow();
-          win.webContents.send("newRelay", fresh[0], { ghost: true });
-        }
-      } else {
-        win.webContents.send("newRelay", fresh[0], { ghost: false });
-      }
-    }
-  }
+  const unreadIds = notifiableRows.filter((row) => row.unread).map((row) => row.id);
+  markRelaysPresented([], unreadIds); // prune old read/deleted history without evicting current unread ids
+  const unpresented = notifiableRows.filter((row) => row.unread && !presentedRelayIds.has(row.id));
+  if (unpresented.length && userIsAway()) deferredAttention = true;
   const sig = JSON.stringify({
     // Include the answered-state fields: a question answered on the web / in a host
     // session flips quickReply/humanAnswered without changing unread/title, and
@@ -473,9 +548,13 @@ async function pushInboxNow(force) {
   });
   // Unchanged data: skip the send entirely. Re-sending identical payloads made the
   // renderer rebuild its DOM every few seconds (hover flicker, restarted transitions).
-  if (!force && sig === lastSig) return;
-  lastSig = sig;
-  if (win && !win.isDestroyed()) win.webContents.send("inbox", payload);
+  // When data did change, the full payload MUST reach the renderer before the arrival
+  // signal; otherwise notification sizing/rendering runs against the previous inbox.
+  if (force || sig !== lastSig) {
+    lastSig = sig;
+    if (win && !win.isDestroyed()) win.webContents.send("inbox", payload);
+  }
+  presentUnopenedStack(payload, unpresented);
 }
 
 // Refresh state-derived rows only (fast path used by fs.watch + the safety poll).
@@ -1107,7 +1186,7 @@ function maybeShow({ force = false, reposition = true } = {}) {
   if (!win || win.isDestroyed()) return;
   // Dismissed keeps the window hidden except while a ghost notification is up.
   // trayForcedVisible honors an explicit status-area click even when no host runs.
-  const wanted = overlayWanted({ hostRunning, trayForcedVisible, trayAvailable, dismissed, ghostActive });
+  const wanted = overlayWanted({ hostRunning, trayForcedVisible, trayAvailable, dismissed, ghostActive, attentionLatched });
   if (wanted) {
     showOverlayWindow({ force, reposition });
   } else if (win.isVisible()) {
@@ -1210,7 +1289,7 @@ function createWindow() {
     setTimeout(() => {
       if (!win || win.isDestroyed()) return;
       lastSig = ""; // force a full repaint after reload
-      knownIds = null;
+      requeueActiveAttention();
       win.webContents.reload();
     }, delay);
   });
@@ -1270,6 +1349,40 @@ function installActiveSpaceWatcher() {
   );
 }
 
+function installPowerAttentionLifecycle() {
+  powerMonitor.on("suspend", () => {
+    systemSuspended = true;
+    requeueActiveAttention();
+  });
+  powerMonitor.on("resume", () => {
+    systemSuspended = false;
+    scheduleReturnReconciliation();
+  });
+  powerMonitor.on("lock-screen", () => {
+    screenLocked = true;
+    requeueActiveAttention();
+  });
+  powerMonitor.on("unlock-screen", () => {
+    screenLocked = false;
+    scheduleReturnReconciliation();
+  });
+  if (process.platform === "darwin") {
+    powerMonitor.on("user-did-resign-active", () => {
+      loginSessionActive = false;
+      requeueActiveAttention();
+    });
+    powerMonitor.on("user-did-become-active", () => {
+      loginSessionActive = true;
+      scheduleReturnReconciliation();
+    });
+  }
+  // Idle has no edge event. Rows noticed while the user is away set this cheap gate;
+  // the first mouse/keyboard activity flushes the durable unpresented set.
+  setInterval(() => {
+    if (deferredAttention && !userIsAway()) reconcileAttentionAfterReturn();
+  }, 1000);
+}
+
 // ---- OS status area (tray/menu bar) ----------------------------------------
 
 // The Relay mark lives in the OS status area: macOS menu bar, Windows system tray.
@@ -1317,7 +1430,10 @@ function pillIsOnScreen() {
 // Persists the dismissal (like the card's ✕) so it stays hidden until the icon is
 // clicked again — reachable because the tray exists whenever this runs.
 function hideFromTray() {
-  setDismissed(true);
+  dismissed = true;
+  attentionLatched = false;
+  activeAttentionIds = new Set();
+  writeOverlayPrefs();
   ghostActive = false;
   trayForcedVisible = false;
   if (win && !win.isDestroyed() && win.isVisible()) win.hide();
@@ -1457,7 +1573,10 @@ ipcMain.on("relay:dismiss", () => {
     if (win && !win.isDestroyed()) win.webContents.send("openFull");
     return;
   }
-  setDismissed(true);
+  dismissed = true;
+  attentionLatched = false;
+  activeAttentionIds = new Set();
+  writeOverlayPrefs();
   ghostActive = false;
   trayForcedVisible = false;
   if (win && !win.isDestroyed() && win.isVisible()) win.hide();
@@ -1475,6 +1594,19 @@ ipcMain.on("relay:notifDone", () => {
   ghostActive = false;
   if (dismissed && win && !win.isDestroyed() && win.isVisible()) win.hide();
 });
+// The notification stack completed its visible interval and folded into the pill.
+// Main tracks this boundary so a later lock does not replay a stack the user already
+// had a full chance to see.
+ipcMain.on("relay:attentionDone", (_event, ids) => {
+  const completed = new Set(Array.isArray(ids) ? ids.map(String) : []);
+  const completesCurrentStack = !completed.size || [...activeAttentionIds].every((id) => completed.has(id));
+  if (!completesCurrentStack) return;
+  // If the user became idle while the animation ran, assume it was missed and leave
+  // it pending for their next input. This covers walking away just before an arrival,
+  // not only explicit sleep/lock events.
+  if (userIsAway()) requeueActiveAttention();
+  else activeAttentionIds = new Set();
+});
 ipcMain.handle("relay:soundBytes", (_e, name) => {
   const clean = String(name).replace(/[^A-Za-z]/g, "");
   const candidates = [
@@ -1504,6 +1636,7 @@ if (!gotSingleInstanceLock) {
     createWindow();
     createTray();
     installActiveSpaceWatcher();
+    installPowerAttentionLifecycle();
     // Test seam: the e2e harness (test/e2e-overlay.mjs) drives the real state machine
     // over the main-process inspector. Never set outside the harness.
     if (process.env.RELAY_OVERLAY_TEST === "1") {
@@ -1514,12 +1647,27 @@ if (!gotSingleInstanceLock) {
         maybeShow,
         refreshOverlayForActiveSpace,
         pollHosts,
+        setAway: (away) => {
+          testAwayOverride = Boolean(away);
+          if (testAwayOverride) requeueActiveAttention();
+          else scheduleReturnReconciliation();
+        },
         setSentCache: (items) => {
           sentCache = Array.isArray(items) ? items : [];
           return pushInbox(true);
         },
         getWin: () => win,
-        state: () => ({ dismissed, ghostActive, trayForcedVisible, hostRunning, visible: win && !win.isDestroyed() ? win.isVisible() : null }),
+        state: () => ({
+          dismissed,
+          attentionLatched,
+          ghostActive,
+          trayForcedVisible,
+          hostRunning,
+          deferredAttention,
+          presentedRelayIds: [...presentedRelayIds],
+          activeAttentionIds: [...activeAttentionIds],
+          visible: win && !win.isDestroyed() ? win.isVisible() : null,
+        }),
       };
     }
   });

package/overlay/preload.cjs

@@ -45,4 +45,5 @@ contextBridge.exposeInMainWorld("relay", {
   dismiss: () => ipcRenderer.send("relay:dismiss"),
   undismiss: () => ipcRenderer.send("relay:undismiss"),
   notifDone: () => ipcRenderer.send("relay:notifDone"),
+  attentionDone: (ids) => ipcRenderer.send("relay:attentionDone", Array.isArray(ids) ? ids : []),
 });

package/overlay/visibility.cjs

@@ -11,9 +11,10 @@ function overlayWanted({
   trayAvailable = false,
   dismissed = false,
   ghostActive = false,
+  attentionLatched = false,
 } = {}) {
   const dismissedEffective = trayAvailable && dismissed;
-  return (hostRunning || trayForcedVisible) && (!dismissedEffective || ghostActive);
+  return (hostRunning || trayForcedVisible || attentionLatched) && (!dismissedEffective || ghostActive);
 }
 
 // Debounced "a host is running" tracker. The OFF transition requires `missThreshold`
@@ -51,4 +52,24 @@ function shouldIgnoreDismiss({ now, lastTrayShowAt, windowMs = 250 } = {}) {
   return delta >= 0 && delta < windowMs;
 }
 
-module.exports = { overlayWanted, createHostRunningTracker, shouldIgnoreDismiss };
+// Keep presentation history bounded without ever evicting a relay that is still
+// unread. Evicting an unread id would make the next safety poll treat it as new and
+// could create an endless re-notification loop on a large inbox.
+function boundedPresentedRelayIds(currentIds, newlyPresentedIds, retainedUnreadIds, cap = 500) {
+  const ids = new Set(Array.isArray(currentIds) ? currentIds.map(String) : []);
+  for (const value of newlyPresentedIds || []) {
+    const id = String(value || "");
+    if (!id) continue;
+    ids.delete(id);
+    ids.add(id);
+  }
+  const retained = new Set(Array.from(retainedUnreadIds || [], String));
+  while (ids.size > cap) {
+    const evictable = [...ids].find((id) => !retained.has(id));
+    if (!evictable) break;
+    ids.delete(evictable);
+  }
+  return [...ids];
+}
+
+module.exports = { overlayWanted, createHostRunningTracker, shouldIgnoreDismiss, boundedPresentedRelayIds };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relay-companion",
-  "version": "0.1.39",
+  "version": "0.1.40",
   "description": "Relay companion: connects local coding agents to Relay tasks, approvals, and connector tools.",
   "type": "module",
   "bin": {