@agenticmail/cli 0.9.41 → 0.9.43

package/dist/public/js/message-view.js

@@ -171,7 +171,7 @@ function renderMessage(msg) {
         <div class="message-date">${escapeHtml(formatDateFull(msg.date))}</div>
       </div>
     </div>
-    <div class="message-body">${renderBodyWithThreading(bodyText, buildAudienceLookup())}</div>
+    <div class="message-body">${renderBodyWithThreading(bodyText, buildAudienceLookup(msg))}</div>
     ${attachmentsHtml}
   `;
 
@@ -239,12 +239,43 @@ function formatBytes(bytes) {
  * header serialises the date with second precision and stripped
  * timezone info.
  */
-function buildAudienceLookup() {
+function buildAudienceLookup(currentMessage = null) {
+  // Two layered sources, server-authoritative wins:
+  //
+  //   1. currentMessage.quotedAudiences — populated by the API when
+  //      it parses the body, scans for `On <date>, <addr> wrote:`
+  //      headers, and matches them against the IMAP envelopes
+  //      (which carry Cc/Bcc on the wire — we just weren't surfacing
+  //      them before 0.9.30). This works even on direct deep links
+  //      where state.messages is empty.
+  //
+  //   2. state.messages — the inbox list view the operator is
+  //      currently looking at. Fallback for older API responses
+  //      that don't yet include the server-side resolution.
+  //
+  // Layer 1 takes precedence because the server actually has access
+  // to the full mailbox envelopes; the client only sees what was
+  // paginated into state.messages.
+  const serverIndex = new Map();
+  if (currentMessage && Array.isArray(currentMessage.quotedAudiences)) {
+    for (const a of currentMessage.quotedAudiences) {
+      if (!a || !a.sender) continue;
+      // Index by sender alone AND by sender::dateIso for fuzzy date match
+      const senderKey = String(a.sender).toLowerCase();
+      const t = a.dateIso ? new Date(a.dateIso).getTime() : NaN;
+      serverIndex.set(senderKey + '::' + (Number.isFinite(t) ? t : ''), { to: a.to, cc: a.cc, bcc: a.bcc, timeMs: t });
+      // Also keep a "most recent for sender" entry as last-resort fallback
+      const allKey = senderKey + '::*';
+      const prev = serverIndex.get(allKey);
+      if (!prev || (Number.isFinite(t) && t > prev.timeMs)) {
+        serverIndex.set(allKey, { to: a.to, cc: a.cc, bcc: a.bcc, timeMs: t });
+      }
+    }
+  }
   // Defensive: state.messages may be empty if the operator navigated
-  // straight to /#/m/N. Lookup degrades to "no match" — the renderer
-  // falls back to sender-only.
+  // straight to /#/m/N. Lookup degrades to layer 1 only.
   const list = Array.isArray(state.messages) ? state.messages : [];
-  if (list.length === 0) return () => null;
+  if (list.length === 0 && serverIndex.size === 0) return () => null;
   // Flatten to a normalised array we can scan. Each entry carries
   // the same shape the renderer expects.
   const entries = list.map(m => {
@@ -265,23 +296,29 @@ function buildAudienceLookup() {
     if (!senderAddr || !dateStr) return null;
     const senderL = senderAddr.toLowerCase();
     const t = new Date(dateStr).getTime();
+
+    // Layer 1: server-resolved index. Exact date match first, then
+    // sender-only fallback. The server already matched against IMAP
+    // envelopes so this is the authoritative source.
+    if (serverIndex.size > 0) {
+      const exactKey = senderL + '::' + (Number.isFinite(t) ? t : '');
+      const exact = serverIndex.get(exactKey);
+      if (exact) return { to: exact.to, cc: exact.cc, bcc: exact.bcc };
+      const senderOnly = serverIndex.get(senderL + '::*');
+      if (senderOnly) return { to: senderOnly.to, cc: senderOnly.cc, bcc: senderOnly.bcc };
+    }
+
+    // Layer 2: state.messages — surrounding inbox list. Bounded by
+    // what the operator's folder view happens to have loaded.
     if (!Number.isFinite(t)) return null;
-    // Match by sender + nearest date within 2 s. Quote headers
-    // typically lose timezone info during render so wall-clock can
-    // shift by hours; the inbox-list date is the canonical UTC.
-    // We prefer the closest match by absolute delta.
     let best = null;
-    let bestDelta = 2000;  // 2-second tolerance for same-second matches
+    let bestDelta = 2000;
     for (const e of entries) {
       if (e.from !== senderL) continue;
       const delta = Math.abs(e.timeMs - t);
       if (delta < bestDelta) { best = e; bestDelta = delta; }
     }
     if (!best) {
-      // Fallback: if the date didn't parse close to anything, just
-      // take the most recent message from that sender. Better than
-      // nothing for the common case of a reply to the most recent
-      // prior reply.
       for (const e of entries) {
         if (e.from !== senderL) continue;
         if (!best || e.timeMs > best.timeMs) best = e;
@@ -324,6 +361,17 @@ function renderBodyWithThreading(src, audienceLookup = null) {
       i++;
       continue;
     }
+    // Strip any trailing blank lines from the prose buffer before
+    // flushing. Reply builders typically pad the new content with
+    // `\n\n` before the `On <date>, <addr> wrote:` header so the
+    // quote stands apart in plaintext clients. In the web view those
+    // blank lines render as empty <p> blocks with their own margins,
+    // producing the huge gap operators flagged between the latest
+    // message and the quoted thread. Trimming here keeps plain-text
+    // readers happy and tightens the rendered HTML at the same time.
+    while (prose.length > 0 && prose[prose.length - 1].trim() === '') {
+      prose.pop();
+    }
     flushProse();
     const dateRaw = m[1];
     const sender = m[2];
@@ -361,16 +409,27 @@ function renderBodyWithThreading(src, audienceLookup = null) {
       }
       break;
     }
-    // Fall back to cross-message lookup if the body didn't carry
-    // audience lines (older replies pre-0.9.32). The lookup uses
-    // the surrounding inbox-list messages to find the original
-    // message by sender + date and lift its To/Cc/Bcc.
-    if (!toAddrs && !ccAddrs && !bccAddrs && typeof audienceLookup === 'function') {
+    // Fall back to cross-message lookup to fill ANY missing audience
+    // field — not just the all-empty case.
+    //
+    // The previous gate (`!toAddrs && !ccAddrs && !bccAddrs`) was wrong:
+    // it treated a body that had a `To:` line but no `Cc:` line as
+    // "audience encoded, lookup not needed", silently dropping the Cc
+    // info that state.messages had. This surfaced as quoted blocks
+    // showing only `TO:` even when the original message had Cc'd
+    // multiple agents — operators correctly flagged this as "the
+    // earlier email's CCs aren't being shown".
+    //
+    // Now: run the lookup whenever any field is missing, and only
+    // backfill the fields that weren't already in the body. The
+    // body-encoded value always wins (it's authoritative); the
+    // lookup is purely a backfill.
+    if ((!toAddrs || !ccAddrs || !bccAddrs) && typeof audienceLookup === 'function') {
       const fromLookup = audienceLookup(sender, dateRaw);
       if (fromLookup) {
-        toAddrs = fromLookup.to;
-        ccAddrs = fromLookup.cc;
-        bccAddrs = fromLookup.bcc;
+        if (!toAddrs) toAddrs = fromLookup.to || '';
+        if (!ccAddrs) ccAddrs = fromLookup.cc || '';
+        if (!bccAddrs) bccAddrs = fromLookup.bcc || '';
       }
     }
     out.push(renderThreadQuote(dateRaw, sender, quoted.join('\n'), { to: toAddrs, cc: ccAddrs, bcc: bccAddrs }, audienceLookup));

package/dist/public/styles.css

@@ -1019,14 +1019,65 @@ mark.search-hl {
    styled card with proper avatar + name + friendly date instead
    of leaving the raw ISO timestamp visible. Nested replies recurse
    so a 3-deep thread gets 3 nested cards. */
+/* Thread-quote: the boxed-up older email a reply quotes. Issues we
+ * sequentially squashed:
+ *
+ *   1. Huge vertical gap before the quote — initially 16px margin-top
+ *      on .thread-quote PLUS empty <p>/<ul> blocks from the markdown
+ *      renderer treating reply sig-lines like `- marlow` as bullet
+ *      lists. message-view.js now trims trailing blank lines from
+ *      the prose buffer; we tighten the rendered block margins below
+ *      so the last <p>/<ul>/<ol> before a quote collapses its
+ *      bottom margin and the gap reads as a single hairline.
+ *   2. The pink left rule looked like a stub. ::before lays a 1px
+ *      full-width divider tucked behind the border so the visual
+ *      break is unambiguous and the rule reads as a continuous
+ *      thread spine through the quoted block.
+ *
+ * Nested quotes (replies-of-replies) get progressively warmer rule
+ * colours (pink → purple → amber) so the depth is visible at a
+ * glance without staring at indentation. */
 .thread-quote {
-  margin: 16px 0;
+  position: relative;
+  margin: 4px 0 8px;
+  padding: 14px 0 4px 16px;
   border-left: 3px solid var(--pink-rule);
-  padding: 0 0 0 16px;
+}
+.thread-quote::before {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: -3px;
+  right: 0;
+  height: 1px;
+  background: var(--line, rgba(255,255,255,0.08));
+}
+/* Collapse the margin-bottom on whichever block lands immediately
+ * before a thread-quote. Markdown's default 1em paragraph/list
+ * margins were stacking with .thread-quote's margin-top, producing
+ * a ~50px dead zone above quoted replies. With :has() we target
+ * only the preceding sibling (other blocks elsewhere keep their
+ * default margins). Modern browsers all support :has() now. */
+.message-body p:has(+ .thread-quote),
+.message-body ul:has(+ .thread-quote),
+.message-body ol:has(+ .thread-quote),
+.message-body h1:has(+ .thread-quote),
+.message-body h2:has(+ .thread-quote),
+.message-body h3:has(+ .thread-quote),
+.message-body pre:has(+ .thread-quote),
+.message-body blockquote:has(+ .thread-quote) {
+  margin-bottom: 0;
+}
+/* Same tightening on the LAST child of a thread-quote-body — keeps
+ * nested quote ladders from accumulating spacing as they descend. */
+.thread-quote-body > p:last-child,
+.thread-quote-body > ul:last-child,
+.thread-quote-body > ol:last-child {
+  margin-bottom: 0;
 }
 .thread-quote .thread-quote {
   border-left-color: #c084fc;
-  margin: 12px 0;
+  margin: 4px 0 8px;
 }
 .thread-quote .thread-quote .thread-quote { border-left-color: #f59e0b; }
 .thread-quote-head {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agenticmail/cli",
-  "version": "0.9.41",
+  "version": "0.9.43",
   "description": "Email and SMS infrastructure for AI agents — the first platform to give agents real email addresses and phone numbers",
   "type": "module",
   "main": "dist/index.js",
@@ -31,8 +31,8 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@agenticmail/api": "^0.9.28",
-    "@agenticmail/core": "^0.9.7",
+    "@agenticmail/api": "^0.9.30",
+    "@agenticmail/core": "^0.9.8",
     "json5": "^2.2.3"
   },
   "optionalDependencies": {