six-degrees 0.4.10 → 0.5.0

package/.next/standalone/CHANGELOG.md

@@ -6,6 +6,241 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.0] - 2026-10-02
+
+### Added
+- **Rank titles your way** (Settings → Scores → Titles). Set how much each kind of title counts, out
+  of 10, or start from a preset: Founders first, Investors, or A role I'm looking for. Add the roles
+  you're after ("account executive", "head of growth", "recruiter") with their own points, and
+  everyone whose title has those words rises, whatever their level: for outbound to one role, or
+  hiring for it. Saving rescores everyone and says how many people changed tier, and a card's score
+  says "your ranking" where it moved a title. Nothing set scores exactly as before.
+
+### Changed
+- **The Scan page is a launch, not a manual.** It opens with what the scanner is and what it never does
+  (never posts or messages anyone, never sees your password, nothing leaves this Mac, stops when you
+  say), then the four steps on a rail: Get ready, Sign in, Who you know, Who they know. The one
+  you're on pulses, with one big button that does it and how long it takes; any other opens with a
+  tap. While it runs, "Your scanner is working" and Stop sit right under the step. How many people
+  this round and who first are beside the radar; the daily budget, how much of each list, the hidden
+  window, retrying hidden lists and paused lists are in Fine-tune, closed until you want them. The
+  log is one tap away, and opens by itself when a run stops badly. Scan has the same header as every
+  page now.
+- **Paths reads like Network Circle.** Its notch is now Map and Companies: companies count for more
+  than industries, and an industry opens from a company's card (its industry is a link there). Whether
+  the map's bubbles are companies or your connections (what was the People tab) is a switch at the
+  top of the Filters panel. Filters use the same tiers × degrees grid as Network Circle. Colour is by
+  sector or by **Heat**: for companies, how strong your people there are (the average power of the
+  five strongest); for people, how strong their cluster is, person for person; size still says how
+  many. And **Physics**: switch it to Live to drag bubbles (the ones joined to them follow) and change
+  Spread, Pull to their group and Pull along lines. Still, as before, is the default. Old links to
+  the People or Industries tab still land on the map.
+- **Heat: power as a thermal map.** A new Colour by in Network Circle's Physics: every dot coloured
+  from cold violet through red and orange to white hot by where their power score ranks among the
+  people showing, with a soft glow behind the hotter ones that pools where powerful people cluster,
+  like a thermal camera. Works with every layout, the replay and the filter grid.
+- **Separation all the way right counts every mutual, scanned or not.** It aims at whoever you share
+  the most mutual connections with, even when most of them are in circles you haven't scanned: an
+  unscanned mutual is still a likely introduction, so it no longer holds someone back. The ones the
+  app can draw are lines as before; the rest are grey dots, each with a faint line in, with "+37 more
+  mutuals, in circles not scanned yet". The person glows less the less of it is scanned. The Next
+  names are in the same order and say their mutual counts. Narrow the tiers (S only, say) first to
+  aim at the strongest.
+- **The right panel follows the circle you're in.** Open someone's circle in Bridge Chains and the
+  panel is about them: how many people are in their circle, tier chips to see just one tier, a
+  search inside it, the people you added from it (with Scan… for the ones ready), then everyone
+  else in it, strongest first. Click anyone for their card.
+- **Orbit is a layout of the Galaxy now**, in Physics next to Rings and Clusters, not a separate
+  view: every tier held on its own orbit, S nearest you, and each connection's circle tucked in
+  behind them. It's still the Galaxy, so you can drag dots and move every slider on it.
+- **Light up a branch on hover starts off.** It dimmed and relit thousands of dots on every hover,
+  which flickered; it's still in Physics if you want it, and moving from one dot to the next no
+  longer flashes the whole Galaxy in between.
+- **Social is part of Outlink.** Outlink has the same header as every page, and its views sit in
+  the notch: Circles, To add, Pending, and Messages & follow-ups, which is the whole Social tab (your
+  LinkedIn export, the live messages sync, the CRM with its inbox, follow-ups, pipeline, sent and
+  received). Adding people and keeping track of them are now one place. The Social tab is gone from
+  the header, and old links to it land on Messages & follow-ups.
+- **Notifications open.** Click one and it takes over the right panel with the detail: who it is
+  about, their tier and score, who you met them through, and, for an S or A, that they're a
+  valuable person to know; with buttons to open their card, their circle in Bridge Chains, or
+  them in Separation. A notification naming several people lists them all.
+- **New notifications:** someone you met through a bridge added you back ("Ana added you back,
+  through Yuki"); a circle scan found people at top companies (a company score of 8 or more), named
+  in one notification; and a scan finished ("Scan done: Yuki's circle", "Check for new: done").
+  Accepted requests and high-value new connections now say who they are about, and older ones are
+  matched by the name in their title.
+- **Paths has the same header as the map.** The app's tabs stay at the top, with Paths lit, and Map,
+  People, Industries and Companies sit in the notch under them, as the map page's views do; a tab
+  for Network Circle, Degrees or Separation takes you straight to it. Paths' filters moved into a
+  Filters panel on the left, like the map page's, with new ways to read the map: what a bubble's
+  size means (your people there, the S and A among them, or the ones you already know; on People,
+  cluster value, size or S tier) and which names show (the biggest, all, or none).
+- **All the way to easy, Separation aims at whoever the most of your connections lead to**, with
+  every one of those lines drawn, the strongest first among equals; the "Next" names are the
+  runners-up by the same measure. It used to aim at the top of the list, which could be someone
+  with many mutual connections by LinkedIn's count but only one the app could draw.
+- **The Scan page has a radar, and a speed: Slow, Medium or Fast.** Mapping the 2nd degree starts
+  from a round Scan button in the middle of a radar: its sweep turns while a scan runs, and the
+  ring round it fills with today's searches against your budget. Beside it, three speeds. Fast is
+  how the scanner has always run, and nothing is faster; Medium waits 45 seconds before each page
+  of results and 3 minutes after every 10, Slow 90 seconds and 5 minutes, and both keep profiles
+  further apart (90 and 120 seconds). Each says about how many searches an hour it makes and how
+  long the rest of today's budget would take. The daily budget stays the cap at every speed:
+  slower spreads it out, it doesn't shrink it. The speed is saved with the budget and the scanner
+  says which it is using at the start of every run; the Scan page's time estimates follow it.
+- **Scores moved into Settings.** Your field, how tiers are graded and every company's score are a
+  Scores section in Settings (the gear), and the Scores tab is gone from the header. Old links to
+  the Scores tab land in the same place in Settings.
+- **Profile has Insights.** An Insights button beside Profile shows network health: how much of
+  your 2nd degree you reach two or more ways, the effective reach of your connections, and the
+  connections who reach the most people no one else does. It was at the top of the Scores tab.
+- **Paths → People.** A new view beside the company map, drawn the same way but with your
+  connections as the bubbles: each is sized by the value of the cluster behind them (S tier counts
+  3, A tier 2, everyone else 1; or by cluster size, or by S tier inside), coloured by their sector
+  and grouped like the companies. A white centre is the share of their cluster you can only reach
+  through them, a gold ring means S-tier people inside, and a line joins two connections whose
+  clusters share people. Point at someone for their numbers and how their cluster compares to the
+  rest you've scanned; click to open it in Bridge Chains. Shows the connections you've scanned,
+  or all of them, with the ones not scanned yet as small grey dots.
+- **Separation's map draws connections as pills and people as cards** on a computer (a phone keeps
+  the dots). Each connection shows their initials, tier and what they are to the people on the
+  map: the only door to someone, the best way in for some, or only another way in; the ones with
+  a solid line are lit. Each person is a card with rank, role, score and how many ways in. With
+  the slider all the way to easy, the one person becomes a large card with LinkedIn's mutual
+  count and how many of those are drawn. Everything still glides as the slider moves.
+- **Separation's list is a ledger.** A title bar says how many are shown and that the order
+  follows the slider. The way in shows the connection's face with "only way in" or how many more
+  ways there are under it, a new column shows how rare the way in is as a bar (full and cyan for
+  one door, short and orange for the warmest), and the power score sits beside its bar.
+- **Separation is a tab of its own**, beside Degrees in the header, instead of a view inside
+  Degrees. It uses the same Filters grid as Degrees. Degrees keeps Bridge Chains, Pyramid and List.
+- **Separation has a slider.** One slider reorders everyone as you drag it: the rarest ways in
+  at one end (strong people only one of your connections knows), the easiest at the other
+  (strong people you share the most mutual connections with), and each person's own score alone
+  in the middle, as the list has always been. A line under it says in words what it is
+  surfacing. It only reorders: scores, tiers and ranks stay as they are, and it claims no odds.
+  Double-click the slider, or tap 50, to go back to the middle. It replaces the Power / Ways in
+  switch. The tier chips and the rarity chips ("Only show") sit in the same card.
+- **Separation's map follows the slider, and glides.** From the rare end to the middle it fans out
+  to ten people, each with the one or two doors that lead to them. Towards the easy end it
+  closes in on fewer people, and at the end on one: the person you're aiming at, with rings
+  round them and every connection of yours who leads to them drawn in, the top-scored one solid.
+  As the slider moves, people, connections and lines slide to their new places and newcomers
+  fade in (still, with Reduce Motion on). Pick anyone in the list, or one of the "Next" names
+  under the map, to aim at them instead. Beside each name it says how many mutual connections
+  lead to them: "only way in", "3 ways in", or, where LinkedIn's own count is higher than the
+  connections the app can draw, "37 mutuals · 6 mapped".
+- **Path, in Separation.** A Path button beside the tier chips narrows everyone to one sector or
+  one company. The picker opens under the button with the sectors (inferred, as in Paths), the
+  biggest companies and a box to type in, and goes away once you've picked; the button then
+  shows your pick with a × to clear it.
+- **Separation's heading no longer sits under the notch.**
+- **One filter for tiers and degrees, the same in Network Circle and in Degrees.** The Filters
+  panel shows the five tiers as bigger rows, each with six dots, one for each degree. Tap a tier
+  to hide or show it, as before. Tap a dot to show or hide that degree for that tier alone:
+  S tier at 2nd degree without everyone else's, say. Tap a number at the top to switch a degree
+  for every tier at once. A dot with nobody behind it is faint and can't be tapped, each row
+  says how many people it is showing, and the last people on screen can't be switched off.
+  Network Circle starts with your own connections; Degrees starts with everything. In Degrees
+  the rows used to pick one bridge tier at a time; now 1st degree is your bridges and 2nd is
+  the people in their circles, each by their own tier.
+- **The Galaxy's physics is the main thing in Network Circle's Filters panel.** The sliders,
+  layouts, colours, find and replay sit straight in the panel under the tiers, always on, with
+  no switch to turn on first and no "experimental" box. With no slider moved the Galaxy is laid
+  out as before; pointing at a dot now lights up its branch unless you turn that off.
+- **Pyramid and List left Network Circle.** Its views are the Galaxy and Orbit. Pyramid and List
+  stay in Degrees.
+- **An opened circle shows the chains that lead on from it.** Anyone you added from that circle
+  and then scanned keeps their dot in the circle, and the cluster their scan formed sits outside
+  it, joined to that dot by a line, so you can see where each path came from. Inside a cluster,
+  anyone you added and scanned in turn has their own dot marked and a line on to their cluster,
+  for as far as your scans reach. Every dot in a cluster is joined to its middle by a faint line.
+  Each cluster says whose circle it is, how many are in it and which degree that is. Point at
+  one and the way back to the middle lights up; click and it opens with the whole trail. The
+  people you added sit together on the side the chains lead off to, their names taking turns
+  above and below so they don't overlap, and the view zooms to fit when it opens.
+- **Bridge Chains shows the bridges you connected with yourself.** Someone you met through a
+  bridge's circle is a link in that bridge's chain, not a bridge of their own: they're inside its
+  circle.
+- **A bridge's ring now counts the people you added through it.** The ring sits tight on the
+  dot, with one bar for each person: orange once they've been scanned and have a cluster of
+  their own, green while they're ready for a scan. A small green number at the top right says
+  how many are ready, in place of the "ready" label. How much of a bridge's own list is scanned
+  is in its tooltip.
+- **A crowded Bridge Chains is easier to read.** When your bridges need more than one ring, the
+  rings sit further apart, each with its own guide line, and the counts under each name wait
+  until you point at the bridge.
+- **Orbit moved to Network Circle.** It shows the size of every circle at once, which is a
+  picture of the network, not a way to follow a chain. The corner switch in Degrees is gone.
+- **Views are in the notch, under the tabs.** Galaxy, Orbit, Pyramid and List in Network Circle,
+  and Bridge Chains, Separation, Pyramid and List in Degrees, switch from the notch that hangs
+  under the top tabs, instead of a list at the top of the Filters panel. A scan's progress
+  shows in the same notch, beside them. The Filters panel now only filters.
+
+### Fixed
+- The scanner's log, shown on the Scan page, says "scanning" throughout; a few lines still said the
+  old word.
+- The "Scanning…" dot in the right panel pulses again; the animation it named was never defined.
+- **Separation's map lines now meet every box.** Each connection sits level with the people it
+  leads to, so a connection with one person is on that person's row and the line between them runs
+  straight; lines start and end exactly on the pill and the card, with a small dot where they plug in.
+- **"Hide the Chrome window while scanning" did nothing for scans started on the Scan page.**
+  Its own buttons (Scan, Check for new, Auto scan and the rest) sent their request without the
+  setting, so Chrome opened anyway; only scans started from a person's card or Resume were hidden.
+  Every scan start now goes through one place that adds it.
+- **"Only way in" could show beside someone with two ways in drawn.** Rarity trusted the mutual
+  count a scan saved even when the app had since found them through more of your connections
+  than that. It now takes whichever is larger.
+
+## [0.4.11] - 2026-09-29
+
+### Added
+- **The Social tab is a personal CRM.** Everyone you've been in touch with on LinkedIn is one contact,
+  connection or not: a list on the left with views and a search box, the person on the right (stacked
+  on a phone). The views:
+  - **Inbox:** they wrote last, or there's something unread. Unread first.
+  - **Awaiting reply:** you wrote last and nothing came back for 7 days or more (you can change the 7).
+  - **Follow-ups due:** a follow-up date of today or before.
+  - **Pipeline:** a board of the people you've given a stage.
+  - **Sent:** connection requests you sent (from your export's Invitations.csv, with the date, and the
+    note you wrote if Keep my messages is on), requests the app tracked (*Mark sent*), each accepted
+    once they're a connection and pending until then, and messages awaiting a reply.
+  - **Received:** requests to you from people who aren't connections yet.
+  - **All:** everyone and every group conversation, newest first.
+
+  Each person's panel shows their tier, company and how you're connected (and who can introduce you,
+  for 2nd degree), their conversations (the messages themselves if you keep them), requests both ways,
+  and **your own stage** (New, Contacted, Replied, Meeting, Won/Partner, Not now; it suggests one),
+  **tags**, **notes** and **next follow-up date**. Those are yours, so they're always kept, in a file of
+  their own per profile in the app's data folder, and never sent anywhere. Search covers names,
+  companies, tags and notes, and what was said while the messages are kept; in All it finds anyone in
+  your network, so you can add a note before you've written to them. **Export CSV** saves the table
+  (name, company, profile, connection, stage, tags, last contact, who wrote last, next follow-up,
+  notes) as a spreadsheet file. The list shows 100 at a time, so thousands of conversations stay quick.
+- **Every conversation in your export, not just your connections'.** People who aren't connections
+  are listed by the name the export gives them, marked *Not a connection*, with their profile link when
+  it has one. Past (archived), current and ones only you wrote in are all there, from every folder;
+  group conversations are listed and marked; Sponsored Messages and InMails are marked, and adverts are
+  kept out of the Inbox. Unsent drafts are left out and said so.
+- **Read my whole history**, beside *Sync messages now*: the live messages sync keeps scrolling your
+  messages list until no new conversations load (at most 60 scrolls, about 1,000 conversations), at the
+  same slow, fixed pace, with no random waits. The daily sync still reads just the top. The sync now
+  also brings in people who aren't your connections (with their name) and group conversations (without
+  any words), and each sync adds to what earlier ones found instead of replacing it.
+- **Delete my CRM notes**, and *Forget it* asks, separately, whether to delete them too, so notes
+  aren't lost by accident.
+
+### Changed
+- **"Save a copy of my network" carries the Social tab too.** A new box, ticked by default,
+  adds its findings, your CRM stages, tags, notes and follow-ups, and any messages you keep,
+  so moving to a new computer brings everything. Importing the copy puts them in place and
+  keeps this computer's beside the old network. Untick it to leave them behind.
+- **Waiting on you has become the CRM's Inbox**, and Conversations is part of the CRM.
+- **The Social tab keeps the names of people who aren't your connections**, from your export and the
+  sync, since nothing else in the app says who they are. A connection's name still isn't copied: the
+  app has it already.
+
 ## [0.4.10] - 2026-09-29
 
 ### Changed

