relay-companion 0.1.310 → 0.1.311

package/overlay/inbox.html

@@ -4617,6 +4617,7 @@
       removeQueuedRunMessage(key, messageId);
       requestWorkDrafts.delete(key);
       setRowNote(key, steerNow ? "Steered into the current turn." : "Queued follow-up started.", "ok");
+      fadeRowNoteLater(key, 3000);
       renderAll();
       return;
     }
@@ -5103,11 +5104,13 @@
         const rt = routeFor(id);
         const note = String((b.closest(".ta-dock")?.querySelector(".ta-note") || {}).value || "").trim();
         const ranAlready = requestHasNativeSession(requestRows().find((row) => row.id === id));
-        setRowNote(id, ranAlready
-          ? `Opening this exact session in ${rt.app}…`
-          : `Opening a new ${rt.app} session with the Relay documents${note ? " and your draft note" : ""}.`, "ok");
         if (ranAlready && window.relay.openInCurrent) window.relay.openInCurrent(id, hostKeyFor(rt.app));
         else openRelayFromUI(id, "relay", "fresh", hostKeyFor(rt.app), note);
+        // AFTER the open, never before: openRelayFromUI clears the row's note
+        // first (a stale failure must not outlive the retry), so a note written
+        // above this line vanished the same instant — the trap already found on
+        // the per-relay rows.
+        setOpeningNote(id, `Opening in ${rt.app}…`);
         if (onDone) onDone("open-in");
       });
     }
@@ -5122,7 +5125,7 @@
         const res = await window.relay.openRunSession(id).catch((error) => ({ ok: false, error: String(error?.message || error) }));
         b.disabled = false;
         if (!res?.ok) setRowNote(id, res?.error || "That Claude session is not ready to open yet.", "err");
-        else setRowNote(id, "Opened the exact completed session in Claude Code.", "ok");
+        else { setRowNote(id, "Opened in Claude Code.", "ok"); fadeRowNoteLater(id, 3000); }
         if (res?.ok && onDone) onDone("open-in");
       });
     }
@@ -5295,6 +5298,7 @@
         if (box) { box.value = ""; clearStagedFiles(box); }
         requestWorkDrafts.delete(key);
         setRowNote(id, "Queued for when the current turn finishes.", "ok");
+        fadeRowNoteLater(id, 5000);
         renderAll();
         return;
       }
@@ -5308,6 +5312,7 @@
         if (box) { box.value = ""; clearStagedFiles(box); }
         requestWorkDrafts.delete(key);
         setRowNote(id, "Follow-up sent into the session.", "ok");
+        fadeRowNoteLater(id, 3000);
         renderAll();
       }
       else {
@@ -6016,6 +6021,7 @@
           input.value = "";
           readerHumanDrafts.delete(String(r.id));
           setRowNote(r.id, `Sent to ${sender}.`, "ok");
+          fadeRowNoteLater(r.id, 3000);
           renderReader();
         };
         send.addEventListener("click", doSend);
@@ -6028,12 +6034,15 @@
         const n = whole ? threadMessages().filter((m) => m.threadId === r.threadId).length : 0;
         // Continuity is judged BEFORE the hand-off marks the conversation.
         const knows = threadHanded(r.threadId || r.id);
-        setRowNote(r.id, whole
+        // An in-chat open answers with its own note (staged / delivered / woken),
+        // which supersedes this one; the paths that answer with nothing used to
+        // leave this line up for good, so it retires with the open too.
+        openRelayFromUI(r.id, r.outbound ? "sent" : "relay", "current");
+        setOpeningNote(r.id, whole
           ? (knows ? `Opening the whole conversation (${n} relays) in the ${agentAppName()} chat that knows it — staged…`
                    : `Opening ${agentAppName()} on this whole conversation (${n} relays) — staged, nothing sends until you do…`)
           : (knows ? `Reopening the ${agentAppName()} chat that knows this conversation…`
-                   : `Opening ${agentAppName()} on this conversation — staged, nothing sends until you do…`), "ok");
-        openRelayFromUI(r.id, r.outbound ? "sent" : "relay", "current");
+                   : `Opening ${agentAppName()} on this conversation — staged, nothing sends until you do…`));
         renderReader();
       });
       // The reader's old "open in a window" hatch pointed at preview.html too;
@@ -6355,6 +6364,45 @@
       el.classList.remove("ok");
     }
   }
