six-degrees 0.4.7 → 0.4.9

package/.next/standalone/app/api/social/messages/route.js

@@ -0,0 +1,130 @@
+import { rmSync } from 'node:fs';
+import { conversationList } from '../../../../lib/linkedin-export';
+import { socialFiles, readJson, writeJsonAtomic, readMessages, deleteMessages } from '../../../../lib/social-store';
+
+// The Social tab's Conversations: the list, one thread at a time, and the
+// messages themselves when Keep my messages is on (lib/social-store.js has the
+// two files and why they're apart).
+//
+//   GET                       the list, no words: who, when, who wrote last,
+//                             unread, how many, the thread's link
+//   GET ?id=<id> | ?with=<key> one thread, a page at a time (before, limit):
+//                             its messages only if they're kept
+//   GET ?q=<words>            the conversations whose kept messages say that
+//   POST                      an import's messages, in parts
+//   DELETE                    the messages gone, the list kept
+//
+// Nothing here goes anywhere but this computer's browser: no route of the app
+// sends messages on, and a copy of the network doesn't carry this file.
+
+const PAGE = 100;
+const MAX_TEXT = 20000;
+
+function state() {
+  const files = socialFiles();
+  if (!files) return null;
+  const social = readJson(files.social, {}) || {};
+  const keep = social.keepMessages === true;
+  const kept = keep ? readMessages(files.messages) : { threads: {}, previews: {} };
+  return { files, social, keep, kept, list: conversationList(social.conversations, social.live) };
+}
+
+/** A conversation's kept messages, oldest first, with the live sync's newest one after them when it's newer. */
+function messagesOf(c, kept) {
+  const msgs = kept.threads[c.id]?.messages || [];
+  const preview = !c.group && c.people.length === 1 ? kept.previews[c.people[0]] : null;
+  if (preview?.text && (!msgs.length || (preview.t || 0) > (msgs[msgs.length - 1].t || 0))) return [...msgs, preview];
+  return msgs;
+}
+
+export async function GET(request) {
+  const s = state();
+  if (!s) return Response.json({ keepMessages: false, conversations: [] });
+  const url = new URL(request.url);
+  const id = url.searchParams.get('id');
+  const withKey = url.searchParams.get('with');
+
+  if (id || withKey) {
+    const c = id
+      ? s.list.find((x) => x.id === id)
+      : s.list.filter((x) => !x.group && x.people[0] === withKey).sort((a, b) => (b.last || 0) - (a.last || 0))[0];
+    if (!c) return Response.json({ error: 'That conversation isn’t here.' }, { status: 404 });
+    if (!s.keep) return Response.json({ kept: false, id: c.id, total: c.count });
+    const msgs = messagesOf(c, s.kept);
+    const total = msgs.length;
+    const limit = Math.min(500, Math.max(1, Number(url.searchParams.get('limit')) || PAGE));
+    const before = url.searchParams.has('before') ? Math.max(0, Math.min(total, Number(url.searchParams.get('before')) || 0)) : total;
+    const start = Math.max(0, before - limit);
+    return Response.json({ kept: true, id: c.id, title: s.kept.threads[c.id]?.title || '', total, start, messages: msgs.slice(start, before) });
+  }
+
+  const q = String(url.searchParams.get('q') || '').trim().toLowerCase();
+  if (url.searchParams.has('q')) {
+    if (!s.keep || q.length < 2) return Response.json({ ids: [] });
+    const ids = s.list.filter((c) => messagesOf(c, s.kept).some((m) => String(m.text || '').toLowerCase().includes(q))).map((c) => c.id);
+    return Response.json({ ids });
+  }
+
+  const conversations = s.list.map((c) => ({
+    ...c,
+    title: s.kept.threads[c.id]?.title || '',
+    hasText: s.keep && messagesOf(c, s.kept).length > 0,
+  }));
+  return Response.json({ keepMessages: s.keep, conversations });
+}
+
+/** One message as it's kept, or null when it isn't one. */
+function cleanMessage(m) {
+  if (!m || typeof m !== 'object' || !Number.isFinite(Number(m.t))) return null;
+  return { t: Number(m.t), fromMe: m.fromMe === true, text: typeof m.text === 'string' ? m.text.slice(0, MAX_TEXT) : '' };
+}
+
+// An import's messages: { part, parts, threads: { id: { title, messages } } }.
+// Each part stays under the 10 MB a request can carry here, so a long history
+// comes in several. They gather in the `incoming` file and replace the kept
+// messages only when the last one lands, so a half-sent import never shows as
+// the whole thing. Refused while Keep my messages is off, whatever the page sent.
+export async function POST(request) {
+  const s = state();
+  if (!s) return Response.json({ error: 'Pick a profile first.' }, { status: 400 });
+  if (!s.keep) return Response.json({ error: 'Keep my messages is off, so nothing was saved.' }, { status: 409 });
+  let body;
+  try { body = await request.json(); } catch { return Response.json({ error: 'That isn’t readable.' }, { status: 400 }); }
+  const part = Number(body?.part);
+  const parts = Number(body?.parts);
+  if (!Number.isInteger(part) || !Number.isInteger(parts) || part < 0 || part >= parts) {
+    return Response.json({ error: 'That isn’t a part of an import.' }, { status: 400 });
+  }
+  let into;
+  if (part === 0) {
+    // A new import replaces the export's messages; the live sync's previews stay.
+    into = { threads: {}, previews: s.kept.previews || {} };
+  } else {
+    into = readJson(s.files.incoming, null);
+    if (!into?.threads) return Response.json({ error: 'The start of this import is missing. Choose the export folder again.' }, { status: 409 });
+  }
+  const threads = body?.threads && typeof body.threads === 'object' ? body.threads : {};
+  for (const [id, t] of Object.entries(threads)) {
+    if (!id || id.length > 200 || !t || !Array.isArray(t.messages)) continue;
+    const to = into.threads[id] || (into.threads[id] = { title: '', messages: [] });
+    if (typeof t.title === 'string' && t.title && !to.title) to.title = t.title.slice(0, 200);
+    for (const m of t.messages) {
+      const c = cleanMessage(m);
+      if (c) to.messages.push(c);
+    }
+  }
+  if (part === parts - 1) {
+    writeJsonAtomic(s.files.messages, into);
+    rmSync(s.files.incoming, { force: true });
+  } else {
+    writeJsonAtomic(s.files.incoming, into);
+  }
+  return Response.json({ ok: true, part, parts, done: part === parts - 1 });
+}
+
+// The words gone, the list and the numbers kept: what switching Keep my
+// messages off does (the PATCH that turns it off deletes them as well).
+export async function DELETE() {
+  deleteMessages(socialFiles());
+  return Response.json({ ok: true });
+}

