relay-companion 0.1.8 → 0.1.10

package/overlay/inbox.html

@@ -159,7 +159,12 @@
     transition:opacity .3s var(--settle) .06s;
   }
   .card.collapsed .scroll { opacity:0; pointer-events:none; transition:opacity .14s var(--settle); }
-  .card.peek .scroll { opacity:1; pointer-events:auto; }
+  .card.peek .scroll {
+    opacity:1; pointer-events:auto;
+    /* safety net: anything beyond the sized first row fades instead of hard-clipping */
+    -webkit-mask-image:linear-gradient(to bottom, #000 calc(100% - 12px), transparent);
+            mask-image:linear-gradient(to bottom, #000 calc(100% - 12px), transparent);
+  }
   .scroll::-webkit-scrollbar { width:10px; }
   .scroll::-webkit-scrollbar-thumb { background:rgba(31,26,23,.12); border-radius:10px; border:3px solid var(--bg); background-clip:padding-box; }
   .scroll::-webkit-scrollbar-thumb:hover { background:rgba(31,26,23,.2); background-clip:padding-box; }
@@ -299,6 +304,40 @@
   .task-meta .sep { color:var(--muted-3); }
   .task-approve { color:var(--accent); font-weight:600; }
 
+  /* ---- task detail (in-pill) ---- */
+  .td-head { display:flex; align-items:center; gap:8px; padding:10px 16px 2px; }
+  .td-back {
+    appearance:none; border:0; background:transparent; cursor:pointer; padding:2px 6px 2px 0;
+    font-family:var(--sans); font-size:12.5px; font-weight:500; color:var(--muted-2);
+    transition:color .15s var(--settle);
+  }
+  .td-back:hover { color:var(--ink); }
+  .td-title { font-family:var(--serif); font-size:16px; font-weight:500; color:var(--ink); padding:2px 16px 0; line-height:1.3; }
+  .td-meta { display:flex; align-items:center; gap:7px; padding:6px 16px 10px; font-size:11.5px; color:var(--muted-2); flex-wrap:wrap; }
+  .td-state { font-weight:500; }
+  .td-state.s-active { color:var(--accent); }
+  .td-section {
+    font-family:var(--serif); font-size:12.5px; font-weight:500; color:var(--muted-2);
+    padding:12px 16px 5px; border-top:1px solid var(--hair);
+  }
+  .td-block { padding:0 16px 10px; font-size:12px; line-height:1.5; color:var(--ink-2); }
+  .td-block .quiet { color:var(--muted-2); }
+  .td-msg { padding:8px 16px 10px; border-bottom:1px solid var(--hair-2); }
+  .td-msg:last-child { border-bottom:0; }
+  .td-msg-top { display:flex; align-items:baseline; gap:7px; }
+  .td-msg-sender { font-size:11.5px; font-weight:600; color:var(--ink); }
+  .td-msg-kind { font-size:10.5px; color:var(--muted-3); }
+  .td-msg-time { margin-left:auto; font-family:var(--mono); font-size:10.5px; color:var(--muted-2); }
+  .td-msg-body { font-size:12px; line-height:1.5; color:var(--muted); margin-top:3px; white-space:pre-line; }
+  .td-part { display:flex; align-items:baseline; gap:8px; padding:5px 16px; font-size:12px; }
+  .td-part-name { color:var(--ink); font-weight:500; }
+  .td-part-state { margin-left:auto; font-size:11px; color:var(--muted-2); }
+  .td-result { padding:6px 16px 10px; }
+  .td-result-title { font-size:12.5px; font-weight:600; color:var(--ink); }
+  .td-result-body { font-size:12px; line-height:1.5; color:var(--muted); margin-top:3px; white-space:pre-line; }
+  .td-actions { display:flex; gap:16px; padding:10px 16px 14px; align-items:center; border-top:1px solid var(--hair); }
+  .td-err { color:#b4332a; font-size:11.5px; padding:8px 16px; }
+
   /* ---- empty states ---- */
   .empty {
     height:100%; display:flex; flex-direction:column; align-items:center; justify-content:center;
@@ -477,6 +516,9 @@
         </div>
       </section>
 
+      <!-- Task detail view (in-pill mirror of the web task page, live-polled) -->
+      <section class="view hidden" id="taskDetailView"></section>
+
       <!-- Contacts view -->
       <section class="view hidden" id="contactsView">
         <div class="cv-head">
@@ -524,6 +566,7 @@
   const tasksListEl = document.getElementById("tasksList");
   const tasksEmptyEl = document.getElementById("tasksEmpty");
   const tasksBadgeEl = document.getElementById("tasksBadge");
+  const taskDetailViewEl = document.getElementById("taskDetailView");
   const contactsViewEl = document.getElementById("contactsView");
   const cvAddEl = document.getElementById("cvAdd");
   const cvListEl = document.getElementById("cvList");
@@ -664,7 +707,6 @@
     clearPeek();
     collapsed = false;
     cardEl.classList.remove("collapsed", "offstage", "bye");
-    snapSize(PEEK.w, PEEK.h);
     ghost = true; peeking = true;
     cardEl.classList.add("peek", "ghost");
     const kind = row && row.relayNotificationKind;
@@ -673,6 +715,8 @@
     applyView();
     renderAll();
     scrollEl.scrollTop = 0;
+    // Size to the rendered first row (no pill morph — the banner just appears at size).
+    snapSize(PEEK.w, peekHeight());
     playTink();
     // Leave after ~7s — but never rug-pull someone mid-reply or with the pointer on
     // the banner; check again shortly instead (macOS banners hold while hovered too).
@@ -705,6 +749,13 @@
     renderAll();
     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 the tab the item lives in: task_request / share_approval -> Tasks
   // (the clean split), everything else -> Relays.
@@ -721,7 +772,7 @@
     applyView();
     renderAll();
     scrollEl.scrollTop = 0;
-    springTo(PEEK.w, PEEK.h);
+    springTo(PEEK.w, peekHeight());
     playTink();
     peekTimer = setTimeout(() => {
       peekTimer = null; peeking = false;
@@ -1058,6 +1109,14 @@
   function relayActionsHtml(r) {
     const k = r.relayNotificationKind;
     if (k === "human_question") {
+      // Once the question is answered (here, on the web, or inside a host session),
+      // show what was sent instead of a live reply box that could double-answer.
+      if (r.humanAnswered) {
+        const sent = r.humanAnswerMarkdown ? firstLine(r.humanAnswerMarkdown, 140) : "";
+        return sent
+          ? `<div class="row-note">You replied: “${esc(sent)}” — the agent run has resumed.</div>`
+          : `<div class="row-note">Answered — the agent run has resumed.</div>`;
+      }
       // relay_answer_human_question requires BOTH taskId and messageId (mcp.js). Only render the
       // inline reply box when both are present; otherwise the box would post a dead answer.
       if (r.quickReply && r.taskId && r.messageId) {
@@ -1156,7 +1215,7 @@
         const text = ta ? ta.value.trim() : "";
         if (!text) { showRowError(id, "Write an answer first."); return; }
         runRowAction(id, btn, async () => {
-          const res = await window.relay.answer(r.taskId, r.messageId, text);
+          const res = await window.relay.answer(r.taskId, r.messageId, text, r.id);
           if (res && res.ok) { if (ta) ta.value = ""; }
           return res;
         });
@@ -1214,6 +1273,168 @@
     }
   }
 
+  // ---------- in-pill task detail (live) ----------
+  // Clicking a task row opens a live detail panel INSIDE the pill (the same data the
+  // web task page renders), polled every 5s while open. "Open in Claude/Codex" keeps
+  // the old materialize-into-host behavior as an explicit action.
+  let taskDetailId = null;
+  let taskDetailData = null;
+  let taskDetailError = "";
+  let taskDetailTimer = null;
+  function showTaskDetail(taskId) {
+    taskDetailId = taskId;
+    taskDetailData = (payload.tasks || []).find((t) => t.id === taskId) || null; // summary while loading
+    taskDetailError = "";
+    activeView = "taskDetail";
+    syncTabs();
+    applyView();
+    renderTaskDetail();
+    refreshTaskDetail();
+    if (taskDetailTimer) clearInterval(taskDetailTimer);
+    taskDetailTimer = setInterval(() => {
+      if (activeView === "taskDetail" && !collapsed) refreshTaskDetail();
+    }, 5000);
+  }
+  function closeTaskDetail() {
+    if (taskDetailTimer) { clearInterval(taskDetailTimer); taskDetailTimer = null; }
+    taskDetailId = null;
+    taskDetailData = null;
+    activeView = "tasks";
+    syncTabs();
+    applyView();
+    renderAll();
+  }
+  async function refreshTaskDetail() {
+    if (!taskDetailId) return;
+    const id = taskDetailId;
+    try {
+      const res = await window.relay.taskStatus(id);
+      if (id !== taskDetailId) return; // navigated away while fetching
+      if (res && res.ok && res.task) {
+        taskDetailData = res.task;
+        taskDetailError = "";
+      } else {
+        taskDetailError = (res && res.error) || "Could not load the task.";
+      }
+    } catch (err) {
+      if (id !== taskDetailId) return;
+      taskDetailError = (err && err.message) || "Could not load the task.";
+    }
+    if (activeView === "taskDetail") renderTaskDetail();
+  }
+  function tdChip(state) {
+    const cls = state === "active" || state === "completing" ? "s-active" : "";
+    return `<span class="td-state ${cls}">${esc(taskStateLabel(state))}</span>`;
+  }
+  function renderTaskDetail() {
+    if (!taskDetailViewEl) return;
+    const t = taskDetailData;
+    if (!t) {
+      taskDetailViewEl.innerHTML = `
+        <div class="td-head"><button class="td-back" type="button" data-td-back="1">‹ Tasks</button></div>
+        <div class="td-block quiet">${taskDetailError ? esc(taskDetailError) : "Loading task…"}</div>`;
+      wireTaskDetail();
+      return;
+    }
+    const participants = Array.isArray(t.participants) ? t.participants : [];
+    const messages = Array.isArray(t.recentMessages) ? t.recentMessages.slice(-5) : [];
+    const results = Array.isArray(t.results) ? t.results : [];
+    const approvals = Array.isArray(t.pendingApprovals) ? t.pendingApprovals : [];
+    const objective = String(t.objective || "").trim();
+
+    let html = `
+      <div class="td-head">
+        <button class="td-back" type="button" data-td-back="1">‹ Tasks</button>
+        <span class="task-time">${esc(timeAgo(t.updatedAt))}</span>
+      </div>
+      <div class="td-title">${esc(t.title || "Untitled task")}</div>
+      <div class="td-meta">${tdChip(t.state)}<span class="sep">·</span><span>${esc(participantSummary(t))}</span></div>`;
+    if (objective) html += `<div class="td-block quiet">${esc(firstLine(objective, 160))}</div>`;
+    if (taskDetailError) html += `<div class="td-err">${esc(taskDetailError)}</div>`;
+
+    if (approvals.length) {
+      html += `<div class="td-section">Waiting on you</div>`;
+      for (const a of approvals) {
+        const preview = firstLine(a.payloadMarkdown || a.bodyMarkdown || "an outbound share", 110);
+        html += `
+          <div class="td-block">
+            ${esc(preview)}
+            <div class="rk-actions" style="margin-top:8px">
+              <button class="act-btn accept" type="button" data-td-approve="${esc(a.id)}">Approve</button>
+              <button class="act-btn decline" type="button" data-td-decline="${esc(a.id)}">Decline</button>
+            </div>
+          </div>`;
+      }
+    }
+    if (results.length) {
+      html += `<div class="td-section">Results visible to you</div>`;
+      for (const r of results) {
+        html += `
+          <div class="td-result">
+            <div class="td-result-title">${esc(r.title || "Result")}</div>
+            <div class="td-result-body">${esc(firstLine(r.bodyMarkdown || "", 400))}</div>
+          </div>`;
+      }
+    }
+    if (messages.length) {
+      html += `<div class="td-section">Messages</div>`;
+      for (const m of messages) {
+        html += `
+          <div class="td-msg">
+            <div class="td-msg-top">
+              <span class="td-msg-sender">${esc(m.senderLabel || "Agent")}</span>
+              <span class="td-msg-kind">${esc(String(m.kind || "").replaceAll("_", " "))}</span>
+              <span class="td-msg-time">${esc(timeAgo(m.createdAt))}</span>
+            </div>
+            <div class="td-msg-body">${esc(firstLine(m.bodyMarkdown || "", 220))}</div>
+          </div>`;
+      }
+    }
+    if (participants.length) {
+      html += `<div class="td-section">Participants</div>`;
+      for (const p of participants) {
+        html += `
+          <div class="td-part">
+            <span class="td-part-name">${esc(p.displayName || p.email || "Participant")}</span>
+            <span class="td-part-state">${esc(String(p.invitationState || "").replaceAll("_", " "))}</span>
+          </div>`;
+      }
+    }
+    html += `
+      <div class="td-actions" data-stop="1">
+        <button class="act-btn accept" type="button" data-td-open="${esc(t.id)}">Open in Claude or Codex</button>
+      </div>`;
+    taskDetailViewEl.innerHTML = html;
+    wireTaskDetail();
+  }
+  async function runTdMutation(btn, fn) {
+    if (!btn || btn.disabled) return;
+    btn.disabled = true;
+    try {
+      const res = await fn();
+      if (res && res.ok === false) taskDetailError = res.error || "Could not complete that.";
+    } catch (err) {
+      taskDetailError = (err && err.message) || "Could not complete that.";
+    } finally {
+      btn.disabled = false;
+      refreshTaskDetail();
+    }
+  }
+  function wireTaskDetail() {
+    for (const btn of taskDetailViewEl.querySelectorAll("[data-td-back]")) {
+      btn.addEventListener("click", closeTaskDetail);
+    }
+    for (const btn of taskDetailViewEl.querySelectorAll("[data-td-open]")) {
+      btn.addEventListener("click", () => window.relay.openTask(btn.getAttribute("data-td-open")));
+    }
+    for (const btn of taskDetailViewEl.querySelectorAll("[data-td-approve]")) {
+      btn.addEventListener("click", () => runTdMutation(btn, () => window.relay.approve(taskDetailId, btn.getAttribute("data-td-approve"))));
+    }
+    for (const btn of taskDetailViewEl.querySelectorAll("[data-td-decline]")) {
+      btn.addEventListener("click", () => runTdMutation(btn, () => window.relay.decline(taskDetailId, btn.getAttribute("data-td-decline"))));
+    }
+  }
+
   function wireTaskRows() {
     // action zones inside a row must not also open the task web detail
     for (const z of tasksListEl.querySelectorAll('[data-stop="1"]')) {
@@ -1235,15 +1456,17 @@
         runTaskAction(btn, () => window.relay.reject(taskId, pid));
       });
     }
-    // "N waiting to approve" -> open the task's web detail (no inline approval)
+    // "N waiting to approve" -> the in-pill detail, where the approval buttons live
     for (const el of tasksListEl.querySelectorAll("[data-approve]")) {
       el.addEventListener("click", (e) => {
         e.stopPropagation();
-        window.relay.openTask(el.getAttribute("data-approve"));
+        showTaskDetail(el.getAttribute("data-approve"));
       });
     }
+    // Row click opens the live in-pill detail; opening in Claude/Codex is an
+    // explicit action inside it.
     for (const el of tasksListEl.querySelectorAll(".task")) {
-      el.addEventListener("click", () => window.relay.openTask(el.getAttribute("data-task")));
+      el.addEventListener("click", () => showTaskDetail(el.getAttribute("data-task")));
     }
   }
   function taskRowHtml(t) {
@@ -1493,12 +1716,19 @@
 
   // ---------- views / tabs ----------
   function syncTabs() {
-    for (const tab of tabEls) tab.classList.toggle("active", tab.getAttribute("data-view") === activeView);
+    // The in-pill task detail lives under the Tasks tab.
+    const tabView = activeView === "taskDetail" ? "tasks" : activeView;
+    for (const tab of tabEls) tab.classList.toggle("active", tab.getAttribute("data-view") === tabView);
   }
   function applyView() {
     relaysViewEl.classList.toggle("hidden", activeView !== "relays");
     tasksViewEl.classList.toggle("hidden", activeView !== "tasks");
+    taskDetailViewEl.classList.toggle("hidden", activeView !== "taskDetail");
     contactsViewEl.classList.toggle("hidden", activeView !== "contacts");
+    if (activeView !== "taskDetail" && taskDetailTimer) {
+      clearInterval(taskDetailTimer);
+      taskDetailTimer = null;
+    }
     if (activeView === "contacts") {
       loadContacts();
     } else {
@@ -1550,6 +1780,9 @@
     else notifyArrival(row);
   });
   if (window.relay.onOpenFull) window.relay.onOpenFull(() => trayOpen());
+  // 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));
   window.relay.refresh().then((p) => {
     onPayload(p);

package/overlay/main.cjs

@@ -226,6 +226,8 @@ function readRelays() {
       provider: p.provider || null,
       contentPath: p.contentPath || null,
       expectedVersion: p.expectedVersion || null,
+      humanAnswered: Boolean(p.humanAnswered),
+      humanAnswerMarkdown: p.humanAnswerMarkdown || null,
     }))
     .sort((a, b) => {
       if (a.unread !== b.unread) return a.unread ? -1 : 1; // unread always on top
@@ -324,7 +326,7 @@ async function pushInbox(force) {
       if (dismissed) {
         if (hostRunning) {
           ghostActive = true;
-          if (!win.isVisible()) win.showInactive();
+          showOverlayWindow();
           win.webContents.send("newRelay", fresh[0], { ghost: true });
         }
       } else {
@@ -454,7 +456,7 @@ async function declineShare(taskId, approvalId) {
   });
 }
 
-async function answerQuestion(taskId, messageId, text) {
+async function answerQuestion(taskId, messageId, text, packetId) {
   const answerMarkdown = String(text || "").trim();
   if (!taskId || !messageId) return { ok: false, error: "Missing task or message id." };
   if (!answerMarkdown) return { ok: false, error: "Write an answer first." };
@@ -464,9 +466,27 @@ async function answerQuestion(taskId, messageId, text) {
       answerMarkdown,
       idempotencyKey: idempotencyKey("answer"),
     });
+    // The reply box must not survive a successful answer: record it on the staged
+    // packet immediately (the daemon reconciles the same way on its next poll).
+    if (packetId) markQuestionAnswered(packetId, answerMarkdown);
   });
 }
 
+function markQuestionAnswered(packetId, answerMarkdown) {
+  const store = readStore();
+  const row = store.packets && store.packets[packetId];
+  if (!row) return;
+  store.packets[packetId] = {
+    ...row,
+    state: "read",
+    quickReply: false,
+    humanAnswered: true,
+    humanAnswerMarkdown: answerMarkdown,
+    updatedAt: new Date().toISOString(),
+  };
+  writeStateAtomic(store);
+}
+
 function taskVersion(taskId) {
   const task = tasksCache.find((t) => t.id === taskId);
   return task && task.version != null ? task.version : null;
@@ -686,13 +706,25 @@ function anchorTopRight() {
   return { x: wa.x + wa.width - WIN.width - MARGIN, y: wa.y + MARGIN, width: WIN.width, height: WIN.height };
 }
 
+// Show the overlay window. Electron's forwarded-mousemove stream (the thing that
+// lets the renderer detect hover on a click-through window) can stall across a
+// hide()/show() cycle, leaving the window permanently click-through. Re-assert
+// setIgnoreMouseEvents on every hidden->shown transition and tell the renderer to
+// reset its interactivity handshake.
+function showOverlayWindow() {
+  if (!win || win.isDestroyed() || win.isVisible()) return;
+  win.showInactive();
+  win.setIgnoreMouseEvents(true, { forward: true });
+  win.webContents.send("shown");
+}
+
 function maybeShow() {
   if (!win || win.isDestroyed()) return;
   // Dismissed keeps the window hidden except while a ghost notification is up.
   // trayForcedVisible honors an explicit menu-bar click even when no host runs.
   const wanted = (hostRunning || trayForcedVisible) && (!dismissed || ghostActive);
   if (wanted) {
-    if (!win.isVisible()) win.showInactive();
+    showOverlayWindow();
   } else if (win.isVisible()) {
     win.hide();
   }
@@ -809,11 +841,23 @@ ipcMain.handle("relay:refreshTasks", async () => {
   await pushInbox(true);
   return tasksCache;
 });
+// Live task detail for the in-pill task view (GET /v1/tasks/:id, same payload the
+// web detail page renders from). The renderer polls this while the view is open.
+ipcMain.handle("relay:taskStatus", async (_e, taskId) => {
+  if (!taskId) return { ok: false, error: "Missing task id." };
+  try {
+    const client = await relayClient();
+    const res = await client.getTask(taskId);
+    return { ok: true, task: (res && res.task) || res };
+  } catch (error) {
+    return { ok: false, error: error && error.message ? error.message : String(error) };
+  }
+});
 ipcMain.handle("relay:accept", (_e, taskId, participantId) => acceptTask(taskId, participantId));
 ipcMain.handle("relay:reject", (_e, taskId, participantId) => rejectTask(taskId, participantId));
 ipcMain.handle("relay:approve", (_e, taskId, approvalId) => approveShare(taskId, approvalId));
 ipcMain.handle("relay:decline", (_e, taskId, approvalId) => declineShare(taskId, approvalId));
-ipcMain.handle("relay:answer", (_e, taskId, messageId, text) => answerQuestion(taskId, messageId, text));
+ipcMain.handle("relay:answer", (_e, taskId, messageId, text, packetId) => answerQuestion(taskId, messageId, text, packetId));
 ipcMain.handle("relay:contacts", () => readContacts());
 ipcMain.handle("relay:contactSave", (_e, input) => saveContact(input));
 

package/overlay/preload.cjs

@@ -6,6 +6,7 @@ contextBridge.exposeInMainWorld("relay", {
   onNewRelay: (cb) => ipcRenderer.on("newRelay", (_e, relay, opts) => cb(relay, opts || {})),
   onOpenDone: (cb) => ipcRenderer.on("openDone", (_e, id) => cb(id)),
   onOpenFull: (cb) => ipcRenderer.on("openFull", () => cb()), // menu-bar icon clicked
+  onShown: (cb) => ipcRenderer.on("shown", () => cb()), // window re-shown; reset hover handshake
 
   // pull the full payload on demand
   refresh: () => ipcRenderer.invoke("relay:get"),
@@ -20,11 +21,12 @@ contextBridge.exposeInMainWorld("relay", {
   reject: (taskId, participantId) => ipcRenderer.invoke("relay:reject", taskId, participantId),
   approve: (taskId, approvalId) => ipcRenderer.invoke("relay:approve", taskId, approvalId),
   decline: (taskId, approvalId) => ipcRenderer.invoke("relay:decline", taskId, approvalId),
-  answer: (taskId, messageId, text) => ipcRenderer.invoke("relay:answer", taskId, messageId, text),
+  answer: (taskId, messageId, text, packetId) => ipcRenderer.invoke("relay:answer", taskId, messageId, text, packetId),
 
   // tasks view
   refreshTasks: () => ipcRenderer.invoke("relay:refreshTasks"),
   openTask: (taskId) => ipcRenderer.send("relay:openTask", taskId),
+  taskStatus: (taskId) => ipcRenderer.invoke("relay:taskStatus", taskId),
 
   // contacts
   contacts: () => ipcRenderer.invoke("relay:contacts"),

package/package.json

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

package/src/materializer.js

@@ -251,9 +251,14 @@ async function materializeRowInHost({ id, row, rowState = {}, host = "claude", l
       setThreadPinned(threadId, true);
     } catch {}
     await waitForCodexOpenReadiness(threadId);
-    const desktopOpenResult = await refreshCodexDesktopForThreads([threadId], { force: true, openThreadId: threadId });
+    // Hydrate the recents rail over the bridge, but do NOT navigate through it:
+    // the bridge's hotkey-window route renders the desktop's in-memory copy of the
+    // thread, which is stale/empty for threads whose visible turn was appended to
+    // the rollout after thread/start. The codex:// deep link below goes through
+    // Codex's own protocol handler, which loads the thread fully from disk.
+    const desktopOpenResult = await refreshCodexDesktopForThreads([threadId], { force: true });
     openedInHost = Boolean(desktopOpenResult?.ok);
-    skipExternalOpen = openedInHost;
+    skipExternalOpen = false;
     url = `codex://threads/${encodeURIComponent(threadId)}`;
   } else {
     let claudeNativeSession = rowState.claudeNativeSession || null;

package/src/mcp.js

@@ -543,7 +543,21 @@ export async function runMcpServer() {
     try {
       return await handleCall(client, req.params.name, req.params.arguments || {});
     } catch (err) {
-      return { content: [{ type: "text", text: `Relay error: ${err.message}` }], isError: true };
+      // Surface the API's validation detail so the calling agent can self-correct
+      // instead of guessing what "invalid_request" meant.
+      let detail = "";
+      const issues = err && err.body && Array.isArray(err.body.issues) ? err.body.issues : null;
+      if (issues && issues.length) {
+        detail =
+          "\n" +
+          issues
+            .slice(0, 8)
+            .map((i) => `- ${Array.isArray(i.path) && i.path.length ? i.path.join(".") : "(request)"}: ${i.message}`)
+            .join("\n");
+      } else if (err && err.body && typeof err.body.instruction === "string") {
+        detail = `\n${err.body.instruction}`;
+      }
+      return { content: [{ type: "text", text: `Relay error: ${err.message}${detail}` }], isError: true };
     }
   });
 

package/src/notifications.js

@@ -287,6 +287,11 @@ function senderForNotification(notification) {
   // anyway via RELAY_HIDDEN_KINDS, but the staged senderName must still be coherent.)
   if (notification.kind === "task_request") return "Your agent";
   if (notification.kind === "share_approval") return "Your agent";
+  // Task lifecycle notices (completed/cancelled/failed) are the agent run reporting
+  // back, not a person — label them as the automation, never "Someone".
+  if (notification.kind === "task_completed") return "Your agent";
+  if (notification.kind === "task_cancelled") return "Your agent";
+  if (notification.kind === "task_failed") return "Your agent";
   if (notification.kind === "connector_reauth") return "Relay connectors";
   return "Someone";
 }
@@ -453,6 +458,44 @@ export function defaultStageRelayCompanionItem(notification) {
   return stageRelayCompanionItem(notification);
 }
 
+// A staged human_question keeps quickReply:true forever once the server stops
+// listing it (requiresAnswer flips false after the human answers anywhere — the
+// pill, the web app, or a host session). Reconcile staged questions against the
+// live attention feed so the pill never renders an active reply box for a
+// question that was already answered; carry the recorded answer when available.
+export function reconcileAnsweredQuestions(relays = [], { statePath = companionStatePath() } = {}) {
+  const awaiting = new Set();
+  const answers = new Map();
+  for (const relay of relays) {
+    const message = relay?.message;
+    if (!message?.id) continue;
+    if (relay.requiresAnswer) awaiting.add(message.id);
+    const response = message.humanResponse;
+    if (response?.status === "answered" && response.answerMarkdown) {
+      answers.set(message.id, response.answerMarkdown);
+    }
+  }
+  const state = readCompanionState(statePath);
+  const packets = state.packets || {};
+  let changed = 0;
+  for (const [id, packet] of Object.entries(packets)) {
+    if (!packet || packet.relayNotificationKind !== "human_question") continue;
+    if (packet.humanAnswered) continue;
+    if (!packet.quickReply) continue;
+    if (packet.messageId && awaiting.has(packet.messageId)) continue;
+    packets[id] = {
+      ...packet,
+      quickReply: false,
+      humanAnswered: true,
+      humanAnswerMarkdown: packet.humanAnswerMarkdown || answers.get(packet.messageId) || null,
+      updatedAt: new Date().toISOString(),
+    };
+    changed += 1;
+  }
+  if (changed) writeCompanionState(statePath, state);
+  return changed;
+}
+
 export function stagePlainRelayItem(
   { item, packet, attachmentUrls = {} },
   { statePath = companionStatePath(), forceUnread = false } = {},

package/src/task-daemon.js

@@ -13,6 +13,7 @@ import {
   defaultStageRelayCompanionItem,
   freshNotifications,
   markNotificationsProcessed,
+  reconcileAnsweredQuestions,
   stagePlainRelayItem as defaultStagePlainRelayItem,
 } from "./notifications.js";
 
@@ -149,6 +150,12 @@ async function pollHumanNotifications({ client, ledger, stageCompanionItem, stag
       }
     }
     if (staged.length) markNotificationsProcessed(ledger, staged);
+    try {
+      const reconciled = reconcileAnsweredQuestions(relays.relays || []);
+      if (reconciled) log(`marked ${reconciled} staged question(s) as answered`);
+    } catch (err) {
+      log(`answered-question reconciliation failed: ${err.message}`);
+    }
     return { notifications: staged, ordinaryRelays, events };
   } catch (err) {
     log(`Relay companion attention polling failed: ${err.message}`);