package/.next/standalone/app/api/data/export/route.js

@@ -20,6 +20,7 @@ export async function POST(request) {
   let body = {};
   try { body = await request.json(); } catch { /* no options: the defaults */ }
   const includePhotos = body?.photos !== false;
+  const includeSocial = body?.social !== false;
 
   const dir = dataDir();
   sweepLeftovers(dir);
@@ -27,7 +28,7 @@ export async function POST(request) {
   try {
     const file = path.join(work, 'export.sixdegrees');
     const made = buildExport(getDb(), {
-      dir, outFile: file, includePhotos, appVersion: APP_VERSION, schemaSql: SCHEMA_SQL,
+      dir, outFile: file, includePhotos, includeSocial, appVersion: APP_VERSION, schemaSql: SCHEMA_SQL,
     });
     const fd = openSync(file, 'r');
     rmSync(work, { recursive: true, force: true });

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

@@ -2,6 +2,7 @@ import { db as supabase } from '../../../lib/db';
 import { uniqueByProfile, splitAlreadyConnected, toIsoDate, refreshNotifications, mutualCountOf } from '../../../lib/ingest';
 import { tiePairs } from '../../../lib/ties';
 import { promoteToFirstDegree } from '../../../lib/promote';
+import { addedBackNotification, topCompanyNotification } from '../../../lib/notifications';
 import { localPhoto } from '../../../lib/photos';
 
 function parseHeadline(h) {
@@ -113,6 +114,8 @@ export async function POST(request) {
     const newRecords = records.filter(r => !existingUrls.has(r.profile_url));
     const existingRecords = records.filter(r => existingUrls.has(r.profile_url));
     let promoted = 0;
+    // Who was promoted, and through whom, for an "added you back" notification once they're rescored.
+    const addedBack = [];
 
     // Someone you met through a bridge and have now actually connected with.
     //
@@ -144,7 +147,7 @@ export async function POST(request) {
             ...(rec.profile_image_url ? { profile_image_url: rec.profile_image_url } : {}),
           },
         });
-        if (res.promoted) promoted += 1;
+        if (res.promoted) { promoted += 1; addedBack.push(res); }
       }
     }
 
@@ -240,6 +243,41 @@ export async function POST(request) {
       } catch (e) { /* notifications are optional */ }
     }
 