package/.next/standalone/app/api/social/route.js

@@ -1,40 +1,66 @@
-import { readFileSync, writeFileSync, renameSync, rmSync } from 'node:fs';
-import path from 'node:path';
-import { dataDir } from '../../../lib/db-client';
+import { rmSync } from 'node:fs';
+import { db } from '../../../lib/db';
 import { resolveProfile } from '../../../lib/profile';
+import { matchLive } from '../../../lib/linkedin-export';
+import { socialFiles, readJson, writeJsonAtomic, readMessages, deleteMessages } from '../../../lib/social-store';
 
 // The Social tab's saved findings (lib/linkedin-export.js): numbers and dates
-// from your own LinkedIn export, one file per profile in the data folder. No
-// message text ever reaches here. GET reads it, POST replaces it, DELETE
-// forgets it.
+// from your own LinkedIn export and the live messages sync, one file per
+// profile in the data folder. No message text is kept in this file: the words,
+// when Keep my messages is on, go to their own file (lib/social-store.js,
+// app/api/social/messages). GET reads it, POST replaces it, PUT takes a live
+// sync, PATCH flips a switch, DELETE forgets it all.
 
-function fileFor() {
-  const me = resolveProfile({ create: false });
-  if (!me?.id || !/^[\w-]+$/.test(String(me.id))) return null;
-  return path.join(dataDir(), `social-${me.id}.json`);
+// A person's key: their profile link, as lib/separation.js keyFor makes it.
+const KEY_OK = (k) => typeof k === 'string' && k.length > 0 && k.length < 300;
+
+/** An import's list of conversations, with nothing but the fields the list shows. */
+function cleanConversations(list) {
+  if (!Array.isArray(list)) return [];
+  const out = [];
+  for (const c of list) {
+    if (!c || typeof c.id !== 'string' || !c.id || c.id.length > 200 || !Array.isArray(c.people)) continue;
+    const people = c.people.filter(KEY_OK).slice(0, 200);
+    if (!people.length) continue;
+    out.push({
+      id: c.id,
+      people,
+      group: c.group === true,
+      last: Number(c.last) || null,
+      lastFromThem: typeof c.lastFromThem === 'boolean' ? c.lastFromThem : null,
+      count: Number.isFinite(Number(c.count)) ? Number(c.count) : null,
+    });
+  }
+  return out;
 }
 
 export async function GET() {
-  const file = fileFor();
-  if (!file) return Response.json({ social: null });
-  try { return Response.json({ social: JSON.parse(readFileSync(file, 'utf8')) }); } catch { return Response.json({ social: null }); }
+  const files = socialFiles();
+  if (!files) return Response.json({ social: null });
+  const social = readJson(files.social, null);
+  if (!social) return Response.json({ social: null });
+  // The list of conversations can run to thousands; the Galaxy and the tab's
+  // counts don't need it, and GET /api/social/messages serves it.
+  const { conversations, ...rest } = social;
+  return Response.json({ social: { ...rest, conversationCount: Array.isArray(conversations) ? conversations.length : 0 } });
 }
 
 export async function POST(request) {
-  const file = fileFor();
-  if (!file) return Response.json({ error: 'Pick a profile first.' }, { status: 400 });
+  const files = socialFiles();
+  if (!files) return Response.json({ error: 'Pick a profile first.' }, { status: 400 });
   let body;
   try { body = await request.json(); } catch { return Response.json({ error: 'That isn’t readable.' }, { status: 400 }); }
   // Only the known fields, so nothing else rides along into the file.
-  let before = {};
-  try { before = JSON.parse(readFileSync(file, 'utf8')) || {}; } catch { /* none yet */ }
+  const before = readJson(files.social, {}) || {};
   const clean = {
     live: before.live || {},
     liveAt: before.liveAt || null,
     autoSync: before.autoSync === true,
+    keepMessages: before.keepMessages === true,
     importedAt: new Date().toISOString(),
     asOf: Number(body?.asOf) || null,
     people: body?.people && typeof body.people === 'object' ? body.people : {},
+    conversations: cleanConversations(body?.conversations),
     chapters: Array.isArray(body?.chapters) ? body.chapters : [],
     posts: body?.posts && typeof body.posts === 'object' ? body.posts : null,
     invites: body?.invites && typeof body.invites === 'object' ? body.invites : null,
@@ -46,51 +72,67 @@ export async function POST(request) {
       if (!clean.emails) delete p.email;
     }
   }
-  const tmp = `${file}.${process.pid}.tmp`;
-  writeFileSync(tmp, JSON.stringify(clean));
-  renameSync(tmp, file);
-  return Response.json({ ok: true, people: Object.keys(clean.people).length });
+  writeJsonAtomic(files.social, clean);
+  return Response.json({ ok: true, people: Object.keys(clean.people).length, conversations: clean.conversations.length });
 }
 
 // From the scanner's experimental messages sync (scripts/scrape.py sync_messages):
-// per person, when your 1:1 conversation was last active and unread count.
-// Merged in beside what the export gave, kept under `live`.
+// per person, when your 1:1 conversation was last active, unread count, the
+// thread's link, who wrote last and the newest message. Merged in beside what
+// the export gave, kept under `live`. The newest message's words go to the
+// messages file, and only while Keep my messages is on.
 export async function PUT(request) {
-  const file = fileFor();
-  if (!file) return Response.json({ error: 'Pick a profile first.' }, { status: 400 });
+  const files = socialFiles();
+  if (!files) return Response.json({ error: 'Pick a profile first.' }, { status: 400 });
   let body;
   try { body = await request.json(); } catch { return Response.json({ error: 'That isn’t readable.' }, { status: 400 }); }
-  let saved = {};
-  try { saved = JSON.parse(readFileSync(file, 'utf8')) || {}; } catch { /* first sync */ }
+  const saved = readJson(files.social, {}) || {};
+  // Matched to your connections here, so the names the sync sends go no further.
+  const me = resolveProfile({ create: false });
+  let conns = [];
+  try {
+    const q = db.from('linkedin_connections').select('name, profile_url, id').eq('degree', 1);
+    if (me?.id) q.eq('user_id', me.id);
+    conns = (await q).data || [];
+  } catch { /* no connections yet */ }
+  const { live: matched, unmatched } = matchLive(body?.live || {}, conns);
   const live = {};
-  for (const [url, v] of Object.entries(body?.live || {})) {
-    if (typeof url !== 'string' || !url.includes('/in/') || !v || typeof v !== 'object') continue;
-    live[url] = { last: Number(v.last) || null, unread: Number.isFinite(Number(v.unread)) ? Number(v.unread) : null };
+  const previews = {};
+  for (const [key, { preview, ...rest }] of Object.entries(matched)) {
+    live[key] = rest;
+    if (saved.keepMessages === true && preview?.text) previews[key] = preview;
+  }
+  writeJsonAtomic(files.social, { ...saved, live, liveAt: new Date().toISOString() });
+  if (Object.keys(previews).length) {
+    const kept = readJson(files.messages, {}) || {};
+    writeJsonAtomic(files.messages, { ...kept, previews: { ...(kept.previews || {}), ...previews } });
   }
-  const next = { ...saved, live, liveAt: new Date().toISOString() };
-  const tmp = `${file}.${process.pid}.tmp`;
-  writeFileSync(tmp, JSON.stringify(next));
-  renameSync(tmp, file);
-  return Response.json({ ok: true, people: Object.keys(live).length });
+  return Response.json({ ok: true, people: Object.keys(live).length, unmatched, previews: Object.keys(previews).length });
 }
 
-// The Social tab's "once a day" switch for the live messages sync.
+// The Social tab's switches: "once a day" for the live messages sync, and
+// Keep my messages. Only the ones sent change. Turning Keep my messages off
+// deletes the kept messages here too, so the words can't outlive the switch
+// whatever the page did first.
 export async function PATCH(request) {
-  const file = fileFor();
-  if (!file) return Response.json({ error: 'Pick a profile first.' }, { status: 400 });
+  const files = socialFiles();
+  if (!files) return Response.json({ error: 'Pick a profile first.' }, { status: 400 });
   let body = {};
   try { body = await request.json(); } catch { /* nothing to change */ }
-  let saved = {};
-  try { saved = JSON.parse(readFileSync(file, 'utf8')) || {}; } catch { /* none yet */ }
-  const next = { ...saved, autoSync: body?.autoSync === true };
-  const tmp = `${file}.${process.pid}.tmp`;
-  writeFileSync(tmp, JSON.stringify(next));
-  renameSync(tmp, file);
-  return Response.json({ ok: true, autoSync: next.autoSync });
+  const next = { ...(readJson(files.social, {}) || {}) };
+  if (typeof body?.autoSync === 'boolean') next.autoSync = body.autoSync;
+  if (typeof body?.keepMessages === 'boolean') next.keepMessages = body.keepMessages;
+  if (next.keepMessages !== true) deleteMessages(files);
+  writeJsonAtomic(files.social, next);
+  return Response.json({ ok: true, autoSync: next.autoSync === true, keepMessages: next.keepMessages === true });
 }
 
+// Forget it: both files, the numbers and the words.
 export async function DELETE() {
-  const file = fileFor();
-  if (file) rmSync(file, { force: true });
+  const files = socialFiles();
+  if (files) {
+    rmSync(files.social, { force: true });
+    deleteMessages(files);
+  }
   return Response.json({ ok: true });
 }

package/.next/standalone/app/components/ScanStatusBar.js

@@ -8,6 +8,8 @@
 // pacing and the caps live in the scanner (scripts/scrape.py, lib/linkedin-limits.js).
 
 import { useEffect, useState, useSyncExternalStore } from 'react';
+import { createPortal } from 'react-dom';
+import { usePathname } from 'next/navigation';
 import Link from 'next/link';
 import { watchScanner, scannerNow, stopScrape } from '../../lib/scraper-client';
 import { watchAllDay, allDayNow } from '../../lib/experimental-client';
@@ -37,19 +39,54 @@ export default function ScanStatusBar() {
   // The Scan page's experimental all-day Auto-Bridge switch: with it on, the bar
   // stays under the tabs even while nothing runs, so you can see the mode is on.
   const allDay = useSyncExternalStore(watchAllDay, allDayNow, () => false);
+  // Where it sits: in the page's own slot under its header when the page has one
+  // (it then pushes the page down rather than covering it), otherwise fixed just
+  // under the header's buttons, measured, since a header can wrap to two rows.
+  const pathname = usePathname();
+  const [spot, setSpot] = useState({ slot: null, top: null });
+  useEffect(() => {
+    // The header can load late or be swapped for a new one (a page that shows
+    // "Loading…" first), so it's found again whenever the page's elements change,
+    // and its size is watched for a wrap to two rows.
+    let header = null;
+    let ro = null;
+    let queued = 0;
+    const measure = () => {
+      queued = 0;
+      const slot = document.getElementById('scan-bar-slot');
+      const now = slot ? null : document.querySelector('header');
+      if (now !== header) {
+        ro?.disconnect();
+        ro = null;
+        header = now;
+        if (header) { ro = new ResizeObserver(later); ro.observe(header); }
+      }
+      const top = header ? Math.round(header.getBoundingClientRect().bottom) + 6 : null;
+      setSpot((was) => (was.slot === slot && was.top === top ? was : { slot, top }));
+    };
+    const later = () => { if (!queued) queued = requestAnimationFrame(measure); };
+    later();
+    const mo = new MutationObserver(later);
+    mo.observe(document.body, { childList: true, subtree: true });
+    window.addEventListener('resize', later);
+    return () => { cancelAnimationFrame(queued); ro?.disconnect(); mo.disconnect(); window.removeEventListener('resize', later); };
+  }, [pathname]);
   useEffect(() => watchScanner(() => {
     const now = scannerNow();
     setJob(now);
     if (!now.running) setStopping(false);
   }), []);
   const place = {
-    position: 'fixed', left: '50%', top: 'var(--scan-bar-top, 94px)', transform: 'translateX(-50%)', zIndex: 60,
+    ...(spot.slot
+      ? { position: 'relative', margin: '8px auto 12px', width: 'fit-content' }
+      : { position: 'fixed', left: '50%', top: spot.top != null ? spot.top : 'var(--scan-bar-top, 94px)', transform: 'translateX(-50%)', zIndex: 60 }),
     maxWidth: 'calc(100vw - 32px)', display: 'flex', alignItems: 'center', gap: 12, flexWrap: 'nowrap', whiteSpace: 'nowrap',
     padding: '8px 12px', borderRadius: 12, fontSize: 12, color: '#cfd8d8', background: 'rgba(14,16,32,0.94)',
   };
+  const put = (bar) => (spot.slot && document.body.contains(spot.slot) ? createPortal(bar, spot.slot) : bar);
   if (!job?.running) {
     if (!allDay) return null;
-    return (
+    return put(
       <div role="status" style={{ ...place, opacity: 0.55, border: '1px solid rgba(255,255,255,0.1)' }}>
         <span style={{ width: 8, height: 8, borderRadius: '50%', background: '#556', flexShrink: 0 }} />
         <b style={{ color: '#b8c4c4' }}>Auto scan</b>
@@ -65,7 +102,7 @@ export default function ScanStatusBar() {
   const b = job.budget;
   const last = [...(job.log || [])].reverse().find((l) => l && l.trim())?.trim();
 
-  return (
+  return put(
     <div role="status" aria-live="polite" style={{ ...place, border: '1px solid rgba(0,255,136,0.25)' }}>
       <span style={{ width: 8, height: 8, borderRadius: '50%', background: '#00ff88', flexShrink: 0 }} />
       <b style={{ color: '#fff' }}>{WHAT[job.action] || 'Scanning'}</b>

package/.next/standalone/app/components/settings/DataSection.js

@@ -334,7 +334,8 @@ export default function DataSection() {
       <Body style={small}>
         The copy holds the names, headlines and photos of the people in your network. Keep it private: don’t
         post it or share it, and delete it once it has been imported. A network opened from a LinkedIn CSV lives
-        only in its browser tab, so it isn’t in the copy; import the CSV again on the new computer.
+        only in its browser tab, so it isn’t in the copy; import the CSV again on the new computer. The Social
+        tab’s findings, and any messages you keep there, stay on this computer and aren’t in the copy either.
       </Body>
 
       <h3 style={subhead}>Bring in a network from another computer</h3>

package/.next/standalone/app/paths/page.js

@@ -106,12 +106,22 @@ function PathsInner() {
   function enrichPeople(people) {
     const d1Urls = new Set(d1Data.map(c => c.profile_url));
     const knownUrls = new Set([...d1Data, ...d2Data].map(c => c.profile_url));
+    // A person's mutuals are everyone here you're connected to but them. Counted
+    // once, then less their own, rather than a pass over everyone per person:
+    // that was 3.7 million checks at a company of 1,900.
+    const connectedById = new Map();
+    let connectedHere = 0;
+    for (const op of people) {
+      if (!d1Urls.has(op.profile_url || op.profileUrl)) continue;
+      connectedHere++;
+      connectedById.set(op.id, (connectedById.get(op.id) || 0) + 1);
+    }
     return people.map(p => ({
       ...p,
       connected: d1Urls.has(p.profile_url || p.profileUrl),
       known: knownUrls.has(p.profile_url || p.profileUrl),
       seniority: getSeniority(p.headline),
-      mutualCount: people.filter(op => d1Urls.has(op.profile_url || op.profileUrl) && op.id !== p.id).length,
+      mutualCount: connectedHere - (connectedById.get(p.id) || 0),
     }));
   }
 
@@ -177,6 +187,9 @@ function PathsInner() {
   }
 
   // Build hierarchy for selected company
+  const d1ById = new Map();
+  for (const d of d1Data) if (!d1ById.has(d.id)) d1ById.set(d.id, d);
+  const d1Urls = new Set(d1Data.map(c => c.profile_url));
   const hierarchy = {};
   let connectedCount = 0;
   companyPeople.forEach(p => {
@@ -195,7 +208,7 @@ function PathsInner() {
     // Find the bridge path for degree-2 people
     let bridgeName = null;
     if (p.degree === 2 && p.source_connection_id) {
-      const bridge = d1Data.find(d => d.id === p.source_connection_id);
+      const bridge = d1ById.get(p.source_connection_id);
       if (bridge) bridgeName = bridge.name;
     }
 
@@ -289,6 +302,8 @@ function PathsInner() {
           )}
         </div>
       </header>
+      {/* The scan status bar sits here, under the header's buttons (ScanStatusBar.js). */}
+      <div id="scan-bar-slot" />
 
       {!selectedCompany && tab !== 'companies' ? (
         <PathsAnalyzer d1={d1Data} d2={d2Data} d3={d3Data} tab={tab}
@@ -380,7 +395,7 @@ function PathsInner() {
               </div>
 
               {level.people.map((p, pi) => (
-                <PathPersonRow key={p.id || pi} p={p} level={level} companyPeople={companyPeople} d1Data={d1Data} selectedCompany={selectedCompany} />
+                <PathPersonRow key={p.id || pi} p={p} level={level} companyPeople={companyPeople} d1Urls={d1Urls} selectedCompany={selectedCompany} />
               ))}
             </div>
           ))}
@@ -391,24 +406,18 @@ function PathsInner() {
   );
 }
 
-function PathPersonRow({ p, level, companyPeople, d1Data, selectedCompany }) {
+function PathPersonRow({ p, level, companyPeople, d1Urls, selectedCompany }) {
   const [expanded, setExpanded] = useState(false);
 
-  // Calculate strategic insights
-  const d1Urls = new Set(d1Data.map(c => c.profile_url));
-  const connectedAtCompany = companyPeople.filter(op => d1Urls.has(op.profile_url || op.profileUrl));
-  const aboveMe = companyPeople.filter(op => {
-    const s = getSeniority(op.headline);
-    return s.level > p.seniority.level && !d1Urls.has(op.profile_url || op.profileUrl);
-  });
-  const sameLevel = companyPeople.filter(op => {
-    const s = getSeniority(op.headline);
-    return s.level === p.seniority.level && op.id !== p.id;
-  });
-
-  // What happens if you add this person
+  // What happens if you add this person. Only worked out for a row that's open,
+  // since only an open row shows it: every row comparing itself with everyone
+  // at the company, each time the page drew, took minutes at a company of 1,900.
+  // Everyone's level is read once already (enrichPeople's seniority).
   const unlockInsights = [];
-  if (!p.connected) {
+  if (expanded && !p.connected) {
+    const aboveMe = companyPeople.filter(op => op.seniority.level > p.seniority.level && !d1Urls.has(op.profile_url || op.profileUrl));
+    const sameLevel = companyPeople.filter(op => op.seniority.level === p.seniority.level && op.id !== p.id);
+
     // How many people above would gain a mutual
     const aboveCount = aboveMe.length;
     if (aboveCount > 0) {

package/.next/standalone/app/profile/page.js

@@ -164,6 +164,8 @@ function ProfileInner() {
           WebkitBackgroundClip: 'text', WebkitTextFillColor: 'transparent',
         }}>Profile</h1>
       </header>
+      {/* The scan status bar sits here, under the header's buttons (ScanStatusBar.js). */}
+      <div id="scan-bar-slot" />
 
       <div style={{ flex: 1, overflow: 'auto', padding: '30px 20px' }}>
       <div style={{ maxWidth: 700, margin: '0 auto' }}>

package/.next/standalone/app/queue/page.js

@@ -301,6 +301,8 @@ function QueueInner() {
           ))}
         </div>
       </header>
+      {/* The scan status bar sits here, under the header's buttons (ScanStatusBar.js). */}
+      <div id="scan-bar-slot" />
 
       {/* Batch action bar — recs view only */}
       {view === 'recs' && selected.size > 0 && (

package/.next/standalone/app/scores/page.js

@@ -56,6 +56,8 @@ function ScoresInner() {
           WebkitBackgroundClip: 'text', WebkitTextFillColor: 'transparent',
         }}>Scores</h1>
       </header>
+      {/* The scan status bar sits here, under the header's buttons (ScanStatusBar.js). */}
+      <div id="scan-bar-slot" />
       <main style={{ maxWidth: 980, margin: '0 auto', padding: '8px 24px 64px' }}>
         <Body style={{ marginTop: 16 }}>
           How someone&rsquo;s power score is worked out, and the three things you can change about it:{' '}

package/.next/standalone/app/settings/page.js

@@ -73,6 +73,8 @@ function SettingsInner() {
           WebkitBackgroundClip: 'text', WebkitTextFillColor: 'transparent',
         }}>Settings</h1>
       </header>
+      {/* The scan status bar sits here, under the header's buttons (ScanStatusBar.js). */}
+      <div id="scan-bar-slot" />
 
       <main style={{ maxWidth: 720, margin: '0 auto', padding: '8px 24px 64px' }}>
         {error && <Body style={{ color: '#ff7676', marginTop: 16 }}>{error}</Body>}

package/.next/standalone/app/setup/page.js

@@ -203,6 +203,8 @@ function SetupInner() {
           WebkitBackgroundClip: 'text', WebkitTextFillColor: 'transparent',
         }}>Scan your network</h1>
       </header>
+      {/* The scan status bar sits here, under the header's buttons (ScanStatusBar.js). */}
+      <div id="scan-bar-slot" />
 
       <div style={{ maxWidth: 720, margin: '0 auto', padding: '32px 24px 64px' }}>
 
@@ -448,9 +450,10 @@ function SetupInner() {
                   <input type="checkbox" checked={experimental} disabled={running} style={{ marginTop: 3 }}
                     onChange={(e) => { setExperimental(e.target.checked); window.dispatchEvent(new Event('six-degrees:experimental')); }} />
                   <span>
-                    <b style={{ color: '#FFD700' }}>Experimental:</b> all-day pacing. Up to 10 pages in a sitting,
-                    then a 45-minute rest; searches only from 9:00 to 19:00; at the daily budget it waits for it to
-                    free up instead of stopping; and it saves every page. It also reads LinkedIn&rsquo;s own data beside
+                    <b style={{ color: '#FFD700' }}>Experimental:</b> all-day pacing. Up to 8 pages in a sitting,
+                    then an hour&rsquo;s rest; searches only from 9:00 to 18:00; never more than 40 searches in a day
+                    or 200 in a week, however high your budget; two days&rsquo; rest after any check from LinkedIn; at
+                    the budget it waits instead of stopping; and it saves every page. It also reads LinkedIn&rsquo;s own data beside
                     the page text, to fill gaps and measure how the two compare. It keeps running while the app is open.
                   </span>
                 </label>