relay-companion 0.1.63 → 0.1.65

package/overlay/codex-open-current.cjs

@@ -50,7 +50,7 @@ function defaultLog(...args) {
 // silent dead end. `finish` (ack + spinner stop) fires exactly once for the
 // bridge/automation tiers; the fresh tier's openPacket owns its own lifecycle.
 async function openCodexInCurrent(
-  { packetId, senderName = "", title = "" } = {},
+  { packetId, senderName = "", title = "", threadId = null, threadCount = 0 } = {},
   {
     inject, // src/codex-inject.js
     desktop, // src/codex-desktop.js
@@ -90,7 +90,7 @@ async function openCodexInCurrent(
         `last active ${new Date(target.lastActiveAt).toISOString()})`,
     );
 
-    const instruction = inject.buildInjectionInstruction({ relayId: packetId, senderName, title });
+    const instruction = inject.buildInjectionInstruction({ relayId: packetId, senderName, title, threadId, threadCount });
 
     // ---- (a) bridge tier ----------------------------------------------------
     if (!bridgeSubmitEnabled(env)) {

package/overlay/inbox.html

@@ -2462,7 +2462,18 @@
       return renderThreads();
     }
     thDetailNameEl.textContent = thread.party;
-    thHistoryEl.innerHTML = thread.msgs.map((m) => `
+    // 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.
+    const newestInbound = [...thread.msgs].reverse().find((m) => m.direction === "in") || thread.msgs[thread.msgs.length - 1];
+    const threadActions = newestInbound ? `
+      <div class="td-card row-open-card" data-stop="1">
+        <div class="td-card-actions">
+          <button class="td-btn primary" type="button" data-thread-open-current="${esc(newestInbound.id)}">Open thread in current chat</button>
+          <button class="td-btn ghost" type="button" data-thread-open-fresh="${esc(newestInbound.id)}">Open thread in new chat</button>
+        </div>
+      </div>` : "";
+    thHistoryEl.innerHTML = threadActions + thread.msgs.map((m) => `
       <button class="th-msg${m.unread ? " unread" : ""}" type="button" data-msg="${esc(m.id)}" data-dir="${m.direction}">
         <span class="th-msg-top">
           <span class="th-dir${m.direction === "out" ? " out" : ""}">${m.direction === "out" ? "←" : "→"}</span>
@@ -2477,6 +2488,10 @@
         openRelayFromUI(id, el.getAttribute("data-dir") === "out" ? "sent" : "relay");
       });
     }
+    const curBtn = thHistoryEl.querySelector("[data-thread-open-current]");
+    if (curBtn) curBtn.addEventListener("click", () => openRelayFromUI(curBtn.getAttribute("data-thread-open-current"), "relay", "current"));
+    const freshBtn = thHistoryEl.querySelector("[data-thread-open-fresh]");
+    if (freshBtn) freshBtn.addEventListener("click", () => openRelayFromUI(freshBtn.getAttribute("data-thread-open-fresh"), "relay", "fresh"));
   }
   thBackEl.addEventListener("click", () => {
     threadDetailId = null;

package/overlay/main.cjs

@@ -42,6 +42,7 @@ const {
   shouldIgnoreDismiss,
   boundedPresentedRelayIds,
   recoverInterruptedAttentionPrefs,
+  quitRelayCommand,
   hostPollDelayMs,
   sentRefreshDelayMs,
 } = require("./visibility.cjs");
@@ -1508,6 +1509,21 @@ async function openPacket(packetId, { sent = false, fresh = false } = {}) {
 // tools; the sender's content is never inlined (relay-briefing's
 // untrusted-content discipline). A missing row or no live session/thread
 // within 6h falls back to the fresh-open flow.
+// 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.
+function threadInfoFor(row) {
+  const threadId = (row && row.threadId) || null;
+  if (!threadId) return { threadId: null, threadCount: 0 };
+  const ids = new Set();
+  for (const r of readRelays()) if (r.threadId === threadId) ids.add(r.id);
+  for (const s of sentCache || []) {
+    const sid = s.relayId || s.id;
+    if (sid && (s.threadId || sid) === threadId) ids.add(sid);
+  }
+  return { threadId, threadCount: ids.size };
+}
+
 async function openPacketInCurrent(packetId) {
   if (!packetId) return;
   const row = rowById(packetId);
@@ -1539,6 +1555,7 @@ async function openPacketInCurrent(packetId) {
               packetId,
               senderName: row.senderName || "",
               title: row.title || row.displayTitle || "",
+              ...threadInfoFor(row),
             },
             {
               inject,
@@ -1574,6 +1591,7 @@ async function openPacketInCurrent(packetId) {
         relayId: packetId,
         senderName: row.senderName || "",
         title: row.title || row.displayTitle || "",
+        ...threadInfoFor(row),
       });
     } catch (error) {
       console.error("[overlay] claude injection staging failed:", error && error.message);
@@ -2158,6 +2176,24 @@ function syncTray() {
   } catch {}
 }
 
+// "Quit Relay" from the tray: stop the daemon and the pill's own service via a
+// DETACHED shell (the second bootout kills this process, so the shell must
+// outlive us), then quit the app immediately for instant visual feedback.
+function quitRelayCompletely() {
+  try {
+    const uid = typeof process.getuid === "function" ? process.getuid() : 501;
+    const [cmd, args] = quitRelayCommand({ platform: process.platform, uid });
+    const child = spawn(cmd, args, { detached: true, stdio: "ignore" });
+    child.on("error", (error) => console.error(`[overlay] ${new Date().toISOString()} quit spawn failed:`, error && error.message));
+    child.unref();
+  } catch (error) {
+    console.error(`[overlay] ${new Date().toISOString()} quit failed:`, error && error.message);
+  }
+  try {
+    app.quit();
+  } catch {}
+}
+
 function createTray() {
   const icon = createTrayIcon();
   if (!icon || icon.isEmpty()) {
@@ -2178,7 +2214,11 @@ function createTray() {
   tray.on("right-click", () => {
     try {
       tray.popUpContextMenu(
-        Menu.buildFromTemplate([{ label: pillIsOnScreen() ? "Hide Relay" : "Show Relay", click: toggleFromTray }]),
+        Menu.buildFromTemplate([
+          { label: pillIsOnScreen() ? "Hide Relay" : "Show Relay", click: toggleFromTray },
+          { type: "separator" },
+          { label: "Quit Relay", click: quitRelayCompletely },
+        ]),
       );
     } catch (error) {
       console.error("[overlay] tray menu failed:", error && error.message);

package/overlay/visibility.cjs

@@ -119,7 +119,30 @@ function sentRefreshDelayMs({ testMode = false, engaged = false, showActive = fa
   return engaged || showActive ? 5000 : 30000;
 }
 
+// The tray's "Quit Relay": one detached shell that stops BOTH background
+// services. Order matters — the daemon first, the pill's own service LAST,
+// because the second bootout kills the process that spawned the shell.
+// launchctl bootout (not kickstart/stop) is the verb that beats KeepAlive;
+// the jobs return at next login (RunAtLoad) or via `relay pill`.
+function quitRelayCommand({ platform = process.platform, uid = 501 } = {}) {
+  if (platform === "win32") {
+    return [
+      "cmd",
+      ["/c", 'schtasks /End /TN "Relay Companion Daemon" & schtasks /End /TN "Relay Companion Pill"'],
+    ];
+  }
+  return [
+    "/bin/sh",
+    [
+      "-c",
+      `/bin/launchctl bootout gui/${uid}/work.relay.companion 2>/dev/null; ` +
+        `/bin/launchctl bootout gui/${uid}/work.relay.companion.pill 2>/dev/null`,
+    ],
+  ];
+}
+
 module.exports = {
+  quitRelayCommand,
   hostPollDelayMs,
   sentRefreshDelayMs,
   overlayWanted,

package/package.json

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

package/src/claude-inject.cjs

@@ -81,15 +81,28 @@ function sanitizeInline(value, cap = 140) {
   return flat.length > cap ? `${flat.slice(0, cap - 1).trimEnd()}\u2026` : flat;
 }
 
-function buildInjectionInstruction({ relayId, senderName, title } = {}) {
+function buildInjectionInstruction({ relayId, senderName, title, threadId, threadCount } = {}) {
   const id = sanitizeInline(relayId, 80) || "unknown";
   const sender = sanitizeInline(senderName) || "someone";
   const subject = sanitizeInline(title) || "a relay";
-  return (
+  const base =
     `The user received relay ${id} from ${sender}: '${subject}'. ` +
     "They clicked Open-in-current-chat. Fetch and open it now with the relay MCP tools " +
-    "(relay_inbox_list / GET the relay), then act on it."
-  );
+    "(relay_inbox_list / GET the relay), then act on it.";
+  const tid = sanitizeInline(threadId, 80);
+  const count = Number(threadCount) || 0;
+  if (tid && count > 1) {
+    return (
+      base +
+      ` This relay is part of a conversation thread (threadId ${tid}, ${count} messages so far). ` +
+      "Call relay_thread_fetch with that threadId FIRST so the whole exchange is in your context, " +
+      "then act on the latest message in the thread."
+    );
+  }
+  if (tid) {
+    return base + ` (Its threadId is ${tid}; if replies exist later, relay_thread_fetch retrieves the full conversation.)`;
+  }
+  return base;
 }
 
 // Stage one pending injection for a live session (or `sessionId: "any"` to

package/src/client.js

@@ -201,6 +201,10 @@ export class RelayClient {
     return this.#req("POST", "/v1/tools/call", payload);
   }
 
+  thread(threadId) {
+    return this.#req("GET", `/v1/threads/${encodeURIComponent(threadId)}`);
+  }
+
   searchContacts(q) {
     return this.#req("GET", `/v1/contacts/search?q=${encodeURIComponent(q)}`);
   }

package/src/materializer.js

@@ -149,9 +149,43 @@ async function resolveRow(id, { log = () => {}, allowTaskRows = false } = {}) {
   // the next render echo the prior seed into itself (a doubled body). briefingMarkdown
   // is preview-only and is not read back by the seed builders, so it is safe to set.
   row.briefingMarkdown = renderRelayRowBriefing(row);
+  await prependThreadTranscript(row, { log });
   return { row, rowState };
 }
 
+// "Open in new chat" on a relay that belongs to a multi-message thread must
+// seed the WHOLE conversation — like opening a group chat — not just the one
+// message. Fetch the thread from the API and prepend a chronological
+// transcript to the briefing; on any failure the single-relay seed stands.
+async function prependThreadTranscript(row, { log = () => {} } = {}) {
+  const threadId = row?.threadId || null;
+  if (!threadId) return;
+  try {
+    const { RelayClient } = await import("./client.js");
+    const client = new RelayClient();
+    const thread = await client.thread(threadId);
+    const msgs = Array.isArray(thread?.messages) ? thread.messages : Array.isArray(thread?.items) ? thread.items : [];
+    if (msgs.length < 2) return;
+    const lines = msgs.map((m) => {
+      const id = m.relayId || m.id || "";
+      const from = m.fromDisplayName || m.senderName || (m.direction === "outbound" ? "You" : "Them");
+      const when = m.createdAt || "";
+      const title = m.title || "";
+      const body = String(m.bodyMarkdown || m.preview || "").trim();
+      return `**${from}** — ${when} (relay ${id})\n${title ? `*${title}*\n` : ""}${body}`;
+    });
+    row.briefingMarkdown =
+      `## Conversation thread (${msgs.length} messages, oldest first — threadId ${threadId})\n\n` +
+      `${lines.join("\n\n---\n\n")}\n\n` +
+      `> The relay the user opened is the one addressed below. The full exchange above is context; ` +
+      `relay_thread_fetch with threadId ${threadId} re-fetches it at any time.\n\n---\n\n` +
+      row.briefingMarkdown;
+    log(`thread transcript seeded: ${msgs.length} messages from ${threadId}`);
+  } catch (error) {
+    log(`thread transcript skipped: ${error?.message || error}`);
+  }
+}
+
 async function resolvePublicOpenToken(token, { log = () => {} } = {}) {
   try {
     const { RelayClient } = await import("./client.js");

package/src/mcp.js

@@ -123,6 +123,21 @@ export const TOOLS = [
       "List ordinary Relay messages addressed to this human. Each item carries threadId (the conversation thread it belongs to — the root relay's id) and, on replies, inReplyToRelayId; use them to reconstruct the recent exchange with a sender before continuing it via relay_send's inReplyToRelayId. This does not list task coordination relays; use relay_task_status for task state.",
     inputSchema: { type: "object", properties: {} },
   },
+  {
+    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).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        threadId: {
+          type: "string",
+          description: "The conversation thread id — the root relay's id, as carried on inbox items and sent responses.",
+        },
+      },
+      required: ["threadId"],
+    },
+  },
   {
     name: "relay_inbox_delete",
     description:
@@ -479,6 +494,7 @@ export const MESSAGE_ONLY_TOOL_NAMES = new Set([
   "relay_contact_update",
   "relay_groups_list",
   "relay_inbox_list",
+  "relay_thread_fetch",
   "relay_acknowledge",
 ]);
 
@@ -548,6 +564,8 @@ export async function handleCall(client, name, args, { mode = DEFAULT_COMPANION_
       );
     case "relay_inbox_list":
       return text(await client.inbox());
+    case "relay_thread_fetch":
+      return text(await client.thread(args.threadId));
     case "relay_inbox_delete":
       return text(await client.deleteInboxItem(args.itemId, { idempotencyKey: args.idempotencyKey }));
     case "relay_recently_deleted_list":