six-degrees 0.4.8 → 0.4.10

package/.next/standalone/CHANGELOG.md

@@ -6,6 +6,54 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.10] - 2026-09-29
+
+### Changed
+- **The scan status bar is now a notch.** A small pill hangs from the bottom of the header,
+  centred, on every page. It shows nothing while nothing runs, only a tiny dimmed *Auto scan*
+  while the all-day mode waits, and while a scan runs, what it's doing with a thin progress
+  line. Hover or click to open it: who, today's searches, the latest line, *Details* and
+  *Stop*. Other long jobs show there too, starting with recording the Galaxy's replay.
+
+## [0.4.9] - 2026-09-29
+
+### Added
+- **Conversations, in the Social tab.** Every conversation with one of your connections, from your
+  export and the live messages sync: who it's with (name and tier), when it was last active, who
+  wrote last, unread, how many messages, and *Open on LinkedIn* (the thread when the sync found
+  its link, else their profile). Waiting on you comes first, then S and A tier, then the most
+  recent. Group conversations are shown and marked, and aren't counted in warmth. A search box
+  finds people by name.
+- **Keep my messages on this computer**, a switch that's off unless you turn it on. When it's on,
+  the messages themselves, what other people wrote to you included, are kept in the app's data
+  folder (a file of their own beside the Social tab's), and a conversation opens as a thread,
+  newest at the bottom, a page at a time so a thread of thousands opens as fast as a short one.
+  The search box then finds what was said, too. They're never sent anywhere, and "Save a copy of
+  my network" doesn't carry them (Settings says so). Switching it off asks first, then deletes
+  them; *Forget it* deletes them with everything else.
+- **The live messages sync reads a little more of the list.** Each conversation's link, whether
+  it's a group, and its newest message: who wrote last, which now feeds warmth and Waiting on you
+  where your export is missing or older, and its words, which go to the app only while Keep my
+  messages is on. It still opens no conversation, and its saved samples still keep no words.
+
+### Changed
+- **Auto scan is slower and has its own ceilings.** Sittings of 8 pages, then an hour's rest;
+  searches only from 9:00 to 18:00; never more than 40 searches in 24 hours or 200 in 7 days,
+  however high the daily budget is set (the account restricted on 28 September did 373 in a
+  day with the budget at 500); and two days with no searches after any check from LinkedIn.
+- **The scan status bar sits under the buttons.** On each page it now sits in its own row
+  under the header, pushing the page down instead of covering it. On Network Circle it floats
+  just under the header, measured, so a header that wraps to two rows no longer hides it.
+
+### Fixed
+- **The live messages sync keeps what it finds.** It read your conversations but matched none of
+  them: the pattern for a profile link never matched, and LinkedIn's messaging gives a member
+  link your connections list doesn't have. It now matches each person to your connections by
+  link, or by a name only one connection has (the name isn't kept), and scrolls the list's own
+  panel so more than the first 20 conversations load.
+- **Messaging samples keep no words.** The sync's saved samples of LinkedIn's data (for tuning
+  the reader) now drop every piece of writing and every name before they're saved.
+
 ## [0.4.8] - 2026-09-29
 
 ### Changed

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/GalaxyLab.js

@@ -12,6 +12,7 @@ import {
   layoutsNow, watchLayouts, saveLayout, applyLayout, forgetLayout, milestones,
 } from '../../lib/galaxy-lab';
 import { savePicture, recordReplay, canRecord } from '../../lib/galaxy-export';
+import { showActivity } from '../../lib/island';
 
 const noLayouts = [];
 
@@ -89,7 +90,9 @@ export default function GalaxyLab() {
   const run = async (what, job) => {
     setBusy(what);
     setNote(null);
-    try { await job(); } catch (e) { setNote(e.message || 'That didn’t work.'); } finally { setBusy(null); }
+    // A recording runs for the whole replay: the notch under the header shows it.
+    const done = what === 'video' ? showActivity({ id: 'replay-video', label: 'Recording the replay', detail: 'The video saves when it ends' }) : () => {};
+    try { await job(); } catch (e) { setNote(e.message || 'That didn’t work.'); } finally { setBusy(null); done(); }
   };
   const canReplay = clock.min != null && clock.max != null && clock.max > clock.min;
   const preset = FORCES.every((f) => lab[f.key] === LAB_DEFAULTS[f.key]) ? 'rings'

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

@@ -1,16 +1,21 @@
 'use client';
 
-// The scan status bar: while a scan runs, every page shows what it's doing,
-// for whom, how far it's got, and today's LinkedIn budget, with Stop. Stop
-// saves what was read, and the Scan page's Resume carries on from that page.
-// It sits just under the header's tabs (Network Circle, Degrees…), on every
-// page, the Scan page too (Blake, 2026-09-29). It only reports: the
-// pacing and the caps live in the scanner (scripts/scrape.py, lib/linkedin-limits.js).
+// The notch: a small pill hanging from the bottom of the header, centred, on
+// every page (Blake, 2026-09-29: "a notch ui of the thing scanning"). It stays
+// out of the way: nothing at all while nothing runs; a tiny dimmed "Auto scan"
+// when the all-day mode is on but idle; while a scan runs, what it's doing and
+// how far it's got. Hover or click it to open it: who, today's LinkedIn budget,
+// the latest line, Details and Stop. Stop saves what was read, and the Scan
+// page's Resume carries on from that page. Other long jobs can show here too
+// (lib/island.js). It only reports: the pacing and the caps live in the scanner
+// (scripts/scrape.py, lib/linkedin-limits.js).
 
 import { useEffect, useState, useSyncExternalStore } from 'react';
+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';
+import { watchActivities, activitiesNow, noActivities } from '../../lib/island';
 
 const WHAT = {
   full: 'Scanning your network',
@@ -34,63 +39,120 @@ const tone = (used, cap) => (!cap ? '#8b9a9a' : used / cap >= 0.9 ? '#ff6b6b' :
 export default function ScanStatusBar() {
   const [job, setJob] = useState(() => scannerNow());
   const [stopping, setStopping] = useState(false);
-  // 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 [open, setOpen] = useState(false);
+  const [pinned, setPinned] = useState(false);
   const allDay = useSyncExternalStore(watchAllDay, allDayNow, () => false);
+  const others = useSyncExternalStore(watchActivities, activitiesNow, noActivities);
   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,
-    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)',
-  };
-  if (!job?.running) {
-    if (!allDay) return null;
-    return (
-      <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>
-        <span style={{ color: '#8b9a9a' }}>ready · press Auto scan beside Scan to start</span>
-      </div>
-    );
-  }
 
-  const p = job.progress;
+  // Hangs from the header's bottom edge, measured: the header can load late,
+  // be swapped for a new one, or wrap to two rows.
+  const pathname = usePathname();
+  const [top, setTop] = useState(null);
+  useEffect(() => {
+    let header = null;
+    let ro = null;
+    let queued = 0;
+    const measure = () => {
+      queued = 0;
+      const now = document.querySelector('header');
+      if (now !== header) {
+        ro?.disconnect();
+        ro = null;
+        header = now;
+        if (header) { ro = new ResizeObserver(later); ro.observe(header); }
+      }
+      const at = header ? Math.round(header.getBoundingClientRect().bottom) : null;
+      setTop((was) => (was === at ? was : at));
+    };
+    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]);
+
+  const running = !!job?.running;
+  const other = others[others.length - 1] || null;
+  if (!running && !other && !allDay) return null;
+
+  const p = job?.progress;
   const step = p?.kind === 'batch' && p.total ? `${p.current || p.done || 0} of ${p.total}`
-    : p?.kind === 'walk' && p.total ? `${(p.done || 0).toLocaleString()} of ${p.total.toLocaleString()} read`
+    : p?.kind === 'walk' && p.total ? `${(p.done || 0).toLocaleString()} of ${p.total.toLocaleString()}`
     : p?.kind === 'saving' ? 'saving' : null;
-  const b = job.budget;
-  const last = [...(job.log || [])].reverse().find((l) => l && l.trim())?.trim();
+  const fraction = p?.total ? Math.min(1, (p.current || p.done || 0) / p.total) : other?.progress ?? null;
+  const b = job?.budget;
+  const last = running ? [...(job.log || [])].reverse().find((l) => l && l.trim())?.trim() : null;
+  const expanded = open || pinned;
+
+  // What the pill says, smallest first.
+  const dot = running ? '#00ff88' : other ? (other.tone === 'warn' ? '#FFD700' : '#3498DB') : '#556';
+  const label = running ? (WHAT[job.action] || 'Scanning') : other ? other.label : 'Auto scan';
+  const short = running ? step : other ? other.detail : null;
 
   return (
-    <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>
-      {job.target?.name && <span>{job.target.name}</span>}
-      {step && <span style={{ color: '#8b9a9a' }}>{step}</span>}
-      {b && (
-        <span style={{ color: tone(b.searches, b.cap) }} title="Searches on your LinkedIn account in the last 24 hours, and your daily budget">
-          {b.searches}{b.cap ? ` of ${b.cap}` : ''} searches today
-        </span>
+    <div
+      role="status"
+      aria-live="polite"
+      onMouseEnter={() => setOpen(true)}
+      onMouseLeave={() => setOpen(false)}
+      style={{
+        position: 'fixed', left: '50%', top: top ?? 'var(--scan-bar-top, 94px)', transform: 'translateX(-50%)', zIndex: 60,
+        maxWidth: 'calc(100vw - 32px)', minWidth: running || other ? 180 : 0,
+        padding: expanded ? '8px 14px 10px' : '4px 12px 6px',
+        borderRadius: '0 0 16px 16px', borderTop: 'none',
+        border: `1px solid ${running ? 'rgba(0,255,136,0.25)' : 'rgba(255,255,255,0.1)'}`,
+        background: 'rgba(8,10,22,0.96)', color: '#cfd8d8', fontSize: 12,
+        opacity: running || other || expanded ? 1 : 0.55,
+        boxShadow: running ? '0 6px 20px rgba(0,0,0,0.35)' : 'none',
+        transition: 'padding 0.18s ease, opacity 0.18s ease',
+      }}
+    >
+      <button
+        onClick={() => setPinned((v) => !v)}
+        aria-expanded={expanded}
+        title={expanded ? 'Close' : 'Open'}
+        style={{ display: 'flex', alignItems: 'center', gap: 8, width: '100%', background: 'none', border: 'none', color: 'inherit', font: 'inherit', cursor: 'pointer', padding: 0, whiteSpace: 'nowrap' }}
+      >
+        <span className={running ? 'notch-pulse' : undefined} style={{ width: 7, height: 7, borderRadius: '50%', background: dot, flexShrink: 0 }} />
+        <b style={{ color: running || other ? '#fff' : '#b8c4c4', fontWeight: 600 }}>{label}</b>
+        {short && <span style={{ color: '#8b9a9a' }}>{short}</span>}
+        {!running && !other && expanded && <span style={{ color: '#8b9a9a' }}>ready · press Auto scan beside Scan to start</span>}
+      </button>
+      {fraction != null && (
+        <div style={{ height: 2, marginTop: 5, borderRadius: 2, background: 'rgba(255,255,255,0.08)', overflow: 'hidden' }}>
+          <div style={{ width: `${Math.round(fraction * 100)}%`, height: '100%', background: running ? '#00ff88' : '#3498DB', transition: 'width 0.4s ease' }} />
+        </div>
       )}
-      {last && (
-        <span style={{ color: '#667', flex: '0 1 240px', minWidth: 0, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }} title={last}>
-          {last}
-        </span>
+      {expanded && running && (
+        <div style={{ display: 'flex', alignItems: 'center', gap: 12, marginTop: 8, flexWrap: 'wrap' }}>
+          {job.target?.name && <span>{job.target.name}</span>}
+          {b && (
+            <span style={{ color: tone(b.searches, b.cap) }} title="Searches on your LinkedIn account in the last 24 hours, and your daily budget">
+              {b.searches}{b.cap ? ` of ${b.cap}` : ''} searches today
+            </span>
+          )}
+          {last && (
+            <span style={{ color: '#667', maxWidth: 280, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }} title={last}>{last}</span>
+          )}
+          <Link href="/setup" style={{ color: '#3498DB', textDecoration: 'none' }}>Details</Link>
+          <button
+            onClick={async () => { setStopping(true); try { await stopScrape(); } catch { setStopping(false); } }}
+            disabled={stopping}
+            title="Stops after saving what's been read; Resume on the Scan page carries on from the same page"
+            style={{
+              padding: '3px 10px', borderRadius: 8, fontSize: 12, cursor: stopping ? 'default' : 'pointer',
+              background: 'rgba(255,107,107,0.12)', color: '#ff9b9b', border: '1px solid rgba(255,107,107,0.35)',
+            }}
+          >{stopping ? 'Stopping…' : 'Stop'}</button>
+        </div>
       )}
-      <Link href="/setup" style={{ color: '#3498DB', textDecoration: 'none' }}>Details</Link>
-      <button
-        onClick={async () => { setStopping(true); try { await stopScrape(); } catch { setStopping(false); } }}
-        disabled={stopping}
-        title="Stops after saving what's been read; Resume on the Scan page carries on from the same page"
-        style={{
-          padding: '4px 10px', borderRadius: 8, fontSize: 12, cursor: stopping ? 'default' : 'pointer',
-          background: 'rgba(255,107,107,0.12)', color: '#ff9b9b', border: '1px solid rgba(255,107,107,0.35)',
-        }}
-      >{stopping ? 'Stopping…' : 'Stop'}</button>
+      {expanded && !running && other?.detail && <div style={{ marginTop: 6, color: '#8b9a9a' }}>{other.detail}</div>}
     </div>
   );
 }

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/globals.css

@@ -42,3 +42,7 @@ html:has([data-field-question]) {
 /* Where the scan status bar sits: just under the header (app/components/ScanStatusBar.js). */
 :root { --scan-bar-top: 94px; }
 @media (max-width: 767px) { :root { --scan-bar-top: 66px; } }
+
+/* The notch's running dot (app/components/ScanStatusBar.js). */
+@keyframes notch-pulse { 50% { opacity: 0.35; } }
+@media (prefers-reduced-motion: no-preference) { .notch-pulse { animation: notch-pulse 1.6s ease-in-out infinite; } }

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

@@ -448,9 +448,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>