relay-companion 0.1.199 → 0.1.201

package/overlay/inbox.html

@@ -4874,6 +4874,15 @@
     roomScrollEl.scrollTop += currentOffset - (Number(saved.anchorOffset) || 0);
   }
   function openReader(id, source) {
+    // A notification banner remains `peeking` even after the user moves into
+    // Requests. Both prepareReaderMorph() and syncCardSize() deliberately
+    // refuse to resize in that state, so opening a row could paint the full
+    // reader into the 400x118 banner window. The click explicitly asks for the
+    // full surface: retire the transient banner before taking the snapshot.
+    if (peeking) {
+      clearPeek();
+      presented = true;
+    }
     const morphFromList = prepareReaderMorph(activeView);
     readerId = id;
     const opened = readerRow(id);

package/overlay/main.cjs

@@ -3411,7 +3411,9 @@ function createWindow() {
   win.once("ready-to-show", () => {
     // First paint is instant: relays come from local state.json; the sent + contacts
     // background loads kicked off here each re-push when they land (buildPayload).
-    pushInbox(true).catch((error) => console.error("[overlay] initial push failed:", error && error.message));
+    pushInbox(true)
+      .then(() => reconcileCanonicalCompletionMonitors())
+      .catch((error) => console.error("[overlay] initial push failed:", error && error.message));
     pillReady = true;
     // Relay is independently useful and searchable even when no host app happens to
     // be open. A normal login launch still respects the persisted dismissed preference.
@@ -4159,6 +4161,7 @@ async function startTaskFromPreview(input) {
     const stamped = new Date().toISOString();
     updateStagedPacket(id, isRequest ? { taskStartedAt: stamped } : { workStartedAt: stamped, workCompletedAt: null });
     pushInbox(true);
+    void ensureCanonicalCompletionMonitor(id);
     return { ok: true, taskStartedAt: stamped, replied: reply.ok, running, runError };
   } catch {
     return { ok: true, taskStartedAt: new Date().toISOString(), replied: reply.ok, running, runError };
@@ -4275,6 +4278,14 @@ function providerWorkIdentity(relayId) {
   };
 }
 
+function expectedProviderTurnId(identity) {
+  return identity?.provider === "codex" ? String(identity.sessionRef?.turnId || "") : "";
+}
+
+function hasWireCompletionTarget(relayId) {
+  return Boolean(relayId) && !String(relayId).startsWith("relay_local_");
+}
+
 function canonicalizeCodexWorkAttachments(relayId, events) {
   const metadata = Array.isArray(rowById(relayId)?.workAttachmentMetadata)
     ? rowById(relayId).workAttachmentMetadata
@@ -4474,6 +4485,94 @@ async function reconnectCanonicalWorkFeed(relayId) {
   }
 }
 
+const canonicalCompletionMonitors = new Map();
+
+async function stopCanonicalCompletionMonitor(relayId) {
+  const id = String(relayId || "");
+  const current = canonicalCompletionMonitors.get(id);
+  if (!current) return false;
+  canonicalCompletionMonitors.delete(id);
+  const bridge = await canonicalWorkBridge();
+  return bridge.unsubscribe({ relayId: id, sessionId: current.sessionId, subscriberId: current.subscriberId });
+}
+
+async function settleCanonicalWorkEnvelope(relayId, identity, envelope) {
+  const id = String(relayId || "");
+  const row = rowById(id);
+  const isRequest = row?.relayNotificationKind === "task";
+  const completedField = isRequest ? "taskCompletedAt" : "workCompletedAt";
+  const startedAt = String((isRequest ? row?.taskStartedAt : row?.workStartedAt) || "");
+  if (!row || !startedAt) return false;
+  const { canonicalProviderCompletionCandidate } = await import("../src/provider-completion.js");
+  const candidate = canonicalProviderCompletionCandidate({
+    provider: identity.provider,
+    presentation: envelope?.presentation,
+    expectedTurnId: expectedProviderTurnId(identity),
+    startedAfter: startedAt,
+  });
+  if (!candidate) return false;
+
+  // Native terminal truth is local truth. Persist Done before attempting the
+  // separate wire receipt: an offline API (or a local-only fixture id) cannot
+  // turn a completed provider run back into "Didn't finish".
+  const latest = rowById(id) || row;
+  if (!completionAfter(latest[completedField], startedAt)) {
+    updateStagedPacket(id, { [completedField]: candidate.completedAt });
+    pushInbox(true).catch(() => {});
+  }
+  if (isRequest && hasWireCompletionTarget(id) && !latest.providerCompletionRelayId && !latest.coworkCompletionRelayId) {
+    queueProviderCompletionBridge(id, identity.provider, identity.sessionId, candidate);
+  }
+  await stopCanonicalCompletionMonitor(id);
+  return true;
+}
+
+async function ensureCanonicalCompletionMonitor(relayId) {
+  const id = String(relayId || "");
+  const row = rowById(id);
+  const isRequest = row?.relayNotificationKind === "task";
+  const startedAt = isRequest ? row?.taskStartedAt : row?.workStartedAt;
+  if (!row || !startedAt || (isRequest && row.providerCompletionRelayId)) return false;
+  const identity = providerWorkIdentity(id);
+  if (!identity) return false;
+  const previous = canonicalCompletionMonitors.get(id);
+  if (previous?.sessionId === identity.sessionId) return true;
+  if (previous) await stopCanonicalCompletionMonitor(id);
+  const subscriberId = `completion:${id}`;
+  canonicalCompletionMonitors.set(id, { sessionId: identity.sessionId, subscriberId });
+  const bridge = await canonicalWorkBridge();
+  try {
+    await bridge.subscribe({
+      relayId: id,
+      sessionId: identity.sessionId,
+      subscriberId,
+      send: (envelope) => { void settleCanonicalWorkEnvelope(id, identity, envelope); },
+      isAlive: () => {
+        const latest = rowById(id);
+        return Boolean(latest && (isRequest ? latest.taskStartedAt : latest.workStartedAt));
+      },
+    });
+    return true;
+  } catch (error) {
+    canonicalCompletionMonitors.delete(id);
+    console.error("[overlay] canonical completion monitor failed:", id, error && error.message);
+    return false;
+  }
+}
+
+function reconcileCanonicalCompletionMonitors() {
+  const packets = readStore().packets || {};
+  for (const [id, value] of Object.entries(packets)) {
+    const row = { id, ...value };
+    const isRequest = row.relayNotificationKind === "task";
+    const startedAt = isRequest ? row.taskStartedAt : row.workStartedAt;
+    const completedAt = isRequest ? row.taskCompletedAt : row.workCompletedAt;
+    const wirePending = isRequest && hasWireCompletionTarget(id) && !row.providerCompletionRelayId && !row.coworkCompletionRelayId;
+    if (!startedAt || (!wirePending && completionAfter(completedAt, startedAt))) continue;
+    if (providerWorkIdentity(id)) void ensureCanonicalCompletionMonitor(id);
+  }
+}
+
 function workEventAuthorized(event, relayId) {
   if (!event?.sender || event.sender.isDestroyed?.()) return false;
   if (win && !win.isDestroyed() && event.sender === win.webContents) return true;
@@ -4591,7 +4690,7 @@ async function taskRunFeed(relayId) {
     turnStartedAt: turn.startedAt,
     turnCompletedAt: turn.completedAt,
     turnDurationMs: turn.durationMs,
-    completedAt: completedAt || session.taskCompletedAt || session.nativeCompletedAt || null,
+    completedAt: completedAt || session.taskCompletedAt || null,
   };
 }
 
@@ -4612,7 +4711,6 @@ async function previewTaskSession(relayId) {
         readCoworkSession,
         coworkEventsToRecords,
         coworkSessionLifecycle,
-        coworkFinalAssistantText,
       } = await import("../src/cowork-sessions.js");
       const remote = await readCoworkSession(coworkSessionId);
       const lifecycle = coworkSessionLifecycle(remote.session, remote.events);
@@ -4622,22 +4720,7 @@ async function previewTaskSession(relayId) {
       updateStagedPacket(id, {
         coworkLiveState: lifecycle.liveState,
         coworkLiveCheckedAt: new Date().toISOString(),
-        ...(terminalAt ? (isRequest ? { taskCompletedAt: terminalAt } : { workCompletedAt: terminalAt }) : {}),
       });
-      // Cowork's cloud worker has no Relay MCP, so its result cannot stamp the
-      // sender's Done receipt itself. Bridge the final assistant answer once,
-      // using a stable idempotency key so every UI poll converges safely.
-      if (isRequest && lifecycle.terminal && !row.providerCompletionRelayId && !row.coworkCompletionRelayId) {
-        const finalText = coworkFinalAssistantText(remote.events);
-        const { providerCompletionCandidate } = await import("../src/provider-completion.js");
-        const candidate = providerCompletionCandidate({
-          provider, records: coworkEventsToRecords(remote.events), liveState: lifecycle.liveState,
-          terminal: true, endedAt: terminalAt,
-        });
-        queueProviderCompletionBridge(id, provider, coworkSessionId, candidate || {
-          body: finalText || "Claude Cowork ended without a final answer.", outcome: finalText ? "completed" : "failed", completedAt: terminalAt,
-        });
-      }
       return {
         ok: true,
         provider,
@@ -4646,7 +4729,7 @@ async function previewTaskSession(relayId) {
         endedAt: terminalAt,
         records: coworkEventsToRecords(remote.events),
         taskStartedAt: (isRequest ? row.taskStartedAt : row.workStartedAt) || null,
-        taskCompletedAt: terminalAt || (isRequest ? row.taskCompletedAt : row.workCompletedAt) || null,
+        taskCompletedAt: (isRequest ? row.taskCompletedAt : row.workCompletedAt) || null,
       };
     }
     const { inspectAiSession } = await import("../src/ai-session-transcript.js");
@@ -4679,8 +4762,6 @@ async function previewTaskSession(relayId) {
       }
     }
     let endedAt = null;
-    let nativeCompletedAt = null;
-    let nativeTerminalStatus = "";
     if (provider === "codex" && row.codexRuntimeSessionRef?.logPath) {
       const { codexAppServerActivity } = await import("../src/codex-app-server-activity.js");
       const native = codexAppServerActivity(row.codexRuntimeSessionRef.logPath, {
@@ -4695,49 +4776,18 @@ async function previewTaskSession(relayId) {
         records.sort((left, right) => Date.parse(String(right?.at || "")) - Date.parse(String(left?.at || "")));
       }
       endedAt = native.terminalAt;
-      nativeTerminalStatus = native.terminalStatus;
-      if (native.terminalStatus === "completed") nativeCompletedAt = native.terminalAt;
     }
     const liveState = await previewTaskLiveState(row, provider, records);
-    const providerSessionId = provider === "claude"
-      ? String(row.claudeNativeSession?.sessionId || "")
-      : String(row.codexRuntimeSessionRef?.turnId || row.codexThreadId || "");
-    const runActive = provider === "claude" && relayOwnedClaudeRuns.has(providerSessionId);
-    if (isRequest && !row.providerCompletionRelayId && !row.coworkCompletionRelayId) {
-      const { providerCompletionCandidate } = await import("../src/provider-completion.js");
-      const candidate = providerCompletionCandidate({
-        provider, records, liveState, runActive,
-        terminal: Boolean(nativeTerminalStatus), endedAt,
-        error: nativeTerminalStatus && nativeTerminalStatus !== "completed"
-          ? `Native turn ended ${nativeTerminalStatus}`
-          : "",
-      });
-      if (candidate) queueProviderCompletionBridge(id, provider, providerSessionId, candidate);
-    }
-    if (!isRequest) {
-      const { providerCompletionCandidate } = await import("../src/provider-completion.js");
-      const localCandidate = providerCompletionCandidate({
-        provider, records, liveState, runActive,
-        terminal: Boolean(nativeTerminalStatus), endedAt,
-        error: nativeTerminalStatus && nativeTerminalStatus !== "completed"
-          ? `Native turn ended ${nativeTerminalStatus}`
-          : "",
-      });
-      if (localCandidate?.completedAt && !row.workCompletedAt) {
-        updateStagedPacket(id, { workCompletedAt: localCandidate.completedAt });
-      }
-    }
     return {
       ok: true,
       provider,
       liveState,
       records,
       endedAt,
-      nativeCompletedAt,
-      // Receipts ride the poll: the content payload is pushed once, and the
-      // Done flip should not wait for a window reopen.
+      // This legacy reader is presentation-only. Canonical push settlement is
+      // the sole path allowed to persist Done or queue its wire receipt.
       taskStartedAt: (isRequest ? row.taskStartedAt : row.workStartedAt) || null,
-      taskCompletedAt: (isRequest ? row.taskCompletedAt : row.workCompletedAt) || nativeCompletedAt || null,
+      taskCompletedAt: (isRequest ? row.taskCompletedAt : row.workCompletedAt) || null,
     };
   } catch (error) {
     return { ok: false, error: (error && error.message) || String(error) };
@@ -4790,7 +4840,6 @@ async function bridgeProviderCompletion(relayId, provider, sessionId, candidate)
       source: { host: provider === "cowork" ? "claude-cowork" : provider, sessionId },
     });
     updateStagedPacket(key, {
-      taskCompletedAt: candidate?.completedAt || new Date().toISOString(),
       providerCompletionRelayId: String(sent?.relayId || "sent"),
       ...(provider === "cowork" ? { coworkCompletionRelayId: String(sent?.relayId || "sent") } : {}),
     });

package/package.json

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

package/src/claude-native-work-feed.js

@@ -34,6 +34,34 @@ function hasToolResult(row) {
   return contentBlocks(row).some((block) => block?.type === "tool_result");
 }
 
+function isUserAttachmentBlock(block) {
+  return block && /^(?:image|file|attachment)$/i.test(string(block.type));
+}
+
+function hasUserAttachment(row) {
+  return contentBlocks(row).some(isUserAttachmentBlock);
+}
+
+function safeClaudeUserAttachments(row) {
+  return contentBlocks(row).filter(isUserAttachmentBlock).slice(0, 20).map((block, index) => {
+    const source = block?.source && typeof block.source === "object" ? block.source : {};
+    const mimeType = string(
+      block.mimeType || block.contentType || block.mediaType
+      || source.media_type || source.mimeType || source.contentType,
+    ).trim();
+    const kind = /^image(?:\/|$)/i.test(mimeType) || /^image$/i.test(string(block.type)) ? "image" : "file";
+    return {
+      id: `claude-attachment:${hash(`${string(row?.uuid || row?.promptId)}\0${index}`)}`,
+      kind,
+      name: string(block.name || block.fileName || block.filename).trim() || (kind === "image" ? "Image" : `Attachment ${index + 1}`),
+      mimeType: mimeType || null,
+      size: Number.isFinite(Number(block.size ?? block.bytes)) ? Math.max(0, Number(block.size ?? block.bytes)) : null,
+      path: null,
+      url: null,
+    };
+  });
+}
+
 function internalRelayPrompt(value) {
   const body = string(value).trim();
   return /^<relay-envelope>/i.test(body)
@@ -47,7 +75,7 @@ function isHumanPrompt(row) {
   if (row.sourceToolAssistantUUID || row.toolUseResult) return false;
   if (["task-notification", "hook", "system", "compact-summary"].includes(string(row?.origin?.kind))) return false;
   const body = textContent(row.message?.content);
-  if (!body || internalRelayPrompt(body) || /<task-notification>[\s\S]*<\/task-notification>/i.test(body)) return false;
+  if ((!body && !hasUserAttachment(row)) || internalRelayPrompt(body) || /<task-notification>[\s\S]*<\/task-notification>/i.test(body)) return false;
   return true;
 }
 
@@ -341,6 +369,7 @@ function parseClaudeRows(inputRows, options) {
         uuid: string(row.uuid) || null,
         promptId: string(row.promptId) || null,
         parentUuid: string(row.parentUuid) || null,
+        attachments: safeClaudeUserAttachments(row),
       });
       continue;
     }
@@ -584,7 +613,7 @@ function canonicalEvents(turns) {
         if (!item.text) continue;
         const lifecycle = item.status === "completed" ? "completed" : "started";
         events.push({
-          eventId: `${item.id}:${lifecycle}:${hash(item.text)}`, method: `item/${lifecycle}`, emittedAtMs: item.completedAtMs ?? item.startedAtMs,
+          eventId: `${item.id}:${lifecycle}:${item.phase}:${hash(item.text)}`, method: `item/${lifecycle}`, emittedAtMs: item.completedAtMs ?? item.startedAtMs,
           params: {
             turnId: turn.id,
             [lifecycle === "completed" ? "completedAtMs" : "startedAtMs"]: item.completedAtMs ?? item.startedAtMs,
@@ -677,8 +706,8 @@ export function createClaudeNativeWorkEventReconciler(initialRows = [], options
     push(row, nextOptions = {}) {
       if (!row || typeof row !== "object") return [];
       currentOptions = { ...currentOptions, ...nextOptions };
-      if (isHumanPrompt(row)) currentRows = [row];
-      else currentRows.push(row);
+      const humanBoundary = isHumanPrompt(row);
+      currentRows.push(row);
       if (currentRows.length > MAX_ROWS) currentRows = currentRows.slice(-MAX_ROWS);
       const events = claudeNativeEventsToWorkEvents(currentRows, currentOptions);
       const fresh = [];
@@ -687,6 +716,10 @@ export function createClaudeNativeWorkEventReconciler(initialRows = [], options
         emitted.add(event.eventId);
         fresh.push(event);
       }
+      // Parse the boundary together with the preceding live turn once so its
+      // end-turn text can transition from commentary to final and the turn can
+      // settle. Subsequent rows only need the new native turn.
+      if (humanBoundary) currentRows = [row];
       return fresh;
     },
   };

package/src/provider-completion.js

@@ -58,6 +58,43 @@ export function providerCompletionCandidate({
   };
 }
 
+/**
+ * Convert a canonical Work envelope into local terminal truth. Unlike the
+ * legacy transcript reader, this requires the exact provider-authored native
+ * start and can be scoped to the Relay-owned turn/cutoff. Materialized session
+ * history therefore cannot finish (or even start) a Request.
+ */
+export function canonicalProviderCompletionCandidate({
+  provider,
+  presentation,
+  expectedTurnId = "",
+  startedAfter = "",
+} = {}) {
+  const turns = Array.isArray(presentation?.turns) ? presentation.turns : [];
+  const expected = clean(expectedTurnId);
+  const cutoff = Date.parse(clean(startedAfter));
+  const turn = [...turns].reverse().find((candidate) => {
+    if (!candidate?.nativeStarted || !candidate?.settled) return false;
+    if (expected && clean(candidate.key) !== expected) return false;
+    const startedAt = Number(candidate.startedAtMs);
+    const completedAt = Number(candidate.completedAtMs);
+    if (!Number.isFinite(cutoff)) return true;
+    if (!Number.isFinite(completedAt) || completedAt < cutoff) return false;
+    // Codex supplies the exact Relay-owned turn id. Claude/Cowork return the
+    // run timestamp only after native launch, so allow a small start-handshake
+    // skew while still rejecting materialized history that settled pre-Start.
+    return expected || (Number.isFinite(startedAt) && startedAt >= cutoff - 60_000);
+  });
+  if (!turn) return null;
+  const completedAtMs = Number(turn.completedAtMs);
+  const completedAt = Number.isFinite(completedAtMs)
+    ? new Date(completedAtMs).toISOString()
+    : new Date().toISOString();
+  const body = clean(turn.final?.text);
+  if (clean(turn.status).toLowerCase() !== "completed" || !turn.finalEligible || !body) return null;
+  return { body, outcome: "completed", completedAt, turnId: clean(turn.key) };
+}
+
 export function providerCompletionIdempotencyKey({ relayId, provider, sessionId } = {}) {
   return ["provider-completion", clean(relayId), clean(provider) || "unknown", clean(sessionId) || "session"]
     .map((part) => part.replace(/[^0-9A-Za-z._-]+/g, "-"))

package/src/work-conversation.js

@@ -202,6 +202,9 @@ function itemIdOf(event) {
 function makeTurn(id, startedAtMs = null) {
   return {
     id,
+    // Only a provider-authored turn/started establishes a Work turn. Session
+    // materialization and historical terminal rows must never manufacture one.
+    nativeStarted: false,
     status: "inProgress",
     startedAtMs,
     completedAtMs: null,
@@ -647,18 +650,43 @@ export function reduceWorkEvent(inputState, event) {
     resolveRequest(state, event);
     return state;
   }
+  // App-server logs contain many conversation-adjacent notifications (MCP
+  // startup, account rate limits, thread status, skill changes, and so on)
+  // that do not belong to a provider turn.  Never allocate a synthetic turn
+  // merely because one of those protocol notifications was observed.  An
+  // empty `turn:unknown` otherwise remains inProgress forever and restart
+  // recovery can falsely report a completed historical run as disconnected.
+  const isTurnEvent = method === "turn/started"
+    || method === "provider/state"
+    || method === "turn/completed"
+    || method === "item/started"
+    || method === "item/completed"
+    || /\/delta$/i.test(method)
+    || /Delta$/.test(method)
+    || method === "error"
+    || method.endsWith("/error")
+    || method === "relay/connectionClosed"
+    || isRequestMethod(method);
+  if (!isTurnEvent) return state;
   const id = turnIdOf(event) || state.turnOrder.at(-1) || "turn:unknown";
   const timestamp = atMs(event, event?.params?.startedAtMs);
   if (method === "turn/started") {
     const turn = bindOptimisticTurn(state, id, timestamp);
     if (TERMINAL.has(turn.status)) return state; // overlapping historical tail
     turn.status = "inProgress";
+    turn.nativeStarted = true;
     turn.startedAtMs = turn.startedAtMs ?? timestamp;
     turn.completedAtMs = null;
     turn.error = null;
     return state;
   }
-  const turn = ensureTurn(state, id, timestamp);
+  // Exact provider rows can be observed out of order during hydration, but a
+  // row without its native start is not evidence that Relay started Work.
+  // Ignore it; authoritative hydration/reconnect will replay the bounded turn
+  // from turn/started. An optimistic user turn may exist, but it likewise does
+  // not become provider Work until the native start binds it above.
+  const turn = state.turns[id] || null;
+  if (!turn?.nativeStarted) return state;
   if (method === "provider/state") {
     turn.providerState = compact(event?.params?.nativeState || "", 64) || null;
     turn.providerLabel = compact(event?.params?.nativeLabel || "", 96) || null;
@@ -1106,6 +1134,9 @@ export function turnPresentation(turn, nowMs = Date.now()) {
     && timing.state !== "cancelled";
   return {
     key: turn?.id || "",
+    nativeStarted: Boolean(turn?.nativeStarted),
+    startedAtMs: Number.isFinite(turn?.startedAtMs) ? turn.startedAtMs : null,
+    completedAtMs: Number.isFinite(turn?.completedAtMs) ? turn.completedAtMs : null,
     status: turn?.status || "",
     active: timing.state === "active",
     settled: timing.state === "settled",