relay-companion 0.1.93 → 0.1.95

package/overlay/inbox.html

@@ -679,14 +679,32 @@
     font-family:var(--serif); font-size:14.5px; font-weight:500; color:var(--ink);
     white-space:nowrap; overflow:hidden; text-overflow:ellipsis; min-width:0; flex:1 1 auto;
   }
+  /* Conversation messages read like a group chat: each person's own messages
+     sit on one side, and every party's name keeps a stable color so a busy
+     thread is scannable by who-said-what (the WhatsApp convention). */
+  .th-detail-title { padding:2px 16px 10px; font-family:var(--serif); font-size:15px; line-height:1.3; color:var(--ink); font-weight:600; overflow-wrap:anywhere; }
+  .th-detail-title:empty { display:none; }
   .th-msg { position:relative; display:block; width:100%; text-align:left; appearance:none; border:0; cursor:pointer; background:transparent; padding:11px 16px; border-bottom:1px solid var(--hair); font-family:var(--sans); }
   .th-msg:hover { background:rgba(31,26,23,.035); }
+  .th-msg.expanded { background:rgba(31,26,23,.045); }
+  .th-msg .open-actions { margin-top:9px; text-align:left; }
   .th-msg-top { display:flex; align-items:baseline; gap:7px; min-width:0; }
   .th-dir { flex:0 0 auto; font-family:var(--mono); font-size:11px; line-height:1; align-self:center; color:var(--muted-2); }
   .th-dir.out { color:var(--accent); }
   .th-msg-title { font-family:var(--serif); font-size:14px; line-height:1.3; color:var(--muted); margin-top:4px;
     overflow:hidden; display:-webkit-box; -webkit-line-clamp:2; -webkit-box-orient:vertical; overflow-wrap:anywhere; }
   .th-msg.unread .th-msg-title { color:var(--ink); font-weight:500; }
