six-degrees 0.4.8 → 0.4.9

package/.next/standalone/lib/linkedin-export.js

@@ -6,6 +6,10 @@
 //
 //   people     per profile: when you last messaged, who wrote last, how many
 //              messages (1:1 conversations only). Never a message's text.
+//   conversations  per conversation: who's in it, when it was last active, who
+//              wrote last, how many messages. The text itself only when you turn
+//              on Keep my messages, and then in a file of its own
+//              (app/api/social/messages).
 //   chapters   your jobs (Positions.csv) and the connections made in each
 //   posts      your posts (Shares.csv) and the connections that came the week after
 //   invites    requests to and from you (Invitations.csv), when the export has them
@@ -49,14 +53,29 @@ export function exportDate(s) {
 
 const urlKey = (u) => keyFor({ profile_url: u });
 
+/** You, in messages.csv: the sender in the most conversations. */
+function selfOf(rows = []) {
+  const senders = new Map();
+  for (const r of rows) {
+    const from = urlKey(r['sender profile url']);
+    const id = r['conversation id'];
+    if (!id || !from) continue;
+    if (!senders.has(from)) senders.set(from, new Set());
+    senders.get(from).add(id);
+  }
+  let self = null;
+  for (const [who, ids] of senders) if (!self || ids.size > senders.get(self).size) self = who;
+  return self;
+}
+
 /**
  * From messages.csv, per person (by profile): { last, lastFromThem, total, recent }.
  * `self` is you: the sender in the most conversations. Only 1:1 conversations
  * count; group threads say little about one relationship. No text is read.
  */
 export function messageStats(rows = []) {
+  const self = selfOf(rows);
   const convos = new Map();
-  const senders = new Map();
   for (const r of rows) {
     const from = urlKey(r['sender profile url']);
     const id = r['conversation id'];
@@ -69,11 +88,7 @@ export function messageStats(rows = []) {
     c.people.add(from);
     to.forEach((p) => c.people.add(p));
     c.msgs.push({ from, t });
-    if (!senders.has(from)) senders.set(from, new Set());
-    senders.get(from).add(id);
   }
-  let self = null;
-  for (const [who, ids] of senders) if (!self || ids.size > senders.get(self).size) self = who;
   let asOf = 0;
   const people = new Map();
   for (const c of convos.values()) {
@@ -96,6 +111,104 @@ export function messageStats(rows = []) {
   return { self, asOf: asOf || null, people };
 }
 
+/**
+ * Every conversation in messages.csv you're part of, one record each:
+ * { id, title, people, group, messages: [{ t, fromMe, text }] }, messages oldest
+ * first. `people` is everyone but you, by profile key; more than one makes it a
+ * group. You are found the way messageStats finds you. The words (the subject,
+ * when there is one, then the message) are read only with keepText: without it
+ * a message is a date and who sent it, and the title (a group's name) is left
+ * out too.
+ */
+export function buildConversations(rows = [], { keepText = false } = {}) {
+  const self = selfOf(rows);
+  const convos = new Map();
+  for (const r of rows) {
+    const from = urlKey(r['sender profile url']);
+    const id = r['conversation id'];
+    if (!id || !from) continue;
+    const t = exportDate(r.date);
+    if (t == null) continue;
+    if (!convos.has(id)) convos.set(id, { id, title: '', everyone: new Set(), messages: [] });
+    const c = convos.get(id);
+    c.everyone.add(from);
+    String(r['recipient profile urls'] || '').split(/[,;\s]+/).filter(Boolean).forEach((u) => c.everyone.add(urlKey(u)));
+    const m = { t, fromMe: from === self };
+    if (keepText) {
+      m.text = [r.subject, r.content].map((x) => String(x || '').trim()).filter(Boolean).join('\n\n');
+      if (!c.title && r['conversation title']) c.title = String(r['conversation title']).trim();
+    }
+    c.messages.push(m);
+  }
+  const conversations = [];
+  for (const c of convos.values()) {
+    if (!c.everyone.has(self)) continue;
+    const people = [...c.everyone].filter((p) => p && p !== self).sort();
+    if (!people.length) continue;
+    c.messages.sort((a, b) => a.t - b.t);
+    const out = { id: c.id, people, group: people.length > 1, messages: c.messages };
+    if (keepText) out.title = c.title;
+    conversations.push(out);
+  }
+  return { self, conversations };
+}
+
+/** What the Conversations list keeps of one conversation, never any words: { id, people, group, last, lastFromThem, count }. */
+export function conversationSummary(c) {
+  const last = c.messages[c.messages.length - 1];
+  return {
+    id: c.id,
+    people: c.people,
+    group: c.group,
+    last: last ? last.t : null,
+    lastFromThem: last ? !last.fromMe : null,
+    count: c.messages.length,
+  };
+}
+
+/**
+ * The Conversations list: the export's conversations with what the live sync
+ * adds (unread, the thread's link, and a newer last message), plus a
+ * conversation for each person the sync found and the export doesn't have yet
+ * (id `live:<key>`, count unknown).
+ */
+export function conversationList(list = [], live = {}) {
+  const out = (Array.isArray(list) ? list : []).map((c) => ({ ...c, unread: null, threadUrl: null }));
+  const oneToOne = new Map();
+  for (const c of out) {
+    if (c.group || c.people?.length !== 1) continue;
+    const had = oneToOne.get(c.people[0]);
+    if (!had || (c.last || 0) > (had.last || 0)) oneToOne.set(c.people[0], c);
+  }
+  for (const [key, v] of Object.entries(live || {})) {
+    if (!v || typeof v !== 'object') continue;
+    let c = oneToOne.get(key);
+    if (!c) {
+      c = { id: `live:${key}`, people: [key], group: false, last: null, lastFromThem: null, count: null, unread: null, threadUrl: null };
+      out.push(c);
+      oneToOne.set(key, c);
+    }
+    if (v.last && (!c.last || v.last > c.last)) {
+      c.last = v.last;
+      if (typeof v.lastFromThem === 'boolean') c.lastFromThem = v.lastFromThem;
+    }
+    c.unread = Number.isFinite(v.unread) ? v.unread : c.unread;
+    c.threadUrl = v.threadUrl || c.threadUrl;
+  }
+  return out;
+}
+
+/**
+ * The order the Conversations list shows: waiting on you (they wrote last, one
+ * to one) first, then your S and A tier people, then the most recent.
+ * `tierOf(conversation)` gives its best tier.
+ */
+export function sortConversations(list = [], tierOf = () => null) {
+  const waiting = (c) => (!c.group && c.lastFromThem === true ? 0 : 1);
+  const tier = (c) => ({ S: 0, A: 1 }[tierOf(c)] ?? 2);
+  return [...list].sort((a, b) => waiting(a) - waiting(b) || tier(a) - tier(b) || (b.last || 0) - (a.last || 0));
+}
+
 /** Warm (in the last 30 days, or 3+ in 90), cool (within a year), dormant (longer ago), or never. */
 export function warmthOf(stat, asOf) {
   if (!stat || !stat.total) return 'never';
@@ -154,3 +267,60 @@ export function invitationSplit(rows = []) {
   }
   return { incoming, outgoing, total: incoming + outgoing };
 }
+
+const nameKey = (s) => String(s || '').split(',')[0].normalize('NFD').replace(/[̀-ͯ]/g, '')
+  .toLowerCase().replace(/[^a-z0-9 ]+/g, ' ').replace(/\s+/g, ' ').trim();
+
+const THREAD_LINK = /^https:\/\/www\.linkedin\.com\/messaging\/[\w\-/%=.]*$/;
+
+/** A link to a LinkedIn messaging thread, or null: nothing else is ever put behind "Open on LinkedIn". */
+export function threadLink(u) {
+  const v = String(u || '').trim();
+  return THREAD_LINK.test(v) ? v : null;
+}
+
+/** A message the live sync read, as it's kept: { t, fromMe, text }, or null. */
+function previewOf(p) {
+  if (!p || typeof p !== 'object') return null;
+  const t = Number(p.t) || null;
+  const text = typeof p.text === 'string' ? p.text.slice(0, 20000) : null;
+  if (!t && !text) return null;
+  return { t, fromMe: p.fromMe === true, text };
+}
+
+/**
+ * The live messages sync's people, matched to your connections. LinkedIn's
+ * messaging gives a member link (/in/ACoA…) your connections list doesn't have,
+ * so a person is matched by their link when it's the same, otherwise by their
+ * name when exactly one connection has it. Only the match is kept, never the
+ * name. Returns { live: { connectionKey: { last, unread, threadUrl,
+ * lastFromThem, preview } }, unmatched }; the caller decides whether the
+ * preview's words are kept.
+ */
+export function matchLive(incoming = {}, connections = []) {
+  const byUrl = new Map();
+  const byName = new Map();
+  for (const c of connections) {
+    const key = keyFor(c);
+    byUrl.set(key, key);
+    const n = nameKey(c.name);
+    if (n) byName.set(n, byName.has(n) ? null : key);   // null: two people share it
+  }
+  const live = {};
+  let unmatched = 0;
+  for (const [url, v] of Object.entries(incoming || {})) {
+    if (!v || typeof v !== 'object') continue;
+    const key = byUrl.get(keyFor({ profile_url: url })) || byName.get(nameKey(v.name)) || null;
+    if (!key) { unmatched += 1; continue; }
+    const last = Number(v.last) || null;
+    if (live[key] && (live[key].last || 0) >= (last || 0)) continue;
+    live[key] = {
+      last,
+      unread: Number.isFinite(Number(v.unread)) && v.unread !== null ? Number(v.unread) : null,
+      threadUrl: threadLink(v.threadUrl),
+      lastFromThem: typeof v.lastFromThem === 'boolean' ? v.lastFromThem : null,
+      preview: previewOf(v.preview),
+    };
+  }
+  return { live, unmatched };
+}

package/.next/standalone/lib/social-store.js

@@ -0,0 +1,73 @@
+// Where the Social tab keeps what it knows, per profile, in the data folder:
+//
+//   social-<profile>.json           numbers and dates (app/api/social): who you
+//                                   messaged, when, who wrote last, the list of
+//                                   conversations. Never any words.
+//   social-messages-<profile>.json  the messages themselves, only while Keep my
+//                                   messages is on (app/api/social/messages).
+//
+// Two files so that turning Keep my messages off, or Forget it, deletes the
+// words by deleting one file, and so the everyday file the Galaxy and the
+// Social tab read stays small however many messages there are. Neither is in
+// "Save a copy of my network": that carries an allow-list of files
+// (lib/data-folder.js TRAVELLING_FILES) and these aren't on it.
+
+import { readFileSync, writeFileSync, renameSync, rmSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { dataDir } from './db-client';
+import { resolveProfile } from './profile';
+
+// The last messages file read, while it's unchanged (readMessages).
+const cache = { file: null, mtimeMs: 0, size: 0, data: null };
+
+/** The Social tab's files for the profile in use, or null before there is one. */
+export function socialFiles() {
+  const me = resolveProfile({ create: false });
+  if (!me?.id || !/^[\w-]+$/.test(String(me.id))) return null;
+  const dir = dataDir();
+  const messages = path.join(dir, `social-messages-${me.id}.json`);
+  return {
+    profileId: me.id,
+    social: path.join(dir, `social-${me.id}.json`),
+    messages,
+    // An import's messages arrive in parts (each request stays under the 10 MB
+    // middleware reads); they gather here and replace `messages` at the end.
+    incoming: `${messages}.incoming`,
+  };
+}
+
+export function readJson(file, fallback = null) {
+  try { return JSON.parse(readFileSync(file, 'utf8')) ?? fallback; } catch { return fallback; }
+}
+
+/** Written whole or not at all: a crash mid-write never leaves half a file. */
+export function writeJsonAtomic(file, value) {
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(value));
+  renameSync(tmp, file);
+  if (cache.file === file) cache.file = null;
+}
+
+/** The kept messages and their live-sync previews, or empty ones. */
+export function readMessages(file) {
+  // Kept in memory while the file is unchanged: a long history is read once,
+  // not on every page of a thread or every letter typed in the search box.
+  let st;
+  try { st = statSync(file); } catch { return { threads: {}, previews: {} }; }
+  if (cache.file === file && cache.mtimeMs === st.mtimeMs && cache.size === st.size) return cache.data;
+  const raw = readJson(file, {});
+  const data = {
+    threads: raw?.threads && typeof raw.threads === 'object' ? raw.threads : {},
+    previews: raw?.previews && typeof raw.previews === 'object' ? raw.previews : {},
+  };
+  Object.assign(cache, { file, mtimeMs: st.mtimeMs, size: st.size, data });
+  return data;
+}
+
+/** The messages gone: the kept file and any import still arriving. */
+export function deleteMessages(files) {
+  if (!files) return;
+  rmSync(files.messages, { force: true });
+  rmSync(files.incoming, { force: true });
+  cache.file = null;
+}

package/.next/standalone/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "six-degrees",
-  "version": "0.4.8",
+  "version": "0.4.9",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "six-degrees",
-      "version": "0.4.8",
+      "version": "0.4.9",
       "license": "MIT",
       "os": [
         "darwin",

package/.next/standalone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "six-degrees",
-  "version": "0.4.8",
+  "version": "0.4.9",
   "description": "Map your professional network as a galaxy — leverage tiers, bridges into new circles, and the shortest path to anyone. Runs locally on your own data.",
   "license": "MIT",
   "author": "Blake Burford",

package/.next/standalone/scripts/scrape.py

@@ -59,7 +59,7 @@ _ENV_LOCAL = _load_env_local()
 # a server they don't control.
 APP_URL = os.getenv("APP_URL", "http://localhost:3000")
 MESSAGING_URL = "https://www.linkedin.com/messaging/"
-MESSAGE_SCROLLS = 6               # scrolls down the conversation list, a few seconds apart
+MESSAGE_SCROLLS = 15
 
 CONNECTIONS_URL = "https://www.linkedin.com/mynetwork/invite-connect/connections/"
 
@@ -330,7 +330,7 @@ def ensure_logged_in(page, timeout_s=LOGIN_WAIT_SECONDS, log_fn=None, stop_on_ch
     if stop_on_checkpoint and signed_out:
         reason = "a security check" if wall == "checkpoint" else "being signed out"
         _keep_pushback_evidence(page, reason)
-        set_cooldown(seconds=DAY_SECONDS, reason=f"LinkedIn pushed back: {reason}")
+        set_cooldown(seconds=AUTO_PUSHBACK_REST if EXPERIMENT["on"] else DAY_SECONDS, reason=f"LinkedIn pushed back: {reason}")
         raise LinkedInPushedBack(0, reason)
 
     if _has_session_cookie(context) and not _looks_logged_out(page) and not wall:
@@ -1282,10 +1282,17 @@ LEGACY_PAGES_READ = 10            # how far every read before 0.1.6 went, at mos
 # A sitting of SESSION_PAGES searches, then a long rest; searches only in the
 # daytime on this computer's clock; and at the daily budget it waits for the
 # budget to free up instead of stopping. Pages are saved one at a time.
+#
+# Its own ceilings sit under whatever budget is set on the Scan page: the account
+# restricted on 2026-09-28 did 373 searches in 24 hours with the budget raised to
+# 500. Auto scan stays far below that however high the budget is set.
 EXPERIMENT = {"on": False, "pages": 0, "wire": 0}
-SESSION_PAGES = 10                # searches in one sitting
-SESSION_REST = 45 * 60            # the rest after each sitting
-DRIP_HOURS = (9, 19)              # searches only from 09:00 to 19:00, local time
+SESSION_PAGES = 8                 # searches in one sitting
+SESSION_REST = 60 * 60            # the rest after each sitting
+DRIP_HOURS = (9, 18)              # searches only from 09:00 to 18:00, local time
+AUTO_DAY_CAP = 40                 # at most this many searches in any 24 hours
+AUTO_WEEK_CAP = 200               # and this many in any 7 days
+AUTO_PUSHBACK_REST = 2 * 24 * 3600   # after any LinkedIn check, nothing for two days
 WIRE_SAMPLES = 5                  # raw LinkedIn responses kept per run, for research
 
 
@@ -1899,6 +1906,18 @@ def voyager_total(payload):
     return None
 
 
+_WORDS = {"body", "text", "subject", "attributedBody", "snippet", "messages", "headline", "firstName", "lastName", "rootUrl", "artifacts", "sponsoredPreviewText", "customPronoun", "advertiserLabel"}
+
+
+def _redact_words(x):
+    """A copy of a LinkedIn response with every piece of writing and every name removed."""
+    if isinstance(x, dict):
+        return {k: ("<removed>" if k in _WORDS else _redact_words(v)) for k, v in x.items()}
+    if isinstance(x, list):
+        return [_redact_words(v) for v in x]
+    return x
+
+
 def _wire_sample(data, prefix="search"):
     if EXPERIMENT["wire"] >= WIRE_SAMPLES:
         return
@@ -1908,6 +1927,10 @@ def _wire_sample(data, prefix="search"):
             return
         folder = _home() / "wire-samples"
         folder.mkdir(parents=True, exist_ok=True)
+        if prefix == "messages":
+            # Messaging responses carry what people wrote, and their names: a sample
+            # keeps only the shape (keys, links, dates, counts), never the words.
+            raw = json.dumps(_redact_words(data))
         (folder / f"{prefix}-{int(time.time() * 1000)}.json").write_text(raw)
         EXPERIMENT["wire"] += 1
     except Exception:
@@ -1948,14 +1971,51 @@ def _wire_merge(page, profile_url, page_results):
     return page_results
 
 
-_PROFILE_LINK = re.compile(r"https://www\\.linkedin\\.com/in/[^/?#\\s\"']+")
+_PROFILE_LINK = re.compile(r"https://www\.linkedin\.com/in/[^/?#\s\"']+")
+
+
+def _dig(x, *keys):
+    """x[k1][k2]..., or None as soon as a step isn't there."""
+    for k in keys:
+        if not isinstance(x, dict):
+            return None
+        x = x.get(k)
+    return x
+
+
+def _link_key(link):
+    """A profile link as the messages sync compares them: no query, one closing slash."""
+    return link.split("?")[0].rstrip("/") + "/" if isinstance(link, str) and "/in/" in link else None
 
 
 def voyager_conversations(payload):
     """Conversations in a LinkedIn messaging response (experimental): per conversation,
-    everyone in it (profile links), when it was last active, and unread messages.
-    Anything with a lastActivityAt and participants, wherever it sits. Never the text."""
+    everyone in it (profile links), when it was last active, unread messages, its link,
+    whether it's a group, and the newest message LinkedIn sent along with it (when,
+    from whom, and its words). Anything with a lastActivityAt and participants,
+    wherever it sits. The words are handed to the app only while Keep my messages is
+    on there (sync_messages); a wire sample never has them (_redact_words)."""
     out = []
+    names = {}
+
+    def text_of(v):
+        return v.get("text", "") if isinstance(v, dict) else (v if isinstance(v, str) else "")
+
+    def latest_of(x):
+        # conversation.messages.elements[]: body.text, deliveredAt, and who sent it
+        # (actor.participantType.member.profileUrl, the same /in/ACoA... link the
+        # participants have, so it tells you from them).
+        msgs = x.get("messages")
+        elements = msgs.get("elements") if isinstance(msgs, dict) else msgs
+        best = None
+        for m in elements if isinstance(elements, list) else []:
+            t = _dig(m, "deliveredAt")
+            if not isinstance(t, (int, float)) or t < 1e12 or (best and t <= best["t"]):
+                continue
+            text = text_of(_dig(m, "body")).strip()
+            best = {"t": int(t), "from": _link_key(_dig(m, "actor", "participantType", "member", "profileUrl")),
+                    "text": text or None}
+        return best
 
     def people(x):
         found = set()
@@ -1966,6 +2026,14 @@ def voyager_conversations(payload):
                 pid = v.get("publicIdentifier")
                 if isinstance(pid, str) and pid and pid != "UNKNOWN":
                     found.add(f"https://www.linkedin.com/in/{pid}/")
+                # Messaging gives a member's link as /in/ACoA… (their member id), not
+                # the /in/name link your connections list has, so their name comes
+                # along to match them up (the app keeps the match, not the name).
+                key = _link_key(v.get("profileUrl"))
+                if key:
+                    name = f"{text_of(v.get('firstName'))} {text_of(v.get('lastName'))}".strip()
+                    if name:
+                        names[key] = name
                 stack.extend(v.values())
             elif isinstance(v, list):
                 stack.extend(v)
@@ -1984,7 +2052,13 @@ def voyager_conversations(payload):
                     who |= people(v)
                 if who:
                     unread = x.get("unreadCount")
-                    out.append({"people": sorted(who), "at": int(at), "unread": int(unread) if isinstance(unread, (int, float)) else None})
+                    link = x.get("conversationUrl")
+                    group = x.get("groupChat")
+                    out.append({"people": sorted(who), "at": int(at), "unread": int(unread) if isinstance(unread, (int, float)) else None,
+                                "names": {u: names[u] for u in who if u in names},
+                                "url": link if isinstance(link, str) and link.startswith("https://www.linkedin.com/messaging/") else None,
+                                "group": group if isinstance(group, bool) else None,
+                                "latest": latest_of(x)})
             for v in x.values():
                 walk(v)
         elif isinstance(x, list):
@@ -1997,8 +2071,9 @@ def voyager_conversations(payload):
 def sync_messages(headless=False):
     """Experimental: read your LinkedIn messages list once, for the Social tab. Opens
     Messaging in your own Chrome, scrolls the list a few times, and keeps from LinkedIn's
-    own data only who each 1:1 conversation is with, when it was last active and whether
-    it has unread messages. No search budget; no message text is read or kept."""
+    own data who each 1:1 conversation is with, when it was last active, whether it has
+    unread messages, its link and who wrote last. The newest message's words go to the
+    app only while Keep my messages is on there. No search budget."""
     from playwright.sync_api import sync_playwright
     kept = []
     with sync_playwright() as p:
@@ -2021,7 +2096,12 @@ def sync_messages(headless=False):
             if stop_requested() or _window_closed(page):
                 break
             try:
-                page.evaluate("""() => { const l = document.querySelector('.msg-conversations-container__conversations-list, [class*="conversations-list"]');
+                # The list scrolls inside its own panel, not the window: find the panel
+                # that holds the conversation links and scroll that to its end.
+                page.evaluate("""() => {
+                  let l = document.querySelector('.msg-conversations-container__conversations-list, [class*="conversations-list"]');
+                  const a = document.querySelector('a[href*="/messaging/thread/"], li[class*="conversation-listitem"]');
+                  for (let e = a; !l && e; e = e.parentElement) if (e.scrollHeight > e.clientHeight + 20) l = e;
                   if (l) l.scrollTop = l.scrollHeight; }""")
             except Exception:
                 pass
@@ -2036,7 +2116,35 @@ def sync_messages(headless=False):
             _wire_sample(data, prefix="messages")
             convos.extend(voyager_conversations(data))
         browser.close()
-    # You are the one in the most conversations; keep the 1:1 ones.
+    _me, people = live_people(convos)
+    print(f"  Found {len(convos)} conversations in LinkedIn's data, {len(people)} with one person.")
+    # The newest message's words go to the app only if Keep my messages is on
+    # there. The app checks too; this way they don't even leave the scanner.
+    keep = False
+    try:
+        r = requests.get(f"{APP_URL}/api/social", headers=app_headers(json_body=False), timeout=15)
+        keep = r.ok and ((r.json() or {}).get("social") or {}).get("keepMessages") is True
+    except Exception:
+        pass
+    if not keep:
+        for v in people.values():
+            if v.get("preview"):
+                v["preview"]["text"] = None
+    try:
+        r = requests.put(f"{APP_URL}/api/social", json={"live": people}, headers=app_headers(), timeout=30)
+        got = r.json() if r.ok else {}
+        matched, unmatched = got.get("people", 0), got.get("unmatched", 0)
+        print(f"  Saved for the Social tab: {matched} matched to your connections, {unmatched} not.")
+    except Exception as e:
+        print(f"  Couldn't save them: {e}")
+
+
+def live_people(convos):
+    """The messages sync's conversations, per person: you are the one in the most
+    conversations, and only the 1:1 ones are kept. For each person, their newest
+    conversation's last activity, unread count, name (for the app to match them to
+    a connection; it keeps the match, not the name), link, who wrote last and the
+    newest message. Returns (you, {profile link: ...})."""
     counts = {}
     for c in convos:
         for u in c["people"]:
@@ -2045,17 +2153,23 @@ def sync_messages(headless=False):
     people = {}
     for c in convos:
         others = [u for u in c["people"] if u != me]
-        if len(others) != 1:
+        if len(others) != 1 or c.get("group") is True:
             continue
         cur = people.get(others[0])
-        if not cur or c["at"] > cur["last"]:
-            people[others[0]] = {"last": c["at"], "unread": c["unread"]}
-    print(f"  Found {len(convos)} conversations in LinkedIn's data, {len(people)} with one person.")
-    try:
-        requests.put(f"{APP_URL}/api/social", json={"live": people}, headers=app_headers(), timeout=30)
-        print("  Saved for the Social tab.")
-    except Exception as e:
-        print(f"  Couldn't save them: {e}")
+        if cur and c["at"] <= cur["last"]:
+            continue
+        entry = {"last": c["at"], "unread": c["unread"], "name": c.get("names", {}).get(others[0]),
+                 "threadUrl": c.get("url"), "lastFromThem": None, "preview": None}
+        latest = c.get("latest")
+        # Who sent it is known only when their link is one of the two in the
+        # conversation; a link in some other form says nothing either way.
+        sender = latest.get("from") if latest else None
+        if sender in (me, others[0]):
+            from_me = sender == me
+            entry["lastFromThem"] = not from_me
+            entry["preview"] = {"t": latest["t"], "fromMe": from_me, "text": latest.get("text")}
+        people[others[0]] = entry
+    return me, people
 
 
 def _drip_wait(label, seconds):
@@ -2095,9 +2209,28 @@ def _drip_before_search():
             if not _drip_wait("Today's searches are used", _seconds_until_search_frees()):
                 return False
             continue
+        wait = _auto_ceiling_wait()
+        if wait:
+            label, seconds = wait
+            if not _drip_wait(label, seconds):
+                return False
+            continue
         return True
 
 
+def _auto_ceiling_wait(now=None):
+    """Auto scan's own ceilings (AUTO_DAY_CAP in 24 hours, AUTO_WEEK_CAP in 7 days):
+    None to go ahead, or (why, seconds until the oldest counted search drops out)."""
+    now = now if now is not None else time.time()
+    searches = sorted(t for t in _read_activity()["searches"] if now - 7 * DAY_SECONDS < t <= now)
+    day = [t for t in searches if now - DAY_SECONDS < t]
+    if len(day) >= AUTO_DAY_CAP:
+        return (f"Auto scan's {AUTO_DAY_CAP} searches for today are used", day[-AUTO_DAY_CAP] + DAY_SECONDS - now + 5)
+    if len(searches) >= AUTO_WEEK_CAP:
+        return (f"Auto scan's {AUTO_WEEK_CAP} searches for this week are used", searches[-AUTO_WEEK_CAP] + 7 * DAY_SECONDS - now + 5)
+    return None
+
+
 def interruptible_sleep(seconds, on_tick=None, step=5):
     """Sleep, but notice a stop request. Returns False if we were interrupted."""
     waited = 0
@@ -4073,7 +4206,7 @@ Examples:
     parser.add_argument("--rescrape", type=str, help="Delete + re-scrape a bridge's cluster from scratch")
     parser.add_argument("--company", type=str, help="Scan everyone the app can see at one company")
     parser.add_argument("--messages", action="store_true",
-                        help="Experimental: read your messages list once for the Social tab (who, when, unread; never text)")
+                        help="Experimental: read your messages list once for the Social tab (who, when, unread; the newest message's words only if Keep my messages is on)")
     parser.add_argument("--experimental", action="store_true",
                         help="Auto-Bridge, experimental: all-day pacing (sittings, rests, daytime only, "
                              "waits for the daily budget) and reading LinkedIn's own data beside the page text")