relay-companion 0.1.80 → 0.1.82

package/overlay/inbox.html

@@ -1702,7 +1702,7 @@
       ${previewHtml}
       ${actions}
       ${openCard}
-      <div class="row-err" data-err="${esc(r.id)}"></div>
+      <div class="row-err${rowNotes.get(r.id)?.cls === "ok" ? " ok" : ""}" data-err="${esc(r.id)}">${esc(rowNotes.get(r.id)?.text || "")}</div>
     </div>`;
   }
 
@@ -1756,9 +1756,23 @@
     if (el) el.textContent = message || "";
   }
   function cssId(id) { return String(id).replace(/"/g, '\\"'); }
+  // Injection hand-off notes are STATE, not one-shot DOM writes: the relay list is
+  // rebuilt via innerHTML on every payload push, which used to wipe the note within
+  // seconds — precisely while the user was staring at a click that looked dead.
+  // relayRowHtml renders the current note into every rebuild; timers only ever
+  // remove entries from this map. id -> { text, cls }
+  const rowNotes = new Map();
+  function setRowNote(id, text, cls) {
+    rowNotes.set(id, { text, cls });
+    for (const el of document.querySelectorAll(`[data-err="${CSS.escape(id)}"]`)) {
+      el.textContent = text;
+      el.classList.toggle("ok", cls === "ok");
+    }
+  }
   // The .row-err slot carries both inline errors and the green injection note, and one
   // relay can be rendered into more than one list, so wipe every copy of the row's slot.
   function clearRowNote(id) {
+    rowNotes.delete(id);
     for (const el of document.querySelectorAll(`[data-err="${CSS.escape(id)}"]`)) {
       el.textContent = "";
       el.classList.remove("ok");
@@ -3067,31 +3081,48 @@
   // 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));
-  // Visible confirmation for "Open in current chat": the injection is staged,
-  // but the agent only ingests it at its next checkpoint (tool boundary / turn
-  // end — or your next message if it's idle). Say so, briefly, in green.
+  // 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
+  //               and tells the user how to pull it in themselves.
+  //   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();
+  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) => {
-    const hostName = info.host === "codex" ? "Codex" : "Claude";
-    for (const el of document.querySelectorAll(`[data-err="${CSS.escape(id)}"]`)) {
-      el.textContent = `✓ Sent to your current ${hostName} chat — it will pick this up at its next checkpoint (or your next message if it's idle).`;
-      el.classList.add("ok");
-      if (injectedNoteTimers.has(id)) clearTimeout(injectedNoteTimers.get(id));
-      injectedNoteTimers.set(id, setTimeout(() => {
-        injectedNoteTimers.delete(id);
-        if (el.isConnected) { el.textContent = ""; el.classList.remove("ok"); }
-      }, 12000));
+    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); }
+      setRowNote(id, "Handed to your current Claude chat…", "ok");
+      return;
     }
+    const hostName = info.host === "codex" ? "Codex" : "Claude";
+    setRowNote(id, `✓ Sent to your current ${hostName} chat — it will pick this up at its next checkpoint.`, "ok");
+    fadeRowNoteLater(id, 12000);
+  });
+  if (window.relay.onInjectionDelivered) window.relay.onInjectionDelivered((id) => {
+    setRowNote(id, "✓ Delivered — your current Claude chat is acting on it now.", "ok");
+    fadeRowNoteLater(id, 8000);
+  });
+  if (window.relay.onInjectionAutoFresh) window.relay.onInjectionAutoFresh((id) => {
+    setRowNote(id, "Your current chat was idle, so this is opening in a new chat instead.", "ok");
+    fadeRowNoteLater(id, 10000);
   });
   // An open that failed leaves the relay UNREAD on purpose (it never reached the user),
   // so the row has to say what happened — otherwise the spinner just stops and the click