+    // A circle scan that found people at top companies: one notification naming them (lib/notifications.js).
+    if (degree === 2 && bridgeId && newRecords.length) {
+      try {
+        const found = [];
+        const urls = newRecords.map((r) => r.profile_url).filter(Boolean);
+        for (let i = 0; i < urls.length; i += 100) {
+          let q = supabase.from('linkedin_connections').select('id, name, company, company_prestige_score, power_score, tier')
+            .in('profile_url', urls.slice(i, i + 100)).eq('source_connection_id', bridgeId);
+          if (userId) q = q.eq('user_id', userId);
+          const { data } = await q;
+          found.push(...(data || []));
+        }
+        const { data: via } = await supabase.from('linkedin_connections').select('id, name').eq('id', bridgeId).single();
+        const note = topCompanyNotification({ people: found, via, userId });
+        if (note) await supabase.from('notifications').insert([note]);
+      } catch (e) { /* notifications are optional */ }
+    }
+
+    // Someone you met through a bridge who is now a connection: "added you back, through …".
+    if (addedBack.length) {
+      try {
+        const rows = [];
+        for (const res of addedBack.slice(0, 10)) {
+          const { data: person } = await supabase.from('linkedin_connections')
+            .select('id, name, tier, power_score, headline, unlocked_from_bridge_id').eq('id', res.id).single();
+          if (!person) continue;
+          const viaId = res.originId ?? person.unlocked_from_bridge_id;
+          const via = viaId != null ? { id: viaId, name: res.originName || null } : null;
+          const note = addedBackNotification({ person, via, userId });
+          if (note) rows.push(note);
+        }
+        if (rows.length) await supabase.from('notifications').insert(rows);
+      } catch (e) { /* notifications are optional */ }
+    }
+
     // Auto-detect accepted pending requests: if a pending person just showed up as d1
     if (degree === 1 && records.length > 0) {
       try {
@@ -286,6 +324,7 @@ export async function POST(request) {
               title: `${p.name} accepted! +${XP_ACCEPT[p.tier] || 5} XP`,
               message: `${p.tier}-Tier connection — bridge their cluster to reach D3`,
               icon: '🤝',
+              data: { personId: p.id, viaId: p.source_connection_id ?? null, tier: p.tier ?? null },
             }))
           ).catch(() => {});
         }

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

