six-degrees 0.4.10 → 0.5.0

package/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/lib/chain-layout.js

@@ -17,19 +17,19 @@ function capacity(radius, spacing, sweep) {
   return Math.max(1, sweep >= TAU - 1e-9 ? Math.floor(arc / spacing) : Math.floor(arc / spacing) + 1);
 }
 
-/** The rings from `inner` outwards, `spacing` apart, until `n` dots fit. */
-function ringsFor(n, inner, spacing, sweep) {
+/** The rings from `inner` outwards, `gap` apart (at least `spacing`), until `n` dots fit. */
+function ringsFor(n, inner, spacing, sweep, gap = spacing) {
   const radii = [];
   let room = 0;
-  for (let r = inner; room < n; r += spacing) {
+  for (let r = inner; room < n; r += Math.max(spacing, gap)) {
     radii.push(r);
     room += capacity(r, spacing, sweep);
   }
   return radii;
 }
 
-const outerOf = (n, inner, spacing, sweep) => {
-  const radii = ringsFor(n, inner, spacing, sweep);
+const outerOf = (n, inner, spacing, sweep, gap) => {
+  const radii = ringsFor(n, inner, spacing, sweep, gap);
   return radii[radii.length - 1];
 };
 
@@ -46,43 +46,44 @@ const outerOf = (n, inner, spacing, sweep) => {
  * neighbouring rings don't line up in spokes.
  *
  * `start` and `sweep` fill an arc instead of the whole circle, each ring from
- * its middle outwards.
+ * its middle outwards. `ringGap` keeps the rings at least that far apart, for
+ * dots that carry a name under them and need the room.
  *
  * @returns {{ spacing: number, inner: number, rings: { radius: number, count: number }[],
  *   points: { x: number, y: number, angle: number, ring: number }[] }}
  */
 export function ringLayout(n, {
   inner, outer, spacing, minSpacing = spacing / 3, innerMin = inner,
-  start = -Math.PI / 2, sweep = TAU,
+  start = -Math.PI / 2, sweep = TAU, ringGap = 0,
 } = {}) {
   const count = Math.max(0, Math.floor(n) || 0);
   if (!count) return { spacing, inner, rings: [], points: [] };
 
   let s = spacing;
   let r0 = inner;
-  if (outerOf(count, r0, s, sweep) > outer) {
+  if (outerOf(count, r0, s, sweep, ringGap) > outer) {
     // Start further in, as far as innerMin, before closing anything up.
-    if (outerOf(count, innerMin, s, sweep) <= outer) {
+    if (outerOf(count, innerMin, s, sweep, ringGap) <= outer) {
       let lo = innerMin, hi = inner;
       for (let i = 0; i < 24; i++) {
         const mid = (lo + hi) / 2;
-        if (outerOf(count, mid, s, sweep) <= outer) lo = mid; else hi = mid;
+        if (outerOf(count, mid, s, sweep, ringGap) <= outer) lo = mid; else hi = mid;
       }
       r0 = lo;
     } else {
       r0 = innerMin;
       let lo = minSpacing, hi = spacing;
-      if (outerOf(count, r0, lo, sweep) <= outer) {
+      if (outerOf(count, r0, lo, sweep, ringGap) <= outer) {
         for (let i = 0; i < 24; i++) {
           const mid = (lo + hi) / 2;
-          if (outerOf(count, r0, mid, sweep) <= outer) lo = mid; else hi = mid;
+          if (outerOf(count, r0, mid, sweep, ringGap) <= outer) lo = mid; else hi = mid;
         }
       }
       s = lo;
     }
   }
 
-  const radii = ringsFor(count, r0, s, sweep);
+  const radii = ringsFor(count, r0, s, sweep, ringGap);
   const caps = radii.map((r) => capacity(r, s, sweep));
   const room = caps.reduce((a, b) => a + b, 0);
 
@@ -162,8 +163,9 @@ const TIER_BANDS = ['S', 'A', 'B', 'C', 'D'];
  *
  * @returns {{ spacing: number, edge: number, bands: { tier: string, inner: number, outer: number }[],
  *   points: { x: number, y: number, angle: number, slot: number }[] }}
+ * `start` is the angle each ring's first dot sits at (the top, unless told).
  */
-export function tierBandLayout(rows, { inner, outer, spacing, minSpacing = spacing / 3, gap = spacing }) {
+export function tierBandLayout(rows, { inner, outer, spacing, minSpacing = spacing / 3, gap = spacing, start = -Math.PI / 2 }) {
   const groups = TIER_BANDS.map((tier) => ({ tier, idx: [] }));
   rows.forEach((row, i) => {
     const t = TIER_BANDS.indexOf(row?.tier);
@@ -175,7 +177,7 @@ export function tierBandLayout(rows, { inner, outer, spacing, minSpacing = spaci
     const bands = [];
     let r = inner;
     for (const g of used) {
-      const l = ringLayout(g.idx.length, { inner: r, outer: Infinity, spacing: s, minSpacing: s });
+      const l = ringLayout(g.idx.length, { inner: r, outer: Infinity, spacing: s, minSpacing: s, start });
       g.idx.forEach((rowIndex, j) => {
         const p = l.points[j];
         points[rowIndex] = { x: p.x, y: p.y, angle: p.angle, slot: TAU / l.rings[p.ring].count };
@@ -201,28 +203,96 @@ export function tierBandLayout(rows, { inner, outer, spacing, minSpacing = spaci
 }
 
 /**
- * The people behind each person in an opened circle: their own circle, drawn
- * as a fan of small dots beyond `from`, centred on that person's angle and no
- * wider than their slot (at most a sixth of the circle), so each fan sits
- * behind its own person. At most `cap` dots a fan and about `total` in all, so
- * a big network stays quick; `more` is how many weren't drawn.
+ * The chains that lead on from an opened circle (Blake, 2026-10-02: "once they
+ * are clicked on and can view the cluster i want any scanned d2,3,4 or whatever
+ * to be show inside with lines out of the d1 leading to the d2s").
  *
- * @param {{ angle: number, slot: number, count: number }[]} anchors
- * @returns {({ points: { x: number, y: number }[], more: number } | null)[]}
+ * `parents[i]` is the index of the link that introduced link i, or -1 when the
+ * person in the middle did. The links one step on sit on a ring at `from`, each
+ * as near its own angle in `angles` as it can get (where that person's dot is
+ * in the circle), or fanned about `toward` without one; each later step sits `hop` further out,
+ * as near the angle of the link it came from as it can get without touching a
+ * neighbour on its own ring (`spacing` apart). So a chain reads outwards from
+ * the middle: the bridge, someone met through them, someone met through *them*.
+ *
+ * @param {number[]} parents
+ * @returns {{ rings: { radius: number, count: number, depth: number }[],
+ *   points: { x: number, y: number, angle: number, radius: number, depth: number, parent: number }[] }}
  */
-export function outerFans(anchors, { from, spacing = 7, cap = 40, total = 1200 } = {}) {
-  const fans = anchors.filter((a) => a?.count > 0).length;
-  const each = Math.max(6, Math.min(cap, Math.floor(total / Math.max(1, fans))));
-  return anchors.map((a) => {
-    if (!(a?.count > 0)) return null;
-    const n = Math.min(a.count, each);
-    // Only as wide as the dots need at `spacing`, never wider than their slot:
-    // more rows once it's full, so a small fan stays a tight cluster.
-    const room = Math.min(a.slot || TAU, TAU / 6);
-    const width = Math.min(room, Math.max((spacing * 3) / from, (n * spacing) / from));
-    const l = ringLayout(n, {
-      inner: from, outer: Infinity, spacing, minSpacing: spacing, start: a.angle - width / 2, sweep: width,
+export function chainTree(parents = [], { from = 0, hop = 60, spacing = 46, toward = 0, angles = [] } = {}) {
+  const n = parents.length;
+  const parent = parents.map((p, i) => (Number.isInteger(p) && p >= 0 && p < n && p !== i ? p : -1));
+
+  // How many steps out each one is. A loop (it shouldn't happen) is cut where
+  // it closes, so everyone still gets a place.
+  const depth = new Array(n).fill(0);
+  for (let i = 0; i < n; i++) {
+    const trail = [];
+    let k = i;
+    while (k >= 0 && !depth[k] && !trail.includes(k)) { trail.push(k); k = parent[k]; }
+    if (k >= 0 && !depth[k]) { parent[trail[trail.length - 1]] = -1; k = -1; }
+    let d = k >= 0 ? depth[k] + 1 : 1;
+    for (let j = trail.length - 1; j >= 0; j--) depth[trail[j]] = d++;
+  }
+
+  const points = new Array(n);
+  const rings = [];
+  for (let d = 1; d <= Math.max(0, ...depth); d++) {
+    const here = [];
+    for (let i = 0; i < n; i++) if (depth[i] === d) here.push(i);
+    const radius = from + (d - 1) * hop;
+    const placed = spread(here.map((i) => (parent[i] < 0 ? (Number.isFinite(angles[i]) ? angles[i] : toward) : points[parent[i]].angle)),
+      Math.min(spacing / Math.max(1, radius), TAU / here.length));
+    here.forEach((i, j) => {
+      const angle = placed[j];
+      points[i] = { x: radius * Math.cos(angle), y: radius * Math.sin(angle), angle, radius, depth: d, parent: parent[i] };
     });
-    return { points: l.points.map(({ x, y }) => ({ x, y })), more: a.count - n };
+    rings.push({ radius, count: here.length, depth: d });
+  }
+  return { rings, points };
+}
+
+/**
+ * Angles as near the ones asked for as they can be while staying `sep` apart:
+ * neighbours that would touch move apart by the same amount each way, so two
+ * people met through the same person sit either side of them. Comes back in
+ * the order given.
+ */
+function spread(wanted, sep) {
+  const m = wanted.length;
+  if (m < 2) return wanted.slice();
+  const turn = (a) => ((a % TAU) + TAU) % TAU;
+  const order = wanted.map((a, i) => i).sort((i, j) => turn(wanted[i]) - turn(wanted[j]) || i - j);
+  // Start counting just after the widest empty stretch, so no group straddles the join.
+  let cut = 0;
+  let widest = -1;
+  order.forEach((i, k) => {
+    const next = order[(k + 1) % m];
+    const gap = turn(turn(wanted[next]) - turn(wanted[i])) || (m > 1 && k === m - 1 ? TAU : 0);
+    if (gap > widest) { widest = gap; cut = (k + 1) % m; }
   });
+  const seq = order.slice(cut).concat(order.slice(0, cut));
+  const first = turn(wanted[seq[0]]);
+  const at = seq.map((i) => first + turn(turn(wanted[i]) - first));
+
+  // Least movement that keeps them `sep` apart: take the spacing out, pool any
+  // neighbours left out of order to their average, put the spacing back.
+  const blocks = [];
+  at.forEach((a, k) => {
+    blocks.push({ sum: a - k * sep, count: 1 });
+    while (blocks.length > 1 && blocks[blocks.length - 2].sum / blocks[blocks.length - 2].count > blocks[blocks.length - 1].sum / blocks[blocks.length - 1].count) {
+      const last = blocks.pop();
+      blocks[blocks.length - 1].sum += last.sum;
+      blocks[blocks.length - 1].count += last.count;
+    }
+  });
+  let placed = blocks.flatMap((b) => new Array(b.count).fill(b.sum / b.count)).map((q, k) => q + k * sep);
+  // Round the join too: if the last has come back round onto the first, share the ring evenly.
+  if (placed[m - 1] - placed[0] > TAU - sep) {
+    const mid = (placed[0] + placed[m - 1]) / 2;
+    placed = placed.map((_, k) => mid + (k - (m - 1) / 2) * (TAU / m));
+  }
+  const out = new Array(m);
+  seq.forEach((i, k) => { out[i] = placed[k]; });
+  return out;
 }

package/lib/data-export.js

@@ -14,7 +14,7 @@ import { DatabaseSync } from 'node:sqlite';
 import { readFileSync, lstatSync, statSync } from 'node:fs';
 import { createHash } from 'node:crypto';
 import path from 'node:path';
-import { AVATAR_FILE, TRAVELLING_FILES, namesInFolder } from './data-folder.js';
+import { AVATAR_FILE, TRAVELLING_FILES, SOCIAL_FILE, namesInFolder } from './data-folder.js';
 
 /** Bump when the file's layout changes in a way an older import can't read. */
 export const EXPORT_FORMAT = 1;
@@ -72,7 +72,7 @@ export function referencedPhotos(db) {
  * plain files are taken, never a link, and avatars/ is read only if it is a
  * real folder, so nothing outside the data folder can be pulled in through one.
  */
-export function travellingFiles(dir, { includePhotos = true, photos = null } = {}) {
+export function travellingFiles(dir, { includePhotos = true, photos = null, includeSocial = true } = {}) {
   const plain = (p) => {
     try { return lstatSync(p).isFile(); } catch { return false; }
   };
@@ -81,6 +81,12 @@ export function travellingFiles(dir, { includePhotos = true, photos = null } = {
     const abs = path.join(dir, name);
     if (plain(abs)) out.push({ rel: name, abs });
   }
+  if (includeSocial) {
+    for (const name of namesInFolder(dir).sort()) {
+      const abs = path.join(dir, name);
+      if (SOCIAL_FILE.test(name) && plain(abs)) out.push({ rel: name, abs });
+    }
+  }
   if (includePhotos) {
     for (const name of namesInFolder(path.join(dir, 'avatars')).sort()) {
       if (!AVATAR_FILE.test(name) || (photos && !photos.has(name))) continue;
@@ -96,7 +102,7 @@ export function travellingFiles(dir, { includePhotos = true, photos = null } = {
  * `outFile`, which must not exist yet.
  * @returns {{ bytes, people, photos, files, counts }}
  */
-export function buildExport(db, { dir, outFile, includePhotos = true, appVersion, schemaSql, now = new Date() }) {
+export function buildExport(db, { dir, outFile, includePhotos = true, includeSocial = true, appVersion, schemaSql, now = new Date() }) {
   db.exec(`VACUUM INTO ${sqlString(outFile)}`);
 
   const out = new DatabaseSync(outFile);
@@ -127,7 +133,7 @@ export function buildExport(db, { dir, outFile, includePhotos = true, appVersion
     // photo of someone whose circle was deleted since; the copy has no row
     // for them, so their face has no reason to travel.
     const inNetwork = includePhotos ? referencedPhotos(out) : null;
-    for (const f of travellingFiles(dir, { includePhotos, photos: inNetwork })) {
+    for (const f of travellingFiles(dir, { includePhotos, photos: inNetwork, includeSocial })) {
       let bytes;
       try { bytes = readFileSync(f.abs); } catch { continue; } // replaced since the listing
       put.run(f.rel, bytes, sha256(bytes));

package/lib/data-folder.js

@@ -44,6 +44,15 @@ export const BUDGET_FILES = [
   'linkedin-cooldown.json',
 ];
 
+/**
+ * The Social tab's files, one set per profile: its findings, the messages kept
+ * with "Keep my messages on this computer", and the CRM's stages, tags and
+ * notes (lib/social-store.js). A copy carries them when asked (Blake,
+ * 2026-09-29: everything goes with the network), and an import puts them back
+ * in place of this computer's, which are kept beside the old network.
+ */
+export const SOCIAL_FILE = /^(?:social|social-messages|crm)-[\w-]+\.json$/;
+
 /** Everything of the scanner's that an export carries. */
 export const TRAVELLING_FILES = [...NETWORK_FILES, ...BUDGET_FILES];
 

package/lib/data-import.js

@@ -31,7 +31,7 @@ import { runningNow } from './scan-state.js';
 import { durable } from './durable.js';
 import { budgetFileProblem, mergeBudgetFiles } from './linkedin-limits.js';
 import {
-  AVATAR_FILE, TRAVELLING_FILES, NETWORK_FILES, BUDGET_FILES, PENDING_DIR, IMPORT_BACKUP_PREFIX,
+  AVATAR_FILE, TRAVELLING_FILES, NETWORK_FILES, BUDGET_FILES, SOCIAL_FILE, PENDING_DIR, IMPORT_BACKUP_PREFIX,
   sweepLeftovers, namesInFolder,
 } from './data-folder.js';
 import {
@@ -158,10 +158,11 @@ export async function receiveUpload(body, file, { declared }) {
   return received;
 }
 
-/** 'photo', 'file' (one of the scanner's travelling files), or null for anything an export never carries. */
+/** 'photo', 'file' (one of the scanner's travelling files), 'social', or null for anything an export never carries. */
 export function exportedFileKind(rel) {
   if (typeof rel !== 'string') return null;
   if (TRAVELLING_FILES.includes(rel)) return 'file';
+  if (SOCIAL_FILE.test(rel)) return 'social';
   // The same pattern the /avatars route serves: no folders, no dots but the
   // extension, so no path can climb out of avatars/.
   if (rel.startsWith('avatars/') && AVATAR_FILE.test(rel.slice('avatars/'.length))) return 'photo';
@@ -421,7 +422,7 @@ export function stageImport(upload, {
         throw new ImportError(`“${shortName(rel)}” inside this file is damaged, so nothing was imported.`);
       }
       writeFileSync(path.join(filesDir, rel), row.bytes, { flag: 'wx' });
-      if (kind === 'file') scannerFiles.push(path.join(filesDir, rel));
+      if (kind === 'file' || kind === 'social') scannerFiles.push(path.join(filesDir, rel));
     }
   } finally {
     db.close();
@@ -731,6 +732,14 @@ export function applyPendingImport({ dir, dbFile, now = new Date(), copyDatabase
         keptFolder();
         move(from, path.join(keptFiles, name));
       }
+      // This computer's Social files step aside only when the copy brings its
+      // own; a copy made without them leaves them where they are.
+      if (namesInFolder(path.join(pending, 'files')).some((n) => SOCIAL_FILE.test(n))) {
+        for (const name of namesInFolder(dir).filter((n) => SOCIAL_FILE.test(n))) {
+          keptFolder();
+          move(path.join(dir, name), path.join(keptFiles, name));
+        }
+      }
       for (const name of BUDGET_FILES) {
         const from = path.join(dir, name);
         if (!exists(from) || !lstatSync(from).isFile()) continue;
@@ -786,6 +795,7 @@ export function applyPendingImport({ dir, dbFile, now = new Date(), copyDatabase
         const from = path.join(files, name);
         if (exists(from)) move(from, path.join(dir, name));
       }
+      for (const name of namesInFolder(files).filter((n) => SOCIAL_FILE.test(n))) move(path.join(files, name), path.join(dir, name));
       mergeBudgetFiles({ dir, from: files });
       durable.syncFolder(dir);
       step('done');

package/lib/degrees.js

@@ -22,9 +22,3 @@ export function peopleByDegree(degree1 = [], degree2 = [], degree3 = []) {
   };
   return { 1: take(degree1, 1), 2: take(degree2, 2), 3: take(degree3, 3) };
 }
-
-export function tierCountsOf(rows = []) {
-  const counts = {};
-  for (const row of rows) counts[row.tier] = (counts[row.tier] || 0) + 1;
-  return counts;
-}

package/lib/dot-rings.js

@@ -18,4 +18,29 @@ export function ringSegments(r) {
   });
 }
 
+/**
+ * The ring round a bridge in Bridge Chains (Blake, 2026-10-02: "the bars on the
+ * ring should signify how many dots in the clusters are ready to be scanned
+ * and new clusters formed"). One bar for each person you added through that
+ * circle: the ones scanned since, with a cluster of their own (`formed`),
+ * then the ones waiting for a scan (`ready`). Past `max` bars the two kinds
+ * share them in proportion, each keeping at least one.
+ *
+ * @returns {{ d: string, kind: 'formed' | 'ready' }[]}
+ */
+export function reachSegments(r, { formed = 0, ready = 0 } = {}, max = 12) {
+  const total = Math.max(0, formed) + Math.max(0, ready);
+  if (!total) return [];
+  const n = Math.min(total, max);
+  let nFormed = formed > 0 ? Math.max(1, Math.round((n * formed) / total)) : 0;
+  if (ready > 0 && nFormed >= n) nFormed = n - 1;
+  const gap = n === 1 ? 0.5 : Math.min(GAP, ((2 * Math.PI) / n) * 0.35);
+  const span = (2 * Math.PI) / n - gap;
+  const p = (a) => `${(r * Math.cos(a)).toFixed(2)} ${(r * Math.sin(a)).toFixed(2)}`;
+  return Array.from({ length: n }, (_, i) => {
+    const a0 = -Math.PI / 2 + gap / 2 + i * (span + gap);
+    return { kind: i < nFormed ? 'formed' : 'ready', d: `M${p(a0)} A${r} ${r} 0 ${span > Math.PI ? 1 : 0} 1 ${p(a0 + span)}` };
+  });
+}
+
 export const RING = { filled: '#1abc9c', empty: 'rgba(255,255,255,0.16)', badge: '#7F77DD' };