-  // looks like it worked. Cleared by the next open of the same row.
+  // looks like it worked. Persisted via rowNotes so a payload-push rebuild can't wipe
+  // 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;
-    for (const el of document.querySelectorAll(`[data-err="${CSS.escape(id)}"]`)) {
-      el.classList.remove("ok");
-      el.innerHTML = esc(message);
-    }
+    if (injectedNoteTimers.has(id)) { clearTimeout(injectedNoteTimers.get(id)); injectedNoteTimers.delete(id); }
+    setRowNote(id, message, "err");
   });
   window.relay.refresh().then((p) => {
     onPayload(p);

package/overlay/main.cjs

@@ -1890,6 +1890,81 @@ async function openPacket(packetId, { sent = false, fresh = false } = {}) {
 // How many messages (inbound rows + sent copies, deduped) share a thread.
 // Gives the injected instruction its "N messages so far" and tells the model
 // when fetching the whole thread is worth it.
+// The staged injection file is consume-once: the claude-hook renames it away at
+// the moment of delivery. Watching for its disappearance is therefore a REAL
+// delivery signal, and the row note can tell the truth in realtime — "waiting
+// for that chat's turn" versus "delivered". Field lesson (2026-08-05): an
+// injection for an idle session sat invisible for minutes and the click read as
+// completely dead; a waiting state that never lies beats a success toast.
+//
+// The GRACE WINDOW closes the remaining gap. Nothing outside a session can make
+// it take a turn (verified against the platform docs: deep links only pre-fill
+// NEW sessions; no external submit API exists), so an idle chat cannot be woken
+// — but the user must still get the relay QUICKLY. A busy chat ingests at a
+// tool boundary within seconds; if the grace window passes unconsumed, the
+// target is idle: reclaim the injection (same rename-first consume-once
+// discipline as the hook, so a racing delivery always wins) and open the relay
+// in a fresh chat instead. Every click produces a visible result in seconds.
+const injectionWatchers = new Map(); // packetId -> interval
+const AUTO_FRESH_GRACE_MS = (() => {
+  const raw = Number(process.env.RELAY_CURRENT_CHAT_GRACE_MS);
+  return Number.isFinite(raw) && raw >= 0 ? raw : 6000; // 0 disables auto-fresh
+})();
+function reclaimInjection(stagedPath) {
+  const claimed = `${stagedPath}.${process.pid}.${Date.now()}.autofresh`;
+  try {
+    fs.renameSync(stagedPath, claimed); // loses the race iff the hook consumed it
+  } catch {
+    return false;
+  }
+  try {
+    fs.rmSync(claimed, { force: true });
+  } catch {}
+  return true;
+}
+function watchInjectionDelivery(packetId, stagedPath, { timeoutMs = 10 * 60 * 1000, intervalMs = 500, autoFreshMs = AUTO_FRESH_GRACE_MS, onAutoFresh = null } = {}) {
+  if (!stagedPath) return;
+  const existing = injectionWatchers.get(packetId);
+  if (existing) clearInterval(existing); // newest click owns the watch
+  const startedAt = Date.now();
+  const timer = setInterval(() => {
+    let gone = false;
+    try {
+      gone = !fs.existsSync(stagedPath);
+    } catch {
+      gone = false;
+    }
+    if (gone) {
+      clearInterval(timer);
+      injectionWatchers.delete(packetId);
+      console.error(`[overlay] openInCurrent ${packetId}: delivered (injection consumed after ${Math.round((Date.now() - startedAt) / 1000)}s)`);
+      if (win && !win.isDestroyed()) win.webContents.send("injectionDelivered", packetId);
+      return;
+    }
+    if (onAutoFresh && autoFreshMs > 0 && Date.now() - startedAt >= autoFreshMs) {
+      clearInterval(timer);
+      injectionWatchers.delete(packetId);
+      if (!reclaimInjection(stagedPath)) {
+        // The hook won the rename race: this IS a delivery.
+        console.error(`[overlay] openInCurrent ${packetId}: delivered (won by the hook at the grace boundary)`);
+        if (win && !win.isDestroyed()) win.webContents.send("injectionDelivered", packetId);
+        return;
+      }
+      console.error(`[overlay] openInCurrent ${packetId}: current chat idle for ${autoFreshMs}ms; reclaimed the injection and opening fresh`);
+      onAutoFresh();
+      return;
+    }
+    // A restaged/overwritten click or a very long idle: stop polling quietly.
+    // The waiting note remains accurate — the injection is still pending.
+    if (Date.now() - startedAt > timeoutMs) {
+      clearInterval(timer);
+      injectionWatchers.delete(packetId);
+    }
+  }, intervalMs);
+  if (typeof timer.unref === "function") timer.unref();
+  injectionWatchers.set(packetId, timer);
+}
+
 function threadInfoFor(row) {
   const threadId = (row && row.threadId) || null;
   if (!threadId) return { threadId: null, threadCount: 0 };
@@ -1913,8 +1988,10 @@ async function openPacketInCurrent(packetId) {
   };
   // Confirm the staging in the UI: without this, a successful injection is
   // indistinguishable from a dead click until the agent's next checkpoint.
-  const confirmInjected = (host) => {
-    if (win && !win.isDestroyed()) win.webContents.send("injected", packetId, { host });
+  // extra.awaitingTurn tells the renderer this is a WAITING state (idle target
+  // session), not a completed hand-off.
+  const confirmInjected = (host, extra = {}) => {
+    if (win && !win.isDestroyed()) win.webContents.send("injected", packetId, { host, ...extra });
   };
   const fallbackFresh = (note) => {
     // The click said "current chat" but we're opening a NEW one — never do that
@@ -1983,8 +2060,9 @@ async function openPacketInCurrent(packetId) {
         `(${target.source}, active ${Math.round((Date.now() - target.lastActiveAt) / 1000)}s ago)`,
     );
     const stageNow = () => {
+      let staged = null;
       try {
-        claudeInject.stageInjection(RELAY_HOME, target.sessionId, {
+        staged = claudeInject.stageInjection(RELAY_HOME, target.sessionId, {
           relayId: packetId,
           senderName: row.senderName || "",
           title: row.title || row.displayTitle || "",
@@ -1997,8 +2075,20 @@ async function openPacketInCurrent(packetId) {
       // Raise Claude Desktop so the user watches the instruction land; a
       // terminal-only session stays where it is (its window is not ours to raise).
       if (target.source === "desktop") activateHost("claude", bundle);
-      confirmInjected("claude");
+      // awaitingTurn: an idle session consumes only on its NEXT hook event, so the
+      // renderer must show an honest "waiting for that chat's turn" state, not a
+      // success toast. The watcher below flips it to Delivered in realtime — or,
+      // past the grace window, hops to a fresh chat so the click is never slow.
+      confirmInjected("claude", { awaitingTurn: true });
       finish();
+      watchInjectionDelivery(packetId, staged.path, {
+        onAutoFresh: () => {
+          if (win && !win.isDestroyed()) win.webContents.send("injectionAutoFresh", packetId);
+          openPacket(packetId, { fresh: true }).catch((error) =>
+            console.error("[overlay] auto-fresh after idle grace failed:", error && error.message),
+          );
+        },
+      });
     };
     // NOTHING but the `relay claude-hook` runtime registered in ~/.claude/settings.json
     // ever reads the staged file. Where setup never wrote those hooks (Windows installs

package/overlay/preload.cjs

@@ -11,6 +11,12 @@ contextBridge.exposeInMainWorld("relay", {
   // "Open in current chat" staged an injection: the UI confirms it so the
   // click has visible feedback (delivery is checkpoint-based, not instant).
   onInjected: (cb) => ipcRenderer.on("injected", (_e, id, info) => cb(id, info || {})),
+  // The staged injection was actually CONSUMED by the target session — flip the
+  // waiting note to a delivered one (main watches the consume-once file).
+  onInjectionDelivered: (cb) => ipcRenderer.on("injectionDelivered", (_e, id) => cb(id)),
+  // The current chat stayed idle through the grace window; the injection was
+  // reclaimed and the relay is opening in a fresh chat instead.
+  onInjectionAutoFresh: (cb) => ipcRenderer.on("injectionAutoFresh", (_e, id) => cb(id)),
   // The open failed (CLI error / helper wouldn't spawn). The row stays unread, so
   // say why inline instead of letting the spinner just stop.
   onOpenError: (cb) => ipcRenderer.on("openError", (_e, id, message) => cb(id, message || "")),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relay-companion",
-  "version": "0.1.80",
+  "version": "0.1.82",
   "description": "Relay companion for ordinary messages, with dormant coordination features available only by explicit opt-in.",
   "type": "module",
   "bin": {