@@ -7,6 +7,8 @@ import { scanProgress } from '../../../lib/scan-progress';
 import { linkedinState, writeLimits, liftCooldown } from '../../../lib/linkedin-limits';
 import { pausedList, readProgress, readUnclear } from '../../../lib/paused';
 import { getDb } from '../../../lib/db-client';
+import { db as notesDb } from '../../../lib/db';
+import { scanDoneNotification } from '../../../lib/notifications';
 import { registerScanState } from '../../../lib/scan-state';
 import { pendingImport } from '../../../lib/data-import';
 import { waitingPhotoCount } from '../../../lib/photos';
@@ -422,8 +424,12 @@ const ACTIONS = {
   company:       { flag: '--company',  needsName: true, label: 'Scanning' },
   // Photos an older version kept as links to LinkedIn: saved here, once each.
   // No browser, no search; every scan does the same at its end.
-  // Experimental, for the Social tab: your messages list, once (who, when, unread; never text).
+  // Experimental, for the Social tab: your messages list, once (who, when, unread; the
+  // newest message's words only while Keep my messages is on).
   messages:      { flag: '--messages',    label: 'Reading your messages list' },
+  // The same, scrolling until the whole list has loaded (60 scrolls or about
+  // 1,000 conversations at most), for the Social tab's "Read my whole history".
+  'messages-full': { flag: '--messages --full-history', label: 'Reading your whole messages history' },
   photos:        { flag: '--save-photos', label: 'Saving profile photos to this computer' },
 };
 