+  // A GREEN NOTE IS TRANSIENT; AN ERROR IS NOT. Every "ok" note narrates an
+  // action the user just took, so it retires when that action lands — main
+  // reports the open home (openDone), or a few seconds pass. An error stays: it
+  // is the only record of a click that went nowhere. Both timers are guarded by
+  // the text that scheduled them, so anything written over the note since is
+  // the newer truth and survives (David, live, on a finished open: the green
+  // line just sat there).
+  const noteTimers = new Map();          // id -> { kind, text, shownAt, timer }
+  const OPENING_NOTE_FALLBACK_MS = 6000; // the safety the row spinner already keeps
+  const OPENING_NOTE_MIN_MS = 900;       // a note nobody can read is worse than none
+  function noteStillReads(id, text) { return rowNotes.get(id)?.text === text; }
+  function cancelNoteTimer(id) {
+    const entry = noteTimers.get(id);
+    if (!entry) return;
+    clearTimeout(entry.timer);
+    noteTimers.delete(id);
+  }
+  function scheduleNoteClear(id, { kind, text, shownAt, ms }) {
+    cancelNoteTimer(id);
+    noteTimers.set(id, { kind, text, shownAt, timer: setTimeout(() => {
+      cancelNoteTimer(id);
+      if (noteStillReads(id, text)) clearRowNote(id);
+    }, ms) });
+  }
+  // "Opening in {app}…" — up until the open lands, never longer.
+  function setOpeningNote(id, text) {
+    setRowNote(id, text, "ok");
+    scheduleNoteClear(id, { kind: "opening", text, shownAt: performance.now(), ms: OPENING_NOTE_FALLBACK_MS });
+  }
+  // The open landed: let the line finish being readable, then take it away.
+  function retireOpeningNote(id) {
+    const entry = noteTimers.get(id);
+    if (!entry || entry.kind !== "opening" || !noteStillReads(id, entry.text)) return;
+    scheduleNoteClear(id, { ...entry, ms: Math.max(0, OPENING_NOTE_MIN_MS - (performance.now() - entry.shownAt)) });
+  }
+  // A note that reports a FINISHED action: read it, then it goes.
+  function fadeRowNoteLater(id, ms) {
+    scheduleNoteClear(id, { kind: "fade", text: rowNotes.get(id)?.text, shownAt: performance.now(), ms });
+  }
 
   async function runRowAction(id, btn, fn) {
     if (!btn || btn.disabled) return;
@@ -8480,7 +8528,7 @@
         // outlive the retry), so the answer to THIS click is written after it —
         // written before, it vanished the same instant (found on the clone).
         openRelayFromUI(id, source, "open", host);
-        setRowNote(id, `Opening this exact Relay in ${app}…`, "ok");
+        setOpeningNote(id, `Opening in ${app}…`);
       });
     }
   }
@@ -10165,7 +10213,7 @@
   // The OS window was just re-shown and main re-asserted click-through; reset the
   // local flag so the next mousemove re-runs the interactivity handshake cleanly.
   if (window.relay.onShown) window.relay.onShown(() => { interactive = false; });
-  if (window.relay.onOpenDone) window.relay.onOpenDone((id) => stopOpening(id));
+  if (window.relay.onOpenDone) window.relay.onOpenDone((id) => { stopOpening(id); retireOpeningNote(id); });
   // Visible confirmation for "Open in current chat". Two honest states:
   //   waiting   — staged for an idle chat; ONLY that chat's next turn can ingest
   //               it, so the note stays up (surviving re-renders) until delivery
@@ -10173,25 +10221,17 @@
   //   delivered — main watched the consume-once injection file disappear; the
   //               instruction is IN the chat. Green check, then fade.
   // A Codex bridge/automation hand-off keeps the classic brief confirmation.
-  const injectedNoteTimers = new Map();
   const deliveredChatNames = new Map(); // packetId -> chat the injection was staged for
-  function fadeRowNoteLater(id, ms) {
-    if (injectedNoteTimers.has(id)) clearTimeout(injectedNoteTimers.get(id));
-    injectedNoteTimers.set(id, setTimeout(() => {
-      injectedNoteTimers.delete(id);
-      clearRowNote(id);
-    }, ms));
-  }
   if (window.relay.onInjected) window.relay.onInjected((id, info) => {
     if (info.channel) {
       // Wake path: a channel event starts a real turn even in an idle chat.
-      if (injectedNoteTimers.has(id)) { clearTimeout(injectedNoteTimers.get(id)); injectedNoteTimers.delete(id); }
+      cancelNoteTimer(id);
       setRowNote(id, "Pushed to your current Claude chat — waking it now…", "ok");
       return;
     }
     if (info.awaitingTurn) {
       // Persistent until delivery / the auto-fresh hop — never a silent limbo.
-      if (injectedNoteTimers.has(id)) { clearTimeout(injectedNoteTimers.get(id)); injectedNoteTimers.delete(id); }
+      cancelNoteTimer(id);
       // Name the destination chat when we know it: "your \u201cgranular-relay\u201d chat"
       // tells the user WHERE to look; "your current chat" leaves them hunting
       // (field report: the injection landed in a chat they never found).
@@ -10219,7 +10259,7 @@
   // the explanation while the user is reading it. Cleared by the next open of the row.
   if (window.relay.onOpenError) window.relay.onOpenError((id, message) => {
     if (!message) return;
-    if (injectedNoteTimers.has(id)) { clearTimeout(injectedNoteTimers.get(id)); injectedNoteTimers.delete(id); }
+    cancelNoteTimer(id);
     setRowNote(id, message, "err");
   });
   window.relay.refresh().then((p) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relay-companion",
-  "version": "0.1.310",
+  "version": "0.1.311",
   "description": "Companion CLI for Relay (sendrelays.com): pairs this machine with your Relay account so coding agents like Claude Code and Codex can send and receive Relay messages.",
   "homepage": "https://sendrelays.com",
   "repository": {