+  /* Your own messages hang to the right, like your side of a group chat. */
+  .th-msg.mine { text-align:right; background:rgba(31,26,23,.022); }
+  .th-msg.mine .th-msg-top { flex-direction:row-reverse; }
+  .th-msg.mine .th-party { text-align:right; }
+  .th-msg.mine .th-msg-title { text-align:right; }
+  /* Per-party name colors. Assigned by a stable hash of the party name, so a
+     person keeps the same color across every conversation and every restart. */
+  .th-party.p0 { color:#1f6f5c; } .th-party.p1 { color:#8a4b2a; } .th-party.p2 { color:#4a4aa8; }
+  .th-party.p3 { color:#8a2f5e; } .th-party.p4 { color:#2f6f8a; } .th-party.p5 { color:#6b5a1f; }
+  .th-party.p6 { color:#7a3030; } .th-party.p7 { color:#3f6b2a; }
+  .th-party.me { color:var(--accent); }
 
   /* Sent-row read receipt chip: "read" sits in a light-green enclosure, "unread" stays quiet. */
   .sent-chip {
@@ -828,6 +846,7 @@
             </button>
             <span class="th-detail-name" id="thDetailName"></span>
           </div>
+          <div class="th-detail-title" id="thDetailTitle"></div>
           <div id="thHistory"></div>
         </div>
       </section>
@@ -944,6 +963,7 @@
   const thDetailEl = document.getElementById("thDetail");
   const thBackEl = document.getElementById("thBack");
   const thDetailNameEl = document.getElementById("thDetailName");
+  const thDetailTitleEl = document.getElementById("thDetailTitle");
   const thHistoryEl = document.getElementById("thHistory");
   const settingsViewEl = document.getElementById("settingsView");
   const signInBannerEl = document.getElementById("signInBanner");
@@ -1702,7 +1722,7 @@
           ${t.msgs.length > 1 ? `<span class="th-count">${t.msgs.length}</span>` : ""}
           <span class="th-time">${esc(timeAgo(t.latest.at))}</span>
         </span>
-        <span class="th-title">${esc(t.latest.title)}</span>
+        <span class="th-title">${esc(t.title || t.latest.title)}</span>
         ${tMenu}
         ${newestInbound ? `<div class="row-err${rowNotes.get(newestInbound.id)?.cls === "ok" ? " ok" : ""}" data-err="${esc(newestInbound.id)}" data-stop="1">${esc(rowNotes.get(newestInbound.id)?.text || "")}</div>` : ""}
       </div>`;
@@ -2984,6 +3004,7 @@
   // relays plus the live Sent list. Local data only — the pill shows the
   // user's own exchanges; the API's /v1/threads serves web and agents.
   let threadDetailId = null; // threadId while a thread's history is open
+  let expandedThreadMsgId = null; // message inside the thread whose actions are open
   let threadDetailScrolledFor = null; // thread already auto-scrolled to newest (reset on leave)
   let threadDetailPartyHint = ""; // who it's with, for the header while messages load
   function threadMessages() {
@@ -2993,7 +3014,7 @@
       msgs.push({
         id: r.id, threadId: r.threadId || r.id, direction: "in",
         title: relaySubject(r), party: relaySender(r), at: r.createdAt || r.updatedAt,
-        unread: Boolean(r.unread),
+        unread: Boolean(r.unread), threadTitle: r.threadTitle || "",
       });
     }
     // A self-send exists on BOTH sides with the same relay id; keep only the
@@ -3005,7 +3026,7 @@
       msgs.push({
         id, threadId: s.threadId || id, direction: "out",
         title: sentSubject(s), party: sentRecipient(s), at: s.createdAt,
-        unread: false,
+        unread: false, threadTitle: s.threadTitle || "",
       });
     }
     return msgs;
@@ -3027,6 +3048,10 @@
       // inbound sender, else the latest outbound recipient.
       const lastIn = [...t.msgs].reverse().find((m) => m.direction === "in");
       t.party = (lastIn && lastIn.party) || latest.party || "Conversation";
+      // The conversation's NAME: an explicit thread title (set by whoever named
+      // the exchange, carried on every item) wins; otherwise the oldest
+      // message's subject, which is the relay that started it.
+      t.title = (t.msgs.find((m) => m.threadTitle) || {}).threadTitle || t.msgs[0].title || "";
     }
     threads.sort((a, b) => new Date(b.latest.at || 0) - new Date(a.latest.at || 0));
     return threads;
@@ -3046,7 +3071,7 @@
           <span class="th-count">${t.msgs.length}</span>
           <span class="th-time">${esc(timeAgo(t.latest.at))}</span>
         </span>
-        <span class="th-title">${esc(t.latest.title)}</span>
+        <span class="th-title">${esc(t.title || t.latest.title)}</span>
       </button>`).join("");
     for (const el of threadsListEl.querySelectorAll(".th-item")) {
       el.addEventListener("click", () => {
@@ -3055,6 +3080,22 @@
       });
     }
   }
+  // Stable per-party color: same person, same color, every conversation and
+  // every restart (a hash, never an index into render order).
+  function partyColorClass(name, mine) {
+    if (mine) return "me";
+    const key = String(name || "").trim().toLowerCase();
+    let h = 0;
+    for (let i = 0; i < key.length; i += 1) h = (h * 31 + key.charCodeAt(i)) >>> 0;
+    return `p${h % 8}`;
+  }
+  // What the user's own messages are labelled with in a conversation. Read from
+  // the inbox payload's account (always present, unlike the Settings view's
+  // lazily-loaded info), falling back to the chat convention "You".
+  function ownDisplayName() {
+    const acct = (payload && payload.account) || {};
+    return String(acct.name || acct.email || "You").trim() || "You";
+  }
   function renderThreadDetail() {
     const thread = buildThreads().find((t) => t.threadId === threadDetailId);
     if (!thread) {
@@ -3068,6 +3109,11 @@
       return;
     }
     thDetailNameEl.textContent = thread.party;
+    // The conversation's name sits under the party, the way a chat header shows
+    // the subject: an explicit thread title when one was set, else the relay
+    // that started the exchange. Hidden when it would only repeat the party.
+    const headerTitle = String(thread.title || "").trim();
+    thDetailTitleEl.textContent = headerTitle && headerTitle !== thread.party ? headerTitle : "";
     // Thread-level opens act on the newest inbound message (falling back to the
     // newest message overall): "current" injects with the threadId so the agent
     // fetches the whole exchange; "new chat" seeds the full transcript.
@@ -3088,25 +3134,88 @@
     // note): messages read oldest -> newest downward, the open actions sit at
     // the BOTTOM next to the newest message, and entering the thread lands you
     // at the newest message, not the stalest.
-    thHistoryEl.innerHTML = thread.msgs.map((m) => `
-      <button class="th-msg${m.unread ? " unread" : ""}" type="button" data-msg="${esc(m.id)}" data-dir="${m.direction}">
+    const me = ownDisplayName();
+    const nextHistory = thread.msgs.map((m) => {
+      // Outbound = this user's own message: labelled with their name (not the
+      // recipient's) and hung on the right, like your side of a group chat.
+      // Labelling it with the recipient read as "Shane sent this" on a message
+      // David sent, contradicting the transcript's own "You" (field report).
+      const mine = m.direction === "out";
+      const who = mine ? me : m.party;
+      // Clicking a message expands ITS own actions rather than firing an open:
+      // a single click used to jump straight to a new chat with no choice.
+      const expanded = m.id === expandedThreadMsgId;
+      const menu = expanded
+        ? openActionsHtml(m.id, { sent: mine, previewable: true })
+        : "";
+      return `
+      <div class="th-msg${m.unread ? " unread" : ""}${mine ? " mine" : ""}${expanded ? " expanded" : ""}" role="button" tabindex="0" data-msg="${esc(m.id)}" data-dir="${m.direction}" data-opening-id="${esc(m.id)}">
         <span class="th-msg-top">
-          <span class="th-dir${m.direction === "out" ? " out" : ""}">${m.direction === "out" ? "←" : "→"}</span>
-          <span class="th-party">${esc(m.party)}</span>
+          <span class="th-party ${partyColorClass(who, mine)}">${esc(who)}</span>
           <span class="th-time">${esc(timeAgo(m.at))}</span>
         </span>
         <span class="th-msg-title">${esc(m.title)}</span>
-      </button>`).join("") + threadActions + threadNote;
-    // Land at the newest message when ENTERING the thread; rebuilds of the same
-    // open thread (payload pushes) keep the user's scroll position untouched.
-    if (threadDetailScrolledFor !== thread.threadId) {
+        ${menu}
+        <div class="row-err${rowNotes.get(m.id)?.cls === "ok" ? " ok" : ""}" data-err="${esc(m.id)}" data-stop="1">${esc(rowNotes.get(m.id)?.text || "")}</div>
+      </div>`;
+    }).join("") + threadActions + threadNote;
+    // Repaint guard. This view is rebuilt on EVERY payload push (and entering it
+    // triggers a sent refresh), which tore down and recreated the open-actions
+    // card ~a second after opening — the flash David reported on "Read the
+    // Conversation". Identical markup now means no DOM write and no rewiring.
+    if (thHistoryEl.innerHTML !== nextHistory) {
+      thHistoryEl.innerHTML = nextHistory;
+      // Land at the newest message when ENTERING the thread; rebuilds of the same
+      // open thread (payload pushes) keep the user's scroll position untouched.
+      if (threadDetailScrolledFor !== thread.threadId) {
+        threadDetailScrolledFor = thread.threadId;
+        requestAnimationFrame(() => { scrollEl.scrollTop = scrollEl.scrollHeight; });
+      }
+    } else if (threadDetailScrolledFor !== thread.threadId) {
       threadDetailScrolledFor = thread.threadId;
       requestAnimationFrame(() => { scrollEl.scrollTop = scrollEl.scrollHeight; });
+      return; // markup unchanged: existing handlers are still bound
+    } else {
+      return; // nothing changed at all
+    }
+    for (const z of thHistoryEl.querySelectorAll('[data-stop="1"]')) {
+      z.addEventListener("click", (e) => e.stopPropagation());
     }
     for (const el of thHistoryEl.querySelectorAll(".th-msg")) {
+      const id = el.getAttribute("data-msg");
+      if (openingIds.has(id)) el.classList.add("opening");
       el.addEventListener("click", () => {
-        const id = el.getAttribute("data-msg");
-        openRelayFromUI(id, el.getAttribute("data-dir") === "out" ? "sent" : "relay");
+        // Expand this message's own actions — never open straight into a new
+        // chat. Same contract as a relay row in the Relays list.
+        expandedThreadMsgId = expandedThreadMsgId === id ? null : id;
+        renderThreadDetail();
+      });
+    }
+    // Per-message actions. A message this user SENT routes through the sent
+    // paths (its copy is forged before injection); a received one through the
+    // relay paths. Both leave the menu closed after acting.
+    for (const btn of thHistoryEl.querySelectorAll("[data-preview], [data-sent-preview]")) {
+      const id = btn.getAttribute("data-preview") || btn.getAttribute("data-sent-preview");
+      btn.addEventListener("click", () => {
+        expandedThreadMsgId = null;
+        window.relay.preview(id);
+        renderThreadDetail();
+      });
+    }
+    for (const btn of thHistoryEl.querySelectorAll("[data-open-current], [data-sent-open-current]")) {
+      const sentSide = btn.hasAttribute("data-sent-open-current");
+      const id = btn.getAttribute("data-open-current") || btn.getAttribute("data-sent-open-current");
+      btn.addEventListener("click", () => {
+        expandedThreadMsgId = null;
+        openRelayFromUI(id, sentSide ? "sent" : "relay", "current");
+      });
+    }
+    for (const btn of thHistoryEl.querySelectorAll("[data-open-fresh], [data-sent-open-fresh]")) {
+      const sentSide = btn.hasAttribute("data-sent-open-fresh");
+      const id = btn.getAttribute("data-open-fresh") || btn.getAttribute("data-sent-open-fresh");
+      btn.addEventListener("click", () => {
+        expandedThreadMsgId = null;
+        openRelayFromUI(id, sentSide ? "sent" : "relay", "fresh");
       });
     }
     const curBtn = thHistoryEl.querySelector("[data-thread-open-current]");
@@ -3119,12 +3228,14 @@
   thBackEl.addEventListener("click", () => {
     threadDetailId = null;
     threadDetailScrolledFor = null;
+    expandedThreadMsgId = null;
     activeView = "relays";
     syncTabs();
     applyView();
     renderAll();
   });
   function openThreadDetail(threadId, partyHint = "") {
+    expandedThreadMsgId = null; // a fresh entry never opens with a menu up
     threadDetailId = threadId;
     threadDetailPartyHint = partyHint;
     activeView = "threads";
@@ -3486,6 +3597,7 @@
   //               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(() => {
@@ -3503,7 +3615,12 @@
     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 — lands when it next takes a turn. If it\u2019s idle: type anything there, or use Open in New Chat for instant.", "ok");
+      // 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).
+      if (info.chat) deliveredChatNames.set(id, info.chat);
+      const where = info.chat ? `your \u201c${info.chat}\u201d chat` : "your current Claude chat";
+      setRowNote(id, `Handed to ${where} — lands when it next takes a turn. If it\u2019s idle: type anything there, or use Open in New Chat for instant.`, "ok");
       return;
     }
     const hostName = info.host === "codex" ? "Codex" : "Claude";
@@ -3511,7 +3628,8 @@
     fadeRowNoteLater(id, 12000);
   });
   if (window.relay.onInjectionDelivered) window.relay.onInjectionDelivered((id) => {
-    setRowNote(id, "✓ Delivered — your current Claude chat is acting on it now.", "ok");
+    const chat = deliveredChatNames.get(id);
+    setRowNote(id, `✓ Delivered — ${chat ? `your \u201c${chat}\u201d chat` : "your current Claude chat"} is acting on it now.`, "ok");
     fadeRowNoteLater(id, 8000);
   });
   if (window.relay.onInjectionAutoFresh) window.relay.onInjectionAutoFresh((id) => {

package/overlay/main.cjs

@@ -697,6 +697,7 @@ function readRelays() {
       updatedAt: p.updatedAt || "",
       inReplyToRelayId: p.inReplyToRelayId || null,
       threadId: p.threadId || null,
+      threadTitle: p.threadTitle || "",
       actionUrl: p.actionUrl || "",
       action: p.action || {},
       quickReply: Boolean(p.quickReply),
@@ -1231,6 +1232,7 @@ async function pushInboxNow(force) {
       // Thread identity: a re-parented or newly threaded relay must repaint so
       // per-thread grouping and unread counts stay correct.
       r.threadId,
+      r.threadTitle,
       r.inReplyToRelayId,
     ]),
     sent: payload.sent.map((r) => [
@@ -2164,7 +2166,8 @@ async function openPacketInCurrent(packetId, { sent = false } = {}) {
     if (!target) return fallbackFresh("No live Claude chat found");
     console.error(
       `[overlay] openInCurrent ${packetId}: staging for claude session ${String(target.sessionId).slice(0, 8)}… ` +
-        `(${target.source}, active ${Math.round((Date.now() - target.lastActiveAt) / 1000)}s ago)`,
+        `(${target.source}${target.label ? `, "${target.label}"` : ""}, active ${Math.round((Date.now() - target.lastActiveAt) / 1000)}s ago` +
+        `${target.skippedStubs ? `, skipped ${target.skippedStubs} never-used chat(s)` : ""})`,
     );
     const stageNow = () => {
       let staged = null;
@@ -2186,7 +2189,10 @@ async function openPacketInCurrent(packetId, { sent = false } = {}) {
       // 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 });
+      // Name the chat the relay actually went to: "your granular-relay chat"
+      // beats "your current chat" when several are open (field report — the
+      // injection landed somewhere invisible and nothing said where).
+      confirmInjected("claude", { awaitingTurn: true, chat: target.label || "" });
       finish();
       watchInjectionDelivery(packetId, staged.path, {
         onAutoFresh: () => {

package/package.json

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

package/src/auto-update.js

@@ -560,6 +560,14 @@ export function spawnDetachedUpdate({
     `start_job "$DAEMON_PLIST" ${DAEMON_LABEL} || true`,
     `ensure_job "$PILL_PLIST" ${PILL_LABEL} || { log_line "pill restart verification FAILED"; RESTART_FAILED=1; }`,
     `ensure_job "$DAEMON_PLIST" ${DAEMON_LABEL} || { log_line "daemon restart verification FAILED"; RESTART_FAILED=1; }`,
+    // A "Boot-out failed: 3: No such process" means launchd had already lost the
+    // job while its PROCESS kept running — bootstrap then registers the job
+    // without replacing that stale pill, which keeps drawing with the old tree's
+    // window state (field report: wedged Space attachment after the 01:58
+    // restart, cured by hand with exactly this kickstart). Forcing the pill once
+    // more guarantees the process on screen came from the new tree. Pill only:
+    // kickstarting the daemon here would kill the job that owns this script.
+    `if [ "$RESTART_FAILED" != 1 ]; then "$LAUNCHCTL" kickstart -k "gui/${uid}/${PILL_LABEL}" >> ${LOG} 2>&1 || log_line "pill kickstart after bootstrap failed (continuing)"; fi`,
     `if [ "$RESTART_FAILED" = 1 ]; then`,
     `  log_line "restart verification FAILED; restoring previous tree"`,
     `  restore_tree`,

package/src/claude-inject.cjs

@@ -255,6 +255,53 @@ function hookResponseFor(eventName, instruction) {
 
 // ---- current-session resolution (pill side) --------------------------------
 
+// A short, human-recognizable name for a chat with no title: its working
+// directory's last segment ("granular-relay"), which is how people refer to
+// their chats anyway.
+function cwdLabel(cwd) {
+  const clean = String(cwd || "").replace(/[/\\]+$/, "");
+  if (!clean) return "";
+  const seg = clean.split(/[/\\]/).filter(Boolean).pop() || "";
+  return seg === "." || seg === ".." ? "" : seg;
+}
+
+// Did a HUMAN ever speak in this session? Reads only the head of the transcript
+// (the first real user message is always near the top), so this stays cheap on
+// multi-megabyte logs. A user line that carries toolUseResult is a tool result
+// being fed back, and isMeta lines are system-injected — neither is a person
+// typing. Returns null when the transcript can't be read: unknown must never
+// masquerade as "nobody spoke here" and disqualify a real chat.
+const TRANSCRIPT_HEAD_BYTES = 512 * 1024;
+function transcriptHasHumanTurn(transcriptPath) {
+  const file = String(transcriptPath || "").trim();
+  if (!file) return null;
+  let fd = null;
+  try {
+    fd = fs.openSync(file, "r");
+    const size = fs.fstatSync(fd).size;
+    const length = Math.min(size, TRANSCRIPT_HEAD_BYTES);
+    const buf = Buffer.alloc(length);
+    fs.readSync(fd, buf, 0, length, 0);
+    const text = buf.toString("utf8");
+    for (const line of text.split("\n")) {
+      if (!line.includes('"type":"user"') && !line.includes('"type": "user"')) continue;
+      if (line.includes('"toolUseResult"') || line.includes('"isMeta":true') || line.includes('"isMeta": true')) continue;
+      return true;
+    }
+    // Only trust a "no" when the whole file was inspected; a longer transcript
+    // whose head is all tool traffic stays unknown.
+    return size <= TRANSCRIPT_HEAD_BYTES ? false : null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== null) {
+      try {
+        fs.closeSync(fd);
+      } catch {}
+    }
+  }
+}
+
 function listDesktopSessionCandidates(desktopSessionsDir, { nowMs, maxAgeMs }) {
   const candidates = [];
   let orgs = [];
@@ -292,7 +339,21 @@ function listDesktopSessionCandidates(desktopSessionsDir, { nowMs, maxAgeMs }) {
         if (!(lastActiveAt > 0) || nowMs - lastActiveAt > maxAgeMs) continue;
         const sessionId = String(meta.cliSessionId || name.replace(/^local_/, "").replace(/\.json$/, "")).trim();
         if (!sessionId) continue;
-        candidates.push({ sessionId, lastActiveAt, source: "desktop" });
+        // completedTurns is Claude Desktop's own count of finished turns: 0 means
+        // nobody has ever spoken in this chat. Field report (Sven, 2026-08-06): a
+        // never-used stub chat won targeting purely on file/hook activity and the
+        // injection sat there forever. `undefined` (older Desktop builds) stays
+        // unknown rather than false — never exclude on missing data.
+        const turns = Number(meta.completedTurns);
+        candidates.push({
+          sessionId,
+          lastActiveAt,
+          source: "desktop",
+          hasHumanTurn: Number.isFinite(turns) ? turns > 0 : null,
+          // What to call this chat when telling the user where the relay went.
+          label: String(meta.title || "").trim() || cwdLabel(meta.cwd || meta.originCwd),
+          cwd: String(meta.cwd || meta.originCwd || ""),
+        });
       }
     }
   }
@@ -319,7 +380,16 @@ function listRendezvousCandidates(homeDir, { nowMs, maxAgeMs }) {
     if (!(lastActiveAt > 0) || nowMs - lastActiveAt > maxAgeMs) continue;
     const sessionId = String((row && row.sessionId) || name.replace(/\.json$/, "")).trim();
     if (!sessionId) continue;
-    candidates.push({ sessionId, lastActiveAt, source: "terminal" });
+    candidates.push({
+      sessionId,
+      lastActiveAt,
+      source: "terminal",
+      // A terminal session has no turn counter, so ask its transcript whether a
+      // human ever spoke there (null when we cannot tell).
+      hasHumanTurn: transcriptHasHumanTurn(row && row.transcriptPath),
+      label: cwdLabel(row && row.cwd),
+      cwd: String((row && row.cwd) || ""),
+    });
   }
   return candidates;
 }
@@ -341,7 +411,7 @@ function findCurrentClaudeSession({
   maxAgeMs = SESSION_MAX_AGE_MS,
   focusPriorityMs = DESKTOP_FOCUS_PRIORITY_MS,
 } = {}) {
-  const merged = new Map(); // sessionId -> { sessionId, lastActiveAt, desktop, focusedAt }
+  const merged = new Map(); // sessionId -> { sessionId, lastActiveAt, desktop, focusedAt, ... }
   const fold = (candidate) => {
     const existing = merged.get(candidate.sessionId);
     if (!existing) {
@@ -353,20 +423,37 @@ function findCurrentClaudeSession({
         // activity. Track focus separately so priority never leaks to busy
         // background sessions.
         focusedAt: candidate.source === "desktop" ? candidate.lastActiveAt : 0,
+        hasHumanTurn: candidate.hasHumanTurn ?? null,
+        label: candidate.label || "",
+        cwd: candidate.cwd || "",
       });
       return;
     }
     existing.lastActiveAt = Math.max(existing.lastActiveAt, candidate.lastActiveAt);
     existing.desktop = existing.desktop || candidate.source === "desktop";
     if (candidate.source === "desktop") existing.focusedAt = Math.max(existing.focusedAt, candidate.lastActiveAt);
+    // Any surface that can prove a human spoke here settles it; otherwise a
+    // known false only survives while nothing else has evidence.
+    if (candidate.hasHumanTurn === true) existing.hasHumanTurn = true;
+    else if (candidate.hasHumanTurn === false && existing.hasHumanTurn === null) existing.hasHumanTurn = false;
+    // Desktop metadata carries the real chat title; prefer it over a cwd label.
+    if (candidate.label && (!existing.label || candidate.source === "desktop")) existing.label = candidate.label;
+    if (candidate.cwd && !existing.cwd) existing.cwd = candidate.cwd;
   };
   if (desktopSessionsDir) {
     for (const candidate of listDesktopSessionCandidates(desktopSessionsDir, { nowMs, maxAgeMs })) fold(candidate);
   }
   for (const candidate of listRendezvousCandidates(homeDir, { nowMs, maxAgeMs })) fold(candidate);
+  // Chats nobody has ever spoken in are a LAST resort, not a rival: they win on
+  // raw activity (a stub can log file/hook events forever) while being exactly
+  // the place a relay must not be delivered. A never-used chat is still allowed
+  // when it is all that exists — the user may have just opened a fresh one.
+  const all = [...merged.values()];
+  const spoken = all.filter((e) => e.hasHumanTurn !== false);
+  const pool = spoken.length ? spoken : all;
   let bestFocused = null;
   let best = null;
-  for (const entry of merged.values()) {
+  for (const entry of pool) {
     if (entry.focusedAt > 0 && nowMs - entry.focusedAt <= focusPriorityMs) {
       if (!bestFocused || entry.focusedAt > bestFocused.focusedAt) bestFocused = entry;
     }
@@ -376,7 +463,15 @@ function findCurrentClaudeSession({
   }
   const chosen = bestFocused || best;
   return chosen
-    ? { sessionId: chosen.sessionId, lastActiveAt: chosen.lastActiveAt, source: chosen.desktop ? "desktop" : "terminal" }
+    ? {
+        sessionId: chosen.sessionId,
+        lastActiveAt: chosen.lastActiveAt,
+        source: chosen.desktop ? "desktop" : "terminal",
+        // What to call this chat when confirming where the relay went.
+        label: chosen.label || "",
+        cwd: chosen.cwd || "",
+        skippedStubs: all.length - pool.length,
+      }
     : null;
 }
 

package/src/mcp.js

@@ -14,7 +14,7 @@ export const TOOLS = [
   {
     name: "relay_send",
     description:
-      "Send an ordinary Relay message or handoff. Use this for the normal product flow when the human says things like 'send Sven a relay asking how he is doing' or 'relay this context to Jordan'. THREADING: Relay groups messages into conversation threads built from reply chains, so before sending, check the recent exchange with this recipient — call relay_inbox_list for what they sent this human (each item carries threadId and inReplyToRelayId), and use the sent context you already have from earlier sends. If the new message continues an ongoing exchange — topically, or within a recent back-and-forth window — pass inReplyToRelayId set to the LATEST relay id of that exchange (whichever side sent it) so the conversation stays one thread. If it starts a new topic, omit inReplyToRelayId and send it standalone. Granular digital employees appear as managed, workspace-labelled contacts; use relay_contacts_search and pass the exact matching contactId so a user with several workspaces reaches the intended employee. That message is authored by this human and wakes their employee; it is NOT a Relay task or deterministic workflow. Never use task-only tools to contact a Granular employee. For other recipients, an on-Relay message appears in their companion and Relays list; an off-Relay recipient receives an email open link.",
+      "Send an ordinary Relay message or handoff. Use this for the normal product flow when the human says things like 'send Sven a relay asking how he is doing' or 'relay this context to Jordan'. THREADING: Relay groups messages into conversation threads built from reply chains, so before sending, check the recent exchange with this recipient — call relay_inbox_list for what they sent this human (each item carries threadId and inReplyToRelayId), and use the sent context you already have from earlier sends. If the new message continues an ongoing exchange — topically, or within a recent back-and-forth window — pass inReplyToRelayId set to the LATEST relay id of that exchange (whichever side sent it) so the conversation stays one thread. If it starts a new topic, omit inReplyToRelayId and send it standalone. A thread has a NAME the human scans in their Relay list: whenever you reply into a thread that is not already well named, pass threadTitle to name the conversation (see that field). Granular digital employees appear as managed, workspace-labelled contacts; use relay_contacts_search and pass the exact matching contactId so a user with several workspaces reaches the intended employee. That message is authored by this human and wakes their employee; it is NOT a Relay task or deterministic workflow. Never use task-only tools to contact a Granular employee. For other recipients, an on-Relay message appears in their companion and Relays list; an off-Relay recipient receives an email open link.",
     inputSchema: {
       type: "object",
       properties: {
@@ -79,6 +79,11 @@ export const TOOLS = [
           description:
             "The id of the relay this message replies to. Threads are built from reply chains: when continuing an ongoing exchange, reply to the NEWEST relay in that exchange (from relay_inbox_list or an earlier send), never an older one, so the whole conversation shares one thread. Omit it to start a new standalone thread. When answering a question relay, pass that relay's id here — this is what resumes the asking agent's run.",
         },
+        threadTitle: {
+          type: "string",
+          description:
+            "Name the CONVERSATION (not this message). A thread comes into existence the moment a relay replies to another, and its name is what both people scan in their Relay list ever after — so whenever you send a reply (inReplyToRelayId set) into a thread that is not already well named, title it here. Same discipline as `title`, one level up: in as few words as it honestly takes (~5-12 words, hard stop 140 characters), say what this exchange IS and what it is for, so someone reading the list weeks later knows whether to open it. Name the ongoing subject, not the latest turn: 'Postmark migration for sendrelays.com — DNS + verification' beats 'Re: DNS records' or 'Postmark'. Never a bare noun ('Update', 'Question'), never a timestamp, never the other person's name alone. Setting it again renames the thread — use that when a conversation genuinely changes subject, and leave it alone when the existing name still fits.",
+        },
         type: {
           type: "string",
           enum: ["question", "completion"],
@@ -181,7 +186,7 @@ export const TOOLS = [
   {
     name: "relay_thread_fetch",
     description:
-      "Fetch ONE full Relay conversation thread, oldest first: every relay in the exchange (both directions) with sender, recipients, timestamps, title, body, and read state. Use this whenever a relay you are opening or replying to is part of a thread (its threadId differs from its own id, or an Open-in-chat instruction names a threadId) so the WHOLE exchange is in context before you act — never reconstruct a conversation by fetching relays one at a time. Pass the threadId (the root relay's id, carried on every relay_inbox_list item).",
+      "Fetch ONE full Relay conversation thread, oldest first: its threadTitle (the conversation's name — check it before replying; if it is missing or no longer describes the exchange, pass a better one as relay_send's threadTitle) and every relay in the exchange (both directions) with sender, recipients, timestamps, title, body, and read state. Use this whenever a relay you are opening or replying to is part of a thread (its threadId differs from its own id, or an Open-in-chat instruction names a threadId) so the WHOLE exchange is in context before you act — never reconstruct a conversation by fetching relays one at a time. Pass the threadId (the root relay's id, carried on every relay_inbox_list item).",
     inputSchema: {
       type: "object",
       properties: {
@@ -602,6 +607,7 @@ export async function handleCall(client, name, args, { mode = DEFAULT_COMPANION_
           targetSurfaces: args.targetSurfaces || [],
           attachments: await prepareOrdinaryRelayAttachments(args),
           ...(args.inReplyToRelayId ? { inReplyToRelayId: args.inReplyToRelayId } : {}),
+          ...(args.threadTitle ? { threadTitle: args.threadTitle } : {}),
           ...(args.type ? { type: args.type } : {}),
           idempotencyKey: args.idempotencyKey,
         })),

package/src/notifications.js

@@ -650,6 +650,9 @@ export function stagePlainRelayItem(
     // exchange and keep its unread counting stable per thread.
     inReplyToRelayId: item.inReplyToRelayId || packet?.inReplyToRelayId || null,
     threadId: item.threadId || packet?.threadId || item.relayId,
+    // The conversation's name, carried on every item by the API so the pill can
+    // label a thread without fetching it.
+    threadTitle: item.threadTitle || packet?.threadTitle || null,
     // A restoration is a fresh inbox delivery even when the underlying relay was
     // read before deletion. Use that timestamp so an older account read-all
     // cutoff cannot immediately collapse the restored row back to read.
@@ -746,6 +749,7 @@ export function stageSentRelayItem(
       // inbound side. An item without one must not clobber a previously staged
       // id (this row is re-staged on every open).
       threadId: item.threadId || existing.threadId || null,
+      threadTitle: item.threadTitle || existing.threadTitle || null,
       inReplyToRelayId: item.inReplyToRelayId || existing.inReplyToRelayId || null,
     };
     const contentPath = writeNotificationPacketContent({ id: materializationId }, content, statePath);