@@ -536,7 +542,7 @@ export async function POST(request) {
 
   // The two settings a person changes here. Neither starts anything.
   if (action === 'set-limits') {
-    const limits = writeLimits(dataDir(), { daily: body.daily, monthly: body.monthly, profiles: body.profiles });
+    const limits = writeLimits(dataDir(), { daily: body.daily, monthly: body.monthly, profiles: body.profiles, pace: body.pace });
     return Response.json({ ok: true, limits });
   }
   if (action === 'lift-cooldown') {
@@ -708,6 +714,7 @@ export async function POST(request) {
       const reason = state.stderrTail.filter((l) => !/Warning|warnings\.warn\(/.test(l)).slice(-6);
       state.failure = reason.length ? reason : null;
     }
+    const stopped = state.stopping;
     push(state.stopping ? 'Stopped.' : code === 0 ? 'Finished.' : `Stopped (exit ${code}).`);
     state.stopping = false;
     state.running = false;
@@ -717,6 +724,9 @@ export async function POST(request) {
     state.recent = [{
       action: state.action, target: state.target, startedAt: state.startedAt, exitCode: code, failure: state.failure,
     }, ...state.recent].slice(0, 5);
+    // A scan that finished leaves a notification ("Scan done: …"); a stop or a failure doesn't.
+    const done = scanDoneNotification({ action: state.action, target: state.target, exitCode: code, stopped, log: state.log.slice(-12), userId: profileId || null });
+    if (done) Promise.resolve(notesDb.from('notifications').insert([done])).catch(() => {});
     // A setup's private folder (the download and what was unpacked from it).
     if (cleanup) {
       try { cleanup(); } catch { /* swept at the next setup (sweepSetupLeftovers) */ }

package/.next/standalone/app/api/settings/sector-preview/route.js

@@ -1,5 +1,5 @@
 import { getDb } from '../../../../lib/db-client';
-import { companyOverrides, readForScoring, scoringRows, sectorFocusOf, tierScaleOf } from '../../../../lib/rpc';
+import { companyOverrides, readForScoring, scoringRows, sectorFocusOf, tierScaleOf, titleRankingOf } from '../../../../lib/rpc';
 import { parseSectorFocus, previewSectorFocus } from '../../../../lib/sector-focus';
 
 // Scores → Your sector, before you save: what a sector focus would change,
@@ -32,6 +32,7 @@ export async function POST(request) {
       from: sectorFocusOf(db),
       to,
       tierScale: tierScaleOf(db),
+      titles: titleRankingOf(db),
     }));
   } catch (err) {
     return Response.json({ error: err.message }, { status: 500 });

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

@@ -0,0 +1,37 @@
+import { rmSync } from 'node:fs';
+import { cleanCrm, patchCrm, emptyCrm } from '../../../../lib/social-crm';
+import { socialFiles, readJson, writeJsonAtomic } from '../../../../lib/social-store';
+
+// The Social tab's CRM: your own stage, tags, notes and next follow-up for each
+// person, in crm-<profile>.json in the data folder (lib/social-crm.js has the
+// shape). Yours, so always kept, whatever Keep my messages says; never sent
+// anywhere, and not in "Save a copy of my network".
+//
+//   GET     the whole store
+//   PATCH   { key, set: { stage?, tags?, notes?, followUp? } } one person's
+//           fields (null or '' clears one), or { settings: { awaitDays } }
+//   DELETE  the file gone: only when you've said so, on its own confirm
+
+export async function GET() {
+  const files = socialFiles();
+  if (!files) return Response.json({ crm: emptyCrm() });
+  return Response.json({ crm: cleanCrm(readJson(files.crm, null)) });
+}
+
+export async function PATCH(request) {
+  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 }); }
+  // Read, change one person, write whole: two quick edits in a row can't
+  // leave half a file, and the second sees the first (Node runs one at a time).
+  const next = patchCrm(readJson(files.crm, null), { key: body?.key, set: body?.set, settings: body?.settings });
+  writeJsonAtomic(files.crm, next);
+  return Response.json({ ok: true, entry: body?.key ? next.people[body.key] || null : null, settings: next.settings });
+}
+
+export async function DELETE() {
+  const files = socialFiles();
+  if (files) rmSync(files.crm, { force: true });
+  return Response.json({ ok: true });
+}

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

@@ -7,11 +7,14 @@ import { socialFiles, readJson, writeJsonAtomic, readMessages, deleteMessages }
 // two files and why they're apart).
 //
 //   GET                       the list, no words: who, when, who wrote last,
-//                             unread, how many, the thread's link
+//                             unread, how many, the thread's link; with the
+//                             requests both ways and people's names, and the
+//                             requests' notes when the messages are kept
 //   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
+//   PUT                       an import's request notes
 //   DELETE                    the messages gone, the list kept
 //
 // Nothing here goes anywhere but this computer's browser: no route of the app
@@ -25,14 +28,20 @@ function state() {
   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) };
+  const kept = keep ? readMessages(files.messages) : { threads: {}, previews: {}, invites: {} };
+  const names = { ...(social.names || {}) };
+  for (const [link, v] of Object.entries(social.liveOthers || {})) if (v?.name && !names[link]) names[link] = v.name;
+  for (const g of social.liveGroups || []) for (const [link, n] of Object.entries(g.names || {})) if (!names[link]) names[link] = n;
+  const list = conversationList(social.conversations, social.live, { others: social.liveOthers, groups: social.liveGroups, names: social.names });
+  return { files, social, keep, kept, names, list };
 }
 
 /** 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;
+  // The sync's newest message is kept by the link it gave: for someone who
+  // isn't a connection that can differ from the export's (liveKey).
+  const preview = !c.group && c.people.length === 1 ? kept.previews[c.people[0]] || (c.liveKey && kept.previews[c.liveKey]) : null;
   if (preview?.text && (!msgs.length || (preview.t || 0) > (msgs[msgs.length - 1].t || 0))) return [...msgs, preview];
   return msgs;
 }
@@ -70,7 +79,13 @@ export async function GET(request) {
     title: s.kept.threads[c.id]?.title || '',
     hasText: s.keep && messagesOf(c, s.kept).length > 0,
   }));
-  return Response.json({ keepMessages: s.keep, conversations });
+  return Response.json({
+    keepMessages: s.keep,
+    conversations,
+    invitations: Array.isArray(s.social.invitations) ? s.social.invitations : [],
+    names: s.names,
+    inviteNotes: s.keep ? s.kept.invites || {} : {},
+  });
 }
 
 /** One message as it's kept, or null when it isn't one. */
@@ -97,8 +112,9 @@ export async function POST(request) {
   }
   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 || {} };
+    // A new import replaces the export's messages; the live sync's previews
+    // and the requests' notes (PUT) stay.
+    into = { threads: {}, previews: s.kept.previews || {}, invites: s.kept.invites || {} };
   } 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 });
@@ -114,7 +130,8 @@ export async function POST(request) {
     }
   }
   if (part === parts - 1) {
-    writeJsonAtomic(s.files.messages, into);
+    // The notes may have changed while the parts came in: the file's win.
+    writeJsonAtomic(s.files.messages, { ...into, invites: readMessages(s.files.messages).invites || into.invites || {} });
     rmSync(s.files.incoming, { force: true });
   } else {
     writeJsonAtomic(s.files.incoming, into);
@@ -122,6 +139,25 @@ export async function POST(request) {
   return Response.json({ ok: true, part, parts, done: part === parts - 1 });
 }
 
+// An import's request notes: { invites: { id: note } }, the words sent with a
+// connection request (Invitations.csv's Message). Written by a person like a
+// message, so kept only while Keep my messages is on, in the same file, and
+// gone with it. They replace the notes kept before: an export has all of them.
+export async function PUT(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 invites = {};
+  for (const [id, note] of Object.entries(body?.invites && typeof body.invites === 'object' ? body.invites : {}).slice(0, 50000)) {
+    if (id && id.length <= 400 && typeof note === 'string' && note.trim()) invites[id] = note.slice(0, 2000);
+  }
+  const kept = readJson(s.files.messages, {}) || {};
+  writeJsonAtomic(s.files.messages, { threads: kept.threads || {}, previews: kept.previews || {}, invites });
+  return Response.json({ ok: true, notes: Object.keys(invites).length });
+}
+
 